@prestyj/agent 5.6.0 → 5.8.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)) {
@@ -260,6 +260,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;
@@ -296,10 +298,14 @@ async function* agentLoop(messages, options) {
   const initialHardTimeoutMs = isSakana ? STREAM_THINKING_HARD_TIMEOUT_MS : STREAM_HARD_TIMEOUT_MS;
   const MAX_TOOLCALL_DELTA_CHARS = 1e6;
   const MAX_TOOLCALL_DELTA_EVENTS = 2e4;
+  let logicalTurnStartedAt = 0;
+  let firstProviderEventAt;
+  let providerDurationMs = 0;
   try {
     while (turn < maxTurns) {
       options.signal?.throwIfAborted();
       turn++;
+      if (logicalTurnStartedAt === 0) logicalTurnStartedAt = Date.now();
       toolMap = new Map((options.tools ?? []).map((t) => [t.name, t]));
       if (_diagFn) {
         let msgChars = 0;
@@ -332,7 +338,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,
@@ -340,6 +350,8 @@ async function* agentLoop(messages, options) {
           });
           messages.length = 0;
           messages.push(...transformed);
+          latestProviderUsage = void 0;
+          usageAnchorIndex = void 0;
         }
         diag("transform_end");
       }
@@ -349,6 +361,7 @@ async function* agentLoop(messages, options) {
       let idleTimer = null;
       let hardTimer = null;
       let idleTimedOut = false;
+      let providerAttemptStartedAt;
       let streamEventCount = 0;
       let lastEventTime = Date.now();
       let streamCallStart = Date.now();
@@ -394,12 +407,14 @@ async function* agentLoop(messages, options) {
       try {
         diag("stream_call", { nonStreaming: useNonStreamingFallback });
         streamCallStart = Date.now();
+        providerAttemptStartedAt = streamCallStart;
         const result = (0, import_ai.stream)({
           provider: options.provider,
           model: options.model,
           messages,
           tools: options.tools,
           serverTools: options.serverTools,
+          toolChoice: options.toolChoice,
           webSearch: options.webSearch,
           maxTokens: options.maxTokens,
           temperature: options.temperature,
@@ -442,6 +457,7 @@ async function* agentLoop(messages, options) {
             maxConsumerLagMs = consumerLag;
           }
           streamEventCount++;
+          if (firstProviderEventAt === void 0) firstProviderEventAt = pullTime;
           eventTypeCounts[event.type] = (eventTypeCounts[event.type] ?? 0) + 1;
           lastEventType = event.type;
           if ((event.type === "text_delta" || event.type === "server_toolcall" || event.type === "toolcall_delta") && !hasReceivedEvent) {
@@ -534,6 +550,7 @@ async function* agentLoop(messages, options) {
           eventTypes: eventTypeCounts
         });
         response = await abortablePromise(result.response, streamController.signal);
+        if (firstProviderEventAt === void 0) firstProviderEventAt = Date.now();
       } catch (err) {
         if (streamController.signal.aborted) closeIterator(streamIterator);
         const errMsg = err instanceof Error ? err.message : String(err);
@@ -595,10 +612,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,
@@ -758,6 +782,9 @@ async function* agentLoop(messages, options) {
         });
         throw err;
       } finally {
+        if (providerAttemptStartedAt !== void 0) {
+          providerDurationMs += Date.now() - providerAttemptStartedAt;
+        }
         if (idleTimer) clearTimeout(idleTimer);
         if (hardTimer) clearTimeout(hardTimer);
         options.signal?.removeEventListener("abort", forwardAbort);
@@ -801,11 +828,29 @@ 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 = {
+        startedAt: logicalTurnStartedAt,
+        ...firstProviderEventAt !== void 0 ? {
+          firstProviderEventAt,
+          ttftMs: Math.max(0, firstProviderEventAt - logicalTurnStartedAt)
+        } : {},
+        completedAt,
+        providerDurationMs,
+        ...outputTokensPerSecond !== void 0 ? { outputTokensPerSecond } : {}
+      };
+      logicalTurnStartedAt = 0;
+      firstProviderEventAt = void 0;
+      providerDurationMs = 0;
       yield {
         type: "turn_end",
         turn,
         stopReason: response.stopReason,
-        usage: response.usage
+        usage: response.usage,
+        timing
       };
       if (response.stopReason === "pause_turn") {
         consecutivePauses++;
@@ -872,6 +917,7 @@ async function* agentLoop(messages, options) {
       const executionOptions = {
         signal: options.signal,
         maxToolResultChars: options.maxToolResultChars,
+        maxTurnToolResultChars: options.maxTurnToolResultChars,
         toolMap,
         invalidToolArgumentCounts,
         markFatalToolArgumentError
@@ -989,8 +1035,8 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
         ctx.signal
       );
       const normalized = normalizeToolResult(raw);
-      resultContent = normalized.content;
-      details = normalized.details;
+      resultContent = (0, import_ai.redactValue)(normalized.content);
+      details = (0, import_ai.redactValue)(normalized.details);
       for (const key of options.invalidToolArgumentCounts.keys()) {
         if (key.startsWith(`${toolCall.name}:`)) options.invalidToolArgumentCounts.delete(key);
       }
@@ -1018,10 +1064,12 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
           );
         }
       } else {
-        resultContent = err instanceof Error ? err.message : String(err);
+        resultContent = (0, import_ai.redactValue)(err instanceof Error ? err.message : String(err));
       }
     }
   }
+  resultContent = (0, import_ai.redactValue)(resultContent);
+  details = (0, import_ai.redactValue)(details);
   const durationMs = Date.now() - startTime;
   pushEvent({
     type: "tool_call_end",
@@ -1109,6 +1157,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) {
@@ -1148,6 +1197,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) {
@@ -1190,6 +1240,34 @@ function capToolResults(toolResults, maxToolResultChars) {
 ` + tail;
   }
 }
+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 headChars = Math.floor(fairShare * 0.7);
+    const tailChars = fairShare - headChars;
+    const omitted = toolResult.content.length - 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) : "");
+  }
+}
 function normalizeToolResult(raw) {
   return typeof raw === "string" ? { content: raw } : raw;
 }