@agent-native/core 0.153.4 → 0.153.5

package/dist/client/agent-chat-adapter.js

@@ -6,7 +6,7 @@ import { getOrCreateAnalyticsSessionId } from "./analytics-session.js";
 import { captureError } from "./analytics.js";
 import { agentNativePath } from "./api-path.js";
 import { formatChatErrorText, normalizeChatError } from "./error-format.js";
-import { AgentAutoContinueSignal, appendMissingFinalResponseWarning, readSSEStream, settleInterruptedToolCalls, } from "./sse-event-processor.js";
+import { AgentAutoContinueSignal, INTERRUPTED_TOOL_RESULT, appendMissingFinalResponseWarning, readSSEStream, settleInterruptedToolCalls, } from "./sse-event-processor.js";
 const TEXT_ATTACHMENT_CONTENT_TYPES = new Set([
     "application/json",
     "application/x-ndjson",
@@ -24,37 +24,20 @@ const AUTO_CONTINUE_COMPLETION_GUARD = "Before doing more work, inspect the prio
 const MAX_RECONNECT_ATTEMPTS = 5;
 const MAX_STARTUP_RECOVERY_ATTEMPTS = 8;
 const MAX_QUEUED_CONFLICT_RETRIES = 120;
-const MAX_STALE_RUN_CONTINUATIONS = 3;
-const MAX_STALLED_TRANSIENT_CONTINUATIONS = 8;
+// How many consecutive continuations that did not advance the turn (see
+// `describeContinuationAdvance`) we tolerate before giving up. This replaced
+// five separate budgets — stale-run, stalled, empty, repeated-narration and
+// repeated-action-preparation — each of which existed because the rung above
+// it had a hole the next one patched. One question answers all five: a round
+// that produced nothing, or produced exactly what the round before it
+// produced, did not advance.
+const MAX_NON_ADVANCING_CONTINUATIONS = 3;
 // Ceiling across the whole turn. Every attempt re-POSTs the full history plus
-// attachments, so a high ceiling only burns tokens and wall time. Unproductive
-// turns are already stopped far earlier by the empty/stalled/repeat budgets;
-// this one only ever binds turns that keep making real progress, so it stays
-// just above the longest recovery we deliberately support.
+// attachments, so a high ceiling only burns tokens and wall time. Non-advancing
+// turns are already stopped far earlier by the budget above; this one only ever
+// binds turns that keep making real progress, so it stays just above the
+// longest recovery we deliberately support.
 const MAX_TOTAL_TRANSIENT_CONTINUATIONS = 12;
-// How many consecutive continuations that produce NO progress (no streamed
-// text, no completed/in-flight tool) we tolerate before giving up. A complex
-// first turn can spend the whole soft-timeout window (~40s) "thinking" with no
-// visible output; giving up after a single such window made the agent feel like
-// it "craps out / stops midway" on heavier prompts (Analytics). Retrying a few
-// times lets a transient slow start recover, while the cap still terminates a
-// genuinely stuck turn with a clear message instead of looping forever.
-const MAX_EMPTY_TRANSIENT_CONTINUATIONS = 3;
-// How many consecutive continuations that re-stream the SAME narration without
-// advancing (no in-flight tool, no completed tool) we tolerate before giving
-// up. A model that degenerates into repeating one phrase ("I have the full
-// HTML. Creating the extension now!") emits "new" text every continuation,
-// which keeps resetting the stalled/empty budgets — so without this guard the
-// stuck turn burns the entire MAX_TOTAL_TRANSIENT_CONTINUATIONS budget (each
-// round re-sending any large pasted payload) before bailing. Catching the
-// repeat ends it in a few rounds with a clear, actionable message instead.
-const MAX_REPEATED_TRANSIENT_CONTINUATIONS = 3;
-// How many consecutive continuations that only reach the SAME "preparing
-// action" activity card we tolerate before giving up. This catches runs that
-// keep timing out while assembling a large tool payload: they are not empty,
-// and the narration may vary enough to bypass the text-repeat guard, but the
-// real tool never starts.
-const MAX_REPEATED_ACTION_PREPARATION_CONTINUATIONS = 3;
 const RETRY_BASE_DELAY_MS = 500;
 const RETRY_MAX_DELAY_MS = 8_000;
 const MAX_HISTORY_ATTACHMENT_CHARS = 60_000;
@@ -636,14 +619,25 @@ function contentToStructuredMessages(content, nextToolCallId, options) {
                     : (part.args ?? {}),
             });
             if (part.result !== undefined) {
+                const body = truncate
+                    ? truncateForHistory(toolResultContent(part.result, part.toolName), MAX_HISTORY_TOOL_RESULT_CHARS, "Tool result")
+                    : toolResultContent(part.result, part.toolName);
                 pendingToolResults.push({
                     type: "tool-result",
                     toolCallId,
                     toolName: part.toolName,
                     toolInput: JSON.stringify(part.args ?? {}),
-                    content: truncate
-                        ? truncateForHistory(toolResultContent(part.result, part.toolName), MAX_HISTORY_TOOL_RESULT_CHARS, "Tool result")
-                        : toolResultContent(part.result, part.toolName),
+                    // A settled-interrupted tool has a result whose outcome is UNKNOWN.
+                    // It is neither a success nor a failure, so it carries the marker the
+                    // server's write-interruption breaker matches on instead of claiming
+                    // either.
+                    content: part.outcome === "unknown" &&
+                        !body.includes(INTERRUPTED_TOOL_RESULT)
+                        ? `${INTERRUPTED_TOOL_RESULT} ${body}`
+                        : body,
+                    ...(part.isError === true && part.outcome !== "unknown"
+                        ? { isError: true }
+                        : {}),
                 });
             }
             else {
@@ -652,7 +646,7 @@ function contentToStructuredMessages(content, nextToolCallId, options) {
                     toolCallId,
                     toolName: part.toolName,
                     toolInput: JSON.stringify(part.args ?? {}),
-                    content: "Interrupted before this tool returned a result.",
+                    content: INTERRUPTED_TOOL_RESULT,
                 });
             }
         }
