codeep 1.0.20 → 1.0.22

package/dist/components/Settings.js

@@ -28,7 +28,7 @@ const SETTINGS = [
         value: () => config.get('apiTimeout'),
         type: 'number',
         min: 5000,
-        max: 120000,
+        max: 300000,
         step: 5000,
     },
     {
@@ -69,6 +69,15 @@ const SETTINGS = [
             { value: 'manual', label: 'Manual' },
         ],
     },
+    {
+        key: 'agentApiTimeout',
+        label: 'Agent API Timeout (ms)',
+        value: () => config.get('agentApiTimeout'),
+        type: 'number',
+        min: 30000,
+        max: 300000,
+        step: 10000,
+    },
 ];
 export const Settings = ({ onClose, notify }) => {
     const [selected, setSelected] = useState(0);

package/dist/config/index.d.ts

@@ -37,6 +37,7 @@ interface ConfigSchema {
     agentMaxFixAttempts: number;
     agentMaxIterations: number;
     agentMaxDuration: number;
+    agentApiTimeout: number;
     projectPermissions: ProjectPermission[];
     providerApiKeys: ProviderApiKey[];
 }

package/dist/config/index.js

@@ -68,6 +68,7 @@ export const config = new Conf({
         agentMaxFixAttempts: 3,
         agentMaxIterations: 100,
         agentMaxDuration: 20, // minutes
+        agentApiTimeout: 90000, // 90 seconds base timeout for agent (dynamically adjusted)
         protocol: 'openai',
         plan: 'lite',
         language: 'en',
@@ -75,7 +76,7 @@ export const config = new Conf({
         currentSessionId: '',
         temperature: 0.7,
         maxTokens: 4096,
-        apiTimeout: 30000,
+        apiTimeout: 60000,
         rateLimitApi: 30, // 30 requests per minute
         rateLimitCommands: 100, // 100 commands per minute
         projectPermissions: [],

package/dist/utils/agent.js

@@ -1,6 +1,61 @@
 /**
  * Agent loop - autonomous task execution
  */
+/**
+ * Custom error class for timeout - allows distinguishing from user abort
+ */
+class TimeoutError extends Error {
+    constructor(message = 'Request timed out') {
+        super(message);
+        this.name = 'TimeoutError';
+    }
+}
+/**
+ * Calculate dynamic timeout based on task complexity
+ * Complex tasks (creating pages, multiple files) need more time
+ */
+function calculateDynamicTimeout(prompt, iteration, baseTimeout) {
+    const promptLower = prompt.toLowerCase();
+    // Keywords that indicate complex tasks requiring more time
+    const complexKeywords = [
+        'create', 'build', 'implement', 'generate', 'make', 'develop', 'setup',
+        'website', 'app', 'application', 'page', 'component', 'feature',
+        'kreiraj', 'napravi', 'izgradi', 'generiraj', 'razvij', 'stranica', 'aplikacija'
+    ];
+    // Keywords indicating very large tasks
+    const veryComplexKeywords = [
+        'full', 'complete', 'entire', 'whole', 'multiple', 'all',
+        'cijeli', 'kompletni', 'sve', 'višestruki'
+    ];
+    let multiplier = 1.0;
+    // Check for complex keywords
+    const hasComplexKeyword = complexKeywords.some(kw => promptLower.includes(kw));
+    if (hasComplexKeyword) {
+        multiplier = 2.0; // Double timeout for complex tasks
+    }
+    // Check for very complex keywords
+    const hasVeryComplexKeyword = veryComplexKeywords.some(kw => promptLower.includes(kw));
+    if (hasVeryComplexKeyword) {
+        multiplier = 3.0; // Triple timeout for very complex tasks
+    }
+    // Long prompts usually mean complex tasks
+    if (prompt.length > 200) {
+        multiplier = Math.max(multiplier, 2.0);
+    }
+    if (prompt.length > 500) {
+        multiplier = Math.max(multiplier, 3.0);
+    }
+    // Later iterations might need more time (context is larger)
+    if (iteration > 5) {
+        multiplier *= 1.2;
+    }
+    if (iteration > 10) {
+        multiplier *= 1.3;
+    }
+    // Minimum 60 seconds, maximum 5 minutes for a single API call
+    const calculatedTimeout = baseTimeout * multiplier;
+    return Math.min(Math.max(calculatedTimeout, 60000), 300000);
+}
 import { parseToolCalls, executeTool, createActionLog, formatToolDefinitions, getOpenAITools, getAnthropicTools, parseOpenAIToolCalls, parseAnthropicToolCalls } from './tools.js';
 import { config, getApiKey } from '../config/index.js';
 import { getProviderBaseUrl, getProviderAuthHeader, supportsNativeTools } from '../config/providers.js';
@@ -123,7 +178,7 @@ You have FULL access. Execute tasks autonomously.`;
 /**
  * Make a chat API call for agent mode with native tool support
  */
-async function agentChat(messages, systemPrompt, onChunk, abortSignal) {
+async function agentChat(messages, systemPrompt, onChunk, abortSignal, dynamicTimeout) {
     const protocol = config.get('protocol');
     const model = config.get('model');
     const apiKey = getApiKey();
@@ -139,9 +194,17 @@ async function agentChat(messages, systemPrompt, onChunk, abortSignal) {
         return await agentChatFallback(messages, systemPrompt, onChunk, abortSignal);
     }
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), config.get('apiTimeout'));
+    const timeoutMs = dynamicTimeout || config.get('apiTimeout');
+    let isTimeout = false;
+    const timeout = setTimeout(() => {
+        isTimeout = true;
+        controller.abort();
+    }, timeoutMs);
     if (abortSignal) {
-        abortSignal.addEventListener('abort', () => controller.abort());
+        abortSignal.addEventListener('abort', () => {
+            isTimeout = false; // User abort, not timeout
+            controller.abort();
+        });
     }
     const headers = {
         'Content-Type': 'application/json',
@@ -224,6 +287,14 @@ async function agentChat(messages, systemPrompt, onChunk, abortSignal) {
     }
     catch (error) {
         const err = error;
+        // Check if this was a timeout vs user abort
+        if (err.name === 'AbortError') {
+            if (isTimeout) {
+                throw new TimeoutError(`API request timed out after ${timeoutMs}ms`);
+            }
+            // User abort - rethrow as-is
+            throw error;
+        }
         // If native tools failed, try fallback
         if (err.message.includes('tools') || err.message.includes('function')) {
             return await agentChatFallback(messages, systemPrompt, onChunk, abortSignal);
@@ -237,7 +308,7 @@ async function agentChat(messages, systemPrompt, onChunk, abortSignal) {
 /**
  * Fallback chat without native tools (text-based parsing)
  */
-async function agentChatFallback(messages, systemPrompt, onChunk, abortSignal) {
+async function agentChatFallback(messages, systemPrompt, onChunk, abortSignal, dynamicTimeout) {
     const protocol = config.get('protocol');
     const model = config.get('model');
     const apiKey = getApiKey();
@@ -248,9 +319,17 @@ async function agentChatFallback(messages, systemPrompt, onChunk, abortSignal) {
         throw new Error(`Provider ${providerId} does not support ${protocol} protocol`);
     }
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), config.get('apiTimeout'));
+    const timeoutMs = dynamicTimeout || config.get('apiTimeout');
+    let isTimeout = false;
+    const timeout = setTimeout(() => {
+        isTimeout = true;
+        controller.abort();
+    }, timeoutMs);
     if (abortSignal) {
-        abortSignal.addEventListener('abort', () => controller.abort());
+        abortSignal.addEventListener('abort', () => {
+            isTimeout = false; // User abort, not timeout
+            controller.abort();
+        });
     }
     const headers = {
         'Content-Type': 'application/json',
@@ -325,6 +404,18 @@ async function agentChatFallback(messages, systemPrompt, onChunk, abortSignal) {
         const toolCalls = parseToolCalls(content);
         return { content, toolCalls, usedNativeTools: false };
     }
+    catch (error) {
+        const err = error;
+        // Check if this was a timeout vs user abort
+        if (err.name === 'AbortError') {
+            if (isTimeout) {
+                throw new TimeoutError(`API request timed out after ${timeoutMs}ms`);
+            }
+            // User abort - rethrow as-is
+            throw error;
+        }
+        throw error;
+    }
     finally {
         clearTimeout(timeout);
     }
@@ -441,6 +532,9 @@ export async function runAgent(prompt, projectContext, options = {}) {
     let iteration = 0;
     let finalResponse = '';
     let result;
+    let consecutiveTimeouts = 0;
+    const maxTimeoutRetries = 3;
+    const baseTimeout = config.get('agentApiTimeout');
     try {
         while (iteration < opts.maxIterations) {
             // Check timeout
@@ -469,24 +563,69 @@ export async function runAgent(prompt, projectContext, options = {}) {
             iteration++;
             console.error(`[DEBUG] Starting iteration ${iteration}/${opts.maxIterations}, actions: ${actions.length}`);
             opts.onIteration?.(iteration, `Iteration ${iteration}/${opts.maxIterations}`);
-            // Get AI response
+            // Calculate dynamic timeout based on task complexity
+            const dynamicTimeout = calculateDynamicTimeout(prompt, iteration, baseTimeout);
+            console.error(`[DEBUG] Using dynamic timeout: ${dynamicTimeout}ms (base: ${baseTimeout}ms, iteration: ${iteration})`);
+            // Get AI response with retry logic for timeouts
             let chatResponse;
-            try {
-                chatResponse = await agentChat(messages, systemPrompt, opts.onThinking, opts.abortSignal);
-            }
-            catch (error) {
-                const err = error;
-                if (err.name === 'AbortError') {
-                    result = {
-                        success: false,
-                        iterations: iteration,
-                        actions,
-                        finalResponse: 'Agent was stopped',
-                        aborted: true,
-                    };
-                    return result;
+            let retryCount = 0;
+            while (true) {
+                try {
+                    chatResponse = await agentChat(messages, systemPrompt, opts.onThinking, opts.abortSignal, dynamicTimeout * (1 + retryCount * 0.5) // Increase timeout on retry
+                    );
+                    consecutiveTimeouts = 0; // Reset on success
+                    break;
+                }
+                catch (error) {
+                    const err = error;
+                    // Handle user abort (not timeout)
+                    if (err.name === 'AbortError') {
+                        result = {
+                            success: false,
+                            iterations: iteration,
+                            actions,
+                            finalResponse: 'Agent was stopped by user',
+                            aborted: true,
+                        };
+                        return result;
+                    }
+                    // Handle timeout with retry
+                    if (err.name === 'TimeoutError') {
+                        retryCount++;
+                        consecutiveTimeouts++;
+                        console.error(`[DEBUG] Timeout occurred (retry ${retryCount}/${maxTimeoutRetries}, consecutive: ${consecutiveTimeouts})`);
+                        opts.onIteration?.(iteration, `API timeout, retrying (${retryCount}/${maxTimeoutRetries})...`);
+                        if (retryCount >= maxTimeoutRetries) {
+                            // Too many retries for this iteration
+                            if (consecutiveTimeouts >= maxTimeoutRetries * 2) {
+                                // Too many consecutive timeouts overall, give up
+                                result = {
+                                    success: false,
+                                    iterations: iteration,
+                                    actions,
+                                    finalResponse: 'Agent stopped due to repeated API timeouts',
+                                    error: `API timed out ${consecutiveTimeouts} times consecutively. The task may be too complex or the API is overloaded.`,
+                                };
+                                return result;
+                            }
+                            // Skip this iteration and try next
+                            console.error(`[DEBUG] Max retries reached, skipping to next iteration`);
+                            messages.push({
+                                role: 'user',
+                                content: 'The previous request timed out. Please continue with the task, using simpler responses if needed.'
+                            });
+                            break;
+                        }
+                        // Wait before retry (exponential backoff)
+                        await new Promise(resolve => setTimeout(resolve, 1000 * retryCount));
+                        continue;
+                    }
+                    throw error;
                 }
-                throw error;
+            }
+            // If we broke out due to max retries without a response, continue to next iteration
+            if (!chatResponse) {
+                continue;
             }
             let { content, toolCalls, usedNativeTools } = chatResponse;
             // If native tools were used but no tool calls returned, try parsing text-based tool calls

package/dist/utils/tools.d.ts

@@ -196,9 +196,6 @@ export declare function getOpenAITools(): OpenAITool[];
  * Get tools in Anthropic Tool Use format
  */
 export declare function getAnthropicTools(): AnthropicTool[];
-/**
- * Parse tool calls from OpenAI response
- */
 export declare function parseOpenAIToolCalls(toolCalls: any[]): ToolCall[];
 /**
  * Parse tool calls from Anthropic response

package/dist/utils/tools.js

@@ -174,6 +174,33 @@ export function getAnthropicTools() {
 /**
  * Parse tool calls from OpenAI response
  */
+/**
+ * Normalize tool name to lowercase with underscores
+ */
+function normalizeToolName(name) {
+    const toolNameMap = {
+        'executecommand': 'execute_command',
+        'execute_command': 'execute_command',
+        'readfile': 'read_file',
+        'read_file': 'read_file',
+        'writefile': 'write_file',
+        'write_file': 'write_file',
+        'editfile': 'edit_file',
+        'edit_file': 'edit_file',
+        'deletefile': 'delete_file',
+        'delete_file': 'delete_file',
+        'listfiles': 'list_files',
+        'list_files': 'list_files',
+        'searchcode': 'search_code',
+        'search_code': 'search_code',
+        'createdirectory': 'create_directory',
+        'create_directory': 'create_directory',
+        'fetchurl': 'fetch_url',
+        'fetch_url': 'fetch_url',
+    };
+    const lower = name.toLowerCase().replace(/-/g, '_');
+    return toolNameMap[lower] || lower;
+}
 export function parseOpenAIToolCalls(toolCalls) {
     if (!toolCalls || !Array.isArray(toolCalls))
         return [];
@@ -186,7 +213,7 @@ export function parseOpenAIToolCalls(toolCalls) {
             parameters = {};
         }
         return {
-            tool: tc.function?.name || '',
+            tool: normalizeToolName(tc.function?.name || ''),
             parameters,
             id: tc.id,
         };
@@ -201,7 +228,7 @@ export function parseAnthropicToolCalls(content) {
     return content
         .filter(block => block.type === 'tool_use')
         .map(block => ({
-        tool: block.name || '',
+        tool: normalizeToolName(block.name || ''),
         parameters: block.input || {},
         id: block.id,
     }))
@@ -386,7 +413,7 @@ function tryParseToolCall(str) {
         const parsed = JSON.parse(cleaned);
         if (parsed.tool && typeof parsed.tool === 'string') {
             return {
-                tool: parsed.tool,
+                tool: normalizeToolName(parsed.tool),
                 parameters: parsed.parameters || {},
                 id: parsed.id,
             };
@@ -394,9 +421,9 @@ function tryParseToolCall(str) {
     }
     catch {
         // Try to extract tool name and parameters manually for malformed JSON
-        const toolMatch = str.match(/"tool"\s*:\s*"([^"]+)"/);
+        const toolMatch = str.match(/"tool"\s*:\s*"([^"]+)"/i);
         if (toolMatch) {
-            const tool = toolMatch[1];
+            const tool = normalizeToolName(toolMatch[1]);
             const params = {};
             // Extract simple string parameters
             const paramMatches = str.matchAll(/"(\w+)"\s*:\s*"([^"]*)"/g);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "1.0.20",
+  "version": "1.0.22",
   "description": "AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.",
   "type": "module",
   "main": "dist/index.js",