codebot-ai 1.4.0 → 1.4.2

package/dist/agent.d.ts

@@ -28,9 +28,16 @@ export declare class Agent {
         after: number;
     };
     getMessages(): Message[];
-    /** Ensure every assistant message with tool_calls has matching tool response messages.
-     *  OpenAI returns 400 if any tool_call_id lacks a response. This can happen if
-     *  a previous LLM call errored out mid-flow. */
+    /**
+     * Validate and repair message history to prevent OpenAI 400 errors.
+     * Handles three types of corruption:
+     *  1. Orphaned tool messages — tool_call_id doesn't match any preceding assistant's tool_calls
+     *  2. Duplicate tool responses — multiple tool messages for the same tool_call_id
+     *  3. Missing tool responses — assistant has tool_calls but no matching tool response
+     *
+     * This runs before every LLM call to self-heal from stream errors, compaction artifacts,
+     * or session resume corruption.
+     */
     private repairToolCallMessages;
     private buildSystemPrompt;
 }

package/dist/agent.js

@@ -38,6 +38,7 @@ const readline = __importStar(require("readline"));
 const tools_1 = require("./tools");
 const parser_1 = require("./parser");
 const manager_1 = require("./context/manager");
+const retry_1 = require("./retry");
 const repo_map_1 = require("./context/repo-map");
 const memory_1 = require("./memory");
 const registry_1 = require("./providers/registry");
@@ -98,6 +99,9 @@ class Agent {
                 yield { type: 'compaction', text: 'Context compacted (summary unavailable).' };
             }
         }
