protoagent 0.0.1 → 0.0.3

package/dist/agentic-loop.js

@@ -4,6 +4,7 @@ import { generateSystemPrompt } from './config/system-prompt.js';
 import { getModelConfig } from './config/providers.js';
 import { estimateTokens, createUsageInfo, logUsageInfo, getContextInfo } from './utils/cost-tracker.js';
 import { checkAndCompactIfNeeded } from './utils/conversation-compactor.js';
+import { logger } from './utils/logger.js';
 // Create system message for ProtoAgent dynamically
 async function createSystemMessage() {
     const systemPrompt = await generateSystemPrompt();
@@ -27,8 +28,13 @@ export class AgenticLoop {
      * Initialize the agentic loop with dynamic system message
      */
     async initialize() {
+        logger.debug('🚀 Initializing agentic loop', { component: 'AgenticLoop' });
         this.systemMessage = await createSystemMessage();
         this.messages = [this.systemMessage];
+        logger.debug('✅ Agentic loop initialized', {
+            component: 'AgenticLoop',
+            systemMessageLength: this.systemMessage.content?.toString().length || 0
+        });
     }
     /**
      * Get the current conversation history
@@ -52,28 +58,67 @@ export class AgenticLoop {
      * Process a user input and run the agentic loop
      */
     async processUserInput(userInput) {
+        logger.debug('📥 Processing user input', {
+            component: 'AgenticLoop',
+            inputLength: userInput.length,
+            currentMessageCount: this.messages.length
+        });
         try {
             // Add user message to conversation history
+            logger.debug('➕ Adding user message to conversation', { component: 'AgenticLoop' });
             this.addMessage({
                 role: 'user',
                 content: userInput
             });
-            console.log('🤔 Thinking...');
+            logger.consoleLog('🤔 Thinking...');
+            logger.info('🤔 AI thinking process started');
+            logger.debug('🧠 Starting thinking process', {
+                component: 'AgenticLoop',
+                totalMessages: this.messages.length,
+                maxIterations: this.options.maxIterations
+            });
             // Start the agentic loop
             let continueProcessing = true;
             let iterationCount = 0;
             while (continueProcessing && iterationCount < this.options.maxIterations) {
                 iterationCount++;
+                logger.trace(`🔄 Starting agentic loop iteration ${iterationCount}/${this.options.maxIterations}`, {
+                    component: 'AgenticLoop',
+                    iteration: iterationCount,
+                    messageCount: this.messages.length,
+                    conversationTokensApprox: this.messages.reduce((sum, msg) => sum + (typeof msg.content === 'string' ? msg.content.length / 4 : 0), 0)
+                });
                 try {
                     // Check if conversation needs compaction before making API call
+                    logger.debug('🔍 Checking context window usage', { component: 'AgenticLoop', iteration: iterationCount });
                     const modelConfig = getModelConfig(this.config.provider, this.config.model);
                     if (modelConfig) {
                         const contextInfo = getContextInfo(this.messages, modelConfig);
+                        logger.debug('📊 Context analysis complete', {
+                            component: 'AgenticLoop',
+                            currentTokens: contextInfo.currentTokens,
+                            maxTokens: modelConfig.contextWindow,
+                            needsCompaction: contextInfo.needsCompaction,
+                            percentageUsed: ((contextInfo.currentTokens / modelConfig.contextWindow) * 100).toFixed(1)
+                        });
                         if (contextInfo.needsCompaction) {
-                            console.log('\n🗜️  Context window approaching limit, compacting conversation...');
+                            logger.consoleLog('\n🗜️  Context window approaching limit, compacting conversation...');
+                            logger.info('🗜️  Context compaction message displayed to user');
+                            logger.debug('🗜️  Starting conversation compaction', { component: 'AgenticLoop' });
                             this.messages = await checkAndCompactIfNeeded(this.openaiClient, this.config.model, this.messages, modelConfig.contextWindow, contextInfo.currentTokens);
+                            logger.debug('✅ Conversation compaction complete', {
+                                component: 'AgenticLoop',
+                                newMessageCount: this.messages.length
+                            });
                         }
                     }
+                    logger.debug('🌐 Creating chat completion request', {
+                        component: 'AgenticLoop',
+                        model: this.config.model,
+                        messageCount: this.messages.length,
+                        toolsCount: tools.length,
+                        streaming: true
+                    });
                     // Create completion using OpenAI with built-in retry logic and cost tracking
                     const { stream, estimatedInputTokens } = await createChatCompletion(this.openaiClient, {
                         model: this.config.model,
@@ -82,7 +127,13 @@ export class AgenticLoop {
                         tool_choice: 'auto',
                         stream: true
                     }, this.config, this.messages);
+                    logger.debug('📡 Chat completion stream created', {
+                        component: 'AgenticLoop',
+                        estimatedInputTokens,
+                        iteration: iterationCount
+                    });
                     // Collect the streamed response
+                    logger.trace('📨 Starting to collect streamed response', { component: 'AgenticLoop' });
                     let assistantMessage = {
                         role: 'assistant',
                         content: '',
@@ -91,10 +142,25 @@ export class AgenticLoop {
                     let streamedContent = '';
                     let hasToolCalls = false;
                     let actualUsage = undefined;
+                    let chunkCount = 0;
                     for await (const chunk of stream) {
+                        chunkCount++;
                         const delta = chunk.choices[0]?.delta;
+                        logger.trace('📦 Processing chunk', {
+                            component: 'AgenticLoop',
+                            chunkNumber: chunkCount,
+                            hasContent: !!delta?.content,
+                            hasToolCalls: !!delta?.tool_calls,
+                            finishReason: chunk.choices[0]?.finish_reason
+                        });
                         if (chunk.usage) {
                             actualUsage = chunk.usage;
+                            logger.trace('📊 Received usage data', {
+                                component: 'AgenticLoop',
+                                promptTokens: chunk.usage.prompt_tokens,
+                                completionTokens: chunk.usage.completion_tokens,
+                                totalTokens: chunk.usage.total_tokens
+                            });
                         }
                         if (delta?.content) {
                             streamedContent += delta.content;
@@ -103,13 +169,17 @@ export class AgenticLoop {
                             if (this.options.streamOutput && !hasToolCalls && !delta.tool_calls) {
                                 if (streamedContent === delta.content) {
                                     // First content chunk
-                                    process.stdout.write('\\n🤖 ProtoAgent: ');
+                                    process.stdout.write('\n🤖 ProtoAgent: ');
                                 }
                                 process.stdout.write(delta.content);
                             }
                         }
                         if (delta?.tool_calls) {
                             hasToolCalls = true;
+                            logger.trace('🔧 Tool calls detected in delta', {
+                                component: 'AgenticLoop',
+                                toolCallsCount: delta.tool_calls.length
+                            });
                             // Initialize tool_calls array if not exists
                             if (!assistantMessage.tool_calls) {
                                 assistantMessage.tool_calls = [];
@@ -117,6 +187,13 @@ export class AgenticLoop {
                             // Handle tool calls in streaming
                             for (const toolCallDelta of delta.tool_calls) {
                                 const index = toolCallDelta.index || 0;
+                                logger.trace('🛠️  Processing tool call delta', {
+                                    component: 'AgenticLoop',
+                                    index,
+                                    hasId: !!toolCallDelta.id,
+                                    hasName: !!toolCallDelta.function?.name,
+                                    hasArgs: !!toolCallDelta.function?.arguments
+                                });
                                 // Ensure we have an entry at this index
                                 if (!assistantMessage.tool_calls[index]) {
                                     assistantMessage.tool_calls[index] = {
@@ -137,7 +214,63 @@ export class AgenticLoop {
                             }
                         }
                     }
+                    logger.debug('✅ Stream processing complete', {
+                        component: 'AgenticLoop',
+                        totalChunks: chunkCount,
+                        finalContentLength: streamedContent.length,
+                        finalToolCallsCount: assistantMessage.tool_calls?.length || 0,
+                        hasActualUsage: !!actualUsage
+                    });
                     const message = assistantMessage;
+                    // DEBUG: Log the complete AI response
+                    logger.debug('🤖 AI Response received', {
+                        component: 'AgenticLoop',
+                        iteration: iterationCount,
+                        responseType: message.tool_calls?.length > 0 ? 'TOOL_CALLS' : 'TEXT_RESPONSE',
+                        contentLength: message.content?.length || 0,
+                        contentPreview: message.content ? message.content.substring(0, 200) + (message.content.length > 200 ? '...' : '') : null,
+                        rawMessage: JSON.stringify(message),
+                        toolCallsCount: message.tool_calls?.length || 0,
+                        toolNames: message.tool_calls?.map((tc) => tc.function.name) || [],
+                        toolCallsDetails: message.tool_calls?.map((tc) => ({
+                            id: tc.id,
+                            name: tc.function.name,
+                            argsLength: tc.function.arguments?.length || 0,
+                            argsPreview: tc.function.arguments ? tc.function.arguments.substring(0, 100) + (tc.function.arguments.length > 100 ? '...' : '') : null
+                        })) || []
+                    });
+                    // TRACE: Log the AI's decision after thinking
+                    logger.trace('🧠 AI thinking complete - analyzing response...', {
+                        component: 'AgenticLoop',
+                        iteration: iterationCount,
+                        hasToolCalls: !!(message.tool_calls && message.tool_calls.length > 0),
+                        hasContent: !!(message.content && message.content.trim().length > 0),
+                        toolCount: message.tool_calls?.length || 0,
+                        contentLength: message.content?.length || 0
+                    });
+                    if (message.tool_calls && message.tool_calls.length > 0) {
+                        logger.trace('🔧 AI decided to use tools', {
+                            component: 'AgenticLoop',
+                            decision: 'TOOL_CALLS',
+                            tools: message.tool_calls.map((tc) => tc.function.name).join(', '),
+                            reasoning: 'AI determined that tool usage is needed to complete the task'
+                        });
+                    }
+                    else if (message.content && message.content.trim().length > 0) {
+                        logger.trace('💬 AI decided to provide direct response', {
+                            component: 'AgenticLoop',
+                            decision: 'DIRECT_RESPONSE',
+                            responsePreview: message.content.slice(0, 100) + (message.content.length > 100 ? '...' : ''),
+                            reasoning: 'AI determined that a direct text response is sufficient'
+                        });
+                    }
+                    else {
+                        logger.trace('⚠️ AI provided empty response', {
+                            component: 'AgenticLoop',
+                            decision: 'EMPTY_RESPONSE',
+                            reasoning: 'AI returned neither tool calls nor content - this may indicate an issue'
+                        });
+                    }
                     // Calculate and log cost information
                     if (modelConfig) {
                         const finalInputTokens = actualUsage?.prompt_tokens ?? estimatedInputTokens;
@@ -148,16 +281,50 @@ export class AgenticLoop {
                     }
                     // Check if AI wants to use tools
                     if (message.tool_calls && message.tool_calls.length > 0) {
+                        logger.debug('🔧 AI requested tool usage', {
+                            component: 'AgenticLoop',
+                            toolCount: message.tool_calls.length,
+                            toolNames: message.tool_calls.map((tc) => tc.function.name)
+                        });
                         // Add the AI's message (with tool calls) to conversation
                         this.addMessage(message);
-                        console.log(`🔧 Using ${message.tool_calls.length} tool(s)...`);
+                        logger.debug('➕ AI message with tool calls added to conversation', {
+                            component: 'AgenticLoop',
+                            messageRole: 'assistant',
+                            hasContent: !!message.content,
+                            contentLength: message.content?.length || 0,
+                            toolCallsCount: message.tool_calls?.length || 0,
+                            conversationLength: this.messages.length
+                        });
+                        logger.consoleLog(`🔧 Using ${message.tool_calls.length} tool(s)...`);
+                        logger.info(`🔧 Tool usage message displayed: ${message.tool_calls.length} tools`);
                         // Execute each tool call
                         for (const toolCall of message.tool_calls) {
                             const { name, arguments: args } = toolCall.function;
-                            console.log(`🛠️  ${name}`);
+                            logger.debug('🛠️  Executing tool', {
+                                component: 'AgenticLoop',
+                                toolName: name,
+                                toolId: toolCall.id,
+                                argsLength: args.length
+                            });
+                            logger.consoleLog(`🛠️  ${name}`);
+                            logger.info(`🛠️  Tool execution message displayed: ${name}`);
                             try {
                                 const toolArgs = JSON.parse(args);
+                                logger.debug('📋 Tool arguments parsed', {
+                                    component: 'AgenticLoop',
+                                    toolName: name,
+                                    parsedArgs: Object.keys(toolArgs)
+                                });
+                                const startTime = Date.now();
                                 const result = await handleToolCall(name, toolArgs);
+                                const executionTime = Date.now() - startTime;
+                                logger.debug('✅ Tool execution successful', {
+                                    component: 'AgenticLoop',
+                                    toolName: name,
+                                    executionTime,
+                                    resultLength: result.length
+                                });
                                 // Add tool result to conversation
                                 this.addMessage({
                                     role: 'tool',
@@ -165,17 +332,25 @@ export class AgenticLoop {
                                     content: result
                                 });
                                 // Show abbreviated result to user
-                                const lines = result.split('\\n');
+                                const lines = result.split('\n');
                                 if (lines.length > 10) {
-                                    console.log(`   ✅ ${lines.slice(0, 3).join('\\n   ')}\\n   ... (${lines.length - 6} more lines) ...\\n   ${lines.slice(-3).join('\\n   ')}`);
+                                    logger.consoleLog(`   ✅ ${lines.slice(0, 3).join('\n   ')}\n   ... (${lines.length - 6} more lines) ...\n   ${lines.slice(-3).join('\n   ')}`);
+                                    logger.info(`   ✅ Tool result displayed (abbreviated, ${lines.length} lines)`);
                                 }
                                 else {
-                                    console.log(`   ✅ ${result.slice(0, 200)}${result.length > 200 ? '...' : ''}`);
+                                    logger.consoleLog(`   ✅ ${result.slice(0, 200)}${result.length > 200 ? '...' : ''}`);
+                                    logger.info(`   ✅ Tool result displayed (full, ${result.length} chars)`);
                                 }
                             }
                             catch (error) {
                                 const errorMessage = error instanceof Error ? error.message : String(error);
-                                console.log(`   ❌ Error: ${errorMessage}`);
+                                logger.error('❌ Tool execution failed', {
+                                    component: 'AgenticLoop',
+                                    toolName: name,
+                                    error: errorMessage
+                                });
+                                logger.consoleLog(`   ❌ Error: ${errorMessage}`);
+                                logger.error(`   ❌ Tool error message displayed: ${errorMessage}`);
                                 // Add error result to conversation
                                 this.addMessage({
                                     role: 'tool',
@@ -185,6 +360,12 @@ export class AgenticLoop {
                             }
                         }
                         // Continue the loop to let AI process tool results
+                        logger.trace('🔄 Continuing agentic loop for AI to process tool results', {
+                            component: 'AgenticLoop',
+                            decision: 'CONTINUE_PROCESSING',
+                            reasoning: 'Tools were executed, AI needs another thinking cycle to process results',
+                            nextIteration: iterationCount + 1
+                        });
                         continue;
                     }
                     else {
@@ -192,78 +373,130 @@ export class AgenticLoop {
                         if (message.content && !hasToolCalls) {
                             // Content was already streamed to user during the loop above
                             if (this.options.streamOutput) {
-                                console.log('\\n'); // Add newline after streaming is complete
+                                logger.consoleLog('\n'); // Add newline after streaming is complete
+                                logger.debug('\\n AI response streaming completed');
                             }
                             else {
-                                console.log(`\\n🤖 ProtoAgent: ${message.content}\\n`);
+                                logger.consoleLog(`\n🤖 ProtoAgent: ${message.content}\n`);
+                                logger.info('🤖 AI response displayed to user (non-streaming)');
                             }
                             // Add AI response to conversation history
                             this.addMessage({
                                 role: 'assistant',
                                 content: message.content
                             });
+                            logger.debug('➕ AI text response added to conversation', {
+                                component: 'AgenticLoop',
+                                messageRole: 'assistant',
+                                contentLength: message.content?.length || 0,
+                                conversationLength: this.messages.length
+                            });
                         }
                         else if (message.content && hasToolCalls) {
                             // AI provided content along with tool calls (rare case)
                             if (this.options.streamOutput) {
-                                process.stdout.write('\\n🤖 ProtoAgent: ');
+                                process.stdout.write('\n🤖 ProtoAgent: ');
                                 process.stdout.write(message.content);
-                                console.log('\\n');
+                                logger.consoleLog('\n');
+                                logger.info('🤖 AI response with tool calls displayed (streaming)');
                             }
                             else {
-                                console.log(`\\n🤖 ProtoAgent: ${message.content}\\n`);
+                                logger.consoleLog(`\n🤖 ProtoAgent: ${message.content}\n`);
+                                logger.info('🤖 AI response with tool calls displayed (non-streaming)');
                             }
                             // Add AI response to conversation history
                             this.addMessage({
                                 role: 'assistant',
                                 content: message.content
                             });
+                            logger.debug('➕ AI mixed response (content + tool calls) added to conversation', {
+                                component: 'AgenticLoop',
+                                messageRole: 'assistant',
+                                contentLength: message.content?.length || 0,
+                                conversationLength: this.messages.length
+                            });
                         }
+                        logger.trace('✅ Agentic loop complete - stopping processing', {
+                            component: 'AgenticLoop',
+                            decision: 'STOP_PROCESSING',
+                            reasoning: 'AI provided final response without tool calls',
+                            totalIterations: iterationCount
+                        });
                         continueProcessing = false;
                     }
                 }
                 catch (apiError) {
                     // Handle API errors that weren't caught by the retry logic
-                    console.error('\\n❌ API Error:', apiError?.message || 'Unknown API error');
+                    logger.trace('❌ API Error occurred - stopping agentic loop', {
+                        component: 'AgenticLoop',
+                        decision: 'STOP_ON_API_ERROR',
+                        errorStatus: apiError?.status,
+                        errorMessage: apiError?.message,
+                        reasoning: 'Unrecoverable API error encountered'
+                    });
+                    console.error('\n❌ API Error:', apiError?.message || 'Unknown API error');
+                    logger.error('\n❌ API Error message displayed to user', {
+                        component: 'AgenticLoop',
+                        error: apiError?.message || 'Unknown API error'
+                    });
                     // Check for specific error types and provide helpful messages
                     if (apiError?.status === 401) {
-                        console.log('💡 Authentication failed. Your API key may be invalid or expired.');
-                        console.log('   Run: protoagent config --update-key');
+                        logger.consoleLog('💡 Authentication failed. Your API key may be invalid or expired.');
+                        logger.consoleLog('   Run: protoagent config --update-key');
+                        logger.info('💡 Auth error help message displayed to user');
                     }
                     else if (apiError?.status === 403) {
-                        console.log('💡 Access forbidden. Check your API key permissions or billing status.');
+                        logger.consoleLog('💡 Access forbidden. Check your API key permissions or billing status.');
+                        logger.info('💡 Access forbidden help message displayed to user');
                     }
                     else if (apiError?.status === 400) {
-                        console.log('💡 Bad request. There may be an issue with the request format.');
-                        console.log('   This could be a bug in ProtoAgent. Please check for updates.');
+                        logger.consoleLog('💡 Bad request. There may be an issue with the request format.');
+                        logger.consoleLog('   This could be a bug in ProtoAgent. Please check for updates.');
+                        logger.info('💡 Bad request help message displayed to user');
                     }
                     else {
-                        console.log('💡 An unexpected API error occurred. Please try again.');
+                        logger.consoleLog('💡 An unexpected API error occurred. Please try again.');
+                        logger.info('💡 Generic API error help message displayed to user');
                     }
                     // Exit the processing loop for API errors
                     break;
                 }
             }
             if (iterationCount >= this.options.maxIterations) {
-                console.log('\\n⚠️  Maximum iteration limit reached. Task may be incomplete.');
+                logger.trace('⚠️ Maximum iteration limit reached - stopping agentic loop', {
+                    component: 'AgenticLoop',
+                    decision: 'STOP_ON_MAX_ITERATIONS',
+                    maxIterations: this.options.maxIterations,
+                    reasoning: 'Reached maximum allowed iterations to prevent infinite loops'
+                });
+                logger.consoleLog('\n⚠️  Maximum iteration limit reached. Task may be incomplete.');
+                logger.warn('⚠️  Max iteration warning displayed to user');
             }
         }
         catch (error) {
             // Handle general processing errors
-            console.error('\\n❌ Error during processing:', error?.message || 'Unknown error');
+            console.error('\n❌ Error during processing:', error?.message || 'Unknown error');
+            logger.error('\n❌ General processing error displayed to user', {
+                component: 'AgenticLoop',
+                error: error?.message || 'Unknown error'
+            });
             // Provide helpful error messages for common issues
             if (error?.message?.includes('API key')) {
-                console.log('💡 There seems to be an issue with your API key configuration.');
-                console.log('   Run: protoagent config --show');
+                logger.consoleLog('💡 There seems to be an issue with your API key configuration.');
+                logger.consoleLog('   Run: protoagent config --show');
+                logger.info('💡 API key error help message displayed');
             }
             else if (error?.message?.includes('model')) {
-                console.log('💡 There seems to be an issue with the selected model.');
-                console.log('   Run: protoagent config --update-model');
+                logger.consoleLog('💡 There seems to be an issue with the selected model.');
+                logger.consoleLog('   Run: protoagent config --update-model');
+                logger.info('💡 Model error help message displayed');
             }
             else {
-                console.log('💡 An unexpected error occurred. Please check your configuration and try again.');
+                logger.consoleLog('💡 An unexpected error occurred. Please check your configuration and try again.');
+                logger.info('💡 Generic error help message displayed');
             }
-            console.log('\\n🤖 ProtoAgent: I encountered an error and cannot continue processing this request.\\n');
+            logger.consoleLog('\n🤖 ProtoAgent: I encountered an error and cannot continue processing this request.\n');
+            logger.info('🤖 Error termination message displayed to user');
         }
     }
 }