@rynx-ai/runtime 0.1.11-beta.3 → 0.1.11-beta.30

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

@@ -1,9 +1,3 @@
-/**
- * Pure codex app-server notification → {@link AgentEvent} mapping. Extracted from
- * the executor so BOTH the per-turn executor and the persistent session
- * forwarder (which mirrors every thread turn — web- AND TUI-initiated — into the
- * canonical log, reference implementation's codex-native model) share one mapping.
- */
 import type { AgentEvent } from "@rynx-ai/core";
 import type { ThreadItem } from "./protocol.js";
 export interface CodexMapResult {
@@ -11,8 +5,11 @@ export interface CodexMapResult {
     finalText?: string;
     usage?: Record<string, unknown>;
     turnCompleted?: boolean;
+    turnInterrupted?: 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,105 @@
+/**
+ * Pure codex app-server notification → {@link AgentEvent} mapping. Extracted from
+ * the executor so BOTH the per-turn executor and the persistent session
+ * forwarder (which mirrors every thread turn — web- AND TUI-initiated — into the
+ * canonical log, reference implementation's codex-native model) share one mapping.
+ */
+import { extname, isAbsolute } from "node:path";
+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";
+    }
+    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");
     }
-    return new Error(fallback);
+    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;
@@ -29,6 +122,23 @@ function webSearchInput(item) {
     }
     return { id: item.id, query: item.query };
 }
