protoagent 0.0.3 → 0.0.4

package/dist/agentic-loop.js

@@ -5,6 +5,7 @@ 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();
@@ -70,7 +71,13 @@ export class AgenticLoop {
                 role: 'user',
                 content: userInput
             });
-            logger.consoleLog('🤔 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',
@@ -143,84 +150,103 @@ export class AgenticLoop {
                     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;
-                            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);
+                    // 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;
-                            logger.trace('🔧 Tool calls detected in delta', {
+                            chunkCount++;
+                            const delta = chunk.choices[0]?.delta;
+                            logger.trace('📦 Processing chunk', {
                                 component: 'AgenticLoop',
-                                toolCallsCount: delta.tool_calls.length
+                                chunkNumber: chunkCount,
+                                hasContent: !!delta?.content,
+                                hasToolCalls: !!delta?.tool_calls,
+                                finishReason: chunk.choices[0]?.finish_reason
                             });
-                            // Initialize tool_calls array if not exists
-                            if (!assistantMessage.tool_calls) {
-                                assistantMessage.tool_calls = [];
-                            }
-                            // Handle tool calls in streaming
-                            for (const toolCallDelta of delta.tool_calls) {
-                                const index = toolCallDelta.index || 0;
-                                logger.trace('🛠️  Processing tool call delta', {
+                            if (chunk.usage) {
+                                actualUsage = chunk.usage;
+                                logger.trace('📊 Received usage data', {
                                     component: 'AgenticLoop',
-                                    index,
-                                    hasId: !!toolCallDelta.id,
-                                    hasName: !!toolCallDelta.function?.name,
-                                    hasArgs: !!toolCallDelta.function?.arguments
+                                    promptTokens: chunk.usage.prompt_tokens,
+                                    completionTokens: chunk.usage.completion_tokens,
+                                    totalTokens: chunk.usage.total_tokens
                                 });
-                                // 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');
                     }
-                    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', {
@@ -299,65 +325,79 @@ export class AgenticLoop {
                         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;
-                            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', {
+                        // 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,
-                                    executionTime,
-                                    resultLength: result.length
-                                });
-                                // Add tool result to conversation
-                                this.addMessage({
-                                    role: 'tool',
-                                    tool_call_id: toolCall.id,
-                                    content: result
+                                    toolId: toolCall.id,
+                                    argsLength: args.length
                                 });
-                                // 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)`);
+                                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 {
-                                    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);
+                                    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);
-                                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}`
-                                });
-                            }
+                        }
+                        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', {
@@ -426,6 +466,15 @@ export class AgenticLoop {
                     }
                 }
                 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
                     logger.trace('❌ API Error occurred - stopping agentic loop', {
                         component: 'AgenticLoop',
@@ -474,6 +523,15 @@ export class AgenticLoop {
             }
         }
         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');
             logger.error('\n❌ General processing error displayed to user', {

package/dist/config/client.js

@@ -2,7 +2,7 @@
  * OpenAI client manager for ProtoAgent
  */
 import OpenAI from 'openai';
-import { geminiProvider, cerebrasProvider, getModelConfig } from './providers.js';
+import { geminiProvider, cerebrasProvider, anthropicProvider, getModelConfig } from './providers.js';
 import { estimateTokens, getContextInfo } from '../utils/cost-tracker.js';
 import { logger } from '../utils/logger.js';
 /**
@@ -40,6 +40,16 @@ export function createOpenAIClient(config) {
             baseURL: cerebrasProvider.baseURL
         });
     }
+    if (config.provider === 'anthropic') {
+        logger.debug('🔑 Using Anthropic provider', {
+            component: 'OpenAIClient',
+            baseURL: anthropicProvider.baseURL
+        });
+        return new OpenAI({
+            apiKey: config.credentials.ANTHROPIC_API_KEY,
+            baseURL: anthropicProvider.baseURL
+        });
+    }
     logger.error('❌ Unknown provider', {
         component: 'OpenAIClient',
         provider: config.provider

package/dist/config/commands.js

@@ -4,7 +4,7 @@
 import inquirer from 'inquirer';
 import { hasConfig, loadConfig, saveConfig, getConfigDirectory } from './manager.js';
 import { setupConfig } from './setup.js';
-import { openaiProvider, geminiProvider, cerebrasProvider } from './providers.js';
+import { openaiProvider, geminiProvider, cerebrasProvider, anthropicProvider } from './providers.js';
 import fs from 'fs/promises';
 import path from 'path';
 import { logger } from '../utils/logger.js';
@@ -46,6 +46,9 @@ export async function showCurrentConfig() {
         else if (config.provider === 'cerebras' && config.credentials.CEREBRAS_API_KEY) {
             logger.consoleLog(`API Key: ${maskApiKey(config.credentials.CEREBRAS_API_KEY)}`);
         }
+        else if (config.provider === 'anthropic' && config.credentials.ANTHROPIC_API_KEY) {
+            logger.consoleLog(`API Key: ${maskApiKey(config.credentials.ANTHROPIC_API_KEY)}`);
+        }
         logger.consoleLog(`Config Location: ${configDir}/config.json`);
         logger.consoleLog('─'.repeat(40));
     }
@@ -84,6 +87,11 @@ export async function updateApiKey() {
             helpUrl = 'https://cloud.cerebras.ai/platform';
             keyPrefix = '';
         }
+        else if (config.provider === 'anthropic') {
+            currentKey = config.credentials.ANTHROPIC_API_KEY || '';
+            helpUrl = 'https://console.anthropic.com/settings/keys';
+            keyPrefix = 'sk-';
+        }
         logger.consoleLog(`Current API Key: ${maskApiKey(currentKey)}`);
         logger.consoleLog(`Get your API key from: ${helpUrl}\n`);
         const { newApiKey } = await inquirer.prompt([
@@ -113,6 +121,9 @@ export async function updateApiKey() {
         else if (config.provider === 'cerebras') {
             config.credentials.CEREBRAS_API_KEY = newApiKey.trim();
         }
+        else if (config.provider === 'anthropic') {
+            config.credentials.ANTHROPIC_API_KEY = newApiKey.trim();
+        }
         await saveConfig(config);
         logger.consoleLog('\n✅ API key updated successfully!');
         logger.consoleLog(`New API Key: ${maskApiKey(newApiKey)}`);
@@ -145,6 +156,9 @@ export async function updateModel() {
         else if (config.provider === 'cerebras') {
             availableModels = cerebrasProvider.models;
         }
+        else if (config.provider === 'anthropic') {
+            availableModels = anthropicProvider.models;
+        }
         const { newModel } = await inquirer.prompt([
             {
                 type: 'list',

package/dist/config/providers.js

@@ -153,6 +153,63 @@ export const cerebrasProvider = {
     },
     baseURL: 'https://api.cerebras.ai/v1'
 };
+export const anthropicModels = {
+    models: [
+        'claude-3-5-sonnet-4-20250126',
+        'claude-3-5-sonnet-20241022',
+        'claude-3-5-haiku-20241022',
+        'claude-3-opus-20240229',
+        'claude-3-sonnet-20240229',
+        'claude-3-haiku-20240307'
+    ],
+    defaultModel: 'claude-3-5-sonnet-4-20250126'
+};
+export const anthropicModelConfigs = {
+    'claude-3-5-sonnet-4-20250126': {
+        name: 'Claude 3.5 Sonnet 4',
+        contextWindow: 200000,
+        pricing: { inputTokens: 0.000003, outputTokens: 0.000015 } // $3.00/$15.00 per 1M tokens
+    },
+    'claude-3-5-sonnet-20241022': {
+        name: 'Claude 3.5 Sonnet',
+        contextWindow: 200000,
+        pricing: { inputTokens: 0.000003, outputTokens: 0.000015 } // $3.00/$15.00 per 1M tokens
+    },
+    'claude-3-5-haiku-20241022': {
+        name: 'Claude 3.5 Haiku',
+        contextWindow: 200000,
+        pricing: { inputTokens: 0.0000008, outputTokens: 0.000004 } // $0.80/$4.00 per 1M tokens
+    },
+    'claude-3-opus-20240229': {
+        name: 'Claude 3 Opus',
+        contextWindow: 200000,
+        pricing: { inputTokens: 0.000015, outputTokens: 0.000075 } // $15.00/$75.00 per 1M tokens
+    },
+    'claude-3-sonnet-20240229': {
+        name: 'Claude 3 Sonnet',
+        contextWindow: 200000,
+        pricing: { inputTokens: 0.000003, outputTokens: 0.000015 } // $3.00/$15.00 per 1M tokens
+    },
+    'claude-3-haiku-20240307': {
+        name: 'Claude 3 Haiku',
+        contextWindow: 200000,
+        pricing: { inputTokens: 0.00000025, outputTokens: 0.00000125 } // $0.25/$1.25 per 1M tokens
+    }
+};
+export const anthropicProvider = {
+    id: 'anthropic',
+    name: 'Anthropic',
+    models: anthropicModels.models,
+    defaultModel: anthropicModels.defaultModel,
+    modelConfigs: anthropicModelConfigs,
+    auth: {
+        type: 'api_key',
+        envVar: 'ANTHROPIC_API_KEY',
+        label: 'Anthropic API Key',
+        helpUrl: 'https://console.anthropic.com/settings/keys'
+    },
+    baseURL: 'https://api.anthropic.com/v1'
+};
 /**
  * Get model configuration for any provider
  */
@@ -164,6 +221,8 @@ export function getModelConfig(provider, model) {
             return geminiModelConfigs[model] || null;
         case 'cerebras':
             return cerebrasModelConfigs[model] || null;
+        case 'anthropic':
+            return anthropicModelConfigs[model] || null;
         default:
             return null;
     }

package/dist/config/setup.js

@@ -2,7 +2,7 @@
  * Interactive configuration setup for ProtoAgent
  */
 import inquirer from 'inquirer';
-import { openaiProvider, geminiProvider, cerebrasProvider } from './providers.js';
+import { openaiProvider, geminiProvider, cerebrasProvider, anthropicProvider } from './providers.js';
 import { saveConfig, getConfigDirectory } from './manager.js';
 import { logger } from '../utils/logger.js';
 /**
@@ -18,6 +18,11 @@ export async function setupConfig() {
             name: model === openaiProvider.defaultModel ? `${model} (recommended)` : model,
             value: { provider: 'openai', model }
         })),
+        new inquirer.Separator('--- Anthropic Models ---'),
+        ...anthropicProvider.models.map(model => ({
+            name: model === anthropicProvider.defaultModel ? `${model} (recommended)` : model,
+            value: { provider: 'anthropic', model }
+        })),
         new inquirer.Separator('--- Gemini Models ---'),
         ...geminiProvider.models.map(model => ({
             name: model === geminiProvider.defaultModel ? `${model} (recommended)` : model,
@@ -45,7 +50,8 @@ export async function setupConfig() {
     let credentials = {
         OPENAI_API_KEY: '',
         GEMINI_API_KEY: '',
-        CEREBRAS_API_KEY: ''
+        CEREBRAS_API_KEY: '',
+        ANTHROPIC_API_KEY: ''
     };
     if (provider === 'openai') {
         logger.consoleLog(`\n📝 ${openaiProvider.auth.label} Setup`);
@@ -71,6 +77,30 @@ export async function setupConfig() {
         apiKey = response.apiKey;
         credentials.OPENAI_API_KEY = apiKey;
     }
+    else if (provider === 'anthropic') {
+        logger.consoleLog(`\n📝 ${anthropicProvider.auth.label} Setup`);
+        logger.consoleLog("You'll need an API key from Anthropic.");
+        logger.consoleLog(`Get your API key from: ${anthropicProvider.auth.helpUrl}`);
+        const response = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'apiKey',
+                message: `Enter your ${anthropicProvider.auth.label}:`,
+                mask: '*',
+                validate: (input) => {
+                    if (!input || input.trim().length === 0) {
+                        return 'API key is required';
+                    }
+                    if (!input.trim().startsWith('sk-')) {
+                        return 'Anthropic API keys should start with "sk-"';
+                    }
+                    return true;
+                }
+            }
+        ]);
+        apiKey = response.apiKey;
+        credentials.ANTHROPIC_API_KEY = apiKey;
+    }
     else if (provider === 'gemini') {
         logger.consoleLog(`\n📝 ${geminiProvider.auth.label} Setup`);
         logger.consoleLog("You'll need an API key from Gemini.");
@@ -121,6 +151,9 @@ export async function setupConfig() {
     if (provider === 'openai') {
         providerName = openaiProvider.name;
     }
+    else if (provider === 'anthropic') {
+        providerName = anthropicProvider.name;
+    }
     else if (provider === 'gemini') {
         providerName = geminiProvider.name;
     }