handleAgentMessage method

void handleAgentMessage(AgentMessage message)

Implementation

void handleAgentMessage(AgentMessage message) {
  final type = message.type;
  final normalizedSourceMessageId = switch (message) {
    TurnStartAccepted() => message.sourceMessageId,
    TurnStartRejected() => message.sourceMessageId,
    TurnSteerRejected() => message.sourceMessageId,
    TurnStarted() => message.sourceMessageId,
    TurnSteered() => message.sourceMessageId,
    _ => null,
  };
  final normalizedThreadPath = message is AgentThreadMessage ? message.threadId.trim() : "";

  if (type == agentTurnStartType || type == agentTurnSteerType) {
    if (message is! AgentThreadMessage) {
      return;
    }
    final pendingMessage = PendingAgentMessage.fromTurnInputMessage(message);
    if (pendingMessage.threadPath.trim().isNotEmpty) {
      _markPendingAgentMessage(message: pendingMessage);
    }
    return;
  }

  if (type == agentTurnStartAcceptedType || type == agentTurnSteerAcceptedType) {
    if (normalizedSourceMessageId != null && _pendingAgentMessages.containsKey(normalizedSourceMessageId)) {
      _markPendingAgentMessageAccepted(normalizedSourceMessageId);
    } else if (message is TurnStartAccepted) {
      final pendingMessage = PendingAgentMessage.fromAcceptedMessage(message);
      if (pendingMessage.threadPath.trim().isNotEmpty && pendingMessage.hasVisibleContent) {
        _markPendingAgentMessage(message: pendingMessage);
      }
    }
    return;
  }

  if (type == agentTurnStartedType || type == agentTurnSteeredType) {
    _markPendingAgentMessageApplied(normalizedSourceMessageId);
    return;
  }

  if (type == agentTurnInterruptAcceptedType || type == agentTurnInterruptedType) {
    return;
  }

  if (type == agentTurnStartRejectedType || type == agentTurnSteerRejectedType) {
    _clearPendingAgentMessage(normalizedSourceMessageId);
    final errorMessage = switch (message) {
      TurnStartRejected() => message.error.message,
      TurnSteerRejected() => message.error.message,
      _ => null,
    };
    outboundStatus.markFailed(
      normalizedSourceMessageId ?? "",
      errorMessage != null && errorMessage.trim().isNotEmpty ? errorMessage.trim() : "Message rejected",
    );
    return;
  }

  if (type == agentTurnEndedType || type == agentThreadClearedType) {
    clearPendingAgentMessagesForThread(normalizedThreadPath);
  }
}