+        // Circuit breaker: track consecutive identical errors
+        let consecutiveErrors = 0;
+        let lastErrorMsg = '';
         for (let i = 0; i < this.maxIterations; i++) {
             // Validate message integrity: ensure every tool_call has a matching tool response
             // This prevents cascading 400 errors from OpenAI when a previous call failed
@@ -136,11 +140,29 @@ class Agent {
                 const msg = err instanceof Error ? err.message : String(err);
                 streamError = `Stream error: ${msg}`;
             }
-            // On error: yield it to the UI but DON'T return — continue to next iteration
             if (streamError) {
                 yield { type: 'error', error: streamError };
+                // Fatal errors (missing API key, auth failure, billing, etc.) — stop immediately
+                if ((0, retry_1.isFatalError)(streamError)) {
+                    return;
+                }
+                // Circuit breaker: stop after 3 consecutive identical errors
+                if (streamError === lastErrorMsg) {
+                    consecutiveErrors++;
+                    if (consecutiveErrors >= 3) {
+                        yield { type: 'error', error: `Same error repeated ${consecutiveErrors} times — stopping. Fix the issue and try again.` };
+                        return;
+                    }
+                }
+                else {
+                    consecutiveErrors = 1;
+                    lastErrorMsg = streamError;
+                }
                 continue;
             }
+            // Reset error tracking on success
+            consecutiveErrors = 0;
+            lastErrorMsg = '';
             // If no native tool calls, try parsing from text
             if (toolCalls.length === 0 && fullText) {
                 toolCalls = (0, parser_1.parseToolCalls)(fullText);
@@ -238,10 +260,45 @@ class Agent {
     getMessages() {
         return [...this.messages];
     }
-    /** Ensure every assistant message with tool_calls has matching tool response messages.
-     *  OpenAI returns 400 if any tool_call_id lacks a response. This can happen if
-     *  a previous LLM call errored out mid-flow. */
+    /**
+     * Validate and repair message history to prevent OpenAI 400 errors.
+     * Handles three types of corruption:
+     *  1. Orphaned tool messages — tool_call_id doesn't match any preceding assistant's tool_calls
+     *  2. Duplicate tool responses — multiple tool messages for the same tool_call_id
+     *  3. Missing tool responses — assistant has tool_calls but no matching tool response
+     *
+     * This runs before every LLM call to self-heal from stream errors, compaction artifacts,
+     * or session resume corruption.
+     */
     repairToolCallMessages() {
+        // Phase 1: Collect all valid tool_call_ids from assistant messages (in order)
+        const validToolCallIds = new Set();
+        for (const msg of this.messages) {
+            if (msg.role === 'assistant' && msg.tool_calls?.length) {
+                for (const tc of msg.tool_calls) {
+                    validToolCallIds.add(tc.id);
+                }
+            }
+        }
+        // Phase 2: Remove orphaned tool messages and duplicates
+        const seenToolResponseIds = new Set();
+        this.messages = this.messages.filter(msg => {
+            if (msg.role !== 'tool')
+                return true;
+            const tcId = msg.tool_call_id;
+            // No tool_call_id at all — malformed, remove
+            if (!tcId)
+                return false;
+            // Orphaned: tool_call_id doesn't match any assistant's tool_calls
+            if (!validToolCallIds.has(tcId))
+                return false;
+            // Duplicate: already have a response for this tool_call_id
+            if (seenToolResponseIds.has(tcId))
+                return false;
+            seenToolResponseIds.add(tcId);
+            return true;
+        });
+        // Phase 3: Add missing tool responses (assistant has tool_calls but no tool response)
         const toolResponseIds = new Set();
         for (const msg of this.messages) {
             if (msg.role === 'tool' && msg.tool_call_id) {
@@ -253,13 +310,12 @@ class Agent {
             if (msg.role === 'assistant' && msg.tool_calls?.length) {
                 for (const tc of msg.tool_calls) {
                     if (!toolResponseIds.has(tc.id)) {
-                        // Missing tool response — inject one right after the assistant message
                         const repairMsg = {
                             role: 'tool',
                             content: 'Error: tool call was not executed (interrupted).',
                             tool_call_id: tc.id,
                         };
-                        // Find the right position: after the assistant message and any existing tool responses
+                        // Insert after the assistant message and any existing tool responses
                         let insertAt = i + 1;
                         while (insertAt < this.messages.length && this.messages[insertAt].role === 'tool') {
                             insertAt++;

package/dist/cli.js

@@ -44,7 +44,7 @@ const setup_1 = require("./setup");
 const banner_1 = require("./banner");
 const tools_1 = require("./tools");
 const scheduler_1 = require("./scheduler");
-const VERSION = '1.4.0';
+const VERSION = '1.4.2';
 // Session-wide token tracking
 let sessionTokens = { input: 0, output: 0, total: 0 };
 const C = {

package/dist/providers/anthropic.js

@@ -10,6 +10,11 @@ class AnthropicProvider {
         this.name = config.model;
     }
     async *chat(messages, tools) {
+        // Early check: Anthropic always requires an API key
+        if (!this.config.apiKey) {
+            yield { type: 'error', error: `No API key configured for ${this.config.model}. Set ANTHROPIC_API_KEY or run: codebot --setup` };
+            return;
+        }
         const { systemPrompt, apiMessages } = this.convertMessages(messages);
         const body = {
             model: this.config.model,
@@ -66,7 +71,28 @@ class AnthropicProvider {
         }
         if (!response || !response.ok) {
             const text = response ? await response.text().catch(() => '') : '';
-            yield { type: 'error', error: `Anthropic error after retries: ${lastError}${text ? ` — ${text}` : ''}` };
+            // Extract readable error message from JSON response
+            let errorMessage = '';
+            try {
+                const json = JSON.parse(text);
+                errorMessage = json?.error?.message || json?.message || '';
+            }
+            catch {
+                errorMessage = text.substring(0, 200);
+            }
+            const status = response?.status;
+            if (status === 401 || (errorMessage && errorMessage.toLowerCase().includes('api key'))) {
+                yield { type: 'error', error: `Authentication failed (${status}): ${errorMessage || 'Invalid API key'}. Set ANTHROPIC_API_KEY or run: codebot --setup` };
+            }
+            else if (status === 403) {
+                yield { type: 'error', error: `Access denied (403): ${errorMessage || 'Permission denied'}. Check your API key permissions.` };
+            }
+            else if (status === 404) {
+                yield { type: 'error', error: `Model not found (404): ${errorMessage || `"${this.config.model}" may not be available`}.` };
+            }
+            else {
+                yield { type: 'error', error: `Anthropic error (${status || 'unknown'}): ${errorMessage || lastError || 'Unknown error'}` };
+            }
             return;
         }
         if (!response.body) {

package/dist/providers/openai.d.ts

@@ -6,6 +6,10 @@ export declare class OpenAIProvider implements LLMProvider {
     constructor(config: ProviderConfig);
     chat(messages: Message[], tools?: ToolSchema[]): AsyncGenerator<StreamEvent>;
     listModels(): Promise<string[]>;
+    /** Get a helpful hint about which env var to set for the current provider */
+    private getApiKeyHint;
+    /** Format API error responses into readable messages (not raw JSON) */
+    private formatApiError;
     private formatMessage;
 }
 //# sourceMappingURL=openai.d.ts.map

package/dist/providers/openai.js

@@ -13,6 +13,13 @@ class OpenAIProvider {
         this.supportsTools = (0, registry_1.getModelInfo)(config.model).supportsToolCalling;
     }
     async *chat(messages, tools) {
+        const isLocal = this.config.baseUrl.includes('localhost') || this.config.baseUrl.includes('127.0.0.1');
+        // Early check: cloud providers require an API key
+        if (!isLocal && !this.config.apiKey) {
+            const hint = this.getApiKeyHint();
+            yield { type: 'error', error: `No API key configured for ${this.config.model}. ${hint}` };
+            return;
+        }
         const body = {
             model: this.config.model,
             messages: messages.map(m => this.formatMessage(m)),
@@ -22,7 +29,6 @@ class OpenAIProvider {
             body.tools = tools;
         }
         // Ollama/local provider optimizations: set context window and keep model loaded
-        const isLocal = this.config.baseUrl.includes('localhost') || this.config.baseUrl.includes('127.0.0.1');
         if (isLocal) {
             const modelInfo = (0, registry_1.getModelInfo)(this.config.model);
             body.options = { num_ctx: modelInfo.contextWindow };
@@ -69,7 +75,8 @@ class OpenAIProvider {
         }
         if (!response || !response.ok) {
             const text = response ? await response.text().catch(() => '') : '';
-            yield { type: 'error', error: `LLM error after retries: ${lastError}${text ? ` — ${text}` : ''}` };
+            const friendlyError = this.formatApiError(response?.status, text, lastError);
+            yield { type: 'error', error: friendlyError };
             return;
         }
         if (!response.body) {
@@ -240,6 +247,51 @@ class OpenAIProvider {
             return [];
         }
     }
+    /** Get a helpful hint about which env var to set for the current provider */
+    getApiKeyHint() {
+        const url = this.config.baseUrl.toLowerCase();
+        if (url.includes('openai.com'))
+            return 'Set OPENAI_API_KEY or run: codebot --setup';
+        if (url.includes('deepseek'))
+            return 'Set DEEPSEEK_API_KEY or run: codebot --setup';
+        if (url.includes('groq'))
+            return 'Set GROQ_API_KEY or run: codebot --setup';
+        if (url.includes('mistral'))
+            return 'Set MISTRAL_API_KEY or run: codebot --setup';
+        if (url.includes('generativelanguage.googleapis') || url.includes('gemini'))
+            return 'Set GEMINI_API_KEY or run: codebot --setup';
+        if (url.includes('x.ai') || url.includes('grok'))
+            return 'Set XAI_API_KEY or run: codebot --setup';
+        return 'Set your API key or run: codebot --setup';
+    }
+    /** Format API error responses into readable messages (not raw JSON) */
+    formatApiError(status, responseText, lastError) {
+        // Try to extract a useful message from JSON error response
+        let errorMessage = '';
+        try {
+            const json = JSON.parse(responseText);
+            errorMessage = json?.error?.message || json?.message || json?.error || '';
+        }
+        catch {
+            errorMessage = responseText.substring(0, 200);
+        }
+        const hint = this.getApiKeyHint();
+        if (status === 401 || (errorMessage && errorMessage.toLowerCase().includes('api key'))) {
+            return `Authentication failed (${status || 'no status'}): ${errorMessage || 'Invalid or missing API key'}. ${hint}`;
+        }
+        if (status === 403) {
+            return `Access denied (403): ${errorMessage || 'Permission denied'}. Check your API key permissions.`;
+        }
+        if (status === 404) {
+            return `Model not found (404): ${errorMessage || `"${this.config.model}" may not be available`}. Check the model name.`;
+        }
+        if (status === 429) {
+            return `Rate limited (429): ${errorMessage || 'Too many requests'}. Wait a moment and try again.`;
+        }
+        // Generic fallback — still clean, not raw JSON
+        const statusStr = status ? `(${status})` : '';
+        return `LLM error ${statusStr}: ${errorMessage || lastError || 'Unknown error'}`;
+    }
     formatMessage(msg) {
         const formatted = { role: msg.role, content: msg.content };
         if (msg.tool_calls) {

package/dist/retry.d.ts

@@ -18,5 +18,10 @@ export declare function isRetryable(error: unknown, status?: number, opts?: Retr
  */
 export declare function getRetryDelay(attempt: number, retryAfterHeader?: string | null, opts?: RetryOptions): number;
 export declare function sleep(ms: number): Promise<void>;
+/**
+ * Returns true if the error message indicates a fatal/permanent failure
+ * that will never succeed on retry (missing API key, auth failure, billing, etc.).
+ */
+export declare function isFatalError(errorMsg: string): boolean;
 export { DEFAULTS as RETRY_DEFAULTS };
 //# sourceMappingURL=retry.d.ts.map

package/dist/retry.js

@@ -9,6 +9,7 @@ exports.RETRY_DEFAULTS = void 0;
 exports.isRetryable = isRetryable;
 exports.getRetryDelay = getRetryDelay;
 exports.sleep = sleep;
+exports.isFatalError = isFatalError;
 const DEFAULTS = {
     maxRetries: 3,
     baseDelayMs: 1000,
@@ -56,4 +57,27 @@ function getRetryDelay(attempt, retryAfterHeader, opts) {
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
+/**
+ * Returns true if the error message indicates a fatal/permanent failure
+ * that will never succeed on retry (missing API key, auth failure, billing, etc.).
+ */
+function isFatalError(errorMsg) {
+    const lower = errorMsg.toLowerCase();
+    return (lower.includes('api key') ||
+        lower.includes('api_key') ||
+        lower.includes('apikey') ||
+        lower.includes('authentication') ||
+        lower.includes('unauthorized') ||
+        lower.includes('invalid_request_error') ||
+        lower.includes('invalid request') ||
+        lower.includes('permission denied') ||
+        lower.includes('account deactivated') ||
+        lower.includes('account suspended') ||
+        lower.includes('billing') ||
+        (lower.includes('quota') && lower.includes('exceeded')) ||
+        lower.includes('insufficient_quota') ||
+        lower.includes('model not found') ||
+        lower.includes('does not exist') ||
+        lower.includes('access denied'));
+}
 //# sourceMappingURL=retry.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebot-ai",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "Zero-dependency autonomous AI agent. Code, browse, search, automate. Works with any LLM — Ollama, Claude, GPT, Gemini, DeepSeek, Groq, Mistral, Grok.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",