@prestyj/agent 4.3.161 → 4.3.200

package/dist/index.js

@@ -2,6 +2,7 @@
 import { EventStream as EventStream2 } from "@prestyj/ai";
 
 // src/agent-loop.ts
+import { ZodError, prettifyError } from "zod";
 import {
   stream,
   EventStream
@@ -26,6 +27,44 @@ function isContextOverflow(err) {
   const msg = err.message.toLowerCase();
   return msg.includes("prompt is too long") || msg.includes("prompt too long") || msg.includes("input is too long") || msg.includes("context_length_exceeded") || msg.includes("context_window_exceeded") || msg.includes("maximum context length") || msg.includes("exceeds model context window") || msg.includes("exceeds the context window") || msg.includes("content_too_large") || msg.includes("request_too_large") || msg.includes("reduce the length") || msg.includes("please shorten") || msg.includes("token") && msg.includes("exceed");
 }
+function parseOverflowNumber(value) {
+  return Number(value.replace(/[,_\s]/g, ""));
+}
+function extractContextOverflowDetails(err) {
+  if (!(err instanceof Error)) return {};
+  const text = err.message;
+  const patterns = [
+    // Anthropic/OpenAI-compatible: "203456 tokens > 200000 maximum"
+    {
+      regex: /([\d,_.\s]+)\s*tokens?\s*>\s*([\d,_.\s]+)\s*(?:maximum|max|limit)?/i,
+      tokensGroup: 1,
+      limitGroup: 2
+    },
+    // OpenAI: "maximum context length is 128000 tokens ... resulted in 130000 tokens"
+    {
+      regex: /maximum context length is\s*([\d,_.\s]+)\s*tokens?[\s\S]*?resulted in\s*([\d,_.\s]+)\s*tokens?/i,
+      tokensGroup: 2,
+      limitGroup: 1
+    },
+    // Generic: "130000 input tokens exceeds 128000 token limit"
+    {
+      regex: /([\d,_.\s]+)\s*(?:input\s*)?tokens?[\s\S]{0,80}?exceeds?[\s\S]{0,80}?([\d,_.\s]+)\s*(?:token\s*)?(?:limit|maximum|max)/i,
+      tokensGroup: 1,
+      limitGroup: 2
+    }
+  ];
+  for (const pattern of patterns) {
+    const match = text.match(pattern.regex);
+    if (!match) continue;
+    const observedTokens = parseOverflowNumber(match[pattern.tokensGroup] ?? "");
+    const observedLimit = parseOverflowNumber(match[pattern.limitGroup] ?? "");
+    return {
+      ...Number.isFinite(observedTokens) && observedTokens > 0 ? { observedTokens } : {},
+      ...Number.isFinite(observedLimit) && observedLimit > 0 ? { observedLimit } : {}
+    };
+  }
+  return {};
+}
 function isBillingError(err) {
   if (!(err instanceof Error)) return false;
   const msg = err.message.toLowerCase();
@@ -37,11 +76,22 @@ function isToolPairingError(err) {
   return msg.includes("tool_use") && msg.includes("tool_result") || msg.includes("unexpected `tool_use_id`") || msg.includes("tool_use ids found without") || // Moonshot/OpenAI-compatible: "tool call id <id> is not found"
   msg.includes("tool call id") && msg.includes("is not found");
 }
-function isOverloaded(err) {
-  if (!(err instanceof Error)) return false;
-  if (isBillingError(err)) return false;
+function classifyOverload(err) {
+  if (!(err instanceof Error)) return null;
+  if (isBillingError(err)) return null;
   const msg = err.message.toLowerCase();
-  return msg.includes("overloaded") || msg.includes("rate limit") || msg.includes("too many requests") || msg.includes("429") || msg.includes("529");
+  const errorWithStatus = err;
+  const statusCode = typeof errorWithStatus.statusCode === "number" ? errorWithStatus.statusCode : void 0;
+  if (statusCode === 429 || msg.includes("rate_limit") || msg.includes("rate limit") || msg.includes("too many requests") || msg.includes("429")) {
+    return "rate_limit";
+  }
+  if (statusCode === 529 || msg.includes("overloaded") || msg.includes("529")) {
+    return "overloaded";
+  }
+  if (statusCode === 500 || statusCode === 502 || statusCode === 503 || statusCode === 504 || msg.includes("api_error") || msg.includes("server_error") || msg.includes("internal server error") || msg.includes("bad gateway") || msg.includes("service unavailable") || msg.includes("gateway timeout")) {
+    return "provider_error";
+  }
+  return null;
 }
 function isMalformedStream(err) {
   if (!(err instanceof Error)) return false;
@@ -51,6 +101,46 @@ function isMalformedStream(err) {
   const msg = err.message;
   return /\bin JSON at position \d+/i.test(msg);
 }
+function isTransportFailure(err) {
+  const codes = /* @__PURE__ */ new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ECONNABORTED",
+    "ETIMEDOUT",
+    "EPIPE",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "ENOTFOUND",
+    "UND_ERR_SOCKET",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_HEADERS_TIMEOUT",
+    "UND_ERR_BODY_TIMEOUT",
+    "UND_ERR_RESPONSE_STATUS_CODE",
+    "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH",
+    "UND_ERR_RES_CONTENT_LENGTH_MISMATCH"
+  ]);
+  const messages = [
+    /^terminated$/i,
+    /\bother side closed\b/i,
+    /\bsocket hang up\b/i,
+    /\bfetch failed\b/i,
+    /\bbody timeout error\b/i,
+    /\bsse stream disconnected\b/i,
+    /\bfailed to reconnect sse stream\b/i
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  let cur = err;
+  while (cur && typeof cur === "object" && !seen.has(cur)) {
+    seen.add(cur);
+    const e = cur;
+    if (typeof e.code === "string" && codes.has(e.code)) return true;
+    if (typeof e.message === "string") {
+      for (const re of messages) if (re.test(e.message)) return true;
+    }
+    cur = e.cause;
+  }
+  return false;
+}
 function abortableSleep(ms, signal) {
   if (signal?.aborted) {
     return Promise.reject(new DOMException("Aborted", "AbortError"));
@@ -81,6 +171,8 @@ async function* agentLoop(messages, options) {
   let emptyResponseRetries = 0;
   let stallRetries = 0;
   let overflowCompactionAttempts = 0;
+  let toolResultTruncationAttempted = false;
+  const invalidToolArgumentCounts = /* @__PURE__ */ new Map();
   let useNonStreamingFallback = false;
   const MAX_OVERLOAD_RETRIES = 10;
   const MAX_EMPTY_RESPONSE_RETRIES = 2;
@@ -97,6 +189,8 @@ async function* agentLoop(messages, options) {
   const STREAM_THINKING_IDLE_TIMEOUT_MS = 3e5;
   const STREAM_THINKING_HARD_TIMEOUT_MS = 6e5;
   const NON_STREAMING_HARD_TIMEOUT_MS = 3e5;
+  const MAX_TOOLCALL_DELTA_CHARS = 1e6;
+  const MAX_TOOLCALL_DELTA_EVENTS = 2e4;
   try {
     while (turn < maxTurns) {
       options.signal?.throwIfAborted();
@@ -152,6 +246,9 @@ async function* agentLoop(messages, options) {
       let streamCallStart = Date.now();
       const eventTypeCounts = {};
       let lastEventType = "";
+      let toolcallDeltaChars = 0;
+      let toolcallDeltaCount = 0;
+      let runawayDetected = null;
       let lastYieldEndTime = Date.now();
       let maxConsumerLagMs = 0;
       const forwardAbort = () => streamController.abort();
@@ -202,9 +299,12 @@ async function* agentLoop(messages, options) {
           signal: streamController.signal,
           accountId: options.accountId,
           cacheRetention: options.cacheRetention,
+          promptCacheKey: options.promptCacheKey,
+          serviceTier: options.serviceTier,
           supportsImages: options.supportsImages,
           compaction: options.compaction,
           clearToolUses: options.clearToolUses,
+          userAgent: options.userAgent,
           // Flip to non-streaming fallback after repeated stream stalls.
           ...useNonStreamingFallback ? { streaming: false } : {}
         });
@@ -215,11 +315,14 @@ async function* agentLoop(messages, options) {
         hasReceivedEvent = false;
         lastEventTime = Date.now();
         streamCallStart = Date.now();
+        lastYieldEndTime = Date.now();
         resetIdleTimer();
         for await (const event of result) {
           const pullTime = Date.now();
           const consumerLag = pullTime - lastYieldEndTime;
-          if (consumerLag > maxConsumerLagMs) maxConsumerLagMs = consumerLag;
+          if (streamEventCount > 0 && consumerLag > maxConsumerLagMs) {
+            maxConsumerLagMs = consumerLag;
+          }
           streamEventCount++;
           eventTypeCounts[event.type] = (eventTypeCounts[event.type] ?? 0) + 1;
           lastEventType = event.type;
@@ -278,9 +381,25 @@ async function* agentLoop(messages, options) {
               data: event.data
             };
           } else if (event.type === "toolcall_delta") {
+            const chunkChars = event.argsJson?.length ?? 0;
+            toolcallDeltaChars += chunkChars;
+            toolcallDeltaCount++;
+            if (!runawayDetected && (toolcallDeltaChars > MAX_TOOLCALL_DELTA_CHARS || toolcallDeltaCount > MAX_TOOLCALL_DELTA_EVENTS)) {
+              runawayDetected = {
+                kind: toolcallDeltaChars > MAX_TOOLCALL_DELTA_CHARS ? "chars" : "events",
+                chars: toolcallDeltaChars,
+                events: toolcallDeltaCount
+              };
+              diag("runaway_toolcall_detected", {
+                ...runawayDetected,
+                provider: options.provider,
+                model: options.model
+              });
+              streamController.abort();
+            }
             yield {
               type: "toolcall_delta",
-              chars: event.argsJson?.length ?? 0
+              chars: chunkChars
             };
           }
           lastYieldEndTime = Date.now();
@@ -305,12 +424,44 @@ async function* agentLoop(messages, options) {
           model: options.model
         });
         if (isContextOverflow(err)) {
+          const overflowDetails = extractContextOverflowDetails(err);
+          diag("context_overflow_detected", {
+            ...overflowDetails,
+            error: errMsg.slice(0, 500),
+            messages: messages.length
+          });
+          const overflowToolResultMaxChars = Math.min(
+            options.maxToolResultChars ?? 1e5,
+            1e5
+          );
+          if (!toolResultTruncationAttempted) {
+            toolResultTruncationAttempted = true;
+            const truncated = truncateOversizedToolResults(messages, overflowToolResultMaxChars);
+            diag("overflow_tool_result_truncation", {
+              truncated,
+              maxChars: overflowToolResultMaxChars
+            });
+            if (truncated) {
+              yield {
+                type: "retry",
+                reason: "overflow_compact",
+                attempt: overflowCompactionAttempts + 1,
+                maxAttempts: MAX_OVERFLOW_COMPACTIONS,
+                delayMs: 0,
+                ...overflowDetails,
+                silent: true
+              };
+              turn--;
+              continue;
+            }
+          }
           if (options.transformContext && overflowCompactionAttempts < MAX_OVERFLOW_COMPACTIONS) {
             overflowCompactionAttempts++;
             diag("overflow_compact_start", {
               attempt: overflowCompactionAttempts,
               maxAttempts: MAX_OVERFLOW_COMPACTIONS,
-              messages: messages.length
+              messages: messages.length,
+              ...overflowDetails
             });
             try {
               const compacted = await options.transformContext(messages, { force: true });
@@ -319,14 +470,16 @@ async function* agentLoop(messages, options) {
                 messages.push(...compacted);
                 diag("overflow_compact_success", {
                   attempt: overflowCompactionAttempts,
-                  messages: messages.length
+                  messages: messages.length,
+                  ...overflowDetails
                 });
                 yield {
                   type: "retry",
                   reason: "overflow_compact",
                   attempt: overflowCompactionAttempts,
                   maxAttempts: MAX_OVERFLOW_COMPACTIONS,
-                  delayMs: 0
+                  delayMs: 0,
+                  ...overflowDetails
                 };
                 turn--;
                 continue;
@@ -334,32 +487,35 @@ async function* agentLoop(messages, options) {
               diag("overflow_compact_noop", {
                 attempt: overflowCompactionAttempts,
                 before: messages.length,
-                after: compacted.length
+                after: compacted.length,
+                ...overflowDetails
               });
             } catch (compactErr) {
               diag("overflow_compact_failed", {
-                error: compactErr instanceof Error ? compactErr.message : String(compactErr)
+                error: compactErr instanceof Error ? compactErr.message : String(compactErr),
+                ...overflowDetails
               });
             }
           }
           yield { type: "error", error: err instanceof Error ? err : new Error(errMsg) };
           throw err;
         }
-        if (overloadRetries < MAX_OVERLOAD_RETRIES && isOverloaded(err)) {
+        const overloadKind = classifyOverload(err);
+        if (overloadRetries < MAX_OVERLOAD_RETRIES && overloadKind) {
           overloadRetries++;
           const delayMs = Math.min(
             OVERLOAD_BASE_DELAY_MS * 2 ** (overloadRetries - 1),
             OVERLOAD_MAX_DELAY_MS
           );
           diag("retry", {
-            reason: "overloaded",
+            reason: overloadKind,
             attempt: overloadRetries,
             maxAttempts: MAX_OVERLOAD_RETRIES,
             delayMs
           });
           yield {
             type: "retry",
-            reason: "overloaded",
+            reason: overloadKind,
             attempt: overloadRetries,
             maxAttempts: MAX_OVERLOAD_RETRIES,
             delayMs
@@ -368,22 +524,39 @@ async function* agentLoop(messages, options) {
           turn--;
           continue;
         }
+        if (runawayDetected) {
+          diag("runaway_toolcall_aborted", {
+            ...runawayDetected,
+            provider: options.provider,
+            model: options.model
+          });
+          const detail = runawayDetected.kind === "chars" ? `${(runawayDetected.chars / 1024).toFixed(0)} KB of tool-call arguments` : `${runawayDetected.events} tool-call delta events`;
+          yield {
+            type: "error",
+            error: new Error(
+              `The model glitched mid-tool-call and produced ${detail} without closing the call. This is usually an upstream model bug \u2014 try the same request again or switch models. Your conversation is preserved.`
+            )
+          };
+          break;
+        }
         const malformed = isMalformedStream(err);
-        const transportFailure = (idleTimedOut || malformed) && !options.signal?.aborted;
+        const socketDrop = isTransportFailure(err);
+        const transportFailure = (idleTimedOut || malformed || socketDrop) && !options.signal?.aborted;
         if (transportFailure && stallRetries < MAX_STALL_RETRIES) {
           stallRetries++;
+          const cause = malformed ? "malformed_stream" : socketDrop ? "socket_drop" : "stream_stall";
           if (!useNonStreamingFallback && stallRetries >= STALL_RETRIES_BEFORE_NON_STREAMING) {
             useNonStreamingFallback = true;
             diag("non_streaming_fallback_enabled", {
               stallRetries,
               provider: options.provider,
               model: options.model,
-              cause: malformed ? "malformed_stream" : "stream_stall"
+              cause
             });
           }
           const delayMs = Math.min(STALL_DELAY_MS * 2 ** (stallRetries - 1), 8e3);
           diag("retry", {
-            reason: malformed ? "malformed_stream" : "stream_stall",
+            reason: cause,
             attempt: stallRetries,
             maxAttempts: MAX_STALL_RETRIES,
             delayMs,
@@ -538,117 +711,26 @@ async function* agentLoop(messages, options) {
           toolCalls.push(tc);
         }
       }
-      const eventStream = new EventStream();
-      const executions = toolCalls.map(async (toolCall) => {
-        const startTime = Date.now();
-        eventStream.push({
-          type: "tool_call_start",
-          toolCallId: toolCall.id,
-          name: toolCall.name,
-          args: toolCall.args
-        });
-        let resultContent;
-        let details;
-        let isError = false;
-        const tool = toolMap.get(toolCall.name);
-        if (!tool) {
-          resultContent = `Unknown tool: ${toolCall.name}`;
-          isError = true;
-        } else {
-          try {
-            const parsed = tool.parameters.parse(toolCall.args);
-            const ctx = {
-              signal: options.signal ?? AbortSignal.timeout(3e5),
-              toolCallId: toolCall.id,
-              onUpdate: (update) => {
-                eventStream.push({
-                  type: "tool_call_update",
-                  toolCallId: toolCall.id,
-                  update
-                });
-              }
-            };
-            const raw = await tool.execute(parsed, ctx);
-            const normalized = normalizeToolResult(raw);
-            resultContent = normalized.content;
-            details = normalized.details;
-          } catch (err) {
-            isError = true;
-            resultContent = err instanceof Error ? err.message : String(err);
-          }
-        }
-        const durationMs = Date.now() - startTime;
-        eventStream.push({
-          type: "tool_call_end",
-          toolCallId: toolCall.id,
-          result: toolResultPreview(resultContent),
-          details,
-          isError,
-          durationMs
-        });
-        return { toolCallId: toolCall.id, content: resultContent, isError };
-      });
-      const abortHandler = () => eventStream.abort(new Error("aborted"));
-      options.signal?.addEventListener("abort", abortHandler, { once: true });
-      let toolResultsFinalized = false;
-      Promise.all(executions).then((results) => {
-        if (toolResultsFinalized) return;
-        const resultsMap = new Map(results.map((r) => [r.toolCallId, r]));
-        for (const tc of toolCalls) {
-          const r = resultsMap.get(tc.id);
-          toolResults.push({
-            type: "tool_result",
-            toolCallId: tc.id,
-            content: r.content,
-            isError: r.isError || void 0
-          });
-        }
-        eventStream.close();
-      }).catch((err) => eventStream.abort(err instanceof Error ? err : new Error(String(err))));
-      let toolsAborted = false;
-      try {
-        for await (const event of eventStream) {
-          yield event;
-        }
-      } catch (err) {
-        if (isAbortError(err) || options.signal?.aborted) {
-          toolsAborted = true;
-        } else {
-          throw err;
-        }
-      } finally {
-        options.signal?.removeEventListener("abort", abortHandler);
-        toolResultsFinalized = true;
-        const resolvedIds = new Set(toolResults.map((r) => r.toolCallId));
-        for (const tc of toolCalls) {
-          if (!resolvedIds.has(tc.id)) {
-            toolResults.push({
-              type: "tool_result",
-              toolCallId: tc.id,
-              content: "Tool execution was aborted.",
-              isError: true
-            });
-          }
-        }
-        if (options.maxToolResultChars) {
-          const HARD_MAX = 4e5;
-          const max = Math.min(options.maxToolResultChars, HARD_MAX);
-          for (const tr of toolResults) {
-            if (typeof tr.content === "string" && tr.content.length > max) {
-              const headChars = Math.floor(max * 0.7);
-              const tailChars = max - headChars;
-              const head = tr.content.slice(0, headChars);
-              const tail = tr.content.slice(-tailChars);
-              const omitted = tr.content.length - headChars - tailChars;
-              tr.content = head + `
-
-[... ${omitted} characters omitted ...]
-
-` + tail;
-            }
-          }
-        }
-        messages.push({ role: "tool", content: toolResults });
+      let fatalToolArgumentError = null;
+      const markFatalToolArgumentError = (error) => {
+        fatalToolArgumentError = error;
+      };
+      const executionOptions = {
+        signal: options.signal,
+        maxToolResultChars: options.maxToolResultChars,
+        toolMap,
+        invalidToolArgumentCounts,
+        markFatalToolArgumentError
+      };
+      const hasSequentialToolCall = toolCalls.some(
+        (toolCall) => toolMap.get(toolCall.name)?.executionMode === "sequential"
+      );
+      const executionResult = hasSequentialToolCall ? yield* executeToolCallsSequential(toolCalls, toolResults, executionOptions) : yield* executeToolCallsParallel(toolCalls, toolResults, executionOptions);
+      messages.push({ role: "tool", content: executionResult.toolResults });
+      const toolsAborted = executionResult.aborted;
+      if (fatalToolArgumentError) {
+        yield { type: "error", error: fatalToolArgumentError };
+        break;
       }
       if (toolsAborted) break;
       if (options.getSteeringMessages) {
@@ -682,6 +764,197 @@ async function* agentLoop(messages, options) {
     totalUsage: { ...totalUsage }
   };
 }
+function pushToolEvent(eventStream, state, event) {
+  if (!state.finalized) eventStream.push(event);
+}
+async function executeSingleToolCall(toolCall, options, pushEvent) {
+  const startTime = Date.now();
+  pushEvent({
+    type: "tool_call_start",
+    toolCallId: toolCall.id,
+    name: toolCall.name,
+    args: toolCall.args
+  });
+  let resultContent;
+  let details;
+  let isError = false;
+  const tool = options.toolMap.get(toolCall.name);
+  if (!tool) {
+    resultContent = `Unknown tool: ${toolCall.name}`;
+    isError = true;
+  } else {
+    try {
+      const parsed = tool.parameters.parse(toolCall.args);
+      const ctx = {
+        signal: options.signal ?? AbortSignal.timeout(3e5),
+        toolCallId: toolCall.id,
+        onUpdate: (update) => {
+          pushEvent({
+            type: "tool_call_update",
+            toolCallId: toolCall.id,
+            update
+          });
+        }
+      };
+      const raw = await tool.execute(parsed, ctx);
+      const normalized = normalizeToolResult(raw);
+      resultContent = normalized.content;
+      details = normalized.details;
+      for (const key of options.invalidToolArgumentCounts.keys()) {
+        if (key.startsWith(`${toolCall.name}:`)) options.invalidToolArgumentCounts.delete(key);
+      }
+    } catch (err) {
+      isError = true;
+      if (err instanceof ZodError) {
+        const prettyError = prettifyError(err);
+        const failureKey = `${toolCall.name}:${prettyError}`;
+        const failureCount = (options.invalidToolArgumentCounts.get(failureKey) ?? 0) + 1;
+        options.invalidToolArgumentCounts.set(failureKey, failureCount);
+        resultContent = `Invalid arguments for tool \`${toolCall.name}\`:
+` + prettyError + "\nRe-issue the call with each field as the correct type.";
+        if (failureCount >= 3) {
+          options.markFatalToolArgumentError(
+            new Error(
+              `The model repeatedly issued invalid arguments for tool \`${toolCall.name}\`. This is usually an upstream model/tool-calling bug. Your conversation is preserved; send another message or switch models to continue.`
+            )
+          );
+        }
+      } else {
+        resultContent = err instanceof Error ? err.message : String(err);
+      }
+    }
+  }
+  const durationMs = Date.now() - startTime;
+  pushEvent({
+    type: "tool_call_end",
+    toolCallId: toolCall.id,
+    result: toolResultPreview(resultContent),
+    details,
+    isError,
+    durationMs
+  });
+  return { toolCallId: toolCall.id, content: resultContent, isError };
+}
+async function* executeToolCallsSequential(toolCalls, initialToolResults, options) {
+  const eventStream = new EventStream();
+  const state = { finalized: false };
+  const resultsById = /* @__PURE__ */ new Map();
+  const abortHandler = () => eventStream.abort(new Error("aborted"));
+  options.signal?.addEventListener("abort", abortHandler, { once: true });
+  void (async () => {
+    try {
+      for (const toolCall of toolCalls) {
+        if (options.signal?.aborted) break;
+        const record = await executeSingleToolCall(
+          toolCall,
+          options,
+          (event) => pushToolEvent(eventStream, state, event)
+        );
+        resultsById.set(record.toolCallId, record);
+      }
+      if (!state.finalized) eventStream.close();
+    } catch (err) {
+      if (!state.finalized) eventStream.abort(err instanceof Error ? err : new Error(String(err)));
+    }
+  })();
+  let aborted = false;
+  try {
+    for await (const event of eventStream) {
+      yield event;
+    }
+  } catch (err) {
+    if (isAbortError(err) || options.signal?.aborted) {
+      aborted = true;
+    } else {
+      throw err;
+    }
+  } finally {
+    options.signal?.removeEventListener("abort", abortHandler);
+    state.finalized = true;
+  }
+  const toolResults = buildToolResults(initialToolResults, toolCalls, resultsById);
+  capToolResults(toolResults, options.maxToolResultChars);
+  return { toolResults, aborted };
+}
+async function* executeToolCallsParallel(toolCalls, initialToolResults, options) {
+  const eventStream = new EventStream();
+  const state = { finalized: false };
+  const resultsById = /* @__PURE__ */ new Map();
+  const abortHandler = () => eventStream.abort(new Error("aborted"));
+  options.signal?.addEventListener("abort", abortHandler, { once: true });
+  Promise.all(
+    toolCalls.map(async (toolCall) => {
+      const record = await executeSingleToolCall(
+        toolCall,
+        options,
+        (event) => pushToolEvent(eventStream, state, event)
+      );
+      resultsById.set(record.toolCallId, record);
+    })
+  ).then(() => {
+    if (!state.finalized) eventStream.close();
+  }).catch((err) => {
+    if (!state.finalized) eventStream.abort(err instanceof Error ? err : new Error(String(err)));
+  });
+  let aborted = false;
+  try {
+    for await (const event of eventStream) {
+      yield event;
+    }
+  } catch (err) {
+    if (isAbortError(err) || options.signal?.aborted) {
+      aborted = true;
+    } else {
+      throw err;
+    }
+  } finally {
+    options.signal?.removeEventListener("abort", abortHandler);
+    state.finalized = true;
+  }
+  const toolResults = buildToolResults(initialToolResults, toolCalls, resultsById);
+  capToolResults(toolResults, options.maxToolResultChars);
+  return { toolResults, aborted };
+}
+function buildToolResults(initialToolResults, toolCalls, resultsById) {
+  const toolResults = [...initialToolResults];
+  for (const toolCall of toolCalls) {
+    const result = resultsById.get(toolCall.id);
+    if (result) {
+      toolResults.push({
+        type: "tool_result",
+        toolCallId: toolCall.id,
+        content: result.content,
+        isError: result.isError || void 0
+      });
+    } else {
+      toolResults.push({
+        type: "tool_result",
+        toolCallId: toolCall.id,
+        content: "Tool execution was aborted.",
+        isError: true
+      });
+    }
+  }
+  return toolResults;
+}
+function capToolResults(toolResults, maxToolResultChars) {
+  if (!maxToolResultChars) return;
+  const hardMax = 4e5;
+  const max = Math.min(maxToolResultChars, hardMax);
+  for (const toolResult of toolResults) {
+    if (typeof toolResult.content !== "string" || toolResult.content.length <= max) continue;
+    const headChars = Math.floor(max * 0.7);
+    const tailChars = max - headChars;
+    const head = toolResult.content.slice(0, headChars);
+    const tail = toolResult.content.slice(-tailChars);
+    const omitted = toolResult.content.length - headChars - tailChars;
+    toolResult.content = head + `
+
+[... ${omitted} characters omitted ...]
+
+` + tail;
+  }
+}
 function normalizeToolResult(raw) {
   return typeof raw === "string" ? { content: raw } : raw;
 }
@@ -689,6 +962,44 @@ function toolResultPreview(content) {
   if (typeof content === "string") return content;
   return content.map((block) => block.type === "text" ? block.text : `[image ${block.mediaType}]`).join("\n");
 }
+function truncateToolResultText(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  const tailChars = Math.min(Math.floor(maxChars * 0.3), 2e4);
+  const headChars = Math.max(maxChars - tailChars, 0);
+  const omitted = text.length - headChars - tailChars;
+  return `${text.slice(0, headChars)}
+
+[... ${omitted} characters omitted after context overflow ...]
+
+${text.slice(-tailChars)}`;
+}
+function truncateOversizedToolResults(messages, maxChars) {
+  if (maxChars <= 0) return false;
+  let changed = false;
+  for (const msg of messages) {
+    if (msg.role !== "tool" || !Array.isArray(msg.content)) continue;
+    const results = msg.content;
+    for (const result of results) {
+      if (typeof result.content === "string") {
+        const truncated = truncateToolResultText(result.content, maxChars);
+        if (truncated !== result.content) {
+          result.content = truncated;
+          changed = true;
+        }
+      } else {
+        for (const block of result.content) {
+          if (block.type !== "text") continue;
+          const truncated = truncateToolResultText(block.text, maxChars);
+          if (truncated !== block.text) {
+            block.text = truncated;
+            changed = true;
+          }
+        }
+      }
+    }
+  }
+  return changed;
+}
 function extractToolCalls(content) {
   if (typeof content === "string") return [];
   return content.filter((part) => part.type === "tool_call");