@prestyj/agent 5.10.0 → 5.12.0

package/dist/index.cjs

@@ -63,6 +63,7 @@ function isLocalBackendUrl(baseUrl) {
 
 // src/agent-loop.ts
 var DEFAULT_MAX_TURNS = 300;
+var DEFAULT_TOOL_TIMEOUT_MS = 3e5;
 var _diagFn = null;
 function setStreamDiagnostic(fn) {
   _diagFn = fn;
@@ -82,7 +83,13 @@ function isContextOverflow(err) {
   if (overflowStatus === 402) return false;
   if (isBillingError(err)) return false;
   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");
+  if (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")) {
+    return true;
+  }
+  const rateLimited = overflowStatus === 429 || msg.includes("rate limit") || msg.includes("rate_limit") || msg.includes("too many requests");
+  const perUnitTime = msg.includes("per min") || msg.includes("/min") || msg.includes("per minute") || msg.includes("per hour") || msg.includes("per day") || msg.includes("tpm") || msg.includes("rpm");
+  if (rateLimited && perUnitTime) return false;
+  return msg.includes("token") && msg.includes("exceed");
 }
 function parseOverflowNumber(value) {
   return Number(value.replace(/[,_\s]/g, ""));
@@ -195,6 +202,17 @@ function isMalformedStream(err) {
   const msg = err.message;
   return /\bin JSON at position \d+/i.test(msg);
 }
+var TIMEOUT_NAMES = /* @__PURE__ */ new Set(["TimeoutError", "ConnectTimeoutError", "HeadersTimeoutError"]);
+var TIMEOUT_MESSAGES = [
+  /^request timed out\.?$/i,
+  /\brequest to [\w .-]+ timed out\b/i,
+  /\b(?:connection|socket|headers|stream) timed out\b/i
+];
+function isBareTimeout(e) {
+  if (typeof e.name === "string" && TIMEOUT_NAMES.has(e.name)) return true;
+  if (typeof e.message !== "string") return false;
+  return TIMEOUT_MESSAGES.some((re) => re.test(e.message));
+}
 function isTransportFailure(err) {
   const codes = /* @__PURE__ */ new Set([
     "ECONNRESET",
@@ -231,6 +249,8 @@ function isTransportFailure(err) {
     if (typeof e.message === "string") {
       for (const re of messages) if (re.test(e.message)) return true;
     }
+    const clientError = typeof e.status === "number" && e.status >= 400 && e.status < 500;
+    if (!clientError && isBareTimeout(e)) return true;
     cur = e.cause;
   }
   return false;
@@ -265,6 +285,9 @@ function abortablePromise(promise, signal) {
     promise.then(resolveOnce, rejectOnce);
   });
 }
+function turnBudgetContinuationPrompt() {
+  return "[You reached the turn limit for this segment but the work is not finished, so you have been granted more turns. Before continuing, state in one or two sentences what is already done and what remains, then keep going from there \u2014 do not restart work that is already complete.]";
+}
 function abortableSleep(ms, signal) {
   if (signal?.aborted) return Promise.reject(createAbortError());
   return new Promise((resolve, reject) => {
@@ -286,6 +309,9 @@ function closeIterator(iterator) {
 }
 async function* agentLoop(messages, options) {
   const maxTurns = options.maxTurns ?? DEFAULT_MAX_TURNS;
+  let effectiveMaxTurns = maxTurns;
+  const maxTurnExtensions = Math.max(0, options.maxTurnExtensions ?? 2);
+  let turnExtensions = 0;
   const maxContinuations = options.maxContinuations ?? 5;
   let toolMap = new Map((options.tools ?? []).map((t) => [t.name, t]));
   const totalUsage = { inputTokens: 0, outputTokens: 0 };
@@ -333,12 +359,12 @@ async function* agentLoop(messages, options) {
   const firstEventTimeoutMs = localBackend ? Number.POSITIVE_INFINITY : usesSilentReasoningBudget ? STREAM_THINKING_IDLE_TIMEOUT_MS : STREAM_FIRST_EVENT_TIMEOUT_MS;
   const initialHardTimeoutMs = localBackend || usesSilentReasoningBudget ? STREAM_THINKING_HARD_TIMEOUT_MS : STREAM_HARD_TIMEOUT_MS;
   const MAX_TOOLCALL_DELTA_CHARS = 1e6;
-  const MAX_TOOLCALL_DELTA_EVENTS = 2e4;
+  const MAX_TOOLCALL_NO_PROGRESS_EVENTS = 2e4;
   let logicalTurnStartedAt = 0;
   let firstProviderEventAt;
   let providerDurationMs = 0;
   try {
-    while (turn < maxTurns) {
+    while (turn < effectiveMaxTurns) {
       options.signal?.throwIfAborted();
       turn++;
       if (logicalTurnStartedAt === 0) logicalTurnStartedAt = Date.now();
@@ -409,6 +435,7 @@ async function* agentLoop(messages, options) {
       let lastEventType = "";
       let toolcallDeltaChars = 0;
       let toolcallDeltaCount = 0;
+      let toolcallNoProgressCount = 0;
       let runawayDetected = null;
       let attemptText = "";
       let lastYieldEndTime = Date.now();
@@ -449,6 +476,21 @@ async function* agentLoop(messages, options) {
         diag("stream_call", { nonStreaming: useNonStreamingFallback });
         streamCallStart = Date.now();
         providerAttemptStartedAt = streamCallStart;
+        let liveApiKey = options.apiKey;
+        let liveAccountId = options.accountId;
+        let liveProjectId = options.projectId;
+        if (options.resolveCredentials) {
+          try {
+            const fresh = await options.resolveCredentials();
+            liveApiKey = fresh.apiKey;
+            if (fresh.accountId !== void 0) liveAccountId = fresh.accountId;
+            if (fresh.projectId !== void 0) liveProjectId = fresh.projectId;
+          } catch (credErr) {
+            diag("credential_refresh_failed", {
+              error: (credErr instanceof Error ? credErr.message : String(credErr)).slice(0, 200)
+            });
+          }
+        }
         const result = (0, import_ai.stream)({
           provider: options.provider,
           model: options.model,
@@ -460,12 +502,12 @@ async function* agentLoop(messages, options) {
           maxTokens: options.maxTokens,
           temperature: options.temperature,
           thinking: options.thinking,
-          apiKey: options.apiKey,
+          apiKey: liveApiKey,
           baseUrl: options.baseUrl,
           signal: streamController.signal,
-          accountId: options.accountId,
+          accountId: liveAccountId,
           transportSessionId: options.transportSessionId,
-          projectId: options.projectId,
+          projectId: liveProjectId,
           cacheRetention: options.cacheRetention,
           promptCacheKey: options.promptCacheKey,
           serviceTier: options.serviceTier,
@@ -563,11 +605,13 @@ async function* agentLoop(messages, options) {
             const chunkChars = event.argsJson?.length ?? 0;
             toolcallDeltaChars += chunkChars;
             toolcallDeltaCount++;
-            if (!runawayDetected && (toolcallDeltaChars > MAX_TOOLCALL_DELTA_CHARS || toolcallDeltaCount > MAX_TOOLCALL_DELTA_EVENTS)) {
+            toolcallNoProgressCount = chunkChars > 0 ? 0 : toolcallNoProgressCount + 1;
+            if (!runawayDetected && (toolcallDeltaChars > MAX_TOOLCALL_DELTA_CHARS || toolcallNoProgressCount > MAX_TOOLCALL_NO_PROGRESS_EVENTS)) {
               runawayDetected = {
                 kind: toolcallDeltaChars > MAX_TOOLCALL_DELTA_CHARS ? "chars" : "events",
                 chars: toolcallDeltaChars,
-                events: toolcallDeltaCount
+                events: toolcallDeltaCount,
+                noProgressEvents: toolcallNoProgressCount
               };
               diag("runaway_toolcall_detected", {
                 ...runawayDetected,
@@ -749,11 +793,15 @@ async function* agentLoop(messages, options) {
             turn--;
             continue;
           }
-          const detail = runawayDetected.kind === "chars" ? `${(runawayDetected.chars / 1024).toFixed(0)} KB of tool-call arguments` : `${runawayDetected.events} tool-call delta events`;
+          const detail = runawayDetected.kind === "chars" ? `${(runawayDetected.chars / 1024).toFixed(0)} KB of tool-call arguments` : `${runawayDetected.noProgressEvents} consecutive tool-call delta events without argument progress`;
           yield {
             type: "error",
-            error: new Error(
-              `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.`
+            error: new import_ai.EZCoderAIError(
+              `The model repeatedly failed to close a tool call after ${MAX_RUNAWAY_TOOLCALL_RETRIES} automatic retries (${detail}). Your conversation is preserved.`,
+              {
+                source: "provider",
+                hint: "Retry once. If it keeps happening, switch models and continue the preserved conversation."
+              }
             )
           };
           break;
@@ -780,7 +828,15 @@ async function* agentLoop(messages, options) {
               role: "assistant",
               content: [{ type: "text", text: attemptText }]
             });
-            messages.push({ role: "user", content: PARTIAL_CONTINUATION_PROMPT });
+            messages.push({
+              role: "user",
+              content: PARTIAL_CONTINUATION_PROMPT,
+              provenance: {
+                source: "runtime",
+                kind: "continuation",
+                visibility: "hidden"
+              }
+            });
             preservedChars = attemptText.length;
           }
           diag("retry", {
@@ -899,6 +955,9 @@ async function* agentLoop(messages, options) {
       useNonStreamingFallback = false;
       totalUsage.inputTokens += response.usage.inputTokens;
       totalUsage.outputTokens += response.usage.outputTokens;
+      if (response.usage.reasoningTokens) {
+        totalUsage.reasoningTokens = (totalUsage.reasoningTokens ?? 0) + response.usage.reasoningTokens;
+      }
       if (response.usage.cacheRead) {
         totalUsage.cacheRead = (totalUsage.cacheRead ?? 0) + response.usage.cacheRead;
       }
@@ -950,7 +1009,15 @@ async function* agentLoop(messages, options) {
               model: options.model
             });
             yield { type: "truncated", reason: "max_tokens", continued: true };
-            messages.push({ role: "user", content: MAX_TOKENS_CONTINUATION_PROMPT });
+            messages.push({
+              role: "user",
+              content: MAX_TOKENS_CONTINUATION_PROMPT,
+              provenance: {
+                source: "runtime",
+                kind: "continuation",
+                visibility: "hidden"
+              }
+            });
             continue;
           }
           yield { type: "truncated", reason: "max_tokens", continued: false };
@@ -1026,6 +1093,7 @@ async function* agentLoop(messages, options) {
       );
       const executionResult = hasSequentialToolCall ? yield* executeToolCallsMixed(toolCalls, toolResults, executionOptions) : yield* executeToolCallsParallel(toolCalls, toolResults, executionOptions);
       messages.push({ role: "tool", content: executionResult.toolResults });
+      yield { type: "checkpoint", turn };
       const toolsAborted = executionResult.aborted;
       if (fatalToolArgumentError) {
         if (fatalToolArgumentRecoverable && !toolArgumentAutoContinueUsed) {
@@ -1057,8 +1125,51 @@ async function* agentLoop(messages, options) {
           }
         }
       }
-      if (turn >= maxTurns) {
-        hitMaxTurns = true;
+      if (turn >= effectiveMaxTurns) {
+        let extended = false;
+        if (options.onTurnBudgetExhausted && turnExtensions < maxTurnExtensions) {
+          const extension = turnExtensions + 1;
+          let granted = false;
+          try {
+            granted = await options.onTurnBudgetExhausted({
+              turn,
+              maxTurns: effectiveMaxTurns,
+              extension
+            });
+          } catch {
+            granted = false;
+          }
+          if (granted) {
+            turnExtensions = extension;
+            effectiveMaxTurns += maxTurns;
+            extended = true;
+            diag("turn_budget_extended", {
+              turn,
+              grantedTurns: effectiveMaxTurns,
+              extension,
+              provider: options.provider,
+              model: options.model
+            });
+            yield {
+              type: "turn_budget_extended",
+              turn,
+              grantedTurns: effectiveMaxTurns,
+              extension
+            };
+            messages.push({
+              role: "user",
+              content: turnBudgetContinuationPrompt(),
+              provenance: {
+                source: "runtime",
+                kind: "continuation",
+                visibility: "hidden"
+              }
+            });
+          }
+        }
+        if (!extended) {
+          hitMaxTurns = true;
+        }
       }
     }
   } finally {
@@ -1074,14 +1185,15 @@ async function* agentLoop(messages, options) {
   if (hitMaxTurns) {
     diag("max_turns_reached", {
       turn,
-      maxTurns,
+      maxTurns: effectiveMaxTurns,
+      extensions: turnExtensions,
       provider: options.provider,
       model: options.model
     });
     yield {
       type: "max_turns",
       totalTurns: turn,
-      maxTurns
+      maxTurns: effectiveMaxTurns
     };
   }
   yield {
@@ -1117,7 +1229,7 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
     try {
       const parsed = tool.parameters.parse(toolCall.args);
       const callerSignal = options.signal;
-      const toolTimeout = AbortSignal.timeout(3e5);
+      const toolTimeout = AbortSignal.timeout(tool.timeoutMs ?? DEFAULT_TOOL_TIMEOUT_MS);
       const ctx = {
         signal: callerSignal ? AbortSignal.any([callerSignal, toolTimeout]) : toolTimeout,
         toolCallId: toolCall.id,
@@ -1330,9 +1442,9 @@ function capToolResults(toolResults, maxToolResultChars) {
     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 = originalChars - headChars - tailChars;
+    const head = (0, import_ai.sliceHead)(toolResult.content, headChars);
+    const tail = (0, import_ai.sliceTail)(toolResult.content, tailChars);
+    const omitted = originalChars - head.length - tail.length;
     toolResult.content = head + `
 
 [... ${omitted} characters omitted ...]
@@ -1367,11 +1479,11 @@ function capTurnToolResults(toolResults, maxTurnToolResultChars) {
     const headChars = Math.floor(fairShare * 0.7);
     const tailChars = fairShare - headChars;
     const omitted = originalChars - fairShare;
-    toolResult.content = toolResult.content.slice(0, headChars) + `
+    toolResult.content = (0, import_ai.sliceHead)(toolResult.content, 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) : "");
+` + (0, import_ai.sliceTail)(toolResult.content, tailChars);
     toolResult.capped = {
       originalChars: toolResult.capped?.originalChars ?? originalChars,
       keptChars: toolResult.content.length,
@@ -1390,12 +1502,14 @@ 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)}
+  const head = (0, import_ai.sliceHead)(text, headChars);
+  const tail = (0, import_ai.sliceTail)(text, tailChars);
+  const omitted = text.length - head.length - tail.length;
+  return `${head}
 
 [... ${omitted} characters omitted after context overflow ...]
 
-${text.slice(-tailChars)}`;
+${tail}`;
 }
 function truncateOversizedToolResults(messages, maxChars) {
   if (maxChars <= 0) return false;