@agent-native/core 0.131.5 → 0.131.6

package/dist/agent/production-agent.js

@@ -775,17 +775,21 @@ export function isRetryableError(err) {
         msg.includes("gateway error") ||
         msg.includes("socket hang up") ||
         msg.includes("connection reset") ||
-        // Anthropic SDK APIConnectionError default message is exactly
-        // "Connection error." — Builder gateway often forwards it as a stop
-        // event with no structured code. Without this match the run fails in
-        // ~3s and the client recovery loop storms POSTs.
-        msg.includes("connection error") ||
+        hasProviderConnectionErrorMessage(msg) ||
         msg.includes("too many requests") ||
         msg.includes("timeout") ||
         msg.includes("gateway timeout") ||
         msg.includes("inactivity timeout") ||
         msg.includes("too much time has passed without sending any data"));
 }
+function hasProviderConnectionErrorMessage(message) {
+    const normalized = message.toLowerCase();
+    // Anthropic's APIConnectionError uses "Connection error."; AI SDK wraps
+    // OpenAI TLS failures as "Cannot connect to API". Both can cross a worker
+    // boundary without their structured EngineError metadata.
+    return (normalized.includes("connection error") ||
+        normalized.includes("cannot connect to api"));
+}
 // ---------------------------------------------------------------------------
 // Context-window overflow recovery
 // ---------------------------------------------------------------------------
