@prestyj/agent 5.7.0 → 5.9.0

package/dist/index.cjs

@@ -154,7 +154,7 @@ function classifyOverload(err) {
   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")) {
+  if (statusCode === 500 || statusCode === 502 || statusCode === 503 || statusCode === 504 || statusCode === 507 || 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") || msg.includes("exceeded request buffer limit while retrying upstream")) {
     return "provider_error";
   }
   if (isOpaqueProviderMessage(err.message)) {
@@ -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);
@@ -260,6 +264,8 @@ async function* agentLoop(messages, options) {
   const maxContinuations = options.maxContinuations ?? 5;
   let toolMap = new Map((options.tools ?? []).map((t) => [t.name, t]));
   const totalUsage = { inputTokens: 0, outputTokens: 0 };
+  let latestProviderUsage;
+  let usageAnchorIndex;
   let turn = 0;
   let hitMaxTurns = false;
   let firstTurn = true;
@@ -269,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();
@@ -277,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;
@@ -336,7 +348,11 @@ async function* agentLoop(messages, options) {
       firstTurn = false;
       if (options.transformContext) {
         diag("transform_start");
-        const transformed = await options.transformContext(messages);
+        const pendingMessages = usageAnchorIndex === void 0 ? [] : messages.slice(usageAnchorIndex + 1);
+        const transformed = await options.transformContext(messages, {
+          usage: latestProviderUsage,
+          pendingMessages
+        });
         if (transformed !== messages) {
           diag("transform_compacted", {
             before: messages.length,
@@ -344,6 +360,8 @@ async function* agentLoop(messages, options) {
           });
           messages.length = 0;
           messages.push(...transformed);
+          latestProviderUsage = void 0;
+          usageAnchorIndex = void 0;
         }
         diag("transform_end");
       }
@@ -604,10 +622,17 @@ async function* agentLoop(messages, options) {
               ...overflowDetails
             });
             try {
-              const compacted = await options.transformContext(messages, { force: true });
+              const pendingMessages = usageAnchorIndex === void 0 ? [] : messages.slice(usageAnchorIndex + 1);
+              const compacted = await options.transformContext(messages, {
+                force: true,
+                usage: latestProviderUsage,
+                pendingMessages
+              });
               if (compacted !== messages && compacted.length < messages.length) {
                 messages.length = 0;
                 messages.push(...compacted);
+                latestProviderUsage = void 0;
+                usageAnchorIndex = void 0;
                 diag("overflow_compact_success", {
                   attempt: overflowCompactionAttempts,
                   messages: messages.length,
@@ -671,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;
@@ -776,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"
@@ -813,6 +861,8 @@ async function* agentLoop(messages, options) {
         totalUsage.cacheWrite = (totalUsage.cacheWrite ?? 0) + response.usage.cacheWrite;
       }
       messages.push(response.message);
+      latestProviderUsage = response.usage;
+      usageAnchorIndex = messages.length - 1;
       const completedAt = Date.now();
       const outputTokensPerSecond = providerDurationMs > 0 && response.usage.outputTokens > 0 ? response.usage.outputTokens / (providerDurationMs / 1e3) : void 0;
       const timing = {
@@ -845,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) {
@@ -900,6 +971,7 @@ async function* agentLoop(messages, options) {
       const executionOptions = {
         signal: options.signal,
         maxToolResultChars: options.maxToolResultChars,
+        maxTurnToolResultChars: options.maxTurnToolResultChars,
         toolMap,
         invalidToolArgumentCounts,
         markFatalToolArgumentError
@@ -1139,6 +1211,7 @@ async function* executeToolCallsMixed(toolCalls, initialToolResults, options) {
   }
   const toolResults = buildToolResults(initialToolResults, toolCalls, resultsById);
   capToolResults(toolResults, options.maxToolResultChars);
+  capTurnToolResults(toolResults, options.maxTurnToolResultChars);
   return { toolResults, aborted };
 }
 async function* executeToolCallsParallel(toolCalls, initialToolResults, options) {
@@ -1178,6 +1251,7 @@ async function* executeToolCallsParallel(toolCalls, initialToolResults, options)
   }
   const toolResults = buildToolResults(initialToolResults, toolCalls, resultsById);
   capToolResults(toolResults, options.maxToolResultChars);
+  capTurnToolResults(toolResults, options.maxTurnToolResultChars);
   return { toolResults, aborted };
 }
 function buildToolResults(initialToolResults, toolCalls, resultsById) {
@@ -1208,16 +1282,56 @@ 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) {
+  if (!maxTurnToolResultChars) return;
+  const textResults = toolResults.filter(
+    (toolResult) => typeof toolResult.content === "string"
+  );
+  const total = textResults.reduce((sum, toolResult) => sum + toolResult.content.length, 0);
+  if (total <= maxTurnToolResultChars) return;
+  const bySize = [...textResults].sort((a, b) => a.content.length - b.content.length);
+  let remaining = maxTurnToolResultChars;
+  let left = bySize.length;
+  for (const toolResult of bySize) {
+    const fairShare = Math.floor(remaining / left);
+    left--;
+    if (toolResult.content.length <= fairShare) {
+      remaining -= toolResult.content.length;
+      continue;
+    }
+    remaining -= fairShare;
+    const originalChars = toolResult.content.length;
+    const headChars = Math.floor(fairShare * 0.7);
+    const tailChars = fairShare - headChars;
+    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) {