codeep 1.0.23 → 1.0.25

package/dist/config/index.js

@@ -68,14 +68,14 @@ export const config = new Conf({
         agentMaxFixAttempts: 3,
         agentMaxIterations: 100,
         agentMaxDuration: 20, // minutes
-        agentApiTimeout: 90000, // 90 seconds base timeout for agent (dynamically adjusted)
+        agentApiTimeout: 120000, // 120 seconds base timeout for agent (dynamically adjusted)
         protocol: 'openai',
         plan: 'lite',
         language: 'en',
         autoSave: true,
         currentSessionId: '',
         temperature: 0.7,
-        maxTokens: 4096,
+        maxTokens: 8192,
         apiTimeout: 60000,
         rateLimitApi: 30, // 30 requests per minute
         rateLimitCommands: 100, // 100 commands per minute

package/dist/utils/agent.js

@@ -15,46 +15,19 @@ class TimeoutError extends Error {
  * 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'
-    ];
+    // Simple approach: just use base timeout with small multiplier for later iterations
+    // Complex calculations were causing more problems than they solved
     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
+    // Later iterations have larger context, may need slightly more time
+    if (iteration > 3) {
+        multiplier = 1.2;
     }
-    // Check for very complex keywords
-    const hasVeryComplexKeyword = veryComplexKeywords.some(kw => promptLower.includes(kw));
-    if (hasVeryComplexKeyword) {
-        multiplier = 3.0; // Triple timeout for very complex tasks
+    if (iteration > 8) {
+        multiplier = 1.5;
     }
-    // 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
+    // Minimum 120 seconds, maximum 5 minutes for a single API call
     const calculatedTimeout = baseTimeout * multiplier;
-    return Math.min(Math.max(calculatedTimeout, 60000), 300000);
+    return Math.min(Math.max(calculatedTimeout, 120000), 300000);
 }
 import { parseToolCalls, executeTool, createActionLog, formatToolDefinitions, getOpenAITools, getAnthropicTools, parseOpenAIToolCalls, parseAnthropicToolCalls } from './tools.js';
 import { config, getApiKey } from '../config/index.js';
@@ -261,10 +234,27 @@ async function agentChat(messages, systemPrompt, onChunk, abortSignal, dynamicTi
             throw new Error(`API error: ${response.status} - ${errorText}`);
         }
         const data = await response.json();
+        // Debug: log raw API response
+        console.error(`[DEBUG] Raw API response:`, JSON.stringify(data, null, 2).substring(0, 1000));
         if (protocol === 'openai') {
             const message = data.choices?.[0]?.message;
             const content = message?.content || '';
-            const toolCalls = parseOpenAIToolCalls(message?.tool_calls || []);
+            const rawToolCalls = message?.tool_calls || [];
+            // Debug: log raw tool calls from API
+            console.error(`[DEBUG] Raw tool_calls from API:`, JSON.stringify(rawToolCalls, null, 2));
+            const toolCalls = parseOpenAIToolCalls(rawToolCalls);
+            // Debug: log parsed tool calls
+            console.error(`[DEBUG] Parsed tool calls:`, JSON.stringify(toolCalls, null, 2));
+            // If no native tool calls, try parsing from content (some models return text-based)
+            if (toolCalls.length === 0 && content) {
+                console.error(`[DEBUG] No native tool calls, checking content for text-based calls...`);
+                console.error(`[DEBUG] Content preview:`, content.substring(0, 500));
+                const textToolCalls = parseToolCalls(content);
+                if (textToolCalls.length > 0) {
+                    console.error(`[DEBUG] Found ${textToolCalls.length} text-based tool calls`);
+                    return { content, toolCalls: textToolCalls, usedNativeTools: false };
+                }
+            }
             if (onChunk && content) {
                 onChunk(content);
             }
@@ -636,13 +626,33 @@ export async function runAgent(prompt, projectContext, options = {}) {
                     toolCalls = textToolCalls;
                 }
             }
-            // If no tool calls, agent is done - simple and clean like Claude Code/Aider
+            // If no tool calls, check if model wants to continue or is really done
             if (toolCalls.length === 0) {
-                console.error(`[DEBUG] No tool calls at iteration ${iteration}, agent finished`);
+                console.error(`[DEBUG] No tool calls at iteration ${iteration}`);
                 // Remove <think>...</think> tags from response (some models include thinking)
                 finalResponse = content.replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
-                // Trust the model - if it says it's done, it's done
-                // No forcing, no blocking, no artificial requirements
+                // Check if model indicates it wants to continue (incomplete response)
+                const continueIndicators = [
+                    'let me', 'i will', 'i\'ll', 'now i', 'next i',
+                    'creating', 'writing', 'generating',
+                    'let\'s', 'going to', 'need to create', 'need to write'
+                ];
+                const lowerResponse = finalResponse.toLowerCase();
+                const wantsToContinue = continueIndicators.some(indicator => lowerResponse.includes(indicator));
+                // Also check if there were tool call parsing failures in this iteration
+                // by looking for incomplete actions (e.g., write_file without content)
+                const hasIncompleteWork = iteration < 10 && wantsToContinue && finalResponse.length < 500;
+                if (hasIncompleteWork) {
+                    console.error(`[DEBUG] Model wants to continue, prompting for next action`);
+                    messages.push({ role: 'assistant', content });
+                    messages.push({
+                        role: 'user',
+                        content: 'Continue. Execute the tool calls now.'
+                    });
+                    continue;
+                }
+                // Model is done
+                console.error(`[DEBUG] Agent finished at iteration ${iteration}`);
                 break;
             }
             // Add assistant response to history

package/dist/utils/tools.js

@@ -204,20 +204,40 @@ function normalizeToolName(name) {
 export function parseOpenAIToolCalls(toolCalls) {
     if (!toolCalls || !Array.isArray(toolCalls))
         return [];
-    return toolCalls.map(tc => {
+    const parsed = [];
+    for (const tc of toolCalls) {
+        const toolName = normalizeToolName(tc.function?.name || '');
+        if (!toolName)
+            continue;
         let parameters = {};
         try {
             parameters = JSON.parse(tc.function?.arguments || '{}');
         }
-        catch {
-            parameters = {};
+        catch (e) {
+            // JSON parsing failed - likely truncated response
+            console.error(`[DEBUG] Failed to parse tool arguments for ${toolName}:`, tc.function?.arguments?.substring(0, 100));
+            continue; // Skip this tool call entirely
         }
-        return {
-            tool: normalizeToolName(tc.function?.name || ''),
+        // Validate required parameters for specific tools
+        if (toolName === 'write_file' && (!parameters.path || parameters.content === undefined)) {
+            console.error(`[DEBUG] Skipping write_file with missing path or content`);
+            continue;
+        }
+        if (toolName === 'read_file' && !parameters.path) {
+            console.error(`[DEBUG] Skipping read_file with missing path`);
+            continue;
+        }
+        if (toolName === 'edit_file' && (!parameters.path || parameters.old_text === undefined || parameters.new_text === undefined)) {
+            console.error(`[DEBUG] Skipping edit_file with missing parameters`);
+            continue;
+        }
+        parsed.push({
+            tool: toolName,
             parameters,
             id: tc.id,
-        };
-    }).filter(tc => tc.tool);
+        });
+    }
+    return parsed;
 }
 /**
  * Parse tool calls from Anthropic response

package/package.json

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