@agent-native/core 0.122.4 → 0.123.1

package/dist/client/agent-chat-adapter.d.ts

@@ -1,5 +1,6 @@
 import type { ChatModelAdapter } from "@assistant-ui/react";
 import type { ReasoningEffort } from "../shared/reasoning-effort.js";
+import { type ContentPart } from "./sse-event-processor.js";
 import type { ChatThreadScope } from "./use-chat-threads.js";
 export type AgentChatSurfaceKind = 
 /**
@@ -13,6 +14,22 @@ export type AgentChatSurfaceKind =
 /** Chat hosted by Desktop for a local app with explicit code access. */
  | "desktop";
 export declare const BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS = 150000;
+export declare const MAX_FOLLOWED_BACKGROUND_RUNS = 6;
+export declare const MAX_BACKGROUND_FOLLOW_WALL_TIME_MS: number;
+/**
+ * Server truth for "does this run still look alive?", used to keep the client
+ * from aborting a run the server believes is healthy — the destructive half of
+ * the old client watchdog. Fails SAFE (true) when the lookup itself fails: an
+ * unreachable server is not evidence that the run is dead. A local content
+ * snapshot with an unresolved tool call is also treated as alive, matching the
+ * server's own in-flight suspension.
+ */
+export declare function activeRunLooksAlive(args: {
+    apiUrl: string;
+    threadId: string | undefined;
+    runId: string;
+    content?: ContentPart[];
+}): Promise<boolean>;
 /**
  * The composer's exec mode is sent as explicit request metadata. The server
  * owns the plan-mode prompt and read-only tool filtering so the chat history

package/dist/client/agent-chat-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-chat-adapter.d.ts","sourceRoot":"","sources":["../../src/client/agent-chat-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAsB,MAAM,qBAAqB,CAAC;AAWhF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAqBrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,MAAM,MAAM,oBAAoB;AAC9B;;;;GAIG;AACD,KAAK;AACP,0EAA0E;GACxE,WAAW;AACb,wEAAwE;GACtE,SAAS,CAAC;AAwId,eAAO,MAAM,iCAAiC,SAAU,CAAC;AAsrCzD;;;;GAIG;AACH;;;GAGG;AACH,MAAM,WAAW,6BAA6B;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IAC3C,SAAS,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IAC5C,SAAS,CAAC,EAAE;QAAE,OAAO,EAAE,eAAe,GAAG,SAAS,CAAA;KAAE,CAAC;IACrD,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE;QAAE,OAAO,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,CAAA;KAAE,CAAC;IAC3D,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC;AAyED,wBAAgB,sBAAsB,CACpC,OAAO,CAAC,EAAE,6BAA6B,GACtC,gBAAgB,CA4qElB"}
+{"version":3,"file":"agent-chat-adapter.d.ts","sourceRoot":"","sources":["../../src/client/agent-chat-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAsB,MAAM,qBAAqB,CAAC;AAWhF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAWrE,OAAO,EAKL,KAAK,WAAW,EAIjB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,MAAM,MAAM,oBAAoB;AAC9B;;;;GAIG;AACD,KAAK;AACP,0EAA0E;GACxE,WAAW;AACb,wEAAwE;GACtE,SAAS,CAAC;AA6Id,eAAO,MAAM,iCAAiC,SAAU,CAAC;AAQzD,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAC9C,eAAO,MAAM,kCAAkC,QAAc,CAAC;AAovB9D;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;CACzB,GAAG,OAAO,CAAC,OAAO,CAAC,CAsBnB;AAqcD;;;;GAIG;AACH;;;GAGG;AACH,MAAM,WAAW,6BAA6B;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IAC3C,SAAS,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IAC5C,SAAS,CAAC,EAAE;QAAE,OAAO,EAAE,eAAe,GAAG,SAAS,CAAA;KAAE,CAAC;IACrD,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE;QAAE,OAAO,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,CAAA;KAAE,CAAC;IAC3D,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC;AAyED,wBAAgB,sBAAsB,CACpC,OAAO,CAAC,EAAE,6BAA6B,GACtC,gBAAgB,CA2wElB"}

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

@@ -25,7 +25,12 @@ const MAX_STARTUP_RECOVERY_ATTEMPTS = 8;
 const MAX_QUEUED_CONFLICT_RETRIES = 120;
 const MAX_STALE_RUN_CONTINUATIONS = 3;
 const MAX_STALLED_TRANSIENT_CONTINUATIONS = 8;
-const MAX_TOTAL_TRANSIENT_CONTINUATIONS = 32;
+// 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.
+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
@@ -118,6 +123,15 @@ const BACKGROUND_FOLLOW_POLL_INTERVAL_MS = 1_000;
 // agent-chat-plugin.ts) instead, and keep this comment's inequality chain
 // accurate if any of the four numbers change.
 export const BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS = 150_000;
+// Per-TURN follow budgets. BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS above is a
+// per-idle-WINDOW bound and resets every time a successor run appears, so a
+// server stuck redispatching the same failing chunk resets the only budget on
+// every poll tick and the follow loop never exits (prod: 26 chained runs over
+// 22 minutes, all error:stale_run, user watching a spinner). These bound the
+// whole turn instead, and an identical repeated failure counts as no progress.
+export const MAX_FOLLOWED_BACKGROUND_RUNS = 6;
+export const MAX_BACKGROUND_FOLLOW_WALL_TIME_MS = 10 * 60_000;
+const MAX_REPEATED_BACKGROUND_TERMINAL_REASONS = 3;
 // A re-observed terminal run whose outcome would be an ERROR (never a
 // genuine "done" success) gets a short extra grace window before the follow
 // loop surfaces it: the server's dead-run recovery can reap a lost
@@ -732,6 +746,33 @@ function hasInFlightToolCall(content) {
         part.result === undefined &&
         part.activity !== true);
 }
+/**
+ * Server truth for "does this run still look alive?", used to keep the client
+ * from aborting a run the server believes is healthy — the destructive half of
+ * the old client watchdog. Fails SAFE (true) when the lookup itself fails: an
+ * unreachable server is not evidence that the run is dead. A local content
+ * snapshot with an unresolved tool call is also treated as alive, matching the
+ * server's own in-flight suspension.
+ */
+export async function activeRunLooksAlive(args) {
+    if (args.content && hasInFlightToolCall(args.content))
+        return true;
+    if (!args.threadId)
+        return false;
+    try {
+        const res = await fetch(`${args.apiUrl}/runs/active?threadId=${encodeURIComponent(args.threadId)}`, { credentials: "same-origin" });
+        if (!res.ok)
+            return true;
+        const data = (await res.json());
+        if (data?.active !== true || String(data.runId ?? "") !== args.runId) {
+            return false;
+        }
+        return data.hasInFlightWork === true || data.status === "running";
+    }
+    catch {
+        return true;
+    }
+}
 function lastActivityTool(trail) {
     for (let i = trail.length - 1; i >= 0; i--) {
         const tool = trail[i]?.tool?.trim();
@@ -1633,9 +1674,6 @@ export function createAgentChatAdapter(options) {
                                 return true;
                             }
                             if (reconnectErr instanceof AgentAutoContinueSignal) {
-                                if (reconnectErr.reason === "no_progress") {
-                                    throw reconnectErr;
-                                }
                                 return false;
                             }
                             lastReconnectError = reconnectErr;
@@ -1647,25 +1685,6 @@ export function createAgentChatAdapter(options) {
                     }
                     return false;
                 };
-                const abortCurrentRun = async () => {
-                    if (!runId)
-                        return;
-                    try {
-                        await fetch(`${apiUrl}/runs/${encodeURIComponent(runId)}/abort`, {
-                            method: "POST",
-                            headers: { "Content-Type": "application/json" },
-                            body: JSON.stringify({ reason: "no_progress" }),
-                            signal: abortSignal,
-                        });
-                    }
-                    catch {
-                        // Best effort. The follow-up POST will still reconnect or 409 if
-                        // the producer is alive and cannot be aborted cross-isolate.
-                    }
-                    finally {
-                        clearActiveRun();
-                    }
-                };
                 const reconnectActiveRunForThread = async function* () {
                     if (!threadId)
                         return false;
@@ -1990,6 +2009,31 @@ export function createAgentChatAdapter(options) {
                         }
                     };
                     dispatchResumingUiEvent();
+                    const durablyAbortBackgroundTurn = async (reason) => {
+                        if (!threadId)
+                            return false;
+                        for (let attempt = 0; attempt < 2; attempt++) {
+                            try {
+                                const response = await fetch(`${apiUrl}/runs/turn/${encodeURIComponent(turnId)}/abort`, {
+                                    method: "POST",
+                                    headers: { "Content-Type": "application/json" },
+                                    body: JSON.stringify({ threadId, reason }),
+                                    signal: abortSignal,
+                                });
+                                if (response.ok)
+                                    return true;
+                            }
+                            catch {
+                                if (abortSignal.aborted)
+                                    return false;
+                            }
+                        }
+                        return false;
+                    };
+                    const stopBackgroundTurnBeforeReporting = async function* (outcome) {
+                        await durablyAbortBackgroundTurn(outcome.errorCode);
+                        yield* emitBackgroundTerminalError(outcome);
+                    };
                     // Before surfacing a background terminal ERROR (never called for a
                     // genuine "done" success — see call site), give the server's
                     // reap-and-recover path a short extra window to insert a claimable
@@ -2028,6 +2072,28 @@ export function createAgentChatAdapter(options) {
                         }
                         return "timeout";
                     };
