@runflow-ai/sdk 1.0.17 → 1.0.19

package/dist/core/agent.js

@@ -4,14 +4,42 @@ exports.Agent = void 0;
 const trace_collector_1 = require("../observability/trace-collector");
 const api_client_1 = require("./api-client");
 const context_1 = require("./context");
+const logger_1 = require("./logger");
+const performance_logger_1 = require("./performance-logger");
+const agent_memory_1 = require("./helpers/agent-memory");
+const agent_rag_1 = require("./helpers/agent-rag");
+const agent_context_1 = require("./helpers/agent-context");
+const agent_utils_1 = require("./helpers/agent-utils");
 // ============================================================================
 // AGENT CLASS
 // ============================================================================
 class Agent {
     constructor(config) {
         this.config = config;
-        // Configurar debug
-        this.debugConfig = this.resolveDebugConfig(config.debug);
+        // Configurar logger
+        this.logger = (0, logger_1.createLogger)({
+            name: `agent:${config.name}`,
+            level: this.resolveLogLevel(config.debug),
+            enabled: config.debug !== false,
+        });
+        // ============================================================================
+        // AUTO-CREATE RAG TOOLS (Agentic RAG)
+        // ============================================================================
+        // Se RAG configurado, criar tools automaticamente
+        // LLM decide quando buscar (não busca sempre)
+        if (config.rag) {
+            this.logger.debug('RAG configuration detected, creating tools');
+            const ragTools = (0, agent_rag_1.createRAGTools)(config.rag, this.logger);
+            this.config.tools = {
+                ...ragTools,
+                ...config.tools,
+            };
+            // Injetar searchPrompt nas instructions (orienta quando buscar)
+            if (config.rag.searchPrompt) {
+                this.config.instructions += `\n\n${config.rag.searchPrompt}`;
+                this.logger.debug('Search prompt injected into instructions');
+            }
+        }
         // Auto-initialize API client if not in execution context
         if (!this.apiClient) {
             this.apiClient = (0, api_client_1.createRunflowAPIClient)();
@@ -21,32 +49,34 @@ class Agent {
                 batchSize: 1, // Flush imediatamente após cada trace
                 flushInterval: 1000,
             });
-            console.log('🔍 [SDK Agent] Trace collector initialized in constructor with projectId:', projectId);
         }
     }
     // Injetar API client (feito pela execution engine)
     _setAPIClient(apiClient) {
-        this.apiClient = apiClient;
-        // Use agentId from environment or config name as fallback
         const projectId = process.env.RUNFLOW_AGENT_ID || this.config.name.toLowerCase().replace(/\s+/g, '-');
+        this.logger.debug('Setting API client', { projectId });
+        this.apiClient = apiClient;
         this.traceCollector = (0, trace_collector_1.createTraceCollector)(apiClient, projectId, {
             batchSize: 1, // Flush imediatamente após cada trace
             flushInterval: 1000,
         });
-        console.log('🔍 [SDK Agent] Trace collector initialized via _setAPIClient with projectId:', projectId);
     }
     // Geração simples (aceita string ou array de messages)
     async generate(input) {
         const isMessagesArray = Array.isArray(input);
-        console.log('💬 [SDK Agent] Generate called with', isMessagesArray ? `${input.length} messages` : `prompt length: ${input.length}`);
         if (!this.apiClient) {
-            console.error('❌ [SDK Agent] API client not initialized!');
+            this.logger.error('API client not initialized');
             throw new Error('Agent not initialized. API client not set.');
         }
-        console.log('🌐 [SDK Agent] Calling chat API...');
         const messages = isMessagesArray
             ? input
             : [{ role: 'user', content: input }];
+        this.logger.debug('Starting generation', {
+            messagesCount: messages.length,
+            isMessagesArray,
+            provider: this.config.model.provider,
+            model: this.config.model.model
+        });
         const chatRequest = {
             projectId: '', // Será injetado pela engine
             provider: this.config.model.provider,
@@ -61,22 +91,32 @@ class Agent {
             stop: this.config.modelConfig?.stop,
             seed: this.config.modelConfig?.seed,
         };
-        console.log('📡 [SDK Agent] Chat request:', JSON.stringify(chatRequest, null, 2));
         try {
             const response = await this.apiClient.chat(chatRequest);
-            console.log('✅ [SDK Agent] Chat response received:', response);
+            this.logger.debug('Generation completed', {
+                responseLength: response.text?.length || 0,
+                usage: response.usage
+            });
             return { text: response.text };
         }
         catch (error) {
-            console.error('❌ [SDK Agent] Chat API failed:', error);
+            this.logger.error('Chat API failed', {
+                error: error instanceof Error ? error.message : 'Unknown error'
+            });
             throw error;
         }
     }
     // Geração com streaming
     async generateStream(prompt) {
         if (!this.apiClient) {
+            this.logger.error('API client not initialized for streaming');
             throw new Error('Agent not initialized. API client not set.');
         }
+        this.logger.debug('Starting stream generation', {
+            promptLength: prompt.length,
+            provider: this.config.model.provider,
+            model: this.config.model.model
+        });
         const stream = this.apiClient.chatStream({
             projectId: '',
             provider: this.config.model.provider,
@@ -91,26 +131,38 @@ class Agent {
             stop: this.config.modelConfig?.stop,
             seed: this.config.modelConfig?.seed,
         });
-        return this.processStreamChunks(stream);
+        return (0, agent_utils_1.processStreamChunks)(stream, this.logger);
     }
     // Geração com tools (implementa loop de tool calling)
     async generateWithTools(input) {
         if (!this.apiClient) {
+            this.logger.error('API client not initialized for tool generation');
             throw new Error('Agent not initialized. API client not set.');
         }
         if (!this.config.tools || Object.keys(this.config.tools).length === 0) {
+            this.logger.debug('No tools configured, falling back to simple generation');
             return this.generate(input);
         }
         const isMessagesArray = Array.isArray(input);
         let messages = isMessagesArray
             ? [...input]
             : [{ role: 'user', content: input }];
+        this.logger.debug('Starting generation with tools', {
+            messagesCount: messages.length,
+            toolsCount: Object.keys(this.config.tools).length,
+            toolNames: Object.keys(this.config.tools)
+        });
         const maxIterations = this.config.maxToolIterations || 10; // Prevenir loops infinitos
         let iteration = 0;
         while (iteration < maxIterations) {
             iteration++;
-            console.log(`🔄 [SDK Agent] Tool calling iteration ${iteration}/${maxIterations}`);
+            this.logger.debug('Tool calling iteration', {
+                iteration,
+                maxIterations,
+                messagesCount: messages.length
+            });
             // 🔍 Trace: LLM Call
+            performance_logger_1.performanceLogger.start(`llm.call.${iteration}`);
             const llmStartTime = Date.now();
             const llmSpan = this.traceCollector?.startSpan('llm_call', {
                 provider: this.config.model.provider,
@@ -119,16 +171,12 @@ class Agent {
                 hasTools: true,
                 toolsCount: Object.keys(this.config.tools).length,
             });
-            // 🔍 Input do trace (detalhado se debug ativado)
+            // 🔍 Input do trace
             const llmInput = {
                 messagesCount: messages.length,
                 temperature: this.config.modelConfig?.temperature,
                 maxTokens: this.config.modelConfig?.maxTokens,
             };
-            if (this.debugConfig.logLLMCalls || this.debugConfig.logMessages) {
-                llmInput.messages = messages;
-                llmInput.instructions = this.config.instructions;
-            }
             llmSpan?.setInput(llmInput);
             const chatRequest = {
                 projectId: '', // Será injetado pela engine
@@ -146,17 +194,26 @@ class Agent {
                 seed: this.config.modelConfig?.seed,
             };
             const response = await this.apiClient.chat(chatRequest);
-            // 🔍 Output do trace (detalhado se debug ativado)
+            performance_logger_1.performanceLogger.end(`llm.call.${iteration}`, {
+                iteration,
+                hasToolCalls: !!response.toolCalls && response.toolCalls.length > 0,
+                toolCallsCount: response.toolCalls?.length || 0,
+                promptTokens: response.usage?.promptTokens,
+                completionTokens: response.usage?.completionTokens
+            });
+            this.logger.debug('LLM response received', {
+                iteration,
+                responseLength: response.text?.length || 0,
+                hasToolCalls: !!response.toolCalls && response.toolCalls.length > 0,
+                toolCallsCount: response.toolCalls?.length || 0,
+                usage: response.usage
+            });
+            // 🔍 Output do trace
             const llmOutput = {
                 responseLength: response.text?.length || 0,
                 hasToolCalls: !!response.toolCalls && response.toolCalls.length > 0,
                 toolCallsCount: response.toolCalls?.length || 0,
             };
-            if (this.debugConfig.logLLMCalls) {
-                llmOutput.responseText = response.text;
-                llmOutput.toolCalls = response.toolCalls;
-                llmOutput.usage = response.usage;
-            }
             llmSpan?.setOutput(llmOutput);
             llmSpan?.setMetadata({
                 provider: this.config.model.provider,
@@ -180,10 +237,12 @@ class Agent {
             llmSpan?.finish();
             // Se não há tool calls, retornar resposta final
             if (!response.toolCalls || response.toolCalls.length === 0) {
-                console.log('✅ [SDK Agent] No tool calls - returning final response');
+                this.logger.info('Generation completed without tool calls', {
+                    iteration,
+                    responseLength: response.text?.length || 0
+                });
                 return { text: response.text };
             }
-            console.log(`🛠️  [SDK Agent] Processing ${response.toolCalls.length} tool call(s)`);
             // Adicionar mensagem do assistente com tool calls
             messages.push({
                 role: 'assistant',
@@ -193,6 +252,11 @@ class Agent {
             // Executar cada tool call
             for (const toolCall of response.toolCalls) {
                 const toolName = toolCall.name;
+                this.logger.debug('Processing tool call', {
+                    toolName,
+                    toolCallId: toolCall.id,
+                    iteration
+                });
                 // Buscar tool por ID (pode estar com nome diferente da key no config)
                 let tool = this.config.tools[toolName];
                 // Se não encontrou, buscar por ID da tool
@@ -203,8 +267,10 @@ class Agent {
                     }
                 }
                 if (!tool) {
-                    console.error(`❌ [SDK Agent] Tool not found: ${toolName}`);
-                    console.error(`   Available tools:`, Object.keys(this.config.tools));
+                    this.logger.warn('Tool not found', {
+                        toolName,
+                        availableTools: Object.keys(this.config.tools)
+                    });
                     // Adicionar mensagem de erro
                     messages.push({
                         role: 'tool',
@@ -215,7 +281,6 @@ class Agent {
                     continue;
                 }
                 try {
-                    console.log(`🔧 [SDK Agent] Executing tool: ${toolName}`);
                     // 🔍 Iniciar trace da tool execution
                     const toolStartTime = Date.now();
                     const toolSpan = this.traceCollector?.startSpan('tool_call', {
@@ -230,20 +295,28 @@ class Agent {
                     }
                     // 🔍 Input sempre vai completo para o trace
                     toolSpan?.setInput(args);
-                    // Executar tool
-                    const toolResult = await tool.execute(args, {
-                        runflowAPI: this.apiClient,
-                        projectId: process.env.RUNFLOW_AGENT_ID || '',
-                        companyId: process.env.RUNFLOW_TENANT_ID || '',
-                    });
-                    console.log(`✅ [SDK Agent] Tool executed successfully: ${toolName}`, toolResult);
+                    // Executar tool com performance tracking
+                    const toolResult = await performance_logger_1.performanceLogger.measure(`tool.${toolName}`, async () => {
+                        return await tool.execute(args, {
+                            runflowAPI: this.apiClient,
+                            projectId: process.env.RUNFLOW_AGENT_ID || '',
+                            companyId: process.env.RUNFLOW_TENANT_ID || '',
+                        });
+                    }, { toolId: tool.id, iteration });
                     // 🔍 Output sempre vai completo para o trace
                     const toolEndTime = Date.now();
+                    const processingTimeMs = toolEndTime - toolStartTime;
+                    this.logger.info('Tool execution completed', {
+                        toolName,
+                        toolId: tool.id,
+                        processingTimeMs,
+                        iteration
+                    });
                     toolSpan?.setOutput(toolResult);
                     toolSpan?.setMetadata({
                         toolName,
                         toolId: tool.id,
-                        processingTimeMs: toolEndTime - toolStartTime,
+                        processingTimeMs,
                         success: true,
                     });
                     toolSpan?.finish();
@@ -256,7 +329,12 @@ class Agent {
                     });
                 }
                 catch (error) {
-                    console.error(`❌ [SDK Agent] Tool execution failed: ${toolName}`, error);
+                    this.logger.error('Tool execution failed', {
+                        toolName,
+                        toolId: tool.id,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                        iteration
+                    });
                     // 🔍 Registrar erro no trace (se existe)
                     const toolSpan = this.traceCollector?.startSpan('tool_call', {
                         toolName,
@@ -284,30 +362,26 @@ class Agent {
             }
         }
         // Se chegou aqui, atingiu o limite de iterações
-        console.warn('⚠️ [SDK Agent] Max tool calling iterations reached');
+        this.logger.warn('Max tool calling iterations reached', {
+            maxIterations,
+            finalMessagesCount: messages.length
+        });
         return { text: 'Maximum tool calling iterations reached. Please try again.' };
     }
     // Processamento principal (chamado pela execution engine)
     async process(input, context) {
-        console.log('🤖 [SDK Agent] Starting process...');
-        console.log('📥 [SDK Agent] Input:', JSON.stringify(input, null, 2));
-        console.log('🔧 [SDK Agent] Config:', {
-            name: this.config.name,
-            model: this.config.model,
-            hasMemory: !!this.config.memory,
-            hasRAG: !!this.config.rag,
-            hasTools: !!(this.config.tools && Object.keys(this.config.tools).length > 0),
+        const processStartTime = Date.now();
+        performance_logger_1.performanceLogger.start('agent.process');
+        this.logger.info('Agent processing started', {
+            agentName: this.config.name,
+            messageLength: input.message?.length || 0,
+            sessionId: input.sessionId,
+            companyId: input.companyId
         });
         // Configurar API client com contexto
         if (context?.apiClient) {
-            console.log('🔗 [SDK Agent] Using injected API client from context');
             this._setAPIClient(context.apiClient);
         }
-        else {
-            console.log('🔗 [SDK Agent] Using auto-configured API client');
-            // this.apiClient já foi inicializado no constructor
-        }
-        console.log('🌐 [SDK Agent] API Client configured:', !!this.apiClient);
         // ============================================================================
         // RESOLVER EXECUTION CONTEXT (prioridade: input > state > env > inferência)
         // ============================================================================
@@ -315,27 +389,26 @@ class Agent {
         const executionId = input.executionId
             || state.executionId
             || process.env.RUNFLOW_EXECUTION_ID
-            || this.generateExecutionId();
+            || (0, agent_context_1.generateExecutionId)();
         const threadId = input.threadId
             || state.threadId
             || process.env.RUNFLOW_THREAD_ID
-            || this.generateThreadId(input);
+            || (0, agent_context_1.generateThreadId)(input, this.logger);
         const entityType = input.entityType
             || state.entityType
-            || this.inferEntityType(input);
+            || (0, agent_context_1.inferEntityType)(input, this.logger);
         const entityValue = input.entityValue
             || state.entityValue
-            || this.inferEntityValue(input);
+            || (0, agent_context_1.inferEntityValue)(input, this.logger);
         const userId = input.userId
             || state.userId
-            || this.inferUserId(input);
-        console.log('🔍 [SDK Agent] Execution Context:', {
+            || (0, agent_context_1.inferUserId)(input, this.logger);
+        this.logger.debug('Execution context resolved', {
             executionId,
             threadId,
             entityType,
-            entityValue: entityValue || '(none)',
-            userId: userId || '(none)',
-            source: input.threadId ? 'input' : state.threadId ? 'state' : 'inferred',
+            entityValue,
+            userId
         });
         // Configurar trace collector com contexto
         if (this.traceCollector) {
@@ -384,6 +457,10 @@ class Agent {
         span?.setInput(input);
         // Se tem multi-agents, usar supervisor pattern
         if (this.config.agents && Object.keys(this.config.agents).length > 0) {
+            this.logger.debug('Multi-agent configuration detected, delegating to supervisor', {
+                agentsCount: Object.keys(this.config.agents).length,
+                agentNames: Object.keys(this.config.agents)
+            });
             return this.processMultiAgent(input, context);
         }
         // Memory management se configurado
@@ -393,48 +470,35 @@ class Agent {
             // Prioridade 1: Custom memoryKey (override completo)
             if (this.config.memory.memoryKey) {
                 memoryId = this.config.memory.memoryKey;
-                console.log('🧠 [SDK Agent] Loading memory with custom key:', memoryId);
             }
             // Prioridade 2: entityType + entityValue (do identify())
             else if (entityType && entityValue) {
                 memoryId = `${entityType}:${entityValue}`;
-                console.log('🧠 [SDK Agent] Loading memory for entity:', memoryId);
             }
             // Prioridade 3: sessionId (backward compatibility)
             else if (input.sessionId) {
                 memoryId = `session:${input.sessionId}`;
-                console.log('🧠 [SDK Agent] Loading memory for session (fallback):', memoryId);
             }
             if (memoryId) {
-                memoryMessages = await this.loadMemory(memoryId);
-                console.log('🧠 [SDK Agent] Memory loaded:', memoryMessages.length > 0 ? `${memoryMessages.length} messages` : 'No history');
-            }
-        }
-        // RAG automático se configurado
-        let ragContext = '';
-        if (this.config.rag?.autoSearch) {
-            console.log('🔍 [SDK Agent] Performing RAG search for:', input.message);
-            const ragData = await this.performRAG(input.message);
-            if (ragData) {
-                ragContext = ragData;
-                console.log('🔍 [SDK Agent] RAG context found:', ragData.substring(0, 100) + '...');
-            }
-            else {
-                console.log('🔍 [SDK Agent] No RAG context found');
+                this.logger.debug('Loading memory', {
+                    memoryId,
+                    memoryType: this.config.memory.type
+                });
+                const memoryLoadTime = await performance_logger_1.performanceLogger.measure('memory.load', async () => {
+                    return await (0, agent_memory_1.loadMemory)(memoryId, this.apiClient, this.config.memory, this.traceCollector, this.logger);
+                }, { memoryId, memoryType: this.config.memory.type });
+                memoryMessages = memoryLoadTime;
             }
         }
+        // ============================================================================
+        // RAG agora é TOOL - LLM decide quando buscar
+        // ============================================================================
+        // REMOVIDO: performRAG() automático
+        // Agora: RAG tools criadas no constructor, LLM chama quando necessário
         // Construir messages para LLM
         let messages = [];
-        // 1. Adicionar RAG context como system message (se houver)
-        if (ragContext) {
-            messages.push({
-                role: 'system',
-                content: `Relevant context from knowledge base:\n\n${ragContext}`
-            });
-        }
         // 2. Se tem messages[] no input, adicionar como contexto
         if (input.messages && input.messages.length > 0) {
-            console.log('💬 [SDK Agent] Using provided messages as context:', input.messages.length);
             const inputMessages = input.messages.map(msg => ({
                 role: msg.role,
                 content: msg.content // Pode ser string ou array multimodal
@@ -443,49 +507,85 @@ class Agent {
         }
         // 3. Adicionar historical messages da memória
         if (memoryMessages.length > 0) {
-            console.log('🧠 [SDK Agent] Adding memory messages:', memoryMessages.length);
             messages.push(...memoryMessages);
         }
         // 4. Adicionar mensagem atual do usuário
         messages.push({ role: 'user', content: input.message });
-        console.log('📝 [SDK Agent] Final messages for LLM:', messages.length);
-        console.log('🤖 [SDK Agent] Calling LLM...');
         // Processar com ou sem tools
-        const result = this.config.tools && Object.keys(this.config.tools).length > 0
+        const hasTools = this.config.tools && Object.keys(this.config.tools).length > 0;
+        this.logger.debug('Processing messages', {
+            messagesCount: messages.length,
+            hasTools,
+            toolsCount: hasTools ? Object.keys(this.config.tools).length : 0
+        });
+        performance_logger_1.performanceLogger.start('llm.processing');
+        const result = hasTools
             ? await this.generateWithTools(messages)
             : await this.generate(messages);
-        console.log('✅ [SDK Agent] LLM response received:', result.text.substring(0, 100) + '...');
+        const llmProcessingTime = performance_logger_1.performanceLogger.end('llm.processing', {
+            hasTools,
+            messagesCount: messages.length
+        });
         // Salvar na memória se configurado
+        let memorySaveTime = 0;
         if (this.config.memory && memoryId) {
-            console.log('💾 [SDK Agent] Saving to memory:', memoryId);
-            await this.saveToMemory(memoryId, input.message, result.text);
-            console.log('💾 [SDK Agent] Memory saved');
+            this.logger.debug('Saving to memory', { memoryId });
+            await performance_logger_1.performanceLogger.measure('memory.save', async () => {
+                await (0, agent_memory_1.saveToMemory)(memoryId, input.message, result.text, this.apiClient, this.config.memory, this.config.model, this.traceCollector, this.logger);
+            }, { memoryId });
+            memorySaveTime = Date.now() - processStartTime - llmProcessingTime;
         }
         const output = {
             message: result.text,
             metadata: {
                 model: this.config.model.model,
                 provider: this.config.model.provider,
-                ragUsed: !!ragContext,
+                ragUsed: false, // Agora detectado via toolCalls
                 memoryUsed: memoryMessages.length > 0,
                 sessionId: input.sessionId,
             },
         };
-        console.log('📤 [SDK Agent] Final output:', JSON.stringify(output, null, 2));
         // Finalizar trace com métricas de performance
-        const executionEndTime = Date.now();
-        const processingTimeMs = executionEndTime - executionStartTime;
+        const processingTimeMs = Date.now() - processStartTime;
+        // Performance summary (se ativado)
+        if (performance_logger_1.performanceLogger.isEnabled()) {
+            const memoryLoadTime = memoryMessages.length > 0 ?
+                (processStartTime + 100) : 0; // Estimativa se não medido diretamente
+            performance_logger_1.performanceLogger.summary('agent.process', {
+                'context_resolution': 5, // Tempo mínimo de setup
+                'memory_load': memoryLoadTime,
+                'llm_processing': llmProcessingTime,
+                'memory_save': memorySaveTime,
+            }, processingTimeMs);
+        }
+        performance_logger_1.performanceLogger.end('agent.process', {
+            agentName: this.config.name,
+            responseLength: result.text?.length || 0,
+            memoryUsed: memoryMessages.length > 0,
+            toolsUsed: (0, agent_utils_1.getUsedTools)(this.config.tools).length,
+            executionId,
+            threadId
+        });
+        this.logger.info('Agent processing completed', {
+            agentName: this.config.name,
+            processingTimeMs,
+            responseLength: result.text?.length || 0,
+            memoryUsed: memoryMessages.length > 0,
+            toolsUsed: (0, agent_utils_1.getUsedTools)(this.config.tools),
+            executionId,
+            threadId
+        });
         span?.setOutput(output);
         span?.setMetadata({
             // Feature usage atualizado
-            ragUsed: !!ragContext,
+            ragUsed: false, // Agora detectado via tool calls
             memoryUsed: memoryMessages.length > 0,
-            toolsUsed: this.getUsedTools(),
+            toolsUsed: (0, agent_utils_1.getUsedTools)(this.config.tools),
             // Performance metrics
             processingTimeMs,
             // Quality metrics
             confidence: 0.9, // Placeholder - pode ser calculado baseado no contexto
-            reasoning: ragContext ? 'Used RAG context for enhanced response' : 'Direct LLM response',
+            reasoning: 'Direct LLM response',
         });
         // Adicionar custos se disponível (placeholder - será implementado quando tivermos dados reais)
         span?.setCosts({
@@ -505,17 +605,19 @@ class Agent {
         span?.finish();
         // Forçar flush dos traces pendentes
         if (this.traceCollector) {
-            console.log('🚀 [SDK Agent] Forcing trace flush...');
             await this.traceCollector.flush();
         }
-        console.log('🎉 [SDK Agent] Process completed successfully');
         return output;
     }
     // Multi-agent processing (supervisor pattern)
     async processMultiAgent(input, context) {
+        this.logger.debug('Starting multi-agent processing with supervisor pattern');
         // Criar supervisor automático
         const supervisor = this.createSupervisor();
         // Supervisor decide qual agent usar
+        this.logger.debug('Supervisor analyzing agent selection', {
+            availableAgents: Object.keys(this.config.agents)
+        });
         const decision = await supervisor.generate(`
 Available agents:
 ${Object.entries(this.config.agents).map(([name, config]) => `- ${name}: ${config.instructions}`).join('\n')}
@@ -527,12 +629,19 @@ Which agent should handle this? Respond with just the agent name.
         const selectedAgentName = decision.text.trim();
         const selectedAgentConfig = this.config.agents[selectedAgentName];
         if (!selectedAgentConfig) {
-            // Fallback para primeiro agent
             const firstAgentName = Object.keys(this.config.agents)[0];
+            this.logger.warn('Supervisor selected invalid agent, using fallback', {
+                selectedAgentName,
+                fallbackAgentName: firstAgentName
+            });
+            // Fallback para primeiro agent
             const firstAgentConfig = this.config.agents[firstAgentName];
             const agent = new Agent(firstAgentConfig);
             return agent.process(input, context);
         }
+        this.logger.info('Supervisor selected agent', {
+            selectedAgentName
+        });
         // Executar agent selecionado
         const selectedAgent = new Agent(selectedAgentConfig);
         return selectedAgent.process(input, context);
@@ -545,76 +654,27 @@ Which agent should handle this? Respond with just the agent name.
             model: this.config.model, // Mesmo modelo do agent principal
         });
     }
-    // RAG automático
-    async performRAG(query) {
-        if (!this.config.rag || !this.apiClient) {
-            return null;
+    // ============================================================================
+    // LOGGER CONFIGURATION
+    // ============================================================================
+    /**
+     * Resolve o nível de log baseado na configuração de debug
+     */
+    resolveLogLevel(debug) {
+        // Se debug é false, desativar logs
+        if (debug === false) {
+            return 'silent';
         }
-        // 🔍 Trace: RAG Search
-        const ragStartTime = Date.now();
-        const ragSpan = this.traceCollector?.startSpan('rag_search', {
-            operation: 'vector_search',
-            vectorStore: this.config.rag.vectorStore,
-            k: this.config.rag.k || 5,
-            threshold: this.config.rag.threshold || 0.7,
-        });
-        ragSpan?.setInput({ query });
-        try {
-            const searchResults = await this.apiClient.vectorSearch(query, {
-                vectorStore: this.config.rag.vectorStore,
-                k: this.config.rag.k || 5,
-                threshold: this.config.rag.threshold || 0.7,
-            });
-            if (searchResults.results.length === 0) {
-                ragSpan?.setOutput({ resultsCount: 0, hasResults: false });
-                ragSpan?.setMetadata({
-                    operation: 'vector_search',
-                    vectorStore: this.config.rag.vectorStore,
-                    resultsCount: 0,
-                    processingTimeMs: Date.now() - ragStartTime,
-                    success: true,
-                });
-                ragSpan?.finish();
-                return null;
-            }
-            const context = searchResults.results
-                .map((result) => result.content)
-                .join('\n\n');
-            // 🔍 Finalizar trace (com dados completos se debug ativado)
-            const ragOutput = {
-                resultsCount: searchResults.results.length,
-                hasResults: true,
-                contextLength: context.length,
-            };
-            if (this.debugConfig.logRAG) {
-                ragOutput.results = searchResults.results;
-                ragOutput.contextGenerated = context;
-            }
-            ragSpan?.setOutput(ragOutput);
-            ragSpan?.setMetadata({
-                operation: 'vector_search',
-                vectorStore: this.config.rag.vectorStore,
-                resultsCount: searchResults.results.length,
-                k: this.config.rag.k || 5,
-                threshold: this.config.rag.threshold || 0.7,
-                processingTimeMs: Date.now() - ragStartTime,
-                success: true,
-            });
-            ragSpan?.finish();
-            return context;
+        // Se debug é true, usar debug level
+        if (debug === true) {
+            return 'debug';
         }
-        catch (error) {
-            console.error('RAG search failed:', error);
-            ragSpan?.setMetadata({
-                operation: 'vector_search',
-                vectorStore: this.config.rag.vectorStore,
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error',
-                processingTimeMs: Date.now() - ragStartTime,
-            });
-            ragSpan?.finish();
-            return null;
+        // Se debug é objeto com level, usar o nível especificado
+        if (typeof debug === 'object' && debug.level) {
+            return debug.level;
         }
+        // Default: info em produção, debug em desenvolvimento
+        return process.env.NODE_ENV === 'production' ? 'info' : 'debug';
     }
     // Getters
     get name() {
@@ -632,293 +692,19 @@ Which agent should handle this? Respond with just the agent name.
     get isMultiAgent() {
         return !!(this.config.agents && Object.keys(this.config.agents).length > 0);
     }
-    // Obter tools utilizadas (para traces)
-    getUsedTools() {
-        if (!this.config.tools)
-            return [];
-        return Object.keys(this.config.tools);
-    }
-    // ============================================================================
-    // DEBUG HELPERS
-    // ============================================================================
-    /**
-     * Resolver configuração de debug
-     */
-    resolveDebugConfig(debug) {
-        // Verificar variável de ambiente
-        const envDebug = process.env.RUNFLOW_DEBUG === 'true' || process.env.RUNFLOW_LOG_LEVEL === 'verbose';
-        if (debug === true || envDebug) {
-            // Debug simples = todos logs ativados
-            return {
-                enabled: true,
-                logMessages: true,
-                logLLMCalls: true,
-                logToolCalls: true,
-                logRAG: true,
-                logMemory: true,
-                truncateAt: undefined,
-            };
-        }
-        else if (typeof debug === 'object' && debug.enabled) {
-            // Debug customizado
-            return {
-                enabled: true,
-                logMessages: debug.logMessages !== false,
-                logLLMCalls: debug.logLLMCalls !== false,
-                logToolCalls: debug.logToolCalls !== false,
-                logRAG: debug.logRAG !== false,
-                logMemory: debug.logMemory !== false,
-                truncateAt: debug.truncateAt,
-            };
-        }
-        return { enabled: false };
-    }
-    // ============================================================================
-    // CONTEXT RESOLUTION HELPERS
-    // ============================================================================
-    /**
-     * Generate unique execution ID
-     */
-    generateExecutionId() {
-        return `exec_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
-    }
-    /**
-     * Generate threadId based on input (fallback quando não fornecido)
-     */
-    generateThreadId(input) {
-        const companyId = input.companyId || 'default';
-        // Se tem sessionId, usar como thread
-        if (input.sessionId) {
-            return `session_${companyId}_${input.sessionId}`;
-        }
-        // Fallback: gerar único
-        return `thread_${companyId}_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
-    }
-    /**
-     * Infer entityType from input metadata
-     */
-    inferEntityType(input) {
-        if (input.metadata?.phone)
-            return 'phone';
-        if (input.metadata?.email)
-            return 'email';
-        if (input.metadata?.contactId)
-            return 'hubspot_contact';
-        if (input.sessionId)
-            return 'session';
-        return 'session'; // Default
-    }
-    /**
-     * Infer entityValue from input metadata
-     */
-    inferEntityValue(input) {
-        if (input.metadata?.phone)
-            return input.metadata.phone;
-        if (input.metadata?.email)
-            return input.metadata.email;
-        if (input.metadata?.contactId)
-            return input.metadata.contactId;
-        if (input.sessionId)
-            return input.sessionId;
-        return null;
-    }
-    /**
-     * Infer userId from input metadata
-     */
-    inferUserId(input) {
-        if (input.metadata?.phone)
-            return input.metadata.phone;
-        if (input.metadata?.email)
-            return input.metadata.email;
-        if (input.metadata?.contactId)
-            return input.metadata.contactId;
-        return null;
-    }
-    // ============================================================================
-    // MEMORY MANAGEMENT
-    // ============================================================================
-    // Carregar memória da entidade (retorna array de messages)
-    async loadMemory(memoryId) {
-        if (!this.apiClient || !this.config.memory) {
-            return [];
-        }
-        // 🔍 Trace: Memory Load
-        const memoryLoadStartTime = Date.now();
-        const memoryLoadSpan = this.traceCollector?.startSpan('memory_operation', {
-            operation: 'load',
-            memoryId,
-            memoryType: this.config.memory.type,
-        });
-        try {
-            const memoryData = await this.apiClient.memory.get(memoryId);
-            if (!memoryData.messages || memoryData.messages.length === 0) {
-                memoryLoadSpan?.setOutput({ messagesCount: 0, hasHistory: false });
-                memoryLoadSpan?.setMetadata({
-                    operation: 'load',
-                    memoryId,
-                    messagesCount: 0,
-                    processingTimeMs: Date.now() - memoryLoadStartTime,
-                    success: true,
-                });
-                memoryLoadSpan?.finish();
-                return [];
-            }
-            // Aplicar configurações de memória
-            let messages = memoryData.messages;
-            // Limitar por número de turnos
-            if (this.config.memory.maxTurns) {
-                messages = messages.slice(-this.config.memory.maxTurns * 2); // user + assistant = 2 messages per turn
-            }
-            // Limitar por tokens (aproximado)
-            if (this.config.memory.maxTokens) {
-                let totalTokens = 0;
-                const filteredMessages = [];
-                for (let i = messages.length - 1; i >= 0; i--) {
-                    const messageTokens = Math.ceil(messages[i].content.length / 4);
-                    if (totalTokens + messageTokens <= this.config.memory.maxTokens) {
-                        filteredMessages.unshift(messages[i]);
-                        totalTokens += messageTokens;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                messages = filteredMessages;
-            }
-            // Retornar messages como array (formato nativo do LLM)
-            const result = messages.map((msg) => ({
-                role: msg.role,
-                content: msg.content,
-            }));
-            // 🔍 Finalizar trace (com dados completos se debug ativado)
-            const memoryOutput = {
-                messagesCount: messages.length,
-                hasHistory: result.length > 0,
-            };
-            if (this.debugConfig.logMemory) {
-                memoryOutput.messages = result;
-            }
-            memoryLoadSpan?.setOutput(memoryOutput);
-            memoryLoadSpan?.setMetadata({
-                operation: 'load',
-                memoryId,
-                messagesCount: messages.length,
-                maxTurns: this.config.memory.maxTurns,
-                processingTimeMs: Date.now() - memoryLoadStartTime,
-                success: true,
-            });
-            memoryLoadSpan?.finish();
-            return result;
-        }
-        catch (error) {
-            console.error('Failed to load memory:', error);
-            // 🔍 Trace de erro
-            memoryLoadSpan?.setMetadata({
-                operation: 'load',
-                memoryId,
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error',
-                processingTimeMs: Date.now() - memoryLoadStartTime,
-            });
-            memoryLoadSpan?.finish();
-            return [];
-        }
-    }
-    // Salvar na memória
-    async saveToMemory(memoryId, userMessage, assistantMessage) {
-        if (!this.apiClient || !this.config.memory) {
-            return;
-        }
-        // 🔍 Trace: Memory Save
-        const memorySaveStartTime = Date.now();
-        const memorySaveSpan = this.traceCollector?.startSpan('memory_operation', {
-            operation: 'save',
-            memoryId,
-            memoryType: this.config.memory.type,
-        });
-        try {
-            // Adicionar mensagem do usuário
-            await this.apiClient.memory.append(memoryId, {
-                role: 'user',
-                content: userMessage,
-                timestamp: new Date(),
-            });
-            // Adicionar resposta do assistant
-            await this.apiClient.memory.append(memoryId, {
-                role: 'assistant',
-                content: assistantMessage,
-                timestamp: new Date(),
-                metadata: {
-                    model: this.config.model.model,
-                },
-            });
-            // Resumir se necessário
-            let summarized = false;
-            if (this.config.memory.summarizeAfter) {
-                const currentMemory = await this.apiClient.memory.get(memoryId);
-                if (currentMemory.messages.length >= this.config.memory.summarizeAfter) {
-                    await this.apiClient.memory.summarize(memoryId);
-                    summarized = true;
-                }
-            }
-            // 🔍 Finalizar trace (com dados completos se debug ativado)
-            const memorySaveOutput = {
-                messagesSaved: 2,
-                summarized,
-            };
-            if (this.debugConfig.logMemory) {
-                memorySaveOutput.userMessage = userMessage;
-                memorySaveOutput.assistantMessage = assistantMessage;
-            }
-            memorySaveSpan?.setOutput(memorySaveOutput);
-            memorySaveSpan?.setMetadata({
-                operation: 'save',
-                memoryId,
-                messagesSaved: 2,
-                summarized,
-                summarizeAfter: this.config.memory.summarizeAfter,
-                processingTimeMs: Date.now() - memorySaveStartTime,
-                success: true,
-            });
-            memorySaveSpan?.finish();
-        }
-        catch (error) {
-            console.error('Failed to save to memory:', error);
-            // 🔍 Trace de erro
-            memorySaveSpan?.setMetadata({
-                operation: 'save',
-                memoryId,
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error',
-                processingTimeMs: Date.now() - memorySaveStartTime,
-            });
-            memorySaveSpan?.finish();
-        }
-    }
-    // Processar stream chunks (helper)
-    async *processStreamChunks(stream) {
-        for await (const chunk of stream) {
-            if (chunk.type === 'content') {
-                yield { text: chunk.content || '', done: false };
-            }
-            else if (chunk.type === 'done') {
-                yield { text: '', done: true };
-                break;
-            }
-            else if (chunk.type === 'error') {
-                throw new Error(chunk.error || 'Streaming error');
-            }
-        }
-    }
     // Streaming com memória
     async processStream(input, context) {
+        this.logger.debug('Starting stream processing', {
+            messageLength: input.message?.length || 0,
+            sessionId: input.sessionId
+        });
         if (context?.apiClient) {
             this.apiClient = context.apiClient;
         }
         // Resolver entity context
         const state = context_1.Runflow.getState();
-        const entityType = input.entityType || state.entityType || this.inferEntityType(input);
-        const entityValue = input.entityValue || state.entityValue || this.inferEntityValue(input);
+        const entityType = input.entityType || state.entityType || (0, agent_context_1.inferEntityType)(input, this.logger);
+        const entityValue = input.entityValue || state.entityValue || (0, agent_context_1.inferEntityValue)(input, this.logger);
         // Resolver memoryId com mesma prioridade do process()
         let memoryId = null;
         if (this.config.memory) {
@@ -938,25 +724,16 @@ Which agent should handle this? Respond with just the agent name.
         // Carregar memória se configurado
         let memoryMessages = [];
         if (this.config.memory && memoryId) {
-            memoryMessages = await this.loadMemory(memoryId);
-        }
-        // RAG automático se configurado
-        let ragContext = '';
-        if (this.config.rag?.autoSearch) {
-            const ragData = await this.performRAG(input.message);
-            if (ragData) {
-                ragContext = ragData;
-            }
+            this.logger.debug('Loading memory for streaming', { memoryId });
+            memoryMessages = await (0, agent_memory_1.loadMemory)(memoryId, this.apiClient, this.config.memory, this.traceCollector, this.logger);
         }
+        // ============================================================================
+        // RAG agora é TOOL - LLM decide quando buscar
+        // ============================================================================
+        // REMOVIDO: performRAG() automático
+        // Agora: RAG tools criadas no constructor, LLM chama quando necessário
         // Construir messages para streaming
         let messages = [];
-        // Adicionar RAG context
-        if (ragContext) {
-            messages.push({
-                role: 'system',
-                content: `Relevant context from knowledge base:\n\n${ragContext}`
-            });
-        }
         // Adicionar memory messages
         if (memoryMessages.length > 0) {
             messages.push(...memoryMessages);
@@ -984,6 +761,11 @@ Which agent should handle this? Respond with just the agent name.
         });
         // Criar async generator
         const self = this;
+        const logger = this.logger;
+        const apiClient = this.apiClient;
+        const memoryConfig = this.config.memory;
+        const modelConfig = this.config.model;
+        const traceCollector = this.traceCollector;
         return (async function* () {
             let fullResponse = '';
             for await (const chunk of stream) {
@@ -993,13 +775,18 @@ Which agent should handle this? Respond with just the agent name.
                 }
                 else if (chunk.type === 'done') {
                     // Salvar na memória quando streaming terminar
-                    if (self.config.memory && memoryId) {
-                        await self.saveToMemory(memoryId, input.message, fullResponse);
+                    if (memoryConfig && memoryId && apiClient) {
+                        logger.debug('Saving stream response to memory', { memoryId });
+                        await (0, agent_memory_1.saveToMemory)(memoryId, input.message, fullResponse, apiClient, memoryConfig, modelConfig, traceCollector, logger);
                     }
+                    logger.info('Stream processing completed', {
+                        responseLength: fullResponse.length
+                    });
                     yield { text: '', done: true };
                     break;
                 }
                 else if (chunk.type === 'error') {
+                    logger.error('Streaming error', { error: chunk.error });
                     throw new Error(chunk.error || 'Streaming error');
                 }
             }