@rynx-ai/runtime 0.1.11-beta.20 → 0.1.11-beta.22

package/dist/codex-app-server/forwarder.js

@@ -1,5 +1,5 @@
 import { codexUserContent } from "../input-resources.js";
-import { mapCodexItem, mapCodexNotification } from "./mapping.js";
+import { codexResumeTerminalStatus, mapCodexItem, mapCodexNotification, } from "./mapping.js";
 const MCP_STARTUP_STATUS_METHOD = "mcpServer/startupStatus/updated";
 const MCP_TERMINAL_STATES = new Set(["ready", "failed", "cancelled"]);
 function threadIdFrom(params) {
@@ -45,6 +45,20 @@ function isModelOutput(method, params) {
     const item = params?.item;
     return Boolean(item?.type && item.type !== "userMessage");
 }
+function isTerminalTurnMethod(method) {
+    return method === "turn/completed" || method === "turn/failed";
+}
+/** Turn-scoped notifications must never be reassigned to whichever newer turn
+ * happens to be current when an app-server frame arrives late. */
+function isTurnScopedMethod(method) {
+    return method.startsWith("turn/") || method.startsWith("item/") ||
+        method === "queue/status" || method === "error";
+}
+/** Recover a missed turn/started only from visible, fully-scoped assistant/plan
+ * deltas. Other deltas require an already matching active turn. */
+function canRecoverMissedTurnFrom(method) {
+    return method === "item/agentMessage/delta" || method === "item/plan/delta";
+}
 export class CodexSessionForwarder {
     client;
     sink;
@@ -55,6 +69,9 @@ export class CodexSessionForwarder {
     currentThreadIdValue = null;
     activeSignaled = false;
     completionTimer = null;
+    /** Turn id retained only for late-item dedup while a terminal response waits
+     * for its bounded output-ordering grace. It is not an active provider turn. */
+    pendingCompletionTurnId = null;
     assistantMessageTimer = null;
     deferredAssistantMessage = null;
     pendingCompletion = null;
@@ -97,12 +114,17 @@ export class CodexSessionForwarder {
         this.flushDeferredAssistantMessage();
         if (this.turnOpen) {
             this.turnOpen = false;
+            this.currentTurnIdValue = null;
             this.sink.onTurnEnd();
         }
+        else {
+            this.currentTurnIdValue = null;
+        }
     }
-    /** True while a turn is open — injection uses `turn/steer` then, else `turn/start`. */
+    /** True while the provider owns an active turn, including the short interval
+     * between injection acceptance and observer confirmation. */
     isTurnOpen() {
-        return this.turnOpen;
+        return this.turnOpen || this.currentTurnIdValue !== null;
     }
     /** The current turn's codex id (only meaningful while {@link isTurnOpen}). */
     currentTurnId() {
@@ -117,8 +139,9 @@ export class CodexSessionForwarder {
     noteTurnAccepted(turnId) {
         if (!turnId)
             return;
+        if (this.pendingCompletion)
+            this.flushPendingCompletion();
         this.currentTurnIdValue = turnId;
-        this.ensureTurn();
         this.emitMcpStartupStatus();
     }
     hasPendingMcpStartup() {
@@ -131,7 +154,7 @@ export class CodexSessionForwarder {
             return pending;
         this.pendingMcpServers.clear();
         this.clearMcpStartupTimer();
-        if (this.turnOpen) {
+        if (this.isTurnOpen()) {
             this.emitMcpStatus(`MCP startup cancelled: ${pending.join(", ")}`);
         }
         return pending;
@@ -150,6 +173,16 @@ export class CodexSessionForwarder {
     threadId() {
         return this.currentThreadIdValue;
     }
+    /** Seed an already-persisted/resumed thread binding. The bridge retains this
+     * state even when app-server does not rebroadcast `thread/started`, so
+     * terminal-boundary recovery must know it too. */
+    noteThreadBound(threadId) {
+        if (!threadId || this.currentThreadIdValue === threadId)
+            return;
+        if (this.currentThreadIdValue !== null || this.turnOpen)
+            return;
+        this.currentThreadIdValue = threadId;
+    }
     /**
      * Replay the backlog turns from a `thread/resume` response as if they were live
      * `item/completed` notifications — the fresh-thread first-turn backfill. Each
@@ -165,34 +198,22 @@ export class CodexSessionForwarder {
             this.ensureTurn();
             for (const item of turn.items ?? [])
                 this.processCompletedItem(item);
-            if (turn.status === "inProgress")
+            if (codexResumeTerminalStatus(turn) === undefined)
                 continue;
             const mapped = mapCodexNotification("turn/completed", { turn });
             this.turnOpen = false;
+            this.currentTurnIdValue = null;
             if (mapped.fatalError)
                 this.sink.onTurnError(mapped.fatalError);
             else
                 this.sink.onTurnEnd(mapped.usage);
         }
     }
-    /** Reconcile only the exact active turn after an observer resume. Historical
-     * items are intentionally not replayed on an existing-thread reconnect. */
-    reconcileActiveTurn(turn) {
-        if (!this.turnOpen || !turn || turn.status === "inProgress")
-            return false;
-        const resumedTurnId = turn.id ?? turn.turnId;
-        if (!this.currentTurnIdValue || resumedTurnId !== this.currentTurnIdValue)
-            return false;
-        const mapped = mapCodexNotification("turn/completed", { turn });
-        this.settle(mapped.fatalError
-            ? { kind: "error", error: mapped.fatalError }
-            : { kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
-        return true;
-    }
     /** Fail an open response exactly once when its observer or terminal exits. */
     failOpenTurn(error) {
-        if (!this.turnOpen)
+        if (!this.isTurnOpen())
             return false;
+        this.ensureTurn();
         this.settle({ kind: "error", error });
         return true;
     }
@@ -240,17 +261,63 @@ export class CodexSessionForwarder {
         // behavior unchanged unless the Traex host explicitly opts in.
         if (method === "queue/status" && !this.options.surfaceQueueStatus)
             return;
+        if (method === "queue/status" && this.currentTurnIdValue === null)
+            return;
         const carriedTurnId = turnIdFrom(params);
         if (method === "turn/started") {
-            this.flushPendingCompletion();
-            this.flushDeferredAssistantMessage();
-            if (carriedTurnId)
+            this.beginTurn(carriedTurnId);
+            this.sink.onTurnObserved?.(carriedTurnId);
+            return;
+        }
+        if (isTerminalTurnMethod(method)) {
+            if (!this.terminalBoundaryMatchesActiveTurn(carriedTurnId, notificationThreadId)) {
+                return;
+            }
+            const hadActiveTurn = this.currentTurnIdValue !== null;
+            const hadOpenResponse = this.turnOpen;
+            const mapped = mapCodexNotification(method, params);
+            if (!hadActiveTurn && !hadOpenResponse) {
+                const turn = params?.turn;
+                const recoveredStatus = mapped.fatalError ||
+                    method === "turn/failed" ||
+                    codexResumeTerminalStatus(turn) === "failed"
+                    ? "failed"
+                    : "idle";
+                this.sink.onRecoveredTurnStatus?.(recoveredStatus, carriedTurnId, mapped.fatalError);
+                return;
+            }
+            if (carriedTurnId && this.currentTurnIdValue === null) {
                 this.currentTurnIdValue = carriedTurnId;
+            }
             this.ensureTurn();
+            this.pendingCompletionTurnId = carriedTurnId ?? this.currentTurnIdValue;
+            // The provider lifecycle closes immediately. A configured grace keeps
+            // only the canonical response open long enough to absorb late items.
+            this.currentTurnIdValue = null;
+            for (const event of mapped.events.filter((event) => event.type !== "runtime_debug")) {
+                this.sink.onEvent(event);
+            }
+            this.scheduleCompletion(mapped.fatalError
+                ? { kind: "error", error: mapped.fatalError }
+                : { kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
             return;
         }
-        if (carriedTurnId)
-            this.currentTurnIdValue = carriedTurnId;
+        // A late event from an older turn must not replace the app-server's active
+        // turn id. That was the source of stale completions closing a newer turn.
+        if (carriedTurnId &&
+            this.currentTurnIdValue &&
+            carriedTurnId !== this.currentTurnIdValue &&
+            isTurnScopedMethod(method)) {
+            return;
+        }
+        if (carriedTurnId && this.currentTurnIdValue === null) {
+            if (canRecoverMissedTurnFrom(method)) {
+                if (!this.notificationMatchesCurrentThread(notificationThreadId))
+                    return;
+                this.currentTurnIdValue = carriedTurnId;
+                this.ensureTurn();
+            }
+        }
         // Completed items (user echo, assistant, tool, reasoning) go through the
         // deduped path so a resume backfill and the live stream never double them.
         if (method === "item/completed") {
@@ -330,6 +397,8 @@ export class CodexSessionForwarder {
     settle(completion) {
         this.flushDeferredAssistantMessage();
         this.turnOpen = false;
+        this.currentTurnIdValue = null;
+        this.pendingCompletionTurnId = null;
         if (completion.kind === "error")
             this.sink.onTurnError(completion.error);
         else
@@ -373,7 +442,7 @@ export class CodexSessionForwarder {
         this.mcpStartupTimer = null;
     }
     emitMcpStartupStatus() {
-        if (!this.turnOpen)
+        if (!this.isTurnOpen())
             return;
         const pending = [...this.pendingMcpServers].sort();
         if (pending.length) {
@@ -464,14 +533,15 @@ export class CodexSessionForwarder {
      *  {@link advanceAnonCounter}). Mirrors reference implementation `_completed_item_key`. */
     completedItemKey(item) {
         const threadId = this.currentThreadIdValue ?? "thread";
-        const turnId = this.currentTurnIdValue ?? "turn";
+        const turnId = this.currentTurnIdValue ?? this.pendingCompletionTurnId ?? "turn";
         if (item.id)
             return { key: `${threadId}:${turnId}:${item.id}`, isAnon: false };
         const n = this.anonCounters.get(`${threadId}:${turnId}`) ?? 0;
         return { key: `${threadId}:${turnId}:anon:${n}`, isAnon: true };
     }
     advanceAnonCounter() {
-        const k = `${this.currentThreadIdValue ?? "thread"}:${this.currentTurnIdValue ?? "turn"}`;
+        const turnId = this.currentTurnIdValue ?? this.pendingCompletionTurnId ?? "turn";
+        const k = `${this.currentThreadIdValue ?? "thread"}:${turnId}`;
         this.anonCounters.set(k, (this.anonCounters.get(k) ?? 0) + 1);
     }
     ensureTurn() {
@@ -480,4 +550,45 @@ export class CodexSessionForwarder {
             this.sink.onTurnStart(this.currentTurnIdValue ?? undefined);
         }
     }
+    /** Start (or confirm) the app-server's authoritative active turn. A newer
+     * start supersedes an older response whose terminal edge arrived late; a
+     * pending Traex completion is flushed first so its final item grace remains
+     * intact. */
+    beginTurn(turnId) {
+        if (this.pendingCompletion)
+            this.flushPendingCompletion();
+        const nextTurnId = turnId ?? null;
+        const changesIdentifiedTurn = this.turnOpen &&
+            this.currentTurnIdValue !== null &&
+            nextTurnId !== null &&
+            this.currentTurnIdValue !== nextTurnId;
+        if (changesIdentifiedTurn) {
+            this.flushPendingCompletion();
+            this.flushDeferredAssistantMessage();
+            if (this.turnOpen) {
+                this.turnOpen = false;
+                this.sink.onTurnEnd(undefined, "superseded");
+            }
+        }
+        this.currentTurnIdValue = nextTurnId;
+        this.ensureTurn();
+    }
+    /** Active-turn clearing contract:
+     *
+     * - an identified active turn is closed only by the same id;
+     * - an id-less boundary cannot close an identified active turn;
+     * - with no observed active turn, an identified boundary may recover a
+     *   missed start only when it carries the currently-bound thread id. */
+    terminalBoundaryMatchesActiveTurn(terminalTurnId, notificationThreadId) {
+        if (this.currentTurnIdValue !== null) {
+            return terminalTurnId === this.currentTurnIdValue;
+        }
+        if (terminalTurnId === undefined)
+            return true;
+        return this.notificationMatchesCurrentThread(notificationThreadId);
+    }
+    notificationMatchesCurrentThread(notificationThreadId) {
+        return this.currentThreadIdValue !== null &&
+            notificationThreadId === this.currentThreadIdValue;
+    }
 }

package/dist/codex-app-server/mapping.d.ts

@@ -13,6 +13,8 @@ export interface CodexMapResult {
     turnCompleted?: boolean;
     fatalError?: Error;
 }
+export declare function codexTurnStatus(turn: unknown): string | undefined;
+export declare function codexResumeTerminalStatus(turn: unknown): "idle" | "failed" | undefined;
 /** Map one thread item (`item/started` | `item/completed`) to events. */
 export declare function mapCodexItem(method: string, item: ThreadItem): CodexMapResult;
 /** Map one codex app-server notification to events (+ turn/usage/error signals). */

package/dist/codex-app-server/mapping.js

@@ -1,12 +1,98 @@
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+const CODEX_AUTH_ERROR_FRAGMENTS = [
+    "401",
+    "403",
+    "unauthorized",
+    "authentication",
+    "not logged in",
+    "not authenticated",
+    "log in",
+    "login",
+    "sign in",
+    "re-authenticate",
+    "reauthenticate",
+    "credentials",
+    "access token",
+    "token expired",
+    "expired token",
+    "session expired",
+    "api key",
+];
+const CODEX_REAUTH_HINT = "Codex needs you to re-authenticate. Run `codex login` and retry.";
+function codexErrorMessage(error) {
+    for (const key of ["message", "error", "text", "detail"]) {
+        const value = error[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return "Codex turn ended with an unspecified error.";
+}
+function codexErrorIsAuth(error, message) {
+    const info = error.codexErrorInfo;
+    let variant;
+    let httpStatusCode;
+    if (typeof info === "string") {
+        variant = info;
+    }
+    else if (isRecord(info)) {
+        variant = info.type ?? info.kind ?? info.variant;
+        httpStatusCode = info.httpStatusCode;
+    }
+    if (typeof variant === "string" && variant.toLowerCase() === "unauthorized")
+        return true;
+    if (httpStatusCode === 401 || httpStatusCode === 403)
+        return true;
+    const lowered = message.toLowerCase();
+    return CODEX_AUTH_ERROR_FRAGMENTS.some((fragment) => lowered.includes(fragment));
+}
 function turnError(error, fallback) {
-    if (typeof error === "string" && error.trim())
-        return new Error(error);
-    if (error && typeof error === "object" && "message" in error) {
-        const message = error.message;
-        if (typeof message === "string" && message.trim())
-            return new Error(message);
+    if (!error)
+        return new Error(fallback);
+    const message = codexErrorMessage(error);
+    return new Error(codexErrorIsAuth(error, message)
+        ? `${message}\n\n${CODEX_REAUTH_HINT}`
+        : message);
+}
+export function codexTurnStatus(turn) {
+    if (!isRecord(turn))
+        return undefined;
+    const status = turn.status;
+    if (typeof status === "string")
+        return status;
+    if (!isRecord(status))
+        return undefined;
+    const value = status.type ?? status.status;
+    return typeof value === "string" ? value : undefined;
+}
+export function codexResumeTerminalStatus(turn) {
+    if (terminalTurnError(turn, "turn/completed"))
+        return "failed";
+    const status = codexTurnStatus(turn);
+    if (status === "completed" || status === "interrupted" ||
+        status === "cancelled" || status === "canceled") {
+        return "idle";
     }
-    return new Error(fallback);
+    if (status === "failed" || status === "errored")
+        return "failed";
+    return undefined;
+}
+function terminalTurnError(turn, method) {
+    if (!isRecord(turn)) {
+        return method === "turn/failed" ? new Error("Codex turn failed") : undefined;
+    }
+    let error = turn.error;
+    if (!isRecord(error) && Array.isArray(turn.items)) {
+        error = turn.items.find((item) => isRecord(item) && item.type === "error");
+    }
+    if (isRecord(error))
+        return turnError(error, "Codex turn failed");
+    const status = codexTurnStatus(turn);
+    if (method === "turn/failed" || status === "failed" || status === "errored") {
+        return turnError(undefined, "Codex turn failed");
+    }
+    return undefined;
 }
 function webSearchInput(item) {
     const action = item.action;
@@ -151,23 +237,11 @@ export function mapCodexNotification(method, params) {
             return { events };
         case "turn/started":
             return { events };
-        case "turn/completed": {
+        case "turn/completed":
+        case "turn/failed": {
             const turnPayload = typed.params?.turn;
-            if (turnPayload?.status === "failed") {
-                return {
-                    events,
-                    fatalError: turnError(turnPayload.error, "Codex turn failed"),
-                    turnCompleted: true,
-                };
-            }
-            if (turnPayload?.status === "interrupted") {
-                return {
-                    events,
-                    fatalError: turnError(turnPayload.error, "Codex turn was interrupted"),
-                    turnCompleted: true,
-                };
-            }
-            return { events, turnCompleted: true };
+            const fatalError = terminalTurnError(turnPayload, typed.method);
+            return { events, ...(fatalError ? { fatalError } : {}), turnCompleted: true };
         }
         case "turn/plan/updated": {
             const planParams = typed.params;

package/dist/codex-app-server/protocol.d.ts

@@ -105,8 +105,7 @@ export interface ThreadStartParams {
 }
 export interface ThreadResumeParams extends ThreadStartParams {
     threadId: string;
-    /** Legacy whole-backlog suppression. New callers should prefer
-     * `initialTurnsPage` so recovery can fetch one summarized terminal status. */
+    /** Suppress rollout history when the caller only needs to load/subscribe. */
     excludeTurns?: boolean;
     initialTurnsPage?: {
         limit?: number | null;
@@ -172,7 +171,7 @@ export interface TurnSteerParams {
     expectedTurnId: string;
     input: UserInput[];
 }
-export type TurnStatus = "completed" | "interrupted" | "failed" | "inProgress";
+export type TurnStatus = "completed" | "interrupted" | "cancelled" | "canceled" | "failed" | "errored" | "inProgress";
 export interface TurnPlanStep {
     step: string;
     status: "pending" | "inProgress" | "completed";

package/dist/host.d.ts

@@ -1,4 +1,4 @@
-import { type ResolvedExecutionSnapshot, type ResolvedExecutionBudget, type RuntimeUserInput, type SessionWorkspaceSnapshot, type SessionInteractionResolution, type SessionEvent } from "@rynx-ai/core";
+import { type ResolvedExecutionSnapshot, type ResolvedExecutionBudget, type RuntimeUserInput, type LiveSessionFailure, type SessionWorkspaceSnapshot, type SessionInteractionResolution, type SessionEvent } from "@rynx-ai/core";
 import { type AgentRuntimeId } from "@rynx-ai/core";
 import { type AppConfig } from "@rynx-ai/core";
 import { createCodexChildEnv } from "./codex-child-env.js";
@@ -125,7 +125,9 @@ export declare class LocalAgentHost implements CodexCapabilities {
     private readonly clock;
     private readonly backendIdleTtlMs;
     private readonly forwarderClientFactory;
-    private readonly observerReconnectTimeoutMs;
+    private readonly preloadClientFactory;
+    /** Builds one short-lived message/interrupt client. */
+    private readonly injectionClientFactory;
     private readonly backends;
     private readonly sessionId;
     private readonly runtimeHomeSessionId;
@@ -146,7 +148,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
     /** Short-lived dedupe for managed fork notifications delivered after the
      * `thread/fork` response. Values are expected source Provider thread ids. */
     private readonly managedForkThreadStarts;
-    constructor({ config, commandRunner, sessionStore, allowedRoots, appServerClient, now, backendIdleTtlMs, forwarderClientFactory, observerReconnectTimeoutMs, sessionId, runtimeHomeSessionId, }: {
+    constructor({ config, commandRunner, sessionStore, allowedRoots, appServerClient, now, backendIdleTtlMs, forwarderClientFactory, preloadClientFactory, injectionClientFactory, sessionId, runtimeHomeSessionId, }: {
         config: AppConfig;
         commandRunner?: CodexCommandRunner;
         sessionStore?: CodexSessionStore;
@@ -158,8 +160,10 @@ export declare class LocalAgentHost implements CodexCapabilities {
         backendIdleTtlMs?: number;
         /** Override the live-session forwarder connection factory (tests inject a fake). */
         forwarderClientFactory?: (appServerUrl: string) => CodexAppServerClient;
-        /** Grace window for observer reconnect before an active response is failed. */
-        observerReconnectTimeoutMs?: number;
+        /** Override the short-lived known-thread preload connection factory. */
+        preloadClientFactory?: (appServerUrl: string) => CodexAppServerClient;
+        /** Override the short-lived message/interrupt connection factory. */
+        injectionClientFactory?: (appServerUrl: string) => CodexAppServerClient;
         /** The rynx session (localThreadId) this host serves — a per-session runner
          *  child sets it from `RYNX_RUNNER_SESSION` so the private CODEX_HOME is
          *  session-scoped. The shared `__cap__` child / tests fall back to a sentinel
@@ -219,32 +223,39 @@ export declare class LocalAgentHost implements CodexCapabilities {
     /** Bind a session's codex thread id once known (TUI broadcast or store): persist
      *  it, unblock injection, and kick off the resume-subscribe loop (once). */
     private onLiveThreadStarted;
+    /** Start the known-thread observer after the replacement TUI has launched.
+     * Fresh sessions already connected their discovery listener before launch;
+     * this is therefore an idempotent no-op for them and for a healthy observer. */
+    startLiveCodexObserver(localThreadId: string): void;
+    /** Omnigent treats the forwarder as a required component of one native
+     * lifecycle: if its transport dies, it closes the app-server instead of
+     * accepting turns that can no longer reach the canonical mirror. */
+    private failObserverLifecycle;
     private shouldIgnoreManagedForkThreadStarted;
     private rememberManagedForkThreadStart;
     /**
      * Subscribe the forwarder connection to a thread (reference implementation's
      * `_subscribe_until_ready`). A fresh TUI thread has no rollout until its first
      * turn, so `thread/resume` is retried: park until the forwarder observes the
-     * thread active, then retry. Resume only fetches the newest summarized Turn:
-     * recovery reconciles the exact active Turn's terminal status and never replays
-     * historical items. Once resume succeeds, subsequent turns arrive live.
+     * thread active, then retry. Like Omnigent, the first attempt always uses
+     * `excludeTurns`: a known-session cold resume therefore never reconstructs
+     * historical running/completed state. Only a fresh thread whose first attempt
+     * failed as not-ready retries without `excludeTurns`, backfilling the newly
+     * materialized first turn and de-duplicating it against live notifications.
      */
     private subscribeUntilReady;
-    /** Restore the independent observer after an unexpected exit. The active turn
-     * remains open during the bounded grace so resume can reconcile its exact id. */
-    private reconnectForwarder;
-    private armObserverReconnectDeadline;
-    private clearObserverReconnectDeadline;
     /** Await a live session's thread binding. `null` leaves the deadline to the
      *  caller; a number keeps the Provider-local bound. Returns false on timeout /
      *  no live session. Injection and the runner's `live.ready` gate on this. */
     waitLiveReady(localThreadId: string, timeoutMs?: number | null): Promise<boolean>;
-    /** Await the stronger Terminal gate: another app-server connection has
-     * successfully resumed the thread, so the detached TUI cannot race rollout
-     * discovery or indexing. */
+    /** Await the observer subscription diagnostic. Codex/Traex Terminal startup
+     * deliberately does not gate on this promise: the dedicated preload owns resume,
+     * while the independent observer attaches in the background. */
     waitTerminalReady(localThreadId: string, timeoutMs?: number | null): Promise<boolean>;
     /** Diagnostic from the provider adapter when native discovery/resume failed. */
     liveSessionError(localThreadId: string): string | undefined;
+    /** Structured phase + concrete cause used by the runner wire protocol. */
+    liveSessionFailure(localThreadId: string): LiveSessionFailure | undefined;
     /** Publish the background TUI/thread discovery failure so an executor
      * already waiting in the 60s bridge window exits immediately with the exact
      * 30s discovery cause. */
@@ -338,7 +349,3 @@ export declare function isUnsupportedMethodError(error: unknown): boolean;
  *  — a fresh TUI thread before its first turn. Retryable (park until active).
  *  Mirrors reference implementation's `_is_thread_not_ready_error`. */
 export declare function isThreadNotReadyError(error: unknown): boolean;
-/** A persisted thread id that a freshly started app-server cannot load yet.
- * During startup, both errors can be transient while the rollout index catches
- * up. Retry the same id; never use either error as permission to replace it. */
-export declare function isRetryableThreadResumeError(error: unknown): boolean;