@vellumai/assistant 0.4.19 → 0.4.21

package/src/agent/loop.ts

@@ -1,20 +1,31 @@
-import * as Sentry from '@sentry/node';
-
-import { truncateOversizedToolResults } from '../context/tool-result-truncation.js';
-import { getHookManager } from '../hooks/manager.js';
-import type { ContentBlock,Message, Provider, ToolDefinition } from '../providers/types.js';
-import type { ToolResultContent } from '../providers/types.js';
-import type { SensitiveOutputBinding } from '../tools/sensitive-output-placeholders.js';
-import { applyStreamingSubstitution, applySubstitutions } from '../tools/sensitive-output-placeholders.js';
-import { getLogger, isDebug, truncateForLog } from '../util/logger.js';
-
-const log = getLogger('agent-loop');
+import * as Sentry from "@sentry/node";
+
+import { truncateOversizedToolResults } from "../context/tool-result-truncation.js";
+import { getHookManager } from "../hooks/manager.js";
+import type {
+  ContentBlock,
+  Message,
+  Provider,
+  ToolDefinition,
+} from "../providers/types.js";
+import type { ToolResultContent } from "../providers/types.js";
+import type { SensitiveOutputBinding } from "../tools/sensitive-output-placeholders.js";
+import {
+  applyStreamingSubstitution,
+  applySubstitutions,
+} from "../tools/sensitive-output-placeholders.js";
+import { getLogger, isDebug, truncateForLog } from "../util/logger.js";
+
+const log = getLogger("agent-loop");
 
 export interface AgentLoopConfig {
   maxTokens: number;
   maxInputTokens?: number; // context window size for tool result truncation
   thinking?: { enabled: boolean; budgetTokens: number };
-  toolChoice?: { type: 'auto' } | { type: 'any' } | { type: 'tool'; name: string };
+  toolChoice?:
+    | { type: "auto" }
+    | { type: "any" }
+    | { type: "tool"; name: string };
   maxToolUseTurns?: number;
   /** Minimum interval (ms) between consecutive LLM calls to prevent spin when tools return instantly */
   minTurnIntervalMs?: number;
@@ -26,18 +37,46 @@ export interface CheckpointInfo {
   hasToolUse: boolean;
 }
 
-export type CheckpointDecision = 'continue' | 'yield';
+export type CheckpointDecision = "continue" | "yield";
 
 export type AgentEvent =
-  | { type: 'text_delta'; text: string }
-  | { type: 'thinking_delta'; thinking: string }
-  | { type: 'message_complete'; message: Message }
-  | { type: 'tool_use'; id: string; name: string; input: Record<string, unknown> }
-  | { type: 'tool_output_chunk'; toolUseId: string; chunk: string }
-  | { type: 'tool_result'; toolUseId: string; content: string; isError: boolean; diff?: { filePath: string; oldContent: string; newContent: string; isNewFile: boolean }; status?: string; contentBlocks?: ContentBlock[] }
-  | { type: 'input_json_delta'; toolName: string; accumulatedJson: string }
-  | { type: 'error'; error: Error }
-  | { type: 'usage'; inputTokens: number; outputTokens: number; cacheCreationInputTokens?: number; cacheReadInputTokens?: number; model: string; providerDurationMs: number; rawRequest?: unknown; rawResponse?: unknown };
+  | { type: "text_delta"; text: string }
+  | { type: "thinking_delta"; thinking: string }
+  | { type: "message_complete"; message: Message }
+  | {
+      type: "tool_use";
+      id: string;
+      name: string;
+      input: Record<string, unknown>;
+    }
+  | { type: "tool_output_chunk"; toolUseId: string; chunk: string }
+  | {
+      type: "tool_result";
+      toolUseId: string;
+      content: string;
+      isError: boolean;
+      diff?: {
+        filePath: string;
+        oldContent: string;
+        newContent: string;
+        isNewFile: boolean;
+      };
+      status?: string;
+      contentBlocks?: ContentBlock[];
+    }
+  | { type: "input_json_delta"; toolName: string; accumulatedJson: string }
+  | { type: "error"; error: Error }
+  | {
+      type: "usage";
+      inputTokens: number;
+      outputTokens: number;
+      cacheCreationInputTokens?: number;
+      cacheReadInputTokens?: number;
+      model: string;
+      providerDurationMs: number;
+      rawRequest?: unknown;
+      rawResponse?: unknown;
+    };
 
 const DEFAULT_CONFIG: AgentLoopConfig = {
   maxTokens: 16000,
@@ -46,11 +85,13 @@ const DEFAULT_CONFIG: AgentLoopConfig = {
 };
 
 const PROGRESS_CHECK_INTERVAL = 5;
-const PROGRESS_CHECK_REMINDER = 'You have been using tools for several turns. Check whether you are making meaningful progress toward the user\'s goal. If you are stuck in a loop or not making progress, summarize what you have tried and ask the user for guidance instead of continuing.';
+const PROGRESS_CHECK_REMINDER =
+  "You have been using tools for several turns. Check whether you are making meaningful progress toward the user's goal. If you are stuck in a loop or not making progress, summarize what you have tried and ask the user for guidance instead of continuing.";
 
 // Warn the model N turns before the hard limit so it can wrap up gracefully
 const APPROACHING_LIMIT_OFFSET = 5;
-const APPROACHING_LIMIT_WARNING = 'You are approaching the tool-use turn limit. You have {remaining} turns remaining. Wrap up your current task — summarize progress and present results to the user. If you cannot finish, explain what remains and ask the user how to proceed.';
+const APPROACHING_LIMIT_WARNING =
+  "You are approaching the tool-use turn limit. You have {remaining} turns remaining. Wrap up your current task — summarize progress and present results to the user. If you cannot finish, explain what remains and ask the user how to proceed.";
 
 export interface ResolvedSystemPrompt {
   systemPrompt: string;
@@ -64,15 +105,53 @@ export class AgentLoop {
   private config: AgentLoopConfig;
   private tools: ToolDefinition[];
   private resolveTools: ((history: Message[]) => ToolDefinition[]) | null;
-  private resolveSystemPrompt: ((history: Message[]) => ResolvedSystemPrompt) | null;
-  private toolExecutor: ((name: string, input: Record<string, unknown>, onOutput?: (chunk: string) => void) => Promise<{ content: string; isError: boolean; diff?: { filePath: string; oldContent: string; newContent: string; isNewFile: boolean }; status?: string; contentBlocks?: ContentBlock[]; sensitiveBindings?: SensitiveOutputBinding[]; yieldToUser?: boolean }>) | null;
+  private resolveSystemPrompt:
+    | ((history: Message[]) => ResolvedSystemPrompt)
+    | null;
+  private toolExecutor:
+    | ((
+        name: string,
+        input: Record<string, unknown>,
+        onOutput?: (chunk: string) => void,
+      ) => Promise<{
+        content: string;
+        isError: boolean;
+        diff?: {
+          filePath: string;
+          oldContent: string;
+          newContent: string;
+          isNewFile: boolean;
+        };
+        status?: string;
+        contentBlocks?: ContentBlock[];
+        sensitiveBindings?: SensitiveOutputBinding[];
+        yieldToUser?: boolean;
+      }>)
+    | null;
 
   constructor(
     provider: Provider,
     systemPrompt: string,
     config?: Partial<AgentLoopConfig>,
     tools?: ToolDefinition[],
-    toolExecutor?: (name: string, input: Record<string, unknown>, onOutput?: (chunk: string) => void) => Promise<{ content: string; isError: boolean; diff?: { filePath: string; oldContent: string; newContent: string; isNewFile: boolean }; status?: string; contentBlocks?: ContentBlock[]; sensitiveBindings?: SensitiveOutputBinding[]; yieldToUser?: boolean }>,
+    toolExecutor?: (
+      name: string,
+      input: Record<string, unknown>,
+      onOutput?: (chunk: string) => void,
+    ) => Promise<{
+      content: string;
+      isError: boolean;
+      diff?: {
+        filePath: string;
+        oldContent: string;
+        newContent: string;
+        isNewFile: boolean;
+      };
+      status?: string;
+      contentBlocks?: ContentBlock[];
+      sensitiveBindings?: SensitiveOutputBinding[];
+      yieldToUser?: boolean;
+    }>,
     resolveTools?: (history: Message[]) => ToolDefinition[],
     resolveSystemPrompt?: (history: Message[]) => ResolvedSystemPrompt,
   ) {
@@ -103,13 +182,13 @@ export class AgentLoop {
     // Bindings are accumulated from tool results; placeholders are
     // resolved in streamed deltas and final assistant message text.
     const substitutionMap = new Map<string, string>();
-    let streamingPending = '';
+    let streamingPending = "";
 
     while (true) {
       if (signal?.aborted) break;
 
       const turnStart = Date.now();
-      let toolUseBlocks: Extract<ContentBlock, { type: 'tool_use' }>[] = [];
+      let toolUseBlocks: Extract<ContentBlock, { type: "tool_use" }>[] = [];
 
       try {
         // Resolve tools for this turn: use the dynamic resolver if provided,
@@ -126,19 +205,21 @@ export class AgentLoop {
         const turnMaxTokens = resolved?.maxTokens ?? this.config.maxTokens;
         const turnModel = resolved?.model;
 
-        const providerConfig: Record<string, unknown> = { max_tokens: turnMaxTokens };
+        const providerConfig: Record<string, unknown> = {
+          max_tokens: turnMaxTokens,
+        };
         if (turnModel) {
           providerConfig.model = turnModel;
         }
         if (this.config.thinking?.enabled && turnMaxTokens >= 4000) {
-          // Skip thinking when turnMaxTokens is too low (e.g. low tier) to
-          // avoid the thinking budget consuming nearly all output tokens.
+          // Skip thinking when turnMaxTokens is too low to avoid the
+          // thinking budget consuming nearly all output tokens.
           const budgetTokens = Math.min(
             this.config.thinking.budgetTokens,
             Math.floor(turnMaxTokens * 0.75),
           );
           providerConfig.thinking = {
-            type: 'enabled',
+            type: "enabled",
             budget_tokens: budgetTokens,
           };
         }
@@ -148,25 +229,34 @@ export class AgentLoop {
         }
 
         if (debug) {
-          rlog.debug({
-            systemPrompt: truncateForLog(turnSystemPrompt, 200),
-            messageCount: history.length,
-            lastMessage: history.length > 0
-              ? summarizeMessage(history[history.length - 1])
-              : null,
-            toolCount: currentTools.length,
-            config: providerConfig,
-          }, 'Sending request to provider');
+          rlog.debug(
+            {
+              systemPrompt: truncateForLog(turnSystemPrompt, 200),
+              messageCount: history.length,
+              lastMessage:
+                history.length > 0
+                  ? summarizeMessage(history[history.length - 1])
+                  : null,
+              toolCount: currentTools.length,
+              config: providerConfig,
+            },
+            "Sending request to provider",
+          );
         }
 
-        const preLlmResult = await getHookManager().trigger('pre-llm-call', {
+        const preLlmResult = await getHookManager().trigger("pre-llm-call", {
           systemPrompt: turnSystemPrompt,
           messages: history,
           toolCount: currentTools.length,
         });
 
         if (preLlmResult.blocked) {
-          onEvent({ type: 'error', error: new Error(`LLM call blocked by hook "${preLlmResult.blockedBy}"`) });
+          onEvent({
+            type: "error",
+            error: new Error(
+              `LLM call blocked by hook "${preLlmResult.blockedBy}"`,
+            ),
+          });
           break;
         }
 
@@ -195,22 +285,29 @@ export class AgentLoop {
           {
             config: providerConfig,
             onEvent: (event) => {
-              if (event.type === 'text_delta') {
+              if (event.type === "text_delta") {
                 // Apply sensitive-output placeholder substitution (chunk-safe)
                 if (substitutionMap.size > 0) {
                   const combined = streamingPending + event.text;
-                  const { emit, pending } = applyStreamingSubstitution(combined, substitutionMap);
+                  const { emit, pending } = applyStreamingSubstitution(
+                    combined,
+                    substitutionMap,
+                  );
                   streamingPending = pending;
                   if (emit.length > 0) {
-                    onEvent({ type: 'text_delta', text: emit });
+                    onEvent({ type: "text_delta", text: emit });
                   }
                 } else {
-                  onEvent({ type: 'text_delta', text: event.text });
+                  onEvent({ type: "text_delta", text: event.text });
                 }
-              } else if (event.type === 'thinking_delta') {
-                onEvent({ type: 'thinking_delta', thinking: event.thinking });
-              } else if (event.type === 'input_json_delta') {
-                onEvent({ type: 'input_json_delta', toolName: event.toolName, accumulatedJson: event.accumulatedJson });
+              } else if (event.type === "thinking_delta") {
+                onEvent({ type: "thinking_delta", thinking: event.thinking });
+              } else if (event.type === "input_json_delta") {
+                onEvent({
+                  type: "input_json_delta",
+                  toolName: event.toolName,
+                  accumulatedJson: event.accumulatedJson,
+                });
               }
             },
             signal,
@@ -220,24 +317,34 @@ export class AgentLoop {
         const providerDurationMs = Date.now() - providerStart;
 
         if (debug) {
-          rlog.debug({
-            providerDurationMs,
-            model: response.model,
-            stopReason: response.stopReason,
-            inputTokens: response.usage.inputTokens,
-            outputTokens: response.usage.outputTokens,
-            cacheCreationInputTokens: response.usage.cacheCreationInputTokens,
-            cacheReadInputTokens: response.usage.cacheReadInputTokens,
-            contentBlocks: response.content.map((b) => ({
-              type: b.type,
-              ...(b.type === 'text' ? { text: truncateForLog(b.text, 1200) } : {}),
-              ...(b.type === 'tool_use' ? { name: b.name, input: truncateForLog(JSON.stringify(b.input), 1200) } : {}),
-            })),
-          }, 'Provider response received');
+          rlog.debug(
+            {
+              providerDurationMs,
+              model: response.model,
+              stopReason: response.stopReason,
+              inputTokens: response.usage.inputTokens,
+              outputTokens: response.usage.outputTokens,
+              cacheCreationInputTokens: response.usage.cacheCreationInputTokens,
+              cacheReadInputTokens: response.usage.cacheReadInputTokens,
+              contentBlocks: response.content.map((b) => ({
+                type: b.type,
+                ...(b.type === "text"
+                  ? { text: truncateForLog(b.text, 1200) }
+                  : {}),
+                ...(b.type === "tool_use"
+                  ? {
+                      name: b.name,
+                      input: truncateForLog(JSON.stringify(b.input), 1200),
+                    }
+                  : {}),
+              })),
+            },
+            "Provider response received",
+          );
         }
 
         onEvent({
-          type: 'usage',
+          type: "usage",
           inputTokens: response.usage.inputTokens,
           outputTokens: response.usage.outputTokens,
           cacheCreationInputTokens: response.usage.cacheCreationInputTokens,
@@ -248,7 +355,7 @@ export class AgentLoop {
           rawResponse: response.rawResponse,
         });
 
-        void getHookManager().trigger('post-llm-call', {
+        void getHookManager().trigger("post-llm-call", {
           model: response.model,
           inputTokens: response.usage.inputTokens,
           outputTokens: response.usage.outputTokens,
@@ -260,9 +367,9 @@ export class AgentLoop {
         if (streamingPending.length > 0) {
           const flushed = applySubstitutions(streamingPending, substitutionMap);
           if (flushed.length > 0) {
-            onEvent({ type: 'text_delta', text: flushed });
+            onEvent({ type: "text_delta", text: flushed });
           }
-          streamingPending = '';
+          streamingPending = "";
         }
 
         // Build the assistant message with placeholder-only text.
@@ -271,40 +378,41 @@ export class AgentLoop {
         // on subsequent loop turns nor on session reload from the database.
         // Substitution to real values happens only in streamed text_delta events.
         const assistantMessage: Message = {
-          role: 'assistant',
+          role: "assistant",
           content: response.content,
         };
         history.push(assistantMessage);
 
-        await onEvent({ type: 'message_complete', message: assistantMessage });
+        await onEvent({ type: "message_complete", message: assistantMessage });
 
         // Check for tool use
         toolUseBlocks = response.content.filter(
-          (block): block is Extract<ContentBlock, { type: 'tool_use' }> =>
-            block.type === 'tool_use',
+          (block): block is Extract<ContentBlock, { type: "tool_use" }> =>
+            block.type === "tool_use",
         );
 
         // Check if the assistant turn contained any visible text (used for
         // both the empty-response nudge and the anti-repetition notice).
         const hasTextBlock = response.content.some(
-          (block) => block.type === 'text' && block.text.trim().length > 0,
+          (block) => block.type === "text" && block.text.trim().length > 0,
         );
 
         if (toolUseBlocks.length === 0 || !this.toolExecutor) {
           // Check if the LLM returned no text after tool results — nudge it to respond
-          const lastUserMsg = history.length >= 2 ? history[history.length - 2] : undefined;
+          const lastUserMsg =
+            history.length >= 2 ? history[history.length - 2] : undefined;
           const lastWasToolResult =
-            lastUserMsg?.role === 'user' &&
-            lastUserMsg.content.some((block) => block.type === 'tool_result');
+            lastUserMsg?.role === "user" &&
+            lastUserMsg.content.some((block) => block.type === "tool_result");
 
           if (!hasTextBlock && lastWasToolResult && !nudgedForEmptyResponse) {
             nudgedForEmptyResponse = true;
             history.push({
-              role: 'user',
+              role: "user",
               content: [
                 {
-                  type: 'text',
-                  text: '<system_notice>You executed tools but didn\'t tell the user what happened. Provide a brief, conversational summary of the results.</system_notice>',
+                  type: "text",
+                  text: "<system_notice>You executed tools but didn't tell the user what happened. Provide a brief, conversational summary of the results.</system_notice>",
                 },
               ],
             });
@@ -318,29 +426,34 @@ export class AgentLoop {
         // Emit all tool_use events upfront, then execute tools in parallel
         for (const toolUse of toolUseBlocks) {
           onEvent({
-            type: 'tool_use',
+            type: "tool_use",
             id: toolUse.id,
             name: toolUse.name,
             input: toolUse.input,
           });
 
           if (debug) {
-            rlog.debug({
-              tool: toolUse.name,
-              input: truncateForLog(JSON.stringify(toolUse.input), 300),
-            }, 'Executing tool');
+            rlog.debug(
+              {
+                tool: toolUse.name,
+                input: truncateForLog(JSON.stringify(toolUse.input), 300),
+              },
+              "Executing tool",
+            );
           }
         }
 
         // If already cancelled, synthesize cancelled results and stop
         if (signal?.aborted) {
-          const cancelledBlocks: ContentBlock[] = toolUseBlocks.map((toolUse) => ({
-            type: 'tool_result' as const,
-            tool_use_id: toolUse.id,
-            content: 'Cancelled by user',
-            is_error: true,
-          }));
-          history.push({ role: 'user', content: cancelledBlocks });
+          const cancelledBlocks: ContentBlock[] = toolUseBlocks.map(
+            (toolUse) => ({
+              type: "tool_result" as const,
+              tool_use_id: toolUse.id,
+              content: "Cancelled by user",
+              is_error: true,
+            }),
+          );
+          history.push({ role: "user", content: cancelledBlocks });
           break;
         }
 
@@ -349,12 +462,12 @@ export class AgentLoop {
         // in the same response create competing browser sessions/windows and can
         // thrash renderer CPU. Reject browser_* calls in that turn.
         const hasComputerUseEscalation = toolUseBlocks.some(
-          (toolUse) => toolUse.name === 'computer_use_request_control',
+          (toolUse) => toolUse.name === "computer_use_request_control",
         );
         const blockedBrowserToolIds = hasComputerUseEscalation
           ? new Set(
               toolUseBlocks
-                .filter((toolUse) => toolUse.name.startsWith('browser_'))
+                .filter((toolUse) => toolUse.name.startsWith("browser_"))
                 .map((toolUse) => toolUse.id),
             )
           : new Set<string>();
@@ -365,7 +478,7 @@ export class AgentLoop {
               blockedBrowserToolCount: blockedBrowserToolIds.size,
               toolNames: toolUseBlocks.map((toolUse) => toolUse.name),
             },
-            'Blocking browser_* tools: computer_use_request_control was requested in same turn',
+            "Blocking browser_* tools: computer_use_request_control was requested in same turn",
           );
         }
 
@@ -380,25 +493,37 @@ export class AgentLoop {
               return {
                 toolUse,
                 result: {
-                  content: 'Error: browser_* tools cannot run in the same turn as computer_use_request_control. Continue using the foreground computer-use session only.',
+                  content:
+                    "Error: browser_* tools cannot run in the same turn as computer_use_request_control. Continue using the foreground computer-use session only.",
                   isError: true,
                 },
               };
             }
 
-            const result = await this.toolExecutor!(toolUse.name, toolUse.input, (chunk) => {
-              onEvent({ type: 'tool_output_chunk', toolUseId: toolUse.id, chunk });
-            });
+            const result = await this.toolExecutor!(
+              toolUse.name,
+              toolUse.input,
+              (chunk) => {
+                onEvent({
+                  type: "tool_output_chunk",
+                  toolUseId: toolUse.id,
+                  chunk,
+                });
+              },
+            );
 
             const toolDurationMs = Date.now() - toolStart;
 
             if (debug) {
-              rlog.debug({
-                tool: toolUse.name,
-                toolDurationMs,
-                isError: result.isError,
-                output: truncateForLog(result.content, 300),
-              }, 'Tool execution complete');
+              rlog.debug(
+                {
+                  tool: toolUse.name,
+                  toolDurationMs,
+                  isError: result.isError,
+                  output: truncateForLog(result.content, 300),
+                },
+                "Tool execution complete",
+              );
             }
 
             return { toolUse, result };
@@ -409,13 +534,19 @@ export class AgentLoop {
         if (signal && !signal.aborted) {
           let abortHandler!: () => void;
           const abortPromise = new Promise<never>((_, reject) => {
-            abortHandler = () => reject(new DOMException('The operation was aborted', 'AbortError'));
-            signal.addEventListener('abort', abortHandler, { once: true });
+            abortHandler = () =>
+              reject(
+                new DOMException("The operation was aborted", "AbortError"),
+              );
+            signal.addEventListener("abort", abortHandler, { once: true });
           });
           try {
-            toolResults = await Promise.race([toolExecutionPromise, abortPromise]);
+            toolResults = await Promise.race([
+              toolExecutionPromise,
+              abortPromise,
+            ]);
           } finally {
-            signal.removeEventListener('abort', abortHandler);
+            signal.removeEventListener("abort", abortHandler);
             // Suppress unhandled rejection from abandoned tool executions
             toolExecutionPromise.catch(() => {});
           }
@@ -435,21 +566,28 @@ export class AgentLoop {
         }
 
         // Collect result blocks preserving tool_use order (Promise.all maintains order)
-        const rawResultBlocks: ContentBlock[] = toolResults.map(({ toolUse, result }) => ({
-          type: 'tool_result' as const,
-          tool_use_id: toolUse.id,
-          content: result.content,
-          is_error: result.isError,
-          ...(result.contentBlocks ? { contentBlocks: result.contentBlocks } : {}),
-        }));
+        const rawResultBlocks: ContentBlock[] = toolResults.map(
+          ({ toolUse, result }) => ({
+            type: "tool_result" as const,
+            tool_use_id: toolUse.id,
+            content: result.content,
+            is_error: result.isError,
+            ...(result.contentBlocks
+              ? { contentBlocks: result.contentBlocks }
+              : {}),
+          }),
+        );
 
         // Pre-emptively truncate oversized tool results to prevent context overflow
-        const { blocks: resultBlocks, truncatedCount } = truncateOversizedToolResults(
-          rawResultBlocks,
-          this.config.maxInputTokens ?? 180_000,
-        );
+        const { blocks: resultBlocks, truncatedCount } =
+          truncateOversizedToolResults(
+            rawResultBlocks,
+            this.config.maxInputTokens ?? 180_000,
+          );
         if (truncatedCount > 0) {
-          log.warn(`Truncated ${truncatedCount} oversized tool result(s) to prevent context overflow`);
+          log.warn(
+            `Truncated ${truncatedCount} oversized tool result(s) to prevent context overflow`,
+          );
         }
 
         // Emit tool_result events AFTER truncation so downstream consumers
@@ -457,13 +595,14 @@ export class AgentLoop {
         for (const { toolUse, result } of toolResults) {
           // Look up the (possibly truncated) content from resultBlocks
           const truncatedBlock = resultBlocks.find(
-            (b) => b.type === 'tool_result' && b.tool_use_id === toolUse.id,
+            (b) => b.type === "tool_result" && b.tool_use_id === toolUse.id,
           );
-          const emitContent = (truncatedBlock && truncatedBlock.type === 'tool_result')
-            ? truncatedBlock.content
-            : result.content;
+          const emitContent =
+            truncatedBlock && truncatedBlock.type === "tool_result"
+              ? truncatedBlock.content
+              : result.content;
           onEvent({
-            type: 'tool_result',
+            type: "tool_result",
             toolUseId: toolUse.id,
             content: emitContent,
             isError: result.isError,
@@ -475,39 +614,44 @@ export class AgentLoop {
 
         // If cancelled during execution, push completed results and stop
         if (signal?.aborted) {
-          history.push({ role: 'user', content: resultBlocks });
+          history.push({ role: "user", content: resultBlocks });
           break;
         }
 
         // If any tool result requests yielding to the user (e.g. interactive
         // surface awaiting a button click), push results and stop the loop.
         if (toolResults.some(({ result }) => result.yieldToUser)) {
-          history.push({ role: 'user', content: resultBlocks });
+          history.push({ role: "user", content: resultBlocks });
           break;
         }
 
         // Track tool-use turns and inject progress reminder every N turns
         toolUseTurns++;
-        if (this.config.maxToolUseTurns && this.config.maxToolUseTurns > 0 && toolUseTurns >= this.config.maxToolUseTurns) {
+        if (
+          this.config.maxToolUseTurns &&
+          this.config.maxToolUseTurns > 0 &&
+          toolUseTurns >= this.config.maxToolUseTurns
+        ) {
           const limitMessage = `Tool-use turn limit reached (${this.config.maxToolUseTurns}). Stopping to prevent runaway loops; ask the user for guidance.`;
-          onEvent({ type: 'error', error: new Error(limitMessage) });
+          onEvent({ type: "error", error: new Error(limitMessage) });
           resultBlocks.push({
-            type: 'text',
+            type: "text",
             text: `<system_notice>${limitMessage}</system_notice>`,
           });
-          history.push({ role: 'user', content: resultBlocks });
+          history.push({ role: "user", content: resultBlocks });
           break;
         }
         // Soft warning a few turns before the hard limit
-        const softLimit = (this.config.maxToolUseTurns ?? 0) - APPROACHING_LIMIT_OFFSET;
+        const softLimit =
+          (this.config.maxToolUseTurns ?? 0) - APPROACHING_LIMIT_OFFSET;
         if (softLimit > 0 && toolUseTurns === softLimit) {
           resultBlocks.push({
-            type: 'text',
-            text: `<system_notice>${APPROACHING_LIMIT_WARNING.replace('{remaining}', String(APPROACHING_LIMIT_OFFSET))}</system_notice>`,
+            type: "text",
+            text: `<system_notice>${APPROACHING_LIMIT_WARNING.replace("{remaining}", String(APPROACHING_LIMIT_OFFSET))}</system_notice>`,
           });
         } else if (toolUseTurns % PROGRESS_CHECK_INTERVAL === 0) {
           resultBlocks.push({
-            type: 'text',
+            type: "text",
             text: `<system_notice>${PROGRESS_CHECK_REMINDER}</system_notice>`,
           });
         }
@@ -515,22 +659,25 @@ export class AgentLoop {
         // Remind the LLM not to repeat text it already streamed
         if (hasTextBlock) {
           resultBlocks.push({
-            type: 'text',
+            type: "text",
             text: '<system_notice>Your previous text was already shown to the user in real time. Do not repeat or rephrase it. Do not narrate retries or internal process chatter ("let me try", "that didn\'t work"). Keep working with tools silently unless you need user input, and only send user-facing text when you have concrete progress or final results.</system_notice>',
           });
         }
 
         // Add tool results as a user message and continue the loop
-        history.push({ role: 'user', content: resultBlocks });
+        history.push({ role: "user", content: resultBlocks });
 
         if (debug) {
           const turnDurationMs = Date.now() - turnStart;
-          rlog.debug({
-            turnDurationMs,
-            providerDurationMs,
-            toolCount: toolUseBlocks.length,
-            turn: toolUseTurns,
-          }, 'Turn complete');
+          rlog.debug(
+            {
+              turnDurationMs,
+              providerDurationMs,
+              toolCount: toolUseBlocks.length,
+              turn: toolUseTurns,
+            },
+            "Turn complete",
+          );
         }
 
         // Invoke checkpoint callback after tool results are in history
@@ -540,7 +687,7 @@ export class AgentLoop {
             toolCount: toolUseBlocks.length,
             hasToolUse: true,
           });
-          if (decision === 'yield') {
+          if (decision === "yield") {
             break;
           }
         }
@@ -550,20 +697,25 @@ export class AgentLoop {
         // Anthropic API (every tool_use must have a matching tool_result).
         if (signal?.aborted) {
           if (toolUseBlocks.length > 0) {
-            const cancelledBlocks: ContentBlock[] = toolUseBlocks.map((toolUse) => ({
-              type: 'tool_result' as const,
-              tool_use_id: toolUse.id,
-              content: 'Cancelled by user',
-              is_error: true,
-            }));
-            history.push({ role: 'user', content: cancelledBlocks });
+            const cancelledBlocks: ContentBlock[] = toolUseBlocks.map(
+              (toolUse) => ({
+                type: "tool_result" as const,
+                tool_use_id: toolUse.id,
+                content: "Cancelled by user",
+                is_error: true,
+              }),
+            );
+            history.push({ role: "user", content: cancelledBlocks });
           }
           break;
         }
         const err = error instanceof Error ? error : new Error(String(error));
-        rlog.error({ err, turn: toolUseTurns, messageCount: history.length }, 'Agent loop error during turn processing');
+        rlog.error(
+          { err, turn: toolUseTurns, messageCount: history.length },
+          "Agent loop error during turn processing",
+        );
         Sentry.captureException(err);
-        onEvent({ type: 'error', error: err });
+        onEvent({ type: "error", error: err });
         break;
       }
     }
@@ -572,7 +724,10 @@ export class AgentLoop {
   }
 }
 
-function summarizeMessage(msg: Message): { role: string; blockTypes: string[] } {
+function summarizeMessage(msg: Message): {
+  role: string;
+  blockTypes: string[];
+} {
   return {
     role: msg.role,
     blockTypes: msg.content.map((b) => b.type),
@@ -596,8 +751,8 @@ function stripOldImageBlocks(history: Message[]): Message[] {
   let lastToolResultUserIdx = -1;
   for (let i = history.length - 1; i >= 0; i--) {
     if (
-      history[i].role === 'user' &&
-      history[i].content.some((b) => b.type === 'tool_result')
+      history[i].role === "user" &&
+      history[i].content.some((b) => b.type === "tool_result")
     ) {
       lastToolResultUserIdx = i;
       break;
@@ -606,11 +761,15 @@ function stripOldImageBlocks(history: Message[]): Message[] {
 
   return history.map((msg, idx) => {
     // Keep the most recent tool-result user message intact (current turn)
-    if (idx === lastToolResultUserIdx || msg.role !== 'user') return msg;
+    if (idx === lastToolResultUserIdx || msg.role !== "user") return msg;
 
     // Check if any tool_result blocks have image contentBlocks
     const hasImages = msg.content.some(
-      (b) => b.type === 'tool_result' && (b as ToolResultContent).contentBlocks?.some(cb => cb.type === 'image'),
+      (b) =>
+        b.type === "tool_result" &&
+        (b as ToolResultContent).contentBlocks?.some(
+          (cb) => cb.type === "image",
+        ),
     );
     if (!hasImages) return msg;
 
@@ -618,13 +777,15 @@ function stripOldImageBlocks(history: Message[]): Message[] {
     return {
       ...msg,
       content: msg.content.map((b) => {
-        if (b.type !== 'tool_result') return b;
+        if (b.type !== "tool_result") return b;
         const tr = b as ToolResultContent;
-        if (!tr.contentBlocks?.some(cb => cb.type === 'image')) return b;
+        if (!tr.contentBlocks?.some((cb) => cb.type === "image")) return b;
         return {
           ...tr,
           contentBlocks: undefined,
-          content: (tr.content || '') + '\n[Screenshot was captured and shown previously — image data removed to save context.]',
+          content:
+            (tr.content || "") +
+            "\n[Screenshot was captured and shown previously — image data removed to save context.]",
         };
       }),
     };