protoagent 0.1.5 → 0.1.6

package/dist/App.js

@@ -503,6 +503,17 @@ export const App = ({ dangerouslyAcceptAll = false, logLevel, sessionId, }) => {
                             }
                         }
                         break;
+                    case 'sub_agent_iteration':
+                        if (event.subAgentTool) {
+                            const { tool, status } = event.subAgentTool;
+                            if (status === 'running') {
+                                setActiveTool(`sub_agent → ${tool}`);
+                            }
+                            else {
+                                setActiveTool(null);
+                            }
+                        }
+                        break;
                     case 'tool_call':
                         if (event.toolCall) {
                             const toolCall = event.toolCall;

package/dist/agentic-loop.js

@@ -126,6 +126,21 @@ function extractFirstCompleteJsonValue(value) {
     }
     return null;
 }
+/**
+ * Repair invalid JSON escape sequences in a string value.
+ *
+ * JSON only allows: \" \\ \/ \b \f \n \r \t \uXXXX
+ * Models sometimes emit \| \! \- etc. (e.g. grep regex args) which make
+ * JSON.parse throw, and Anthropic strict-validates tool_call arguments on
+ * every subsequent request, bricking the session permanently.
+ *
+ * We double the backslash for any \X where X is not a valid JSON escape char.
+ */
+function repairInvalidEscapes(value) {
+    // Match a backslash followed by any character that is NOT a valid JSON escape
+    // Valid escapes: " \ / b f n r t u
+    return value.replace(/\\([^"\\\/bfnrtu])/g, '\\\\$1');
+}
 function normalizeJsonArguments(argumentsText) {
     const trimmed = argumentsText.trim();
     if (!trimmed)
@@ -157,6 +172,25 @@ function normalizeJsonArguments(argumentsText) {
             // Give up and return the original text below.
         }
     }
+    // Heuristic: repair invalid escape sequences (e.g. \| from grep regex args)
+    const repaired = repairInvalidEscapes(trimmed);
+    if (repaired !== trimmed) {
+        try {
+            JSON.parse(repaired);
+            return repaired;
+        }
+        catch {
+            // Try repair + first-value extraction together
+            const repairedFirst = extractFirstCompleteJsonValue(repaired);
+            if (repairedFirst) {
+                try {
+                    JSON.parse(repairedFirst);
+                    return repairedFirst;
+                }
+                catch { /* give up */ }
+            }
+        }
+    }
     return argumentsText;
 }
 function sanitizeToolCall(toolCall, validToolNames) {
@@ -231,6 +265,7 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
     }
     let iterationCount = 0;
     let repairRetryCount = 0;
+    let contextRetryCount = 0;
     const validToolNames = getValidToolNames();
     while (iterationCount < maxIterations) {
         // Check if abort was requested
@@ -389,10 +424,24 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                     })),
                 });
                 updatedMessages.push(assistantMessage);
+                // Track which tool_call_ids still need a tool result message.
+                // This set is used to inject stub responses on abort, preventing
+                // orphaned tool_call_ids from permanently bricking the session.
+                const pendingToolCallIds = new Set(assistantMessage.tool_calls.map((tc) => tc.id));
+                const injectStubsForPendingToolCalls = () => {
+                    for (const id of pendingToolCallIds) {
+                        updatedMessages.push({
+                            role: 'tool',
+                            tool_call_id: id,
+                            content: 'Aborted by user.',
+                        });
+                    }
+                };
                 for (const toolCall of assistantMessage.tool_calls) {
                     // Check abort between tool calls
                     if (abortSignal?.aborted) {
                         logger.debug('Agentic loop aborted between tool calls');
+                        injectStubsForPendingToolCalls();
                         emitAbortAndFinish(onEvent);
                         return updatedMessages;
                     }
@@ -408,16 +457,11 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                         if (name === 'sub_agent') {
                             const subProgress = (evt) => {
                                 onEvent({
-                                    type: 'tool_call',
-                                    toolCall: {
-                                        id: toolCall.id,
-                                        name: `sub_agent → ${evt.tool}`,
-                                        args: '',
-                                        status: evt.status === 'running' ? 'running' : 'done',
-                                    },
+                                    type: 'sub_agent_iteration',
+                                    subAgentTool: { tool: evt.tool, status: evt.status, iteration: evt.iteration },
                                 });
                             };
-                            result = await runSubAgent(client, model, args.task, args.max_iterations, requestDefaults, subProgress);
+                            result = await runSubAgent(client, model, args.task, args.max_iterations, requestDefaults, subProgress, abortSignal);
                         }
                         else {
                             result = await handleToolCall(name, args, { sessionId, abortSignal });
@@ -433,6 +477,7 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                             tool_call_id: toolCall.id,
                             content: result,
                         });
+                        pendingToolCallIds.delete(toolCall.id);
                         onEvent({
                             type: 'tool_result',
                             toolCall: { id: toolCall.id, name, args: argsStr, status: 'done', result },
@@ -445,6 +490,14 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                             tool_call_id: toolCall.id,
                             content: `Error: ${errMsg}`,
                         });
