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

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,10 +198,11 @@ 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
@@ -178,21 +212,56 @@ export class CodexSessionForwarder {
     /** 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")
+        if (!this.isTurnOpen() || !turn || codexResumeTerminalStatus(turn) === undefined)
             return false;
         const resumedTurnId = turn.id ?? turn.turnId;
         if (!this.currentTurnIdValue || resumedTurnId !== this.currentTurnIdValue)
             return false;
         const mapped = mapCodexNotification("turn/completed", { turn });
+        this.ensureTurn();
         this.settle(mapped.fatalError
             ? { kind: "error", error: mapped.fatalError }
             : { kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
         return true;
     }
+    /** Reconcile an observer reconnect from the explicit resume snapshot. An
+     * identified active turn must match exactly; with no active turn, only the
+     * newest explicit terminal status is published and no history is replayed. */
+    reconcileResumeTurns(turns) {
+        if (this.currentThreadIdValue === null)
+            return false;
+        for (let index = turns.length - 1; index >= 0; index -= 1) {
+            const turn = turns[index];
+            if (!turn)
+                continue;
+            const turnId = turn.id ?? turn.turnId;
+            if (!turnId)
+                return false;
+            if (this.currentTurnIdValue !== null && this.currentTurnIdValue !== turnId) {
+                return false;
+            }
+            const status = codexResumeTerminalStatus(turn);
+            if (!status)
+                return false;
+            const mapped = mapCodexNotification("turn/completed", { turn });
+            if (this.currentTurnIdValue !== null || this.turnOpen) {
+                this.ensureTurn();
+                this.settle(mapped.fatalError
+                    ? { kind: "error", error: mapped.fatalError }
+                    : { kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
+            }
+            else {
+                this.sink.onRecoveredTurnStatus?.(status, turnId, mapped.fatalError);
+            }
+            return true;
+        }
+        return false;
+    }
     /** 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 +309,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;
+        }
+        // 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 = carriedTurnId;
+        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 +445,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 +490,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 +581,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 +598,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

@@ -172,7 +172,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

@@ -226,8 +226,9 @@ export declare class LocalAgentHost implements CodexCapabilities {
      * `_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.
+     * recovery reconciles the exact active Turn or publishes the newest explicit
+     * terminal status without replaying historical items. Once resume succeeds,
+     * subsequent turns arrive live.
      */
     private subscribeUntilReady;
     /** Restore the independent observer after an unexpected exit. The active turn