@@ -712,6 +706,14 @@ function assistantUiMessagesToStructuredHistory(messages) {
                     ...(part.result !== undefined
                         ? { result: toolResultContent(part.result, toolName) }
                         : {}),
+                    // A failed call replayed without `isError` reads to the next turn as
+                    // an ordinary success whose body happens to contain error prose, so
+                    // the model cannot tell it already tried this and failed. The
+                    // server's repeat-error breaker keys on exactly this flag.
+                    ...(part.isError === true ? { isError: true } : {}),
+                    ...(part.outcome === "unknown"
+                        ? { outcome: "unknown" }
+                        : {}),
                 });
             }
         }
@@ -721,8 +723,29 @@ function assistantUiMessagesToStructuredHistory(messages) {
     }
     return structured;
 }
+/**
+ * Size this message will actually contribute to the request, AFTER the
+ * per-part truncation `assistantUiMessagesToStructuredHistory` applies. Tool
+ * calls are most of a tool-heavy turn, so counting only text parts priced a
+ * turn of 40 tool calls at ~0: it survived every trim against
+ * MAX_HISTORY_TOTAL_CHARS while the user's own prose was evicted around it.
+ */
 function estimateHistoryMessageCost(message) {
-    return Math.max(1, messageTextForHistory(message).length);
+    let cost = messageTextForHistory(message).length;
+    for (const part of message.content) {
+        if (part.type !== "tool-call")
+            continue;
+        const tool = part;
+        const argsCap = LARGE_INPUT_TOOL_NAMES.has(tool.toolName ?? "")
+            ? MAX_HISTORY_LARGE_TOOL_ARGS_CHARS
+            : MAX_HISTORY_TOOL_ARGS_CHARS;
+        const argsText = tool.argsText ?? stableJson(tool.args ?? {});
+        cost += Math.min(argsText.length, argsCap);
+        if (tool.result !== undefined) {
+            cost += Math.min(String(tool.result).length, MAX_HISTORY_TOOL_RESULT_CHARS);
+        }
+    }
+    return Math.max(1, cost);
 }
 function limitPriorMessagesForRequest(messages) {
     const recent = messages.slice(-MAX_HISTORY_MESSAGES);
@@ -826,6 +849,59 @@ function continuationRepeatSignature(content) {
         return "";
     return Array.from(new Set(segments)).sort().join("\u0000");
 }
+/**
+ * Everything a continuation could have advanced, as one signature over the
+ * work it produced: the distinct tool results it completed, the tool it left
+ * in flight, and the action card it left unstarted. Two consecutive
+ * continuations with the same signature moved the turn nowhere, whatever the
+ * server's reason code called it.
+ *
+ * DISTINCT, not per-occurrence: a round that degenerates into four hundred
+ * copies of one tool call collapses to the same signature as the round before
+ * it, which is exactly the shape production shows (up to 28 identical calls in
+ * one turn).
+ *
+ * Narration counts only when the round left NO unfinished work. A model stuck
+ * re-wording "I have the file, creating it now!" while the same action never
+ * starts emits new prose every round, and prose alone is why that used to look
+ * like progress.
+ */
+function describeContinuationAdvance(content, preparingToolName) {
+    const work = new Set();
+    let stall = null;
+    for (const part of content) {
+        if (part.type !== "tool-call")
+            continue;
+        if (part.result !== undefined) {
+            if (part.activity !== true) {
+                work.add(`done ${part.toolName} ${inFlightToolInputSignature(part)} ${part.result.length} ${part.result.slice(0, 256)}`);
+            }
+            continue;
+        }
+        if (part.activity === true) {
+            work.add(`preparing ${part.toolName}`);
+            stall ??= { kind: "preparing", toolName: part.toolName };
+        }
+        else {
+            work.add(`pending ${part.toolName} ${inFlightToolInputSignature(part)}`);
+            stall = { kind: "in-flight", toolName: part.toolName };
+        }
+    }
+    // A "Preparing X action" card is an activity-trail entry, not a content
+    // part, so a round can sit on an unstarted action while its content holds
+    // nothing but narration.
+    if (preparingToolName && !stall) {
+        work.add(`preparing ${preparingToolName}`);
+        stall = { kind: "preparing", toolName: preparingToolName };
+    }
+    if (!stall) {
+        const text = continuationRepeatSignature(content);
+        if (text)
+            work.add(`text ${text}`);
+        stall = text ? { kind: "repeat" } : { kind: "empty" };
+    }
+    return { signature: Array.from(work).sort().join(""), stall };
+}
 /**
  * True when an action was streamed but never returned a result yet — i.e. a
  * `tool_start` with no matching `tool_done`. The server is still executing it,
@@ -1557,30 +1633,20 @@ export function createAgentChatAdapter(options) {
             let internalContinuationRequest = latestUserIsRecovery;
             let startupRecoveryAttempts = 0;
             let queuedConflictRetries = 0;
-            let staleRunContinuationAttempts = 0;
-            let stalledTransientContinuationAttempts = 0;
-            let emptyTransientContinuationAttempts = 0;
             let totalTransientContinuationAttempts = 0;
-            let repeatedTransientContinuationAttempts = 0;
-            let lastContinuationRepeatSignature = null;
-            let recoveryGaveUpOnRepetition = false;
-            // Track when the same write tool is stuck in-flight across consecutive
-            // continuations (connection keeps dropping mid-execution). This is
-            // orthogonal to the text-repeat guard — in-flight tools reset
-            // madeProgress=true so the stalled/empty budgets never fire, but the tool
-            // never actually completes. After MAX_REPEATED_INFLIGHT_TOOL_STALLS
-            // consecutive interruptions of the same tool, bail with a clear message.
-            let lastInFlightToolName;
-            // Signature of the stuck tool's input. A retry with a changed payload
-            // (different signature) resets the stall count so the new attempt gets
-            // its own budget rather than inheriting the prior payload's.
-            let lastInFlightToolSignature;
-            let repeatedInFlightToolCount = 0;
-            let recoveryGaveUpOnInFlightTool = false;
-            const MAX_REPEATED_INFLIGHT_TOOL_STALLS = 3;
-            let lastPreparingToolName;
-            let repeatedActionPreparationCount = 0;
-            let recoveryGaveUpOnActionPreparation = false;
+            // Consecutive continuations whose advance signature matched the previous
+            // round's (or was empty). Reset by any real advance.
+            let nonAdvancingContinuations = 0;
+            let lastAdvanceSignature = null;
+            // Set at the moment we give up, so the user-facing message can name what
+            // the turn was stuck on without a counter per shape of stuck.
+            let recoveryStall = null;
+            // Content already accounted for by a previous advance check. Tracked
+            // separately from `visibleContinuationPrefix`, which deliberately does
+            // NOT advance on a `loop_limit` boundary so that round's output stays in
+            // continuation history; the advance check needs the per-round delta for
+            // every reason code, `loop_limit` included.
+            let advanceCheckPrefix = [];
             // Set when the turn is stopped by MAX_TOTAL_TRANSIENT_CONTINUATIONS —
             // the whole-turn continuation ceiling, not a dropped connection. This
             // can trip on a turn that was making real progress the entire time, so
@@ -1633,17 +1699,10 @@ export function createAgentChatAdapter(options) {
                     lastRecoverableRunError?.message
                         ? `last_recoverable_error: ${lastRecoverableRunError.message}`
                         : "",
-                    `stale_run_continuations: ${staleRunContinuationAttempts}`,
-                    `stalled_transient_continuations: ${stalledTransientContinuationAttempts}`,
-                    `empty_transient_continuations: ${emptyTransientContinuationAttempts}`,
-                    `repeated_transient_continuations: ${repeatedTransientContinuationAttempts}`,
-                    `repeated_inflight_tool_stalls: ${repeatedInFlightToolCount}`,
-                    lastInFlightToolName
-                        ? `last_inflight_tool: ${lastInFlightToolName}`
-                        : "",
-                    `repeated_action_preparation_stalls: ${repeatedActionPreparationCount}`,
-                    lastPreparingToolName
-                        ? `last_preparing_tool: ${lastPreparingToolName}`
+                    `non_advancing_continuations: ${nonAdvancingContinuations}`,
+                    recoveryStall ? `stalled_on: ${recoveryStall.kind}` : "",
+                    recoveryStall?.toolName
+                        ? `stalled_on_tool: ${recoveryStall.toolName}`
                         : "",
                     formatActivityTrail(lastActivityTrail)
                         ? `activity_trail: ${formatActivityTrail(lastActivityTrail)}`
@@ -1667,15 +1726,15 @@ export function createAgentChatAdapter(options) {
                     .join("\n");
             };
             const exhaustedRecoveryMessage = (reason) => {
-                if (recoveryGaveUpOnInFlightTool) {
+                if (recoveryStall?.kind === "in-flight") {
                     return "The agent got stuck waiting for the same tool to finish, so I stopped the automatic retries. The tool did not report a completed result.";
                 }
-                if (recoveryGaveUpOnRepetition) {
+                if (recoveryStall?.kind === "repeat") {
                     return "The agent got stuck repeating the same response without finishing, so I stopped the automatic retries. This often happens when it tries to re-type a large pasted file into one action — starting a new chat, or asking for a smaller first step, usually gets it unstuck.";
                 }
-                if (recoveryGaveUpOnActionPreparation) {
-                    const tool = lastPreparingToolName
-                        ? ` the ${humanizeActionName(lastPreparingToolName)} action`
+                if (recoveryStall?.kind === "preparing") {
+                    const tool = recoveryStall.toolName
+                        ? ` the ${humanizeActionName(recoveryStall.toolName)} action`
                         : " the same action";
                     return `The agent got stuck preparing${tool} input and never started the tool, so I stopped the automatic retries. Try a smaller first step or a more compact version of the request.`;
                 }
@@ -1688,6 +1747,9 @@ export function createAgentChatAdapter(options) {
                         reason === "stream_ended")) {
                     return "The agent request started but did not produce any visible progress before timing out. I stopped the automatic retries so this chat would not stay stuck on Thinking.";
                 }
+                if (recoveryStall?.kind === "empty") {
+                    return "The agent stopped producing new output across several automatic retries, so I stopped it here rather than leaving the chat stuck on Thinking.";
+                }
                 return "The agent connection kept failing after several automatic recovery attempts.";
             };
             const dispatchAuthError = (reason) => {
@@ -1818,14 +1880,9 @@ export function createAgentChatAdapter(options) {
                         attemptedRunIds: [...attemptedRunIds],
                         activityTrail: [...lastActivityTrail],
                         startupRecoveryAttempts,
-                        staleRunContinuationAttempts,
-                        stalledTransientContinuationAttempts,
-                        emptyTransientContinuationAttempts,
-                        repeatedTransientContinuationAttempts,
-                        repeatedInFlightToolCount,
-                        lastInFlightToolName,
-                        repeatedActionPreparationCount,
-                        lastPreparingToolName,
+                        nonAdvancingContinuations,
+                        stalledOn: recoveryStall?.kind,
+                        stalledOnTool: recoveryStall?.toolName,
                         totalTransientContinuationAttempts,
                         ...extra,
                     },
@@ -1837,14 +1894,9 @@ export function createAgentChatAdapter(options) {
                             lastSeq,
                             contentParts: content.length,
                             startupRecoveryAttempts,
-                            staleRunContinuationAttempts,
-                            stalledTransientContinuationAttempts,
-                            emptyTransientContinuationAttempts,
-                            repeatedTransientContinuationAttempts,
-                            repeatedInFlightToolCount,
-                            lastInFlightToolName,
-                            repeatedActionPreparationCount,
-                            lastPreparingToolName,
+                            nonAdvancingContinuations,
+                            stalledOn: recoveryStall?.kind,
+                            stalledOnTool: recoveryStall?.toolName,
                             totalTransientContinuationAttempts,
                         },
                     },
@@ -2762,192 +2814,63 @@ export function createAgentChatAdapter(options) {
                     const isTransient = signal.reason !== "loop_limit";
                     const visibleContent = visibleContentForContinuation();
                     let currentPartialHistory = contentToContinuationHistory(visibleContent);
-                    // Real, content-weight progress: streamed text or a completed tool
-                    // result. Used to reset the stalled/empty counters so trivial
-                    // whitespace-only output cannot keep the run alive indefinitely.
                     const madeContentProgress = hasContinuationProgress(visibleContent);
                     // An action was streamed but has not returned yet (a tool_start with
-                    // no tool_done). This is durable enough to survive continuation: the
-                    // server already emitted a real tool call. A tool-scoped activity
-                    // card ("Preparing generate-design") is useful UI, but it happens
-                    // before tool_start; treating it as progress caused silent retry
-                    // loops when the LLM timed out while assembling a large tool input.
+                    // no tool_done). Only a run_timeout in that window means the SERVER
+                    // is still executing it and a reconnect can still deliver the result;
+                    // every other reason means the stream is dead and nothing will
+                    // complete the tool.
                     const hasInFlightTool = hasInFlightToolCall(visibleContent);
                     const completedTool = lastCompletedTimeoutCandidateTool(content);
-                    // Either real output or an actively-running tool counts as progress
-                    // for the stalled/empty caps.
-                    const madeProgress = madeContentProgress || hasInFlightTool;
-                    const emptyRun = !madeProgress && signal.reason !== "loop_limit";
-                    const madeDurableToolProgress = visibleContent.some((part) => part.type === "tool-call" &&
-                        part.activity !== true &&
-                        part.result !== undefined);
                     const currentPreparingToolName = lastUnresolvedToolActivity(visibleContent) ??
                         lastPreparingActionTool(signal.activityTrail);
-                    // In-flight tool stall guard. When the same write tool is stuck
-                    // in-flight because the connection keeps dropping (stream_ended),
-                    // hasInFlightTool=true keeps madeProgress=true and completely
-                    // bypasses the stalled/empty budgets. Track the last in-flight tool
-                    // name; when the same tool is still unresolved after
-                    // MAX_REPEATED_INFLIGHT_TOOL_STALLS consecutive stream_ended events,
-                    // bail with a clear message.
-                    //
-                    // Count broken streams (connection drop / reconnect failed) and
-                    // no_progress stalls (the client aborts a stream that stayed open but
-                    // stopped producing events). Do NOT count run_timeout: with an
-                    // in-flight tool that means the server is still actively executing a
-                    // slow action and reconnection may recover the result.
-                    const currentInFlightToolPart = visibleContent.find((p) => p.type === "tool-call" &&
-                        p.result === undefined &&
-                        p.activity !== true);
-                    const currentInFlightToolName = currentInFlightToolPart?.toolName;
-                    const currentInFlightToolSignature = currentInFlightToolPart
-                        ? inFlightToolInputSignature(currentInFlightToolPart)
-                        : undefined;
-                    const isBrokenInFlightTool = signal.reason === "stream_ended" || signal.reason === "no_progress";
-                    if (currentInFlightToolName && isBrokenInFlightTool) {
-                        if (currentInFlightToolName === lastInFlightToolName &&
-                            currentInFlightToolSignature === lastInFlightToolSignature) {
-                            repeatedInFlightToolCount += 1;
-                        }
-                        else {
-                            // New tool, or the same tool retried with a CHANGED (e.g.
-                            // smaller) payload — give the changed input a fresh stall budget
-                            // instead of aborting it as a repeat of the prior payload.
-                            repeatedInFlightToolCount = 0;
-                            lastInFlightToolName = currentInFlightToolName;
-                            lastInFlightToolSignature = currentInFlightToolSignature;
-                        }
-                    }
-                    else if (!currentInFlightToolName) {
-                        repeatedInFlightToolCount = 0;
-                    }
-                    const isRepeatedActionPreparationCandidate = signal.reason !== "loop_limit" &&
-                        currentPreparingToolName !== undefined &&
-                        !hasInFlightTool &&
-                        !madeDurableToolProgress;
-                    if (isRepeatedActionPreparationCandidate) {
-                        if (currentPreparingToolName === lastPreparingToolName) {
-                            repeatedActionPreparationCount += 1;
-                        }
-                        else {
-                            repeatedActionPreparationCount = 0;
-                            lastPreparingToolName = currentPreparingToolName;
-                        }
-                    }
-                    else if (!currentPreparingToolName ||
-                        hasInFlightTool ||
-                        madeDurableToolProgress) {
-                        repeatedActionPreparationCount = 0;
-                        lastPreparingToolName = undefined;
+                    // THE boundary. One question — did this continuation advance the
+                    // turn? — decides every reason code, `loop_limit` included. It used
+                    // to skip this block entirely AND reset two of the budgets, so a
+                    // model that degenerated into a tool loop re-POSTed the same turnId
+                    // until the user gave up (measured in production at 186 minutes with
+                    // no answer). The durable per-turn ledger lives server-side inside
+                    // one run and never sees a client re-POST, so nothing else bounds it.
+                    const advanceDelta = contentAfterContinuationPrefix(content, advanceCheckPrefix);
+                    const advance = describeContinuationAdvance(advanceDelta, currentPreparingToolName);
+                    const serverStillRunningTool = signal.reason === "run_timeout" && hasInFlightTool;
+                    const advanced = serverStillRunningTool ||
+                        (advance.signature !== "" &&
+                            advance.signature !== lastAdvanceSignature);
+                    // Only remember a non-empty signature, so an empty round between two
+                    // identical rounds cannot launder the second one into "new work".
+                    if (advance.signature)
+                        lastAdvanceSignature = advance.signature;
+                    nonAdvancingContinuations = advanced
+                        ? 0
+                        : nonAdvancingContinuations + 1;
+                    totalTransientContinuationAttempts += 1;
+                    advanceCheckPrefix = snapshotContent(content);
+                    // If a tool already completed, do not turn a missing closing
+                    // sentence into a scary connection failure. Give the model one
+                    // continuation opportunity (the completed tool itself counts as an
+                    // advance on the first timeout); if the follow-up produces no new
+                    // content, stop locally with a clear completed-tool warning.
+                    if (signal.reason === "run_timeout" &&
+                        completedTool &&
+                        !hasInFlightToolCall(content) &&
+                        !currentPreparingToolName &&
+                        !madeContentProgress &&
+                        !hasInFlightTool) {
+                        return {
+                            ok: false,
+                            resetVisibleContent: false,
+                            completedToolName: completedTool.toolName,
+                        };
                     }
-                    // Degenerate repetition guard. When the model gets stuck re-streaming
-                    // the SAME narration every continuation without ever starting or
-                    // finishing a tool, each round is "new" text — so madeProgress stays
-                    // true and the stalled/empty budgets never trip. Compare this round's
-                    // unique-sentence signature to the previous round's; a match with no
-                    // tool progress is a non-advancing loop. Tracked by its own counter
-                    // so it bails after a few rounds instead of the full transient budget,
-                    // without perturbing the stalled/empty/stale accounting.
-                    const repeatSignature = continuationRepeatSignature(visibleContent);
-                    const isNonAdvancingRepeat = signal.reason !== "loop_limit" &&
-                        repeatSignature !== "" &&
-                        repeatSignature === lastContinuationRepeatSignature &&
-                        !hasInFlightTool &&
-                        !madeDurableToolProgress;
-                    if (signal.reason === "loop_limit") {
-                        stalledTransientContinuationAttempts = 0;
-                        emptyTransientContinuationAttempts = 0;
+                    if (nonAdvancingContinuations >= MAX_NON_ADVANCING_CONTINUATIONS) {
+                        recoveryStall = advance.stall;
+                        return { ok: false, resetVisibleContent: false };
                     }
-                    else {
-                        totalTransientContinuationAttempts += 1;
-                        // If a tool already completed, do not turn a missing closing
-                        // sentence into a scary connection failure. Give the model one
-                        // continuation opportunity (the completed tool itself counts as
-                        // progress on the first timeout); if the follow-up produces no new
-                        // content, stop locally with a clear completed-tool warning.
-                        if (signal.reason === "run_timeout" &&
-                            completedTool &&
-                            !hasInFlightToolCall(content) &&
-                            !currentPreparingToolName &&
-                            !madeContentProgress &&
-                            !hasInFlightTool) {
-                            return {
-                                ok: false,
-                                resetVisibleContent: false,
-                                completedToolName: completedTool.toolName,
-                            };
-                        }
-                        // Bail when the same write tool is stuck in-flight across too many
-                        // consecutive continuations. Checked before the text-repeat guard
-                        // because hasInFlightTool=true would mask the repeat as progress.
-                        if (repeatedInFlightToolCount >= MAX_REPEATED_INFLIGHT_TOOL_STALLS) {
-                            recoveryGaveUpOnInFlightTool = true;
-                            return { ok: false, resetVisibleContent: false };
-                        }
-                        if (repeatedActionPreparationCount >
-                            MAX_REPEATED_ACTION_PREPARATION_CONTINUATIONS) {
-                            recoveryGaveUpOnActionPreparation = true;
-                            return { ok: false, resetVisibleContent: false };
-                        }
-                        // Bail fast on a non-advancing repetition loop, well before the
-                        // stalled/empty/total budgets would (each round otherwise re-sends
-                        // the whole pasted payload). Tracked separately so it never trips
-                        // on legitimately-progressing runs that happen to be slow.
-                        if (isNonAdvancingRepeat) {
-                            repeatedTransientContinuationAttempts += 1;
-                            if (repeatedTransientContinuationAttempts >
-                                MAX_REPEATED_TRANSIENT_CONTINUATIONS) {
-                                recoveryGaveUpOnRepetition = true;
-                                return { ok: false, resetVisibleContent: false };
-                            }
-                        }
-                        else {
-                            repeatedTransientContinuationAttempts = 0;
-                        }
-                        if (repeatSignature) {
-                            lastContinuationRepeatSignature = repeatSignature;
-                        }
-                        // A run_timeout that produced nothing visible and no activity (the
-                        // model spent the whole soft-timeout window thinking before its
-                        // first output) is NOT an immediate give-up: a transient slow start
-                        // routinely recovers on the next continuation. Let it fall through
-                        // to the empty-continuation budget below so it retries a bounded
-                        // number of times before surfacing the "no visible progress" error.
-                        // Reset the empty-continuation counter on real progress — streamed
-                        // text/completed tool OR an in-flight tool the server is running —
-                        // not merely on a non-zero part count, which whitespace-only or
-                        // unresolved-only output would falsely satisfy.
-                        if (!madeProgress) {
-                            emptyTransientContinuationAttempts += 1;
-                            if (emptyTransientContinuationAttempts >
-                                MAX_EMPTY_TRANSIENT_CONTINUATIONS) {
-                                return { ok: false, resetVisibleContent: false };
-                            }
-                        }
-                        else {
-                            emptyTransientContinuationAttempts = 0;
-                        }
-                        if (signal.reason === "stale_run") {
-                            staleRunContinuationAttempts = madeDurableToolProgress
-                                ? 0
-                                : staleRunContinuationAttempts + 1;
-                            if (staleRunContinuationAttempts > MAX_STALE_RUN_CONTINUATIONS) {
-                                return { ok: false, resetVisibleContent: false };
-                            }
-                        }
-                        stalledTransientContinuationAttempts = madeProgress
-                            ? 0
-                            : stalledTransientContinuationAttempts + 1;
-                        if (totalTransientContinuationAttempts >
-                            MAX_TOTAL_TRANSIENT_CONTINUATIONS) {
-                            recoveryGaveUpOnTransientBudget = true;
-                        }
-                        if (stalledTransientContinuationAttempts >
-                            MAX_STALLED_TRANSIENT_CONTINUATIONS ||
-                            totalTransientContinuationAttempts >
-                                MAX_TOTAL_TRANSIENT_CONTINUATIONS) {
-                            return { ok: false, resetVisibleContent: false };
-                        }
+                    if (totalTransientContinuationAttempts >
+                        MAX_TOTAL_TRANSIENT_CONTINUATIONS) {
+                        recoveryGaveUpOnTransientBudget = true;
+                        return { ok: false, resetVisibleContent: false };
                     }
                     if (isTransient) {
                         const settledInterruptedTools = settleInterruptedToolCalls(visibleContent, undefined, { includeActivity: true });
@@ -2997,13 +2920,21 @@ export function createAgentChatAdapter(options) {
                     startupRecoveryAttempts = 0;
                     clearActiveRun();
                     if (!isTransient) {
-                        return { ok: true, resetVisibleContent: false, emptyRun };
+                        return {
+                            ok: true,
+                            resetVisibleContent: false,
+                            nonAdvancing: !advanced,
+                        };
                     }
                     // Keep everything visible during transient recovery. The continuation
                     // prefix diff tracks what the next request has already seen, so
                     // preserving text no longer causes duplicate continuation history.
                     visibleContinuationPrefix = snapshotContent(content);
-                    return { ok: true, resetVisibleContent: false, emptyRun };
+                    return {
+                        ok: true,
+                        resetVisibleContent: false,
+                        nonAdvancing: !advanced,
+                    };
                 };
                 while (true) {
                     try {
@@ -3410,11 +3341,11 @@ export function createAgentChatAdapter(options) {
                                     detail: { tabId },
                                 }));
                             }
-                            // A run that produced nothing visible never got past
+                            // A run that advanced nothing usually never got past
                             // startup/gateway; re-POSTing the identical payload immediately
                             // just hits the identical wall. Back that case off instead.
-                            if (continuation.emptyRun) {
-                                await retryDelay(Math.max(0, emptyTransientContinuationAttempts - 1), abortSignal);
+                            if (continuation.nonAdvancing) {
+                                await retryDelay(Math.max(0, nonAdvancingContinuations - 1), abortSignal);
                             }
                             else {
                                 await delay(250, abortSignal);

package/dist/client/sse-event-processor.d.ts

@@ -110,6 +110,13 @@ export interface AgentAutoContinueErrorInfo {
     recoverable?: boolean;
     upgradeUrl?: string;
 }
+/**
+ * Kept verbatim in sync with `INTERRUPTED_TOOL_RESULT_MARKER`
+ * (agent/production-agent.ts): the server matches this substring in replayed
+ * history to count how many times a write tool was interrupted, which is the
+ * only thing that tells "we do not know if it landed" apart from "it failed".
+ */
+export declare const INTERRUPTED_TOOL_RESULT = "Interrupted before this tool returned a result.";
 export declare function settleInterruptedToolCalls(content: ContentPart[], result?: string, options?: {
     includeActivity?: boolean;
     activityResult?: string;