codeep 1.0.19 → 1.0.21

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
@@ -508,12 +647,15 @@ export async function runAgent(prompt, projectContext, options = {}) {
                 const taskKeywords = ['create', 'build', 'make', 'implement', 'add', 'generate', 'write', 'setup', 'develop', 'kreiraj', 'napravi', 'dodaj', 'website', 'app', 'feature'];
                 const promptLowerCase = prompt.toLowerCase();
                 const isCreationTask = taskKeywords.some(kw => promptLowerCase.includes(kw));
-                const hasCreatedFiles = actions.some(a => a.type === 'write' || a.type === 'mkdir');
+                // Only count actual FILE writes, not directories
+                const hasCreatedFiles = actions.some(a => a.type === 'write');
                 const writeFileCount = actions.filter(a => a.type === 'write').length;
+                const hasMkdir = actions.some(a => a.type === 'mkdir');
                 const isVeryEarlyIteration = iteration <= 5; // Extended to 5 iterations
-                console.error(`[DEBUG] Task check: isCreationTask=${isCreationTask}, hasCreatedFiles=${hasCreatedFiles}, writeFileCount=${writeFileCount}, iteration=${iteration}`);
-                // STRICT RULE: If it's a creation task, agent MUST create files
-                // Don't accept early stopping even if it has "done some actions"
+                console.error(`[DEBUG] Task check: isCreationTask=${isCreationTask}, hasCreatedFiles=${hasCreatedFiles}, writeFileCount=${writeFileCount}, hasMkdir=${hasMkdir}, iteration=${iteration}`);
+                console.error(`[DEBUG] Actions breakdown:`, actions.map(a => `${a.type}:${a.target}`).join(', '));
+                // STRICT RULE: If it's a creation task, agent MUST create FILES (not just directories)
+                // Creating a directory is not enough - we need actual file content
                 if (isCreationTask && !hasCreatedFiles && iteration <= 10) {
                     console.error(`[DEBUG] BLOCKING early stop - creation task detected but NO files created yet (iteration ${iteration}, ${actions.length} actions)`);
                     // Force agent to create files

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "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",