fix(a2a): usar UUID da conversa como contextId (restaura memória do agente)

O ai_adapter enviava o display_id numérico da conversa como contextId no
JSON-RPC para o AI Processor. O Processor monta a chave de sessão do ADK como
"{contextId}_{agentID}", então com o display_id ("3") a chave nunca casava com
a sessão persistida (que usa o UUID), resultando em "404 Session not found" e 0
mensagens de histórico em toda mensagem — o agente perdia a memória da conversa
e respondia cada turno do zero (fluxo stateful quebrado, etiquetas reaplicadas,
respostas fora de ordem).

Correção: extrair o UUID que o CRM aninha em
metadata.evoai_crm_data.conversation.id e usá-lo como contextId, com fallback
para o ID numérico quando o metadata estiver ausente (callers legados).

Testes: pkg/ai/service passa, incluindo cobertura do UUID e do fallback.
Nota: o test file estava órfão de um refactor anterior de NewAIAdapter
(assinatura antiga) — foi realinhado aqui. `go test ./...` segue vermelho no
repo por outros test files órfãos do mesmo refactor (dispatch_engine_test.go,
e2e_test.go), pré-existentes a esta mudança; CI publica imagem e não roda go test.

Author: DavidsonGomes

pkg/ai/service/ai_adapter.go

@@ -48,13 +48,21 @@ func (a *aiAdapter) Call(ctx context.Context, req *model.A2ARequest) (*model.Nor
 	// Use the full outgoing_url provided by the CRM (already contains the agent ID)
 	url := req.OutgoingURL
 
-	// Build JSON-RPC 2.0 envelope
+	// Build JSON-RPC 2.0 envelope.
+	// contextId MUST be the conversation UUID, not the numeric display_id: the AI
+	// Processor builds the ADK session key as "{contextId}_{agentID}". Using the
+	// display_id ("3") collides across accounts and never matches the session the
+	// Processor persisted (which keys on the UUID), so every turn reads 0 history
+	// and the agent loses memory. Prefer the UUID from the CRM metadata; fall back
+	// to the numeric ID only when the metadata is absent (e.g. legacy callers).
+	contextID := conversationContextID(req.Metadata, req.ConversationID)
+
 	rpcReq := model.JSONRPCRequest{
 		JSONRPC: "2.0",
 		ID:      fmt.Sprintf("%d:%d", req.ContactID, req.ConversationID),
 		Method:  "message/send",
 		Params: model.JSONRPCParams{
-			ContextID: fmt.Sprintf("%d", req.ConversationID),
+			ContextID: contextID,
 			UserID:    fmt.Sprintf("%d", req.ContactID),
 			Message: model.JSONRPCMessage{
 				Role: "user",
@@ -149,3 +157,33 @@ func nonNilMetadata(m map[string]any) map[string]any {
 	}
 	return m
 }
+
+// conversationContextID resolves the contextId for the JSON-RPC call. It reads the
+// conversation UUID the CRM nests at metadata.evoai_crm_data.conversation.id and
+// returns it; if any hop is missing or empty it falls back to the numeric
+// conversation ID (legacy behaviour) so callers without metadata still work.
+func conversationContextID(metadata map[string]any, conversationID int64) string {
+	fallback := fmt.Sprintf("%d", conversationID)
+	if uuid := extractConversationUUID(metadata); uuid != "" {
+		return uuid
+	}
+	return fallback
+}
+
+// extractConversationUUID digs metadata.evoai_crm_data.conversation.id out of the
+// untyped CRM metadata map. Returns "" when the path is absent or not a string.
+func extractConversationUUID(metadata map[string]any) string {
+	crmData, ok := metadata["evoai_crm_data"].(map[string]any)
+	if !ok {
+		return ""
+	}
+	conversation, ok := crmData["conversation"].(map[string]any)
+	if !ok {
+		return ""
+	}
+	id, ok := conversation["id"].(string)
+	if !ok {
+		return ""
+	}
+	return id
+}

pkg/ai/service/ai_adapter_test.go

@@ -15,6 +15,19 @@ import (
 	aiService "github.com/EvolutionAPI/evo-bot-runtime/pkg/ai/service"
 )
 
+// crmMetadata builds the nested CRM metadata map the Rails AgentBotListener sends,
+// carrying the conversation UUID at evoai_crm_data.conversation.id.
+func crmMetadata(conversationUUID string) map[string]any {
+	return map[string]any{
+		"evoai_crm_data": map[string]any{
+			"conversation": map[string]any{
+				"id":         conversationUUID,
+				"display_id": 7,
+			},
+		},
+	}
+}
+
 func TestCall_Success(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		// Verify X-API-Key header (per-event auth)
@@ -25,7 +38,7 @@ func TestCall_Success(t *testing.T) {
 			t.Errorf("Content-Type = %q, want application/json", got)
 		}
 
-		// Verify URL path contains agent_bot_id
+		// Verify URL path is the OutgoingURL provided by the CRM (already contains the agent ID)
 		if !strings.HasSuffix(r.URL.Path, "/api/v1/a2a/agent-123") {
 			t.Errorf("URL path = %q, want suffix /api/v1/a2a/agent-123", r.URL.Path)
 		}
@@ -41,8 +54,9 @@ func TestCall_Success(t *testing.T) {
 		if req.Method != "message/send" {
 			t.Errorf("req.Method = %q, want %q", req.Method, "message/send")
 		}
-		if req.Params.ContextID != "7" {
-			t.Errorf("req.Params.ContextID = %q, want %q", req.Params.ContextID, "7")
+		// contextId must be the conversation UUID from metadata, not the numeric ID.
+		if req.Params.ContextID != "conv-uuid-abc" {
+			t.Errorf("req.Params.ContextID = %q, want %q", req.Params.ContextID, "conv-uuid-abc")
 		}
 		if req.Params.UserID != "42" {
 			t.Errorf("req.Params.UserID = %q, want %q", req.Params.UserID, "42")
@@ -65,13 +79,14 @@ func TestCall_Success(t *testing.T) {
 	}))
 	defer server.Close()
 
-	adapter := aiService.NewAIAdapter(server.URL, 30)
+	adapter := aiService.NewAIAdapter(30)
 	resp, err := adapter.Call(context.Background(), &aiModel.A2ARequest{
-		AgentBotID:     "agent-123",
+		OutgoingURL:    server.URL + "/api/v1/a2a/agent-123",
 		Message:        "hello world",
 		ContactID:      42,
 		ConversationID: 7,
 		ApiKey:         "test-key",
+		Metadata:       crmMetadata("conv-uuid-abc"),
 	})
 	if err != nil {
 		t.Fatalf("Call returned unexpected error: %v", err)
@@ -81,6 +96,41 @@ func TestCall_Success(t *testing.T) {
 	}
 }
 
+// TestCall_ContextID_FallsBackToNumericID asserts that when the CRM metadata is
+// absent the adapter falls back to the numeric conversation ID (legacy behaviour),
+// so callers that do not send metadata keep working.
+func TestCall_ContextID_FallsBackToNumericID(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var req aiModel.JSONRPCRequest
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			t.Errorf("decode request body: %v", err)
+		}
+		if req.Params.ContextID != "7" {
+			t.Errorf("req.Params.ContextID = %q, want fallback %q", req.Params.ContextID, "7")
+		}
+		json.NewEncoder(w).Encode(aiModel.A2AResponse{
+			Result: &aiModel.A2AResult{
+				Artifacts: []aiModel.A2AArtifact{
+					{Parts: []aiModel.A2APart{{Type: "text", Text: "ok"}}},
+				},
+			},
+		})
+	}))
+	defer server.Close()
+
+	adapter := aiService.NewAIAdapter(30)
+	_, err := adapter.Call(context.Background(), &aiModel.A2ARequest{
+		OutgoingURL:    server.URL,
+		Message:        "test",
+		ConversationID: 7,
+		ApiKey:         "key",
+		// No Metadata → must fall back to the numeric ConversationID.
+	})
+	if err != nil {
+		t.Fatalf("Call returned unexpected error: %v", err)
+	}
+}
+
 func TestCall_Success_MessageFormat(t *testing.T) {
 	// Test the fallback response format (result.message instead of result.artifacts)
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -95,11 +145,11 @@ func TestCall_Success_MessageFormat(t *testing.T) {
 	}))
 	defer server.Close()
 
