protoagent 0.0.2 → 0.0.4

package/dist/agentic-loop.js

@@ -4,6 +4,8 @@ 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';
+import { interruptHandler, UserInterruptError } from './utils/interrupt-handler.js';
 // Create system message for ProtoAgent dynamically
 async function createSystemMessage() {
     const systemPrompt = await generateSystemPrompt();
@@ -27,8 +29,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 +59,73 @@ 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...');
+            // Show a subtle hint about Q key on first use (only if this is the first interaction)
+            if (this.messages.length === 2) { // System message + first user message
+                logger.consoleLog('🤔 Thinking... (press Q to pause)');
+            }
+            else {
+                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 +134,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,53 +149,154 @@ export class AgenticLoop {
                     let streamedContent = '';
                     let hasToolCalls = false;
                     let actualUsage = undefined;
-                    for await (const chunk of stream) {
-                        const delta = chunk.choices[0]?.delta;
-                        if (chunk.usage) {
-                            actualUsage = chunk.usage;
-                        }
-                        if (delta?.content) {
-                            streamedContent += delta.content;
-                            assistantMessage.content = streamedContent;
-                            // Stream content to user in real-time if no tool calls are being made
-                            if (this.options.streamOutput && !hasToolCalls && !delta.tool_calls) {
-                                if (streamedContent === delta.content) {
-                                    // First content chunk
-                                    process.stdout.write('\\n🤖 ProtoAgent: ');
-                                }
-                                process.stdout.write(delta.content);
+                    let chunkCount = 0;
+                    // Start listening for 'Q' key interrupts during streaming
+                    interruptHandler.startListening();
+                    try {
+                        for await (const chunk of stream) {
+                            // Check for user interrupt
+                            if (interruptHandler.isInterrupted()) {
+                                logger.debug('User requested pause during streaming', { component: 'AgenticLoop' });
+                                break;
                             }
-                        }
-                        if (delta?.tool_calls) {
-                            hasToolCalls = true;
-                            // Initialize tool_calls array if not exists
-                            if (!assistantMessage.tool_calls) {
-                                assistantMessage.tool_calls = [];
+                            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
+                                });
                             }
-                            // Handle tool calls in streaming
-                            for (const toolCallDelta of delta.tool_calls) {
-                                const index = toolCallDelta.index || 0;
-                                // Ensure we have an entry at this index
-                                if (!assistantMessage.tool_calls[index]) {
-                                    assistantMessage.tool_calls[index] = {
-                                        id: '',
-                                        type: 'function',
-                                        function: { name: '', arguments: '' }
-                                    };
-                                }
-                                if (toolCallDelta.id) {
-                                    assistantMessage.tool_calls[index].id = toolCallDelta.id;
+                            if (delta?.content) {
+                                streamedContent += delta.content;
+                                assistantMessage.content = streamedContent;
+                                // Stream content to user in real-time if no tool calls are being made
+                                if (this.options.streamOutput && !hasToolCalls && !delta.tool_calls) {
+                                    if (streamedContent === delta.content) {
+                                        // First content chunk
+                                        process.stdout.write('\n🤖 ProtoAgent: ');
+                                    }
+                                    process.stdout.write(delta.content);
                                 }
-                                if (toolCallDelta.function?.name) {
-                                    assistantMessage.tool_calls[index].function.name += toolCallDelta.function.name;
+                            }
+                            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 = [];
                                 }
-                                if (toolCallDelta.function?.arguments) {
-                                    assistantMessage.tool_calls[index].function.arguments += toolCallDelta.function.arguments;
+                                // 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] = {
+                                            id: '',
+                                            type: 'function',
+                                            function: { name: '', arguments: '' }
+                                        };
+                                    }
+                                    if (toolCallDelta.id) {
+                                        assistantMessage.tool_calls[index].id = toolCallDelta.id;
+                                    }
+                                    if (toolCallDelta.function?.name) {
+                                        assistantMessage.tool_calls[index].function.name += toolCallDelta.function.name;
+                                    }
+                                    if (toolCallDelta.function?.arguments) {
+                                        assistantMessage.tool_calls[index].function.arguments += toolCallDelta.function.arguments;
+                                    }
                                 }
                             }
                         }
+                        logger.debug('✅ Stream processing complete', {
+                            component: 'AgenticLoop',
+                            totalChunks: chunkCount,
+                            finalContentLength: streamedContent.length,
+                            finalToolCallsCount: assistantMessage.tool_calls?.length || 0,
+                            hasActualUsage: !!actualUsage
+                        });
+                    }
+                    finally {
+                        // Always stop listening for interrupts when streaming ends
+                        interruptHandler.stopListening();
+                    }
+                    // Check if streaming was interrupted
+                    if (interruptHandler.isInterrupted()) {
+                        logger.debug('User paused during streaming', { component: 'AgenticLoop' });
+                        interruptHandler.reset();
+                        throw new UserInterruptError('User paused during streaming');
                     }
                     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,43 +307,105 @@ 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}`);
-                            try {
-                                const toolArgs = JSON.parse(args);
-                                const result = await handleToolCall(name, toolArgs);
-                                // Add tool result to conversation
-                                this.addMessage({
-                                    role: 'tool',
-                                    tool_call_id: toolCall.id,
-                                    content: result
+                        // Start listening for interrupts during tool execution
+                        interruptHandler.startListening();
+                        try {
+                            for (const toolCall of message.tool_calls) {
+                                // Check for user interrupt before each tool
+                                if (interruptHandler.isInterrupted()) {
+                                    logger.debug('User requested pause during tool execution', { component: 'AgenticLoop' });
+                                    interruptHandler.reset();
+                                    throw new UserInterruptError('User paused during tool execution');
+                                }
+                                const { name, arguments: args } = toolCall.function;
+                                logger.debug('🛠️  Executing tool', {
+                                    component: 'AgenticLoop',
+                                    toolName: name,
+                                    toolId: toolCall.id,
+                                    argsLength: args.length
                                 });
-                                // Show abbreviated result to user
-                                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(`🛠️  ${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',
+                                        tool_call_id: toolCall.id,
+                                        content: result
+                                    });
+                                    // Show abbreviated result to user
+                                    const lines = result.split('\n');
+                                    if (lines.length > 10) {
+                                        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 {
+                                        logger.consoleLog(`   ✅ ${result.slice(0, 200)}${result.length > 200 ? '...' : ''}`);
+                                        logger.info(`   ✅ Tool result displayed (full, ${result.length} chars)`);
+                                    }
                                 }
-                                else {
-                                    console.log(`   ✅ ${result.slice(0, 200)}${result.length > 200 ? '...' : ''}`);
+                                catch (error) {
+                                    const errorMessage = error instanceof Error ? error.message : String(error);
+                                    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',
+                                        tool_call_id: toolCall.id,
+                                        content: `Error: ${errorMessage}`
+                                    });
                                 }
                             }
-                            catch (error) {
-                                const errorMessage = error instanceof Error ? error.message : String(error);
-                                console.log(`   ❌ Error: ${errorMessage}`);
-                                // Add error result to conversation
-                                this.addMessage({
-                                    role: 'tool',
-                                    tool_call_id: toolCall.id,
-                                    content: `Error: ${errorMessage}`
-                                });
-                            }
+                        }
+                        finally {
+                            // Always stop listening for interrupts when tool execution ends
+                            interruptHandler.stopListening();
                         }
                         // 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 +413,148 @@ 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) {
+                    // Check if this is a user interrupt first
+                    if (apiError instanceof UserInterruptError) {
+                        logger.warn('🛑 User pressed Q - interrupt during processing', {
+                            component: 'AgenticLoop',
+                            reason: apiError.message
+                        });
+                        console.log('\n'); // Just a clean newline
+                        return;
+                    }
                     // 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) {
+            // Check if this is a user interrupt
+            if (error instanceof UserInterruptError) {
+                logger.debug('🛑 User interrupt detected - returning control to user', {
+                    component: 'AgenticLoop',
+                    reason: error.message
+                });
+                logger.consoleLog('\n');
+                return;
+            }
             // 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');
         }
     }
 }