+                    const followStartedAt = Date.now();
+                    const followedRunIds = new Set();
+                    let repeatedTerminalReason = null;
+                    let repeatedTerminalReasonCount = 0;
+                    // Returns true once the SAME terminal reason has come back from
+                    // enough successive successors that produced no events at all.
+                    const noteRepeatedTerminalReason = (reason, producedEvents) => {
+                        if (producedEvents || !reason) {
+                            repeatedTerminalReason = null;
+                            repeatedTerminalReasonCount = 0;
+                            return false;
+                        }
+                        if (reason === repeatedTerminalReason) {
+                            repeatedTerminalReasonCount += 1;
+                        }
+                        else {
+                            repeatedTerminalReason = reason;
+                            repeatedTerminalReasonCount = 1;
+                        }
+                        return (repeatedTerminalReasonCount >=
+                            MAX_REPEATED_BACKGROUND_TERMINAL_REASONS);
+                    };
                     let idleSince = null;
                     let lastSeenActive = null;
                     // Terminal runs already replayed once. A recoverable terminal error
@@ -2045,6 +2111,15 @@ export function createAgentChatAdapter(options) {
                             clearActiveRun();
                             return "completed";
                         }
+                        if (Date.now() - followStartedAt >=
+                            MAX_BACKGROUND_FOLLOW_WALL_TIME_MS) {
+                            yield* stopBackgroundTurnBeforeReporting({
+                                message: `The agent kept restarting this step for ${Math.round(MAX_BACKGROUND_FOLLOW_WALL_TIME_MS / 60_000)} minutes without finishing it. It was stopped so you can retry from the preserved chat context — a smaller request usually gets through.`,
+                                errorCode: "background_follow_time_budget_exhausted",
+                                details: `followed_runs: ${followedRunIds.size}`,
+                            });
+                            return "completed";
+                        }
                         let active = null;
                         try {
                             const activeRes = await fetch(`${apiUrl}/runs/active?threadId=${encodeURIComponent(threadId)}`, { signal: abortSignal });
@@ -2108,7 +2183,7 @@ export function createAgentChatAdapter(options) {
                                         idleSince = Date.now();
                                     if (Date.now() - idleSince >=
                                         BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS) {
-                                        yield* emitBackgroundTerminalError({
+                                        yield* stopBackgroundTurnBeforeReporting({
                                             message: "The agent's background run stopped between chunks and no continuation appeared. You can retry from the preserved chat context.",
                                             errorCode: "background_run_lost",
                                             details: `terminal_reason: ${rawTerminalReason}`,
@@ -2136,6 +2211,15 @@ export function createAgentChatAdapter(options) {
                                 yield* emitBackgroundTerminalOutcome(active);
                                 return "completed";
                             }
+                            followedRunIds.add(activeRunId);
+                            if (followedRunIds.size > MAX_FOLLOWED_BACKGROUND_RUNS) {
+                                yield* stopBackgroundTurnBeforeReporting({
+                                    message: `The agent restarted this step ${followedRunIds.size} times without finishing it. It was stopped so you can retry from the preserved chat context — a smaller request usually gets through.`,
+                                    errorCode: "background_follow_run_budget_exhausted",
+                                    details: `followed_runs: ${followedRunIds.size}`,
+                                });
+                                return "completed";
+                            }
                             const previousRunId = runId;
                             runId = activeRunId;
                             if (!attemptedRunIds.includes(activeRunId)) {
@@ -2145,6 +2229,7 @@ export function createAgentChatAdapter(options) {
                             if (threadId) {
                                 setActiveRun({ threadId, runId: activeRunId, lastSeq });
                             }
+                            const seqBeforeAttach = lastSeq;
                             const attach = yield* followAttachOnce();
                             if (attach === "completed" || attach === "aborted") {
                                 return "completed";
@@ -2152,6 +2237,17 @@ export function createAgentChatAdapter(options) {
                             if (isTerminal) {
                                 replayedTerminalRunIds.add(activeRunId);
                             }
+                            const observedTerminalReason = typeof active?.terminalReason === "string"
+                                ? active.terminalReason
+                                : "";
+                            if (noteRepeatedTerminalReason(observedTerminalReason, lastSeq > seqBeforeAttach)) {
+                                yield* stopBackgroundTurnBeforeReporting({
+                                    message: "The agent's background run failed the same way several times in a row without producing any output. It was stopped so you can retry from the preserved chat context.",
+                                    errorCode: "background_follow_repeated_failure",
+                                    details: `terminal_reason: ${observedTerminalReason}`,
+                                });
+                                return "completed";
+                            }
                             // Server-authoritative "silently deferred, recovery in
                             // progress" signal (see `awaitingRedispatch` on
                             // `getActiveRunForThreadAsync`, run-manager.ts): a
@@ -2182,6 +2278,7 @@ export function createAgentChatAdapter(options) {
                                     idleSince = Date.now();
                                 if (Date.now() - idleSince >=
                                     BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS) {
+                                    await durablyAbortBackgroundTurn("background_run_lost");
                                     yield* emitBackgroundTerminalOutcome(lastSeenActive);
                                     return "completed";
                                 }
@@ -2204,6 +2301,7 @@ export function createAgentChatAdapter(options) {
                                         ? lastSeenActive.status
                                         : null,
                                 });
+                                await durablyAbortBackgroundTurn("background_run_lost");
                                 yield* emitBackgroundTerminalOutcome(lastSeenActive);
                                 return "completed";
                             }
@@ -2242,6 +2340,7 @@ export function createAgentChatAdapter(options) {
                     // 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);
@@ -2457,13 +2556,13 @@ export function createAgentChatAdapter(options) {
                     startupRecoveryAttempts = 0;
                     clearActiveRun();
                     if (!isTransient) {
-                        return { ok: true, resetVisibleContent: false };
+                        return { ok: true, resetVisibleContent: false, emptyRun };
                     }
                     // 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 };
+                    return { ok: true, resetVisibleContent: false, emptyRun };
                 };
                 while (true) {
                     try {
@@ -2735,15 +2834,18 @@ export function createAgentChatAdapter(options) {
                                 }
                                 return;
                             }
-                            if (err.reason === "no_progress") {
-                                await abortCurrentRun();
-                            }
                             if (err.reason === "run_timeout" && !err.errorInfo) {
                                 const reconnected = yield* reconnectBackgroundContinuationForRunTimeout();
                                 if (reconnected)
                                     return;
                             }
-                            if (err.reason === "stream_ended") {
+                            // A CLIENT watchdog expiring means "reattach", never "kill the
+                            // run": the server owns recovery and still believes this run is
+                            // healthy. Aborting here was the single largest source of
+                            // user-visible failure. A server-sent `auto_continue` is a
+                            // different thing entirely — it wants a fresh POST.
+                            if (err.reason === "stream_ended" ||
+                                (err.reason === "no_progress" && err.clientWatchdog)) {
                                 const reconnected = yield* reconnectCurrentRun();
                                 if (reconnected)
                                     return;
@@ -2841,7 +2943,15 @@ export function createAgentChatAdapter(options) {
                                     detail: { tabId },
                                 }));
                             }
-                            await delay(250, abortSignal);
+                            // A run that produced nothing visible 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);
+                            }
+                            else {
+                                await delay(250, abortSignal);
+                            }
                             if (abortSignal.aborted)
                                 return;
                             continue;