codebot-ai 1.4.1 → 1.4.3

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

@@ -260,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) {
@@ -275,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.1';
+const VERSION = '1.4.3';
 // Session-wide token tracking
 let sessionTokens = { input: 0, output: 0, total: 0 };
 const C = {

package/dist/context/manager.d.ts

@@ -14,9 +14,16 @@ export declare class ContextManager {
     availableTokens(): number;
     /** Check if messages fit within budget */
     fitsInBudget(messages: Message[]): boolean;
-    /** Compact conversation by dropping old messages and inserting a summary placeholder */
+    /**
+     * Group messages into atomic blocks that must never be split.
+     * An assistant message with tool_calls + its following tool responses = one block.
+     * All other messages are individual blocks.
+     * This prevents compaction from creating orphaned tool messages.
+     */
+    private groupMessages;
+    /** Compact conversation by dropping old messages. Never splits tool_call groups. */
     compact(messages: Message[], force?: boolean): Message[];
-    /** Smart compaction: use LLM to summarize dropped messages instead of just discarding */
+    /** Smart compaction: use LLM to summarize dropped messages. Never splits tool_call groups. */
     compactWithSummary(messages: Message[]): Promise<{
         messages: Message[];
         summary: string;

package/dist/context/manager.js

@@ -29,23 +29,55 @@ class ContextManager {
         const total = messages.reduce((sum, m) => sum + this.estimateTokens(m.content), 0);
         return total <= this.availableTokens();
     }
-    /** Compact conversation by dropping old messages and inserting a summary placeholder */
+    /**
+     * Group messages into atomic blocks that must never be split.
+     * An assistant message with tool_calls + its following tool responses = one block.
+     * All other messages are individual blocks.
+     * This prevents compaction from creating orphaned tool messages.
+     */
+    groupMessages(messages) {
+        const groups = [];
+        let i = 0;
+        while (i < messages.length) {
+            const msg = messages[i];
+            if (msg.role === 'assistant' && msg.tool_calls?.length) {
+                // Start of a tool_call group — keep assistant + all following tool messages together
+                const group = [msg];
+                i++;
+                while (i < messages.length && messages[i].role === 'tool') {
+                    group.push(messages[i]);
+                    i++;
+                }
+                groups.push(group);
+            }
+            else {
+                groups.push([msg]);
+                i++;
+            }
+        }
+        return groups;
+    }
+    /** Compact conversation by dropping old messages. Never splits tool_call groups. */
     compact(messages, force = false) {
         if (!force && this.fitsInBudget(messages))
             return messages;
         const system = messages[0]?.role === 'system' ? messages[0] : null;
         const rest = system ? messages.slice(1) : [...messages];
-        // Keep recent messages that fit within 80% of budget
-        const kept = [];
+        // Group messages into atomic blocks (assistant + tool responses stay together)
+        const groups = this.groupMessages(rest);
+        // Keep recent groups that fit within 80% of budget
+        const keptGroups = [];
         let tokenCount = 0;
         const budget = this.availableTokens();
-        for (let i = rest.length - 1; i >= 0; i--) {
-            const msgTokens = this.estimateTokens(rest[i].content);
-            if (tokenCount + msgTokens > budget * 0.8)
+        for (let i = groups.length - 1; i >= 0; i--) {
+            const group = groups[i];
+            const groupTokens = group.reduce((sum, m) => sum + this.estimateTokens(m.content), 0);
+            if (tokenCount + groupTokens > budget * 0.8)
                 break;
-            kept.unshift(rest[i]);
-            tokenCount += msgTokens;
+            keptGroups.unshift(group);
+            tokenCount += groupTokens;
         }
+        const kept = keptGroups.flat();
         const dropped = rest.length - kept.length;
         if (dropped > 0) {
             kept.unshift({
@@ -57,21 +89,25 @@ class ContextManager {
             kept.unshift(system);
         return kept;
     }
-    /** Smart compaction: use LLM to summarize dropped messages instead of just discarding */
+    /** Smart compaction: use LLM to summarize dropped messages. Never splits tool_call groups. */
     async compactWithSummary(messages) {
         const system = messages[0]?.role === 'system' ? messages[0] : null;
         const rest = system ? messages.slice(1) : [...messages];
-        // Determine which messages to keep vs summarize
-        const kept = [];
+        // Group messages into atomic blocks
+        const groups = this.groupMessages(rest);
+        // Keep recent groups that fit within 80% of budget
+        const keptGroups = [];
         let tokenCount = 0;
         const budget = this.availableTokens();
-        for (let i = rest.length - 1; i >= 0; i--) {
-            const msgTokens = this.estimateTokens(rest[i].content);
-            if (tokenCount + msgTokens > budget * 0.8)
+        for (let i = groups.length - 1; i >= 0; i--) {
+            const group = groups[i];
+            const groupTokens = group.reduce((sum, m) => sum + this.estimateTokens(m.content), 0);
+            if (tokenCount + groupTokens > budget * 0.8)
                 break;
-            kept.unshift(rest[i]);
-            tokenCount += msgTokens;
+            keptGroups.unshift(group);
+            tokenCount += groupTokens;
         }
+        const kept = keptGroups.flat();
         const droppedCount = rest.length - kept.length;
         if (droppedCount === 0) {
             return { messages, summary: '' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebot-ai",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "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",