+                        pendingToolCallIds.delete(toolCall.id);
+                        // If the tool was aborted, inject stubs for remaining pending calls and stop
+                        if (abortSignal?.aborted || (err instanceof Error && (err.name === 'AbortError' || err.message === 'Operation aborted'))) {
+                            logger.debug('Agentic loop aborted during tool execution');
+                            injectStubsForPendingToolCalls();
+                            emitAbortAndFinish(onEvent);
+                            return updatedMessages;
+                        }
                         onEvent({
                             type: 'tool_result',
                             toolCall: { id: toolCall.id, name, args: argsStr, status: 'error', result: errMsg },
@@ -520,6 +573,48 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                     continue;
                 }
             }
+            // Handle context-window-exceeded (prompt too long) — attempt forced compaction
+            // This fires when our token estimate was too low (e.g. base64 images from MCP tools)
+            // and the request actually hit the hard provider limit.
+            const isContextTooLong = apiError?.status === 400 &&
+                typeof errMsg === 'string' &&
+                /prompt.{0,30}too long|context.{0,30}length|maximum.{0,30}token|tokens?.{0,10}exceed/i.test(errMsg);
+            if (isContextTooLong && contextRetryCount < 2) {
+                contextRetryCount++;
+                logger.warn(`Prompt too long (attempt ${contextRetryCount}); forcing compaction`, { errMsg });
+                onEvent({
+                    type: 'error',
+                    error: 'Prompt too long. Compacting conversation and retrying...',
+                    transient: true,
+                });
+                if (pricing) {
+                    // Use the normal LLM-based compaction path
+                    try {
+                        const compacted = await compactIfNeeded(client, model, updatedMessages, pricing.contextWindow, 
+                        // Pass the context window itself as currentTokens to force compaction
+                        pricing.contextWindow, requestDefaults, sessionId);
+                        updatedMessages.length = 0;
+                        updatedMessages.push(...compacted);
+                    }
+                    catch (compactErr) {
+                        logger.error(`Forced compaction failed: ${compactErr}`);
+                        // Fall through to truncation fallback below
+                    }
+                }
+                // Fallback: truncate any tool result messages whose content looks like
+                // base64 or is extremely large (e.g. MCP screenshot data)
+                const MAX_TOOL_RESULT_CHARS = 20_000;
+                for (let i = 0; i < updatedMessages.length; i++) {
+                    const m = updatedMessages[i];
+                    if (m.role === 'tool' && typeof m.content === 'string' && m.content.length > MAX_TOOL_RESULT_CHARS) {
+                        updatedMessages[i] = {
+                            ...m,
+                            content: m.content.slice(0, MAX_TOOL_RESULT_CHARS) + '\n... (truncated — content was too large)',
+                        };
+                    }
+                }
+                continue;
+            }
             // Retry on 429 (rate limit) with backoff
             if (apiError?.status === 429) {
                 const retryAfter = parseInt(apiError?.headers?.['retry-after'] || '5', 10);

package/dist/sub-agent.js

@@ -39,7 +39,7 @@ export const subAgentTool = {
  * Run a sub-agent with its own isolated conversation.
  * Returns the sub-agent's final text response.
  */
-export async function runSubAgent(client, model, task, maxIterations = 30, requestDefaults = {}, onProgress) {
+export async function runSubAgent(client, model, task, maxIterations = 30, requestDefaults = {}, onProgress, abortSignal) {
     const op = logger.startOperation('sub-agent');
     const subAgentSessionId = `sub-agent-${crypto.randomUUID()}`;
     const systemPrompt = await generateSystemPrompt();
@@ -56,13 +56,17 @@ Do NOT ask the user questions — work autonomously with the tools available.`;
     ];
     try {
         for (let i = 0; i < maxIterations; i++) {
+            // Check abort at the top of each iteration
+            if (abortSignal?.aborted) {
+                return '(sub-agent aborted)';
+            }
             const response = await client.chat.completions.create({
                 ...requestDefaults,
                 model,
                 messages,
                 tools: getAllTools(),
                 tool_choice: 'auto',
-            });
+            }, { signal: abortSignal });
             const message = response.choices[0]?.message;
             if (!message)
                 break;
@@ -70,12 +74,16 @@ Do NOT ask the user questions — work autonomously with the tools available.`;
             if (message.tool_calls && message.tool_calls.length > 0) {
                 messages.push(message);
                 for (const toolCall of message.tool_calls) {
+                    // Check abort between tool calls
+                    if (abortSignal?.aborted) {
+                        return '(sub-agent aborted)';
+                    }
                     const { name, arguments: argsStr } = toolCall.function;
                     logger.debug(`Sub-agent tool call: ${name}`);
                     onProgress?.({ tool: name, status: 'running', iteration: i });
                     try {
                         const args = JSON.parse(argsStr);
-                        const result = await handleToolCall(name, args, { sessionId: subAgentSessionId });
+                        const result = await handleToolCall(name, args, { sessionId: subAgentSessionId, abortSignal });
                         messages.push({
                             role: 'tool',
                             tool_call_id: toolCall.id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protoagent",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "type": "module",
   "files": [
     "dist",