@prestyj/agent 5.26.0 → 5.28.0

package/dist/index.js

@@ -7,6 +7,7 @@ import {
   stream,
   EventStream,
   EZCoderAIError,
+  environmentSecrets,
   isHardBillingMessage,
   redactValue,
   sliceHead,
@@ -92,6 +93,11 @@ function clampOutputTokens(key, requested) {
 // src/agent-loop.ts
 var DEFAULT_MAX_TURNS = 300;
 var DEFAULT_TOOL_TIMEOUT_MS = 3e5;
+var _toolRedaction;
+function toolRedactionOptions() {
+  _toolRedaction ??= { secrets: environmentSecrets(process.env) };
+  return _toolRedaction;
+}
 var _diagFn = null;
 function setStreamDiagnostic(fn) {
   _diagFn = fn;
@@ -427,11 +433,14 @@ async function* agentLoop(messages, options) {
   const OVERLOAD_BASE_DELAY_MS = 2e3;
   const OVERLOAD_MAX_DELAY_MS = 3e4;
   const STREAM_IDLE_TIMEOUT_MS = 9e4;
+  const STREAM_TOOL_INPUT_IDLE_TIMEOUT_MS = 3e5;
   const STREAM_HARD_TIMEOUT_MS = 9e4;
   const STREAM_OUTPUT_HARD_TIMEOUT_MS = 3e5;
-  const STREAM_THINKING_IDLE_TIMEOUT_MS = 3e5;
-  const STREAM_THINKING_HARD_TIMEOUT_MS = 6e5;
+  const STREAM_THINKING_IDLE_TIMEOUT_MS = 6e5;
+  const STREAM_THINKING_HARD_TIMEOUT_MS = 9e5;
   const NON_STREAMING_HARD_TIMEOUT_MS = 3e5;
+  const nonStreamingHardTimeoutMs = options.thinking != null ? STREAM_THINKING_HARD_TIMEOUT_MS : NON_STREAMING_HARD_TIMEOUT_MS;
+  const VISIBLE_STALL_AFTER_MS = 6e4;
   const usesSilentReasoningBudget = options.provider === "sakana" || options.provider === "openai" && options.thinking != null;
   const localBackend = isLocalBackendUrl(options.baseUrl);
   const baseFirstEventTimeoutMs = localBackend ? Number.POSITIVE_INFINITY : usesSilentReasoningBudget ? STREAM_THINKING_IDLE_TIMEOUT_MS : STREAM_FIRST_EVENT_TIMEOUT_MS;
@@ -533,10 +542,11 @@ async function* agentLoop(messages, options) {
       options.signal?.addEventListener("abort", forwardAbort, { once: true });
       let hasReceivedEvent = false;
       let hasReceivedThinking = false;
+      let toolInputOpen = false;
       const resetIdleTimer = () => {
         if (useNonStreamingFallback) return;
         if (idleTimer) clearTimeout(idleTimer);
-        const timeoutMs = hasReceivedEvent ? STREAM_IDLE_TIMEOUT_MS : hasReceivedThinking ? STREAM_THINKING_IDLE_TIMEOUT_MS : firstEventTimeoutMs;
+        const timeoutMs = hasReceivedEvent ? toolInputOpen ? STREAM_TOOL_INPUT_IDLE_TIMEOUT_MS : STREAM_IDLE_TIMEOUT_MS : hasReceivedThinking ? STREAM_THINKING_IDLE_TIMEOUT_MS : firstEventTimeoutMs;
         if (!Number.isFinite(timeoutMs)) return;
         idleTimer = setTimeout(() => {
           diag("idle_timeout_fired", {
@@ -544,14 +554,14 @@ async function* agentLoop(messages, options) {
             sinceLastEventMs: Date.now() - lastEventTime,
             lastEventType,
             maxConsumerLagMs,
-            phase: hasReceivedEvent ? "mid_stream" : hasReceivedThinking ? "post_thinking" : "first_event",
+            phase: hasReceivedEvent ? toolInputOpen ? "mid_tool_input" : "mid_stream" : hasReceivedThinking ? "post_thinking" : "first_event",
             eventTypes: eventTypeCounts
           });
           idleTimedOut = true;
           streamController.abort();
         }, timeoutMs);
       };
-      let hardTimeoutMs = useNonStreamingFallback ? NON_STREAMING_HARD_TIMEOUT_MS : initialHardTimeoutMs;
+      let hardTimeoutMs = useNonStreamingFallback ? nonStreamingHardTimeoutMs : initialHardTimeoutMs;
       hardTimer = setTimeout(() => {
         diag("hard_timeout_fired", {
           events: typeof streamEventCount !== "undefined" ? streamEventCount : 0,
@@ -646,6 +656,8 @@ async function* agentLoop(messages, options) {
           if (firstProviderEventAt === void 0) firstProviderEventAt = pullTime;
           eventTypeCounts[event.type] = (eventTypeCounts[event.type] ?? 0) + 1;
           lastEventType = event.type;
+          if (event.type === "toolcall_delta") toolInputOpen = true;
+          else if (event.type === "toolcall_done") toolInputOpen = false;
           if ((event.type === "text_delta" || event.type === "server_toolcall" || event.type === "toolcall_delta") && !hasReceivedEvent) {
             hasReceivedEvent = true;
             if (hardTimer && hardTimeoutMs < STREAM_OUTPUT_HARD_TIMEOUT_MS) {
@@ -980,7 +992,7 @@ async function* agentLoop(messages, options) {
             attempt: stallRetries,
             maxAttempts: MAX_STALL_RETRIES,
             delayMs,
-            silent: stallRetries <= 2,
+            silent: stallRetries <= 2 && Date.now() - streamCallStart < VISIBLE_STALL_AFTER_MS,
             ...preservedChars > 0 ? { preservedChars } : {}
           };
           await abortableSleep(delayMs, options.signal);
@@ -1243,7 +1255,8 @@ async function* agentLoop(messages, options) {
         maxTurnToolResultChars: options.maxTurnToolResultChars,
         toolMap,
         invalidToolArgumentCounts,
-        markFatalToolArgumentError
+        markFatalToolArgumentError,
+        seenToolCalls: /* @__PURE__ */ new Set()
       };
       const hasSequentialToolCall = toolCalls.some(
         (toolCall) => toolMap.get(toolCall.name)?.executionMode === "sequential"
@@ -1364,6 +1377,15 @@ async function* agentLoop(messages, options) {
     totalUsage: { ...totalUsage }
   };
 }
+function canonicalToolArgs(value) {
+  if (Array.isArray(value)) return value.map(canonicalToolArgs);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => [k, canonicalToolArgs(v)])
+    );
+  }
+  return value;
+}
 function pushToolEvent(eventStream, state, event) {
   if (!state.finalized) eventStream.push(event);
 }
@@ -1380,6 +1402,21 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
   let isError = false;
   let invalidArgAttempt;
   const tool = options.toolMap.get(toolCall.name);
+  if (tool) {
+    const signature = JSON.stringify([toolCall.name, canonicalToolArgs(toolCall.args)]);
+    if (options.seenToolCalls.has(signature)) {
+      const content = "Tool call cancelled: an identical call already appeared in this response; this call was not executed.";
+      pushEvent({
+        type: "tool_call_end",
+        toolCallId: toolCall.id,
+        result: content,
+        isError: true,
+        durationMs: Date.now() - startTime
+      });
+      return { toolCallId: toolCall.id, content, isError: true };
+    }
+    options.seenToolCalls.add(signature);
+  }
   if (!tool) {
     resultContent = `Unknown tool: ${toolCall.name}`;
     isError = true;
@@ -1414,8 +1451,8 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
         ctx.signal
       );
       const normalized = normalizeToolResult(raw);
-      resultContent = redactValue(normalized.content);
-      details = redactValue(normalized.details);
+      resultContent = redactValue(normalized.content, toolRedactionOptions());
+      details = redactValue(normalized.details, toolRedactionOptions());
       for (const key of options.invalidToolArgumentCounts.keys()) {
         if (key.startsWith(`${toolCall.name}:`)) options.invalidToolArgumentCounts.delete(key);
       }
@@ -1446,12 +1483,15 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
       } else if (options.signal?.aborted && isAbortError(err)) {
         resultContent = indeterminateOutcomeText(toolCall.name);
       } else {
-        resultContent = redactValue(err instanceof Error ? err.message : String(err));
+        resultContent = redactValue(
+          err instanceof Error ? err.message : String(err),
+          toolRedactionOptions()
+        );
       }
     }
   }
-  resultContent = redactValue(resultContent);
-  details = redactValue(details);
+  resultContent = redactValue(resultContent, toolRedactionOptions());
+  details = redactValue(details, toolRedactionOptions());
   const durationMs = Date.now() - startTime;
   pushEvent({
     type: "tool_call_end",
@@ -1493,6 +1533,11 @@ async function* executeToolCallsMixed(toolCalls, initialToolResults, options) {
       for (const phase of phases) {
         if (options.signal?.aborted) break;
         if (phase.sequential) {
+          const signature = JSON.stringify([
+            phase.sequential.name,
+            canonicalToolArgs(phase.sequential.args)
+          ]);
+          if (!options.seenToolCalls.has(signature)) options.seenToolCalls.clear();
           dispatchedIds.add(phase.sequential.id);
           const record = await executeSingleToolCall(
             phase.sequential,