@@ -1384,11 +1388,13 @@ export function appendAgentLoopContinuation(messages, reason, options = {}) {
                 ? "The previous stream ended before the agent sent a final completion signal."
                 : reason === "gateway_timeout"
                     ? "The previous LLM call hit an upstream gateway timeout before the response finished streaming."
-                    : reason === "network_interrupted"
-                        ? "The previous LLM call was cut off by a transport-level interruption (socket dropped, connection reset, or stream closed unexpectedly)."
-                        : reason === "no_progress"
-                            ? "The previous run stopped producing progress events while the connection stayed open."
-                            : "The previous run reached an internal execution budget.";
+                    : reason === "rate_limited"
+                        ? "The previous LLM call was temporarily rate limited after exhausting its short provider retry budget."
+                        : reason === "network_interrupted"
+                            ? "The previous LLM call was cut off by a transport-level interruption (socket dropped, connection reset, or stream closed unexpectedly)."
+                            : reason === "no_progress"
+                                ? "The previous run stopped producing progress events while the connection stayed open."
+                                : "The previous run reached an internal execution budget.";
     const actionInputNote = options.actionPreparationTool
         ? actionPreparationContinuationNote(options.actionPreparationTool)
         : "";
@@ -1447,7 +1453,7 @@ export function isResumableEngineError(err) {
         text.includes("econnaborted") ||
         text.includes("fetch failed") ||
         text.includes("network error") ||
-        text.includes("connection error") ||
+        hasProviderConnectionErrorMessage(text) ||
         text.includes("connection reset") ||
         text.includes("connection closed") ||
         text.includes("stream closed") ||
@@ -1458,6 +1464,32 @@ export function isResumableEngineError(err) {
         text.includes("too much time has passed without sending any data") ||
         text.includes("terminated"));
 }
+/**
+ * True only for transient provider throttling that may recover after one
+ * cooled-down background continuation. This is deliberately narrower than
+ * `isRetryableError`: daily/account caps are terminal, and generic retryable
+ * transport errors keep using the normal resumable-error path.
+ *
+ * The engine has already spent its short in-call retry budget before this
+ * helper is consulted. Callers must add their own small continuation cap so a
+ * sustained provider limit cannot turn into an unbounded request storm.
+ */
+export function isTransientProviderRateLimitError(err) {
+    if (!(err instanceof EngineError))
+        return false;
+    const code = (err.errorCode ?? "").toLowerCase();
+    const text = errorSearchText(err);
+    if (code === "rate_limit_exceeded" ||
+        text.includes("daily gateway request cap")) {
+        return false;
+    }
+    if (err.statusCode === 429 || err.statusCode === 529) {
+        return true;
+    }
+    if (code === "http_429" || code === "http_529")
+        return true;
+    return false;
+}
 /**
  * Map a resumable error to the most descriptive continuation reason. Used
  * when surfacing the resume to the agent and to clients via the
@@ -2667,6 +2699,18 @@ function validateRawToolInput(entry, input) {
  */
 export async function runAgentLoop(opts) {
     const { engine, model, systemPrompt, tools, availableTools, messages, actions, send, signal, } = opts;
+    let outcomeReported = false;
+    const reportOutcome = (outcome) => {
+        if (outcomeReported)
+            return;
+        outcomeReported = true;
+        try {
+            opts.onOutcome?.(outcome);
+        }
+        catch {
+            // Outcome observers are telemetry/protocol adapters and cannot alter the run.
+        }
+    };
     const budgetStartedAt = opts.budgetStartedAt ?? Date.now();
     const finalResponseGuardRequestText = opts.finalResponseGuardRequestText ??
         resolveFinalResponseGuardRequestText(messages);
@@ -2756,6 +2800,7 @@ export async function runAgentLoop(opts) {
     // `loop_limit` and `done` share one terminal-event slot in run-manager, so a
     // trailing `done` would overwrite the boundary the continuation logic reads.
     let endedAtLoopLimit = false;
+    let terminalActionStop = null;
     // Overridden (raised tokens, lowered effort) only after an empty-final-
     // response retry below — kept separate from `opts.maxOutputTokens`/
     // `opts.reasoningEffort` so the very first attempt is unaffected and later
@@ -3720,9 +3765,12 @@ export async function runAgentLoop(opts) {
             const toolTimeoutMs = runToolTimeoutCeilingMs > 0
                 ? Math.min(requestedToolTimeoutMs, runToolTimeoutCeilingMs)
                 : requestedToolTimeoutMs;
-            const toolMaxResultChars = actionEntry.maxResultChars ??
+            const configuredToolMaxResultChars = actionEntry.maxResultChars ??
                 opts.toolLimits?.maxResultChars ??
                 DEFAULT_TOOL_RESULT_CHARS;
+            const toolMaxResultChars = typeof opts.toolLimits?.hardMaxResultChars === "number"
+                ? Math.min(configuredToolMaxResultChars, opts.toolLimits.hardMaxResultChars)
+                : configuredToolMaxResultChars;
             // TOOL-CALL JOURNAL HARD-BLOCK (resume safety, tool-layer enforcement).
             // The prompt-level resume journal already TELLS a resuming model not to
             // re-run completed tool calls; this enforces it at the tool layer so a
@@ -4029,6 +4077,8 @@ export async function runAgentLoop(opts) {
                     networkProtocol: opts.networkProtocol,
                     networkId: opts.networkId,
                     networkPeer: opts.networkPeer,
+                    delegationDepth: opts.delegationDepth,
+                    visitedApps: opts.visitedApps,
                     attachments: opts.attachments,
                     signal,
                     // Audit attribution: the action name + the agent thread/turn that
@@ -4292,6 +4342,7 @@ export async function runAgentLoop(opts) {
         if (requestedActionStop) {
             // TypeScript can't track ??= through async closures; cast to known type.
             const stop = requestedActionStop;
+            terminalActionStop = stop;
             send({ type: "text", text: stop.message });
             break;
         }
@@ -4301,6 +4352,9 @@ export async function runAgentLoop(opts) {
     // ended on a guardrail, not a clean turn. The result hook still fires below
     // so processors can observe the (halted) final text.
     if (tripwire) {
+        // TypeScript cannot see assignments performed by the processor callback
+        // inside the loop, so preserve the runtime narrowing explicitly here.
+        const terminalTripwire = tripwire;
         if (processorChain) {
             try {
                 await processorChain.runResult(collectTextParts(messages.flatMap((m) => (m.role === "assistant" ? m.content : []))));
@@ -4311,9 +4365,22 @@ export async function runAgentLoop(opts) {
                 // A result-hook abort is a no-op: the run is already halting.
             }
         }
+        reportOutcome({
+            state: "failed",
+            code: terminalTripwire.processor === "run-input-token-budget"
+                ? "budget_exhausted"
+                : terminalTripwire.processor
+                    ? `guardrail:${terminalTripwire.processor}`
+                    : "guardrail",
+            // Re-running the same request with the same deterministic guardrail
+            // would reproduce the stop. A caller can issue a smaller follow-up, but
+            // must not automatically replay this turn.
+            retryable: false,
+            message: terminalTripwire.message,
+        });
         return usage;
     }
-    if (!signal.aborted && !endedAtLoopLimit) {
+    if (!signal.aborted && !endedAtLoopLimit && !terminalActionStop) {
         // In-loop processor seam (result hook). Fires once at clean run end with the
         // final assistant text so processors (e.g. a proof-of-done gate) can record
         // a verdict. A result-hook abort cannot un-finish a completed run, so a
@@ -4352,6 +4419,35 @@ export async function runAgentLoop(opts) {
             }
         }
     }
+    if (signal.aborted) {
+        reportOutcome({ state: "canceled", message: "Agent run was aborted." });
+    }
+    else if (endedAtLoopLimit) {
+        reportOutcome({
+            state: "failed",
+            code: "loop_limit",
+            retryable: false,
+            message: `Agent stopped after ${maxIterations} iterations.`,
+        });
+    }
+    else if (terminalActionStop?.errorCode === "needs-approval") {
+        reportOutcome({
+            state: "input_required",
+            code: "needs_approval",
+            message: terminalActionStop.message,
+        });
+    }
+    else if (terminalActionStop) {
+        reportOutcome({
+            state: "failed",
+            code: terminalActionStop.errorCode ?? "tool_failed",
+            retryable: false,
+            message: terminalActionStop.message,
+        });
+    }
+    else {
+        reportOutcome({ state: "completed" });
+    }
     return usage;
 }
 function backgroundChatProgressRunId(turnId) {
@@ -4379,7 +4475,7 @@ function isRecoverableContinuationError(event) {
         code === "http_529" ||
         code === "run_timeout" ||
         message.includes("timeout") ||
-        message.includes("connection error") ||
+        hasProviderConnectionErrorMessage(message) ||
         message.includes("temporarily unavailable"));
 }
 function endsAtInternalContinuationBoundary(run) {
@@ -5311,7 +5407,9 @@ function progressStepFromAgentChatEvent(event) {
                 ? `Calling ${event.agent}.`
                 : event.status === "done"
                     ? `Finished ${event.agent}.`
-                    : `${event.agent} failed.`;
+                    : event.status === "pending"
+                        ? `${event.agent} is still working.`
+                        : `${event.agent} failed.`;
         case "agent_task":
             return event.status === "running"
                 ? "Started background task."