-	adapter := aiService.NewAIAdapter(server.URL, 30)
+	adapter := aiService.NewAIAdapter(30)
 	resp, err := adapter.Call(context.Background(), &aiModel.A2ARequest{
-		AgentBotID: "bot-1",
-		Message:    "test",
-		ApiKey:     "key",
+		OutgoingURL: server.URL,
+		Message:     "test",
+		ApiKey:      "key",
 	})
 	if err != nil {
 		t.Fatalf("Call returned unexpected error: %v", err)
@@ -122,15 +172,15 @@ func TestCall_ContextCancellation_ReturnsPipelineCancelled(t *testing.T) {
 		server.Close()
 	})
 
-	adapter := aiService.NewAIAdapter(server.URL, 30)
+	adapter := aiService.NewAIAdapter(30)
 	ctx, cancel := context.WithCancel(context.Background())
 
 	go func() {
 		time.Sleep(50 * time.Millisecond)
 		cancel()
 	}()
 
-	_, err := adapter.Call(ctx, &aiModel.A2ARequest{AgentBotID: "bot-1", Message: "test", ApiKey: "key"})
+	_, err := adapter.Call(ctx, &aiModel.A2ARequest{OutgoingURL: server.URL, Message: "test", ApiKey: "key"})
 	if !errors.Is(err, brtErrors.ErrPipelineCancelled) {
 		t.Errorf("expected ErrPipelineCancelled, got %v", err)
 	}
@@ -149,8 +199,8 @@ func TestCall_Timeout_ReturnsAITimeout(t *testing.T) {
 		server.Close()
 	})
 
-	adapter := aiService.NewAIAdapter(server.URL, 1) // 1 s timeout
-	_, err := adapter.Call(context.Background(), &aiModel.A2ARequest{AgentBotID: "bot-1", Message: "test", ApiKey: "key"})
+	adapter := aiService.NewAIAdapter(1) // 1 s timeout
+	_, err := adapter.Call(context.Background(), &aiModel.A2ARequest{OutgoingURL: server.URL, Message: "test", ApiKey: "key"})
 	if !errors.Is(err, brtErrors.ErrAITimeout) {
 		t.Errorf("expected ErrAITimeout, got %v", err)
 	}
@@ -162,8 +212,8 @@ func TestCall_NonOKStatus_ReturnsError(t *testing.T) {
 	}))
 	defer server.Close()
 
-	adapter := aiService.NewAIAdapter(server.URL, 30)
-	_, err := adapter.Call(context.Background(), &aiModel.A2ARequest{AgentBotID: "bot-1", Message: "test", ApiKey: "key"})
+	adapter := aiService.NewAIAdapter(30)
+	_, err := adapter.Call(context.Background(), &aiModel.A2ARequest{OutgoingURL: server.URL, Message: "test", ApiKey: "key"})
 	if err == nil {
 		t.Fatal("expected error for non-200 response, got nil")
 	}