+function fileChangeSummary(changes) {
+    const lines = [];
+    for (const change of changes) {
+        if (!isRecord(change))
+            continue;
+        const kind = isRecord(change.kind) && typeof change.kind.type === "string" && change.kind.type
+            ? change.kind.type
+            : "change";
+        lines.push(`${kind} ${String(change.path)}`);
+    }
+    return lines.join("\n");
+}
+function isSupportedAbsoluteImagePath(path) {
+    if (!isAbsolute(path))
+        return false;
+    return [".png", ".jpg", ".jpeg", ".webp", ".gif", ".svg"].includes(extname(path).toLowerCase());
+}
 /** Map one thread item (`item/started` | `item/completed`) to events. */
 export function mapCodexItem(method, item) {
     const events = [];
@@ -58,16 +168,18 @@ export function mapCodexItem(method, item) {
             return { events };
         }
         case "fileChange": {
+            const fileChange = item;
+            const changes = Array.isArray(fileChange.changes) ? fileChange.changes : [];
             events.push({
                 type: "tool",
                 event: isStart ? "on_tool_start" : "on_tool_end",
-                name: "file_change",
-                input: isStart ? { id: item.id } : undefined,
+                name: "apply_patch",
+                input: isStart || isEnd ? { id: item.id, ...(changes.length ? { changes } : {}) } : undefined,
                 output: isEnd
                     ? {
                         id: item.id,
-                        changes: item.changes,
-                        status: item.status,
+                        status: fileChange.status,
+                        aggregatedOutput: fileChangeSummary(changes),
                     }
                     : undefined,
                 data: { method, item },
@@ -113,6 +225,30 @@ export function mapCodexItem(method, item) {
             });
             return { events };
         }
+        case "imageGeneration": {
+            const image = item;
+            events.push({
+                type: "tool",
+                event: isStart ? "on_tool_start" : "on_tool_end",
+                name: "image_generation",
+                input: isStart ? { id: image.id } : undefined,
+                output: isEnd
+                    ? {
+                        id: image.id,
+                        status: image.status,
+                        generatedImage: {
+                            ...(!image.savedPath || !isSupportedAbsoluteImagePath(image.savedPath)
+                                ? { result: image.result }
+                                : {}),
+                            revisedPrompt: image.revisedPrompt,
+                            ...(image.savedPath ? { savedPath: image.savedPath } : {}),
+                        },
+                    }
+                    : undefined,
+                data: { method, item: { ...image, result: image.result ? "[image data omitted]" : "" } },
+            });
+            return { events };
+        }
         case "agentMessage": {
             const text = item.text?.trim() ?? "";
             if (isEnd && text) {
@@ -122,7 +258,11 @@ export function mapCodexItem(method, item) {
             return { events };
         }
         case "plan": {
-            events.push({ type: "runtime_debug", channel: "codexEvent", data: { method, item } });
+            const text = item.text?.trim() ?? "";
+            if (isEnd && text) {
+                events.push({ type: "message_completed", itemId: item.id, text });
+                return { events, finalText: text };
+            }
             return { events };
         }
         case "reasoning": {
@@ -151,23 +291,18 @@ 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);
+            const turnInterrupted = typed.method === "turn/completed" &&
+                ["interrupted", "cancelled", "canceled"].includes(codexTurnStatus(turnPayload) ?? "");
+            return {
+                events,
+                ...(fatalError ? { fatalError } : {}),
+                turnCompleted: true,
+                ...(turnInterrupted ? { turnInterrupted: true } : {}),
+            };
         }
         case "turn/plan/updated": {
             const planParams = typed.params;
@@ -195,6 +330,17 @@ export function mapCodexNotification(method, params) {
             }
             return { events };
         }
+        case "item/plan/delta": {
+            const delta = typed.params.delta ?? "";
+            if (delta) {
+                events.push({
+                    type: "token",
+                    text: delta,
+                    metadata: { source: "app_server", itemId: typed.params.itemId },
+                });
+            }
+            return { events };
+        }
         case "item/reasoning/summaryTextDelta":
         case "item/reasoning/textDelta": {
             const p = typed.params;

package/dist/codex-app-server/mcp-startup.d.ts

@@ -0,0 +1,13 @@
+import type { CodexLineageRuntime } from "../codex-home.js";
+export interface McpStartupPlan {
+    servers: string[];
+    settleTimeoutMs: number;
+}
+/**
+ * Read the MCP table fields needed for startup tracking. Provider config stays
+ * authoritative: malformed TOML disables the synthesized status rather than
+ * preventing the native CLI from reporting its own startup error.
+ */
+export declare function parseMcpStartupToml(input: string): McpStartupPlan | null;
+/** Enabled Provider-configured MCP servers and their synthesized settle window. */
+export declare function readMcpStartupPlan(runtimeHome: string, runtime: CodexLineageRuntime): McpStartupPlan | null;

package/dist/codex-app-server/mcp-startup.js

@@ -0,0 +1,63 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse } from "smol-toml";
+const DEFAULT_SERVER_TIMEOUT_MS = 10_000;
+const SETTLE_GRACE_MS = 15_000;
+const MAX_SETTLE_TIMEOUT_MS = 240_000;
+function configNames(runtime) {
+    return runtime === "codex"
+        ? ["config.toml"]
+        : ["traecli.toml"];
+}
+function isTomlTable(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Read the MCP table fields needed for startup tracking. Provider config stays
+ * authoritative: malformed TOML disables the synthesized status rather than
+ * preventing the native CLI from reporting its own startup error.
+ */
+export function parseMcpStartupToml(input) {
+    let config;
+    try {
+        config = parse(input);
+    }
+    catch {
+        return null;
+    }
+    const servers = config.mcp_servers;
+    if (!isTomlTable(servers))
+        return null;
+    const enabled = Object.entries(servers)
+        .filter(([name, server]) => Boolean(name) && isTomlTable(server) && server.enabled !== false)
+        .sort(([left], [right]) => left.localeCompare(right));
+    if (enabled.length === 0)
+        return null;
+    const slowest = Math.max(DEFAULT_SERVER_TIMEOUT_MS, ...enabled.map(([, server]) => {
+        if (!isTomlTable(server))
+            return DEFAULT_SERVER_TIMEOUT_MS;
+        const seconds = server.startup_timeout_sec;
+        return typeof seconds === "number" && Number.isFinite(seconds) && seconds > 0
+            ? seconds * 1_000
+            : DEFAULT_SERVER_TIMEOUT_MS;
+    }));
+    return {
+        servers: enabled.map(([name]) => name),
+        settleTimeoutMs: Math.min(slowest + SETTLE_GRACE_MS, MAX_SETTLE_TIMEOUT_MS),
+    };
+}
+/** Enabled Provider-configured MCP servers and their synthesized settle window. */
+export function readMcpStartupPlan(runtimeHome, runtime) {
+    for (const name of configNames(runtime)) {
+        try {
+            const plan = parseMcpStartupToml(readFileSync(join(runtimeHome, name), "utf8"));
+            if (plan)
+                return plan;
+        }
+        catch {
+            // Missing/unreadable config: the Provider still owns startup; Rynx simply
+            // cannot synthesize per-server progress for this launch.
+        }
+    }
+    return null;
+}

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

@@ -56,6 +56,21 @@ export interface GetAuthStatusResponse {
     authToken: string | null;
     requiresOpenaiAuth: boolean;
 }
+/** Read the Provider's effective configuration through the app-server rather
+ * than parsing a runtime-specific config file (Traex has used both YAML and
+ * TOML across releases). `cwd` includes project-scoped configuration layers. */
+export interface ConfigReadParams {
+    includeLayers: boolean;
+    cwd?: string | null;
+}
+export interface ConfigReadResponse {
+    config: {
+        model: string | null;
+        model_reasoning_effort: ReasoningEffort | null;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
 export type AskForApproval = "untrusted" | "on-failure" | "on-request" | "never";
 export type SandboxMode = "read-only" | "workspace-write" | "danger-full-access";
 export type SandboxPolicy = {
@@ -87,6 +102,16 @@ export interface PermissionProfileModificationParams {
 export type PermissionSelection = string | PermissionProfileSelectionParams;
 /** Open since Codex App Server 0.144; values are advertised by `model/list`. */
 export type ReasoningEffort = string;
+export type CollaborationModeKind = "plan" | "default";
+/** Full Codex-lineage mode snapshot required by the App Server wire protocol. */
+export interface CollaborationMode {
+    mode: CollaborationModeKind;
+    settings: {
+        model: string;
+        reasoning_effort: ReasoningEffort | null;
+        developer_instructions: string | null;
+    };
+}
 export interface ThreadStartParams {
     model?: string | null;
     modelProvider?: string | null;
@@ -102,14 +127,18 @@ export interface ThreadStartParams {
     baseInstructions?: string | null;
     developerInstructions?: string | null;
     ephemeral?: boolean | null;
+    /** Native UI intent for a context-clearing fresh thread. */
+    sessionStartSource?: "clear" | string;
 }
 export interface ThreadResumeParams extends ThreadStartParams {
     threadId: string;
-    /** When true, the resume response omits the thread's `turns` backlog (used to
-     *  SUBSCRIBE without re-replaying history). When false/absent, the response
-     *  carries `thread.turns[].items[]` — the backfill the forwarder replays for a
-     *  fresh thread's first turn (reference implementation's `_replay_resume_response`). */
+    /** Suppress rollout history when the caller only needs to load/subscribe. */
     excludeTurns?: boolean;
+    initialTurnsPage?: {
+        limit?: number | null;
+        sortDirection?: "asc" | "desc" | null;
+        itemsView?: "notLoaded" | "summary" | "full" | null;
+    } | null;
 }
 /** One turn in a resumed thread's backlog (`thread/resume` response). */
 export interface ResumedTurn {
@@ -125,6 +154,13 @@ export interface ResumedThread {
     turns?: ResumedTurn[];
     [key: string]: unknown;
 }
+/** Settings selected by the Provider while starting or resuming a thread.
+ * Older app-server builds may omit them, so the bridge treats them as optional
+ * and falls back to `config/read` only for a fresh, not-yet-created thread. */
+export interface ThreadRuntimeSettings {
+    model?: string;
+    reasoningEffort?: ReasoningEffort | null;
+}
 export interface ThreadDescriptor {
     id: string;
     cwd: string;
@@ -155,6 +191,7 @@ export interface TurnStartParams {
     permissions?: PermissionSelection | null;
     model?: string | null;
     effort?: ReasoningEffort | null;
+    collaborationMode?: CollaborationMode | null;
 }
 export interface TurnInterruptParams {
     threadId: string;
@@ -169,7 +206,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";
@@ -252,7 +289,16 @@ export interface WebSearchItem extends ThreadItemBase {
         type: "other";
     } | null;
 }
-export type ThreadItem = UserMessageItem | AgentMessageItem | ReasoningItem | PlanItem | CommandExecutionItem | FileChangeItem | McpToolCallItem | DynamicToolCallItem | WebSearchItem | (ThreadItemBase & Record<string, unknown>);
+export interface ImageGenerationItem extends ThreadItemBase {
+    type: "imageGeneration";
+    status: string;
+    revisedPrompt: string | null;
+    /** Base64 image bytes supplied when no durable saved path is available. */
+    result: string;
+    /** Codex App Server guarantees this is absolute when present. */
+    savedPath?: string;
+}
+export type ThreadItem = UserMessageItem | AgentMessageItem | ReasoningItem | PlanItem | CommandExecutionItem | FileChangeItem | McpToolCallItem | DynamicToolCallItem | WebSearchItem | ImageGenerationItem | (ThreadItemBase & Record<string, unknown>);
 export interface ThreadSummary {
     id?: string;
     threadId?: string;
@@ -302,7 +348,7 @@ export interface ThreadSettingsUpdateParams {
     serviceTier?: string | null;
     effort?: ReasoningEffort | null;
     summary?: string | null;
-    collaborationMode?: Record<string, unknown> | null;
+    collaborationMode?: CollaborationMode | null;
     personality?: string | null;
 }
 export interface ModelListParams {
@@ -476,6 +522,14 @@ export interface QueueStatusNotificationParams {
 export type ServerNotification = {
     method: "thread/started";
     params: ThreadStartedNotificationParams;
+} | {
+    method: "thread/settings/updated";
+    params: {
+        threadId: string;
+        threadSettings: {
+            collaborationMode?: CollaborationMode | null;
+        } & Record<string, unknown>;
+    };
 } | {
     method: "turn/started";
     params: TurnStartedNotificationParams;
@@ -497,6 +551,9 @@ export type ServerNotification = {
 } | {
     method: "item/agentMessage/delta";
     params: AgentMessageDeltaNotificationParams;
+} | {
+    method: "item/plan/delta";
+    params: AgentMessageDeltaNotificationParams;
 } | {
     method: "item/reasoning/summaryTextDelta";
     params: ReasoningSummaryTextDeltaNotificationParams;

package/dist/codex-app-server/ws-channel.js

@@ -28,6 +28,7 @@ async function freeLoopbackPort() {
         });
     });
 }
+const DEFAULT_CONNECT_TIMEOUT_MS = 10_000;
 export class WsRpcChannel {
     opts;
     child = null;
@@ -40,7 +41,7 @@ export class WsRpcChannel {
     url = "";
     constructor(opts) {
         this.opts = opts;
-        this.readyTimeoutMs = opts.readyTimeoutMs ?? 15_000;
+        this.readyTimeoutMs = opts.readyTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
     }
     onLine(cb) {
         this.lineCb = cb;
@@ -114,7 +115,7 @@ export class WsRpcChannel {
         // eslint-disable-next-line no-constant-condition
         while (Date.now() < deadline) {
             try {
-                return await this.tryConnect(url);
+                return await this.tryConnect(url, Math.max(1, deadline - Date.now()));
             }
             catch (error) {
                 lastError = error;
@@ -123,9 +124,9 @@ export class WsRpcChannel {
         }
         throw new Error(`codex app-server ws did not become ready at ${url}: ${lastError?.message ?? "timeout"}`);
     }
-    tryConnect(url) {
+    tryConnect(url, handshakeTimeout) {
         return new Promise((resolve, reject) => {
-            const ws = new WebSocket(url);
+            const ws = new WebSocket(url, { handshakeTimeout });
             const onOpen = () => {
                 ws.off("error", onError);
                 resolve(ws);
@@ -166,7 +167,7 @@ export class ExternalWsChannel {
     /** The `ws://IP:PORT` of the already-running app-server to attach to. */
     url, opts = {}) {
         this.url = url;
-        this.readyTimeoutMs = opts.readyTimeoutMs ?? 15_000;
+        this.readyTimeoutMs = opts.readyTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
     }
     onLine(cb) {
         this.lineCb = cb;
@@ -178,20 +179,16 @@ export class ExternalWsChannel {
         return this.ws?.readyState === WebSocket.OPEN;
     }
     async start() {
-        const deadline = Date.now() + this.readyTimeoutMs;
-        let lastError;
-        while (Date.now() < deadline) {
-            try {
-                this.ws = await this.connect(this.url);
-                break;
-            }
-            catch (error) {
-                lastError = error;
-                await new Promise((r) => setTimeout(r, 150));
-            }
+        // A channel instance is reusable after an observer disconnect. Do not let
+        // the prior closed socket make a failed reconnect look successful, and arm
+        // close delivery for the newly connected socket.
+        this.ws = null;
+        this.closedEmitted = false;
+        try {
+            this.ws = await this.connect(this.url);
         }
-        if (!this.ws) {
-            throw new Error(`could not attach to app-server ws ${this.url}: ${lastError?.message ?? "timeout"}`);
+        catch (error) {
+            throw new Error(`could not attach to app-server ws ${this.url}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
         }
         this.ws.on("message", (data) => this.lineCb?.(data.toString()));
         this.ws.on("close", (code) => this.emitClose(code ?? null, null, null));
@@ -227,7 +224,10 @@ export class ExternalWsChannel {
     }
     connect(url) {
         return new Promise((resolve, reject) => {
-            const ws = new WebSocket(url);
+            // The app-server owner has already completed its readiness probe. Use one
+            // bounded attach, then reuse this exact connection as the forwarder
+            // instead of running a second startup retry stage.
+            const ws = new WebSocket(url, { handshakeTimeout: this.readyTimeoutMs });
             const onOpen = () => {
                 ws.off("error", onError);
                 resolve(ws);

package/dist/codex-home.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { copyFileSync, cpSync, existsSync, mkdirSync, renameSync, rmSync, symlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { getRuntimeProfile, resolveRuntimeHome, SAFE_SKILL_NAME, } from "@rynx-ai/core";
+import { assertSkillPathComponent, getRuntimeProfile, resolveRuntimeHome, } from "@rynx-ai/core";
 import { adoptLegacyRuntimeDirectory, legacyRuntimeStateRoot, runtimeSessionDigest, runtimeSessionStateDir, } from "./runtime-state-paths.js";
 /** Inherit the user's LIVE login by symlink (stays in sync). */
 const SYMLINK_FILES = ["auth.json"];
@@ -113,9 +113,7 @@ export function prepareRuntimeHome(sessionId, runtime, realHome = runtime === "c
 export function populateCodexSkills(codexHome, skills) {
     const skillsDir = join(codexHome, "skills");
     for (const skill of skills) {
-        if (!SAFE_SKILL_NAME.test(skill.name)) {
-            throw new Error(`unsafe skill name: ${skill.name}`);
-        }
+        assertSkillPathComponent(skill.name);
     }
     if (skills.length === 0)
         return;