@prestyj/agent 5.8.0 → 5.9.0

package/dist/index.cjs

@@ -215,7 +215,11 @@ function createAbortError() {
 }
 function abortablePromise(promise, signal) {
   if (!signal) return promise;
-  if (signal.aborted) return Promise.reject(createAbortError());
+  if (signal.aborted) {
+    promise.catch(() => {
+    });
+    return Promise.reject(createAbortError());
+  }
   return new Promise((resolve, reject) => {
     let settled = false;
     const cleanup = () => signal.removeEventListener("abort", onAbort);
@@ -271,6 +275,7 @@ async function* agentLoop(messages, options) {
   let overloadRetries = 0;
   let emptyResponseRetries = 0;
   let stallRetries = 0;
+  let runawayToolcallRetries = 0;
   let overflowCompactionAttempts = 0;
   let toolResultTruncationAttempted = false;
   const invalidToolArgumentCounts = /* @__PURE__ */ new Map();
@@ -279,11 +284,16 @@ async function* agentLoop(messages, options) {
   const MAX_OVERLOAD_RETRIES = 10;
   const MAX_EMPTY_RESPONSE_RETRIES = 2;
   const MAX_STALL_RETRIES = 10;
+  const MAX_RUNAWAY_TOOLCALL_RETRIES = 2;
+  const RUNAWAY_TOOLCALL_RETRY_DELAY_MS = 1e3;
   const MAX_OVERFLOW_COMPACTIONS = 2;
   const STALL_RETRIES_BEFORE_NON_STREAMING = 2;
   const STALL_DELAY_MS = 1e3;
   const MIN_PARTIAL_PRESERVE_CHARS = 200;
   const PARTIAL_CONTINUATION_PROMPT = "[Your previous response was cut off by a connection failure. The text above is what was already delivered to the user. Continue exactly from where it stopped \u2014 do not repeat or restart it.]";
+  const MAX_OUTPUT_CONTINUATIONS = 2;
+  const MAX_TOKENS_CONTINUATION_PROMPT = "[Your previous response hit the output-token limit and was cut off. The text above is what was already delivered to the user. Continue exactly from where it stopped \u2014 do not repeat or restart it.]";
+  let maxTokensContinuations = 0;
   const OVERLOAD_BASE_DELAY_MS = 2e3;
   const OVERLOAD_MAX_DELAY_MS = 3e4;
   const STREAM_FIRST_EVENT_TIMEOUT_MS = 45e3;
@@ -686,11 +696,33 @@ async function* agentLoop(messages, options) {
             provider: options.provider,
             model: options.model
           });
+          if (runawayToolcallRetries < MAX_RUNAWAY_TOOLCALL_RETRIES) {
+            runawayToolcallRetries++;
+            const delayMs = RUNAWAY_TOOLCALL_RETRY_DELAY_MS * runawayToolcallRetries;
+            diag("retry", {
+              reason: "runaway_toolcall",
+              attempt: runawayToolcallRetries,
+              maxAttempts: MAX_RUNAWAY_TOOLCALL_RETRIES,
+              delayMs,
+              ...runawayDetected
+            });
+            yield {
+              type: "retry",
+              reason: "runaway_toolcall",
+              attempt: runawayToolcallRetries,
+              maxAttempts: MAX_RUNAWAY_TOOLCALL_RETRIES,
+              delayMs,
+              silent: true
+            };
+            await abortableSleep(delayMs, options.signal);
+            turn--;
+            continue;
+          }
           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.`
+              `The model repeatedly failed to close a tool call after ${MAX_RUNAWAY_TOOLCALL_RETRIES} automatic retries (${detail}). Switch models and retry; your conversation is preserved.`
             )
           };
           break;
@@ -791,6 +823,7 @@ async function* agentLoop(messages, options) {
       }
       overloadRetries = 0;
       stallRetries = 0;
+      runawayToolcallRetries = 0;
       const contentArr = Array.isArray(response.message.content) ? response.message.content : null;
       const hasActionableContent = response.message.content !== "" && contentArr !== null && contentArr.some(
         (p) => p.type === "text" || p.type === "tool_call" || p.type === "server_tool_call"
@@ -862,6 +895,27 @@ async function* agentLoop(messages, options) {
       consecutivePauses = 0;
       const allToolCalls = extractToolCalls(response.message.content);
       if (response.stopReason !== "tool_use" && allToolCalls.length === 0) {
+        if (response.stopReason === "max_tokens") {
+          if (maxTokensContinuations < MAX_OUTPUT_CONTINUATIONS) {
+            maxTokensContinuations++;
+            diag("max_tokens_continuation", {
+              attempt: maxTokensContinuations,
+              maxAttempts: MAX_OUTPUT_CONTINUATIONS,
+              provider: options.provider,
+              model: options.model
+            });
+            yield { type: "truncated", reason: "max_tokens", continued: true };
+            messages.push({ role: "user", content: MAX_TOKENS_CONTINUATION_PROMPT });
+            continue;
+          }
+          yield { type: "truncated", reason: "max_tokens", continued: false };
+        } else if (response.stopReason === "refusal" || response.stopReason === "error") {
+          yield {
+            type: "truncated",
+            reason: response.stopReason === "refusal" ? "refusal" : "provider_error",
+            continued: false
+          };
+        }
         if (options.getSteeringMessages) {
           const steering = await options.getSteeringMessages();
           if (steering && steering.length > 0) {
@@ -1228,16 +1282,22 @@ function capToolResults(toolResults, maxToolResultChars) {
   const max = Math.min(maxToolResultChars, hardMax);
   for (const toolResult of toolResults) {
     if (typeof toolResult.content !== "string" || toolResult.content.length <= max) continue;
+    const originalChars = toolResult.content.length;
     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;
+    const omitted = originalChars - headChars - tailChars;
     toolResult.content = head + `
 
 [... ${omitted} characters omitted ...]
 
 ` + tail;
+    toolResult.capped = {
+      originalChars,
+      keptChars: toolResult.content.length,
+      scope: "per-result"
+    };
   }
 }
 function capTurnToolResults(toolResults, maxTurnToolResultChars) {
@@ -1258,14 +1318,20 @@ function capTurnToolResults(toolResults, maxTurnToolResultChars) {
       continue;
     }
     remaining -= fairShare;
+    const originalChars = toolResult.content.length;
     const headChars = Math.floor(fairShare * 0.7);
     const tailChars = fairShare - headChars;
-    const omitted = toolResult.content.length - fairShare;
+    const omitted = originalChars - fairShare;
     toolResult.content = toolResult.content.slice(0, headChars) + `
 
 [... ${omitted} characters trimmed: this turn's combined tool results exceeded the per-turn budget. Re-run this call alone with narrower filters or offset/limit if you need the omitted content ...]
 
 ` + (tailChars > 0 ? toolResult.content.slice(-tailChars) : "");
+    toolResult.capped = {
+      originalChars: toolResult.capped?.originalChars ?? originalChars,
+      keptChars: toolResult.content.length,
+      scope: "per-turn"
+    };
   }
 }
 function normalizeToolResult(raw) {