@rynx-ai/runtime 0.1.11-beta.28 → 0.1.11-beta.29

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

@@ -1,5 +1,5 @@
 import type { RuntimeUserInput, SessionInteractionResolution } from "@rynx-ai/core";
-import type { AskForApproval, ClientInfo, CollaborationModeListResponse, GetAuthStatusParams, GetAuthStatusResponse, InitializeResponse, ModelListParams, ModelListResponse, ReviewStartParams, ReviewStartResponse, SandboxMode, ThreadForkParams, ThreadGoalClearParams, ThreadGoalGetParams, ThreadGoalGetResponse, ThreadGoalSetParams, ThreadListParams, ThreadListResponse, ResumedThread, ThreadResumeParams, ThreadSettingsUpdateParams, ThreadStartParams, TurnInterruptParams, TurnStartParams, TurnSteerParams, UserInput } from "./protocol.js";
+import type { AskForApproval, ClientInfo, CollaborationModeListResponse, ConfigReadParams, ConfigReadResponse, GetAuthStatusParams, GetAuthStatusResponse, InitializeResponse, ModelListParams, ModelListResponse, ReviewStartParams, ReviewStartResponse, SandboxMode, ThreadForkParams, ThreadGoalClearParams, ThreadGoalGetParams, ThreadGoalGetResponse, ThreadGoalSetParams, ThreadListParams, ThreadListResponse, ResumedThread, ThreadResumeParams, ThreadRuntimeSettings, ThreadSettingsUpdateParams, ThreadStartParams, TurnInterruptParams, TurnStartParams, TurnSteerParams, UserInput } from "./protocol.js";
 import { CodexAppServerTransport, type CodexAppServerProcessSpawner, type RpcChannel, type TransportLogger } from "./transport.js";
 import type { ResolveInteractionResult, RuntimeInteractionListener } from "../interactions.js";
 export type ApprovalDecisionPolicy = "auto-approve-session" | "auto-decline" | "auto-cancel";
@@ -44,13 +44,16 @@ export declare class CodexAppServerClient {
     terminalRemoteUrl(): string | undefined;
     ensureInitialized(): Promise<InitializeResponse>;
     getAuthStatus(params?: GetAuthStatusParams): Promise<GetAuthStatusResponse>;
+    /** Read the runtime's merged effective config. This is the stable seam for
+     * discovering a fresh thread's model across Traex YAML/TOML generations. */
+    configRead(params: ConfigReadParams): Promise<ConfigReadResponse>;
     threadStart(params: ThreadStartParams): Promise<{
         threadId: string;
-    }>;
+    } & ThreadRuntimeSettings>;
     threadResume(params: ThreadResumeParams): Promise<{
         threadId: string;
         thread: ResumedThread;
-    }>;
+    } & ThreadRuntimeSettings>;
     turnStart(params: TurnStartParams): Promise<{
         turnId: string;
     }>;

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

@@ -1020,17 +1020,36 @@ export class CodexAppServerClient {
         await this.ensureInitialized();
         return this.transport.sendRequest("getAuthStatus", params);
     }
+    /** Read the runtime's merged effective config. This is the stable seam for
+     * discovering a fresh thread's model across Traex YAML/TOML generations. */
+    async configRead(params) {
+        await this.ensureInitialized();
+        return this.transport.sendRequest("config/read", params);
+    }
     async threadStart(params) {
         await this.ensureInitialized();
         const response = await this.transport.sendRequest("thread/start", params);
-        return { threadId: response.thread.id };
+        return {
+            threadId: response.thread.id,
+            ...(response.model ? { model: response.model } : {}),
+            ...(response.reasoningEffort === undefined
+                ? {}
+                : { reasoningEffort: response.reasoningEffort }),
+        };
     }
     async threadResume(params) {
         await this.ensureInitialized();
         const response = await this.transport.sendRequest("thread/resume", params);
         // Expose the whole `thread` (not just its id): its `turns[].items[]` are the
         // backfill the forwarder replays for a fresh thread's first turn.
-        return { threadId: response.thread.id, thread: response.thread };
+        return {
+            threadId: response.thread.id,
+            thread: response.thread,
+            ...(response.model ? { model: response.model } : {}),
+            ...(response.reasoningEffort === undefined
+                ? {}
+                : { reasoningEffort: response.reasoningEffort }),
+        };
     }
     async turnStart(params) {
         await this.ensureInitialized();

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

@@ -24,7 +24,7 @@
 import type { AgentEvent, UserContentPart } from "@rynx-ai/core";
 import type { CodexAppServerClient } from "./client.js";
 import type { McpStartupPlan } from "./mcp-startup.js";
-import type { CollaborationModeKind, ResumedTurn } from "./protocol.js";
+import type { CollaborationModeKind, ReasoningEffort, ResumedTurn } from "./protocol.js";
 export interface CodexForwarderSink {
     /** A turn began. `turnId` is codex's turn id, used to derive a stable
      *  `responseId`. Start a fresh normalizer/response. */
@@ -65,6 +65,12 @@ export interface CodexForwarderSink {
     onThreadActive?(): void;
     /** The native TUI or another app-server client changed collaboration mode. */
     onCollaborationModeChanged?(mode: CollaborationModeKind): void;
+    /** Full mutable settings reported by the native thread. In particular, a
+     * TUI `/model` switch must become the model used by the next mode snapshot. */
+    onThreadSettingsChanged?(settings: {
+        model?: string;
+        reasoningEffort?: ReasoningEffort | null;
+    }): void;
     /** Codex's terminal-local Plan picker is not emitted by app-server today.
      * Synthesize it only after a live Plan item and its Turn both complete. */
     onPlanImplementationPrompt?(prompt: CodexPlanImplementationPrompt): void;

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

@@ -279,6 +279,18 @@ export class CodexSessionForwarder {
         }
         if (method === "thread/settings/updated") {
             const threadSettings = params?.threadSettings;
+            const model = typeof threadSettings?.model === "string" && threadSettings.model.trim()
+                ? threadSettings.model.trim()
+                : undefined;
+            const effort = threadSettings?.effort;
+            if (model !== undefined || effort === null || typeof effort === "string") {
+                this.sink.onThreadSettingsChanged?.({
+                    ...(model === undefined ? {} : { model }),
+                    ...(effort === null || typeof effort === "string"
+                        ? { reasoningEffort: effort }
+                        : {}),
+                });
+            }
             const mode = (threadSettings?.collaborationMode ?? threadSettings?.collaboration_mode)?.mode;
             if (mode === "plan" || mode === "default") {
                 this.sink.onCollaborationModeChanged?.(mode);

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 = {
@@ -139,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;

package/dist/host.js

@@ -531,10 +531,13 @@ export class LocalAgentHost {
         try {
             if (!suppliedClient)
                 await client.ensureInitialized();
+            const collaborationMode = buildCollaborationMode(mode, live.model, live.reasoningEffort);
             await client.threadSettingsUpdate({
                 threadId,
-                collaborationMode: await buildCollaborationMode(client, mode, live.model, live.reasoningEffort),
+                collaborationMode,
             });
+            live.appliedModel = collaborationMode.settings.model;
+            live.appliedReasoningEffort = collaborationMode.settings.reasoning_effort ?? undefined;
             live.appliedCollaborationMode = mode;
             live.execution = { ...live.execution, collaborationMode: mode };
         }
@@ -746,6 +749,34 @@ export class LocalAgentHost {
             console.error(`[codex-live] session=${localThreadId} runtime=${runtime} app-server init failed: ${err instanceof Error ? err.message : String(err)}`);
             return abandon();
         }
+        // A fresh remote TUI creates the thread, so Rynx does not receive its
+        // `thread/start` response. Ask the already-initialized app-server for the
+        // effective model instead of parsing Traex's version-dependent YAML/TOML
+        // files or confusing `model/list.isDefault` with this Session's model.
+        let configModel;
+        let configReasoningEffort;
+        if (!execution.model || !execution.reasoningEffort) {
+            try {
+                const effective = await appServerOwner.configRead({
+                    includeLayers: false,
+                    cwd: workspace.cwd,
+                });
+                const reportedModel = effective.config.model;
+                if (typeof reportedModel === "string" && reportedModel.trim()) {
+                    configModel = reportedModel.trim();
+                }
+                const reportedEffort = effective.config.model_reasoning_effort;
+                if (typeof reportedEffort === "string" && reportedEffort) {
+                    configReasoningEffort = reportedEffort;
+                }
+            }
+            catch (error) {
+                // Explicit Session settings remain usable on an older Provider. If a
+                // requested collaboration mode later needs an unknown model, that
+                // update fails clearly without mutating the native thread.
+                console.warn(`[codex-live] session=${localThreadId} runtime=${runtime} effective config unavailable: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
         const appServerUrl = appServerOwner.terminalRemoteUrl();
         if (!appServerUrl) {
             this.liveStartupErrors.set(localThreadId, nativeLiveFailure(runtime, "native_app_server_endpoint_missing", "app-server started without a Terminal remote endpoint"));
@@ -772,8 +803,8 @@ export class LocalAgentHost {
                 return abandon();
             }
         }
-        const model = execution.model ?? "";
-        const reasoningEffort = execution.reasoningEffort ?? undefined;
+        const model = execution.model?.trim() || configModel || "";
+        const reasoningEffort = execution.reasoningEffort ?? configReasoningEffort;
         let markReady;
         const ready = new Promise((resolve) => {
             markReady = resolve;
@@ -1024,7 +1055,7 @@ export class LocalAgentHost {
                         const client = this.injectionClientFactory(live.appServerUrl);
                         try {
                             await client.ensureInitialized();
-                            const collaborationMode = await buildCollaborationMode(client, "default", live.model, live.reasoningEffort);
+                            const collaborationMode = buildCollaborationMode("default", live.model, live.reasoningEffort);
                             let threadId = prompt.threadId;
                             let text = CODEX_PLAN_IMPLEMENTATION_CODING_MESSAGE;
                             if (choice === CODEX_PLAN_IMPLEMENTATION_CLEAR_CONTEXT) {
@@ -1292,6 +1323,16 @@ export class LocalAgentHost {
                     mode,
                 });
             },
+            onThreadSettingsChanged: ({ model: reportedModel, reasoningEffort: reportedEffort }) => {
+                if (reportedModel) {
+                    live.model = reportedModel;
+                    live.appliedModel = reportedModel;
+                }
+                if (reportedEffort !== undefined) {
+                    live.reasoningEffort = reportedEffort ?? undefined;
+                    live.appliedReasoningEffort = reportedEffort ?? undefined;
+                }
+            },
             onPlanImplementationPrompt: publishPlanImplementationPrompt,
         };
         const forwarder = new CodexSessionForwarder(forwarderClient, sink, {
@@ -1400,6 +1441,7 @@ export class LocalAgentHost {
                             approvalPolicy,
                             excludeTurns: true,
                         });
+                        adoptResumedThreadSettings(live, resumed);
                         if (execution.collaborationMode) {
                             await this.applyLiveCollaborationMode(live, resumed.threadId, execution.collaborationMode, preloadClient);
                         }
@@ -1597,6 +1639,7 @@ export class LocalAgentHost {
                     approvalPolicy: live.approvalPolicy,
                     ...(!sawNotReady ? { excludeTurns: true } : {}),
                 });
+                adoptResumedThreadSettings(live, resp);
                 if (sawNotReady) {
                     const turns = Array.isArray(resp.thread.turns)
                         ? resp.thread.turns
@@ -1848,7 +1891,7 @@ export class LocalAgentHost {
                 const desiredCollaborationMode = options?.collaborationMode ?? live.execution.collaborationMode;
                 const collaborationMode = desiredCollaborationMode &&
                     desiredCollaborationMode !== live.appliedCollaborationMode
-                    ? await buildCollaborationMode(injectionClient, desiredCollaborationMode, desiredModel, desiredReasoningEffort)
+                    ? buildCollaborationMode(desiredCollaborationMode, desiredModel, desiredReasoningEffort)
                     : undefined;
                 const settings = {
                     threadId,
@@ -2895,28 +2938,30 @@ function raceReady(ready, timeoutMs, failed) {
             clearTimeout(timer);
     });
 }
+/** Record the authoritative settings returned while binding an existing
+ * native thread. A Session-level explicit selection remains a pending desired
+ * override; otherwise the resumed thread itself is the source of truth. */
+function adoptResumedThreadSettings(live, settings) {
+    const model = settings.model?.trim();
+    if (model) {
+        live.appliedModel = model;
+        if (!live.execution.model)
+            live.model = model;
+    }
+    if (settings.reasoningEffort !== undefined) {
+        live.appliedReasoningEffort = settings.reasoningEffort ?? undefined;
+        if (!live.execution.reasoningEffort) {
+            live.reasoningEffort = settings.reasoningEffort ?? undefined;
+        }
+    }
+}
 /** Expand the public mode enum into the App Server's required settings
- * snapshot. This mirrors Omnigent: an explicit Session model wins; otherwise
- * the Provider's advertised native default is required, and an unknown model
- * fails the update instead of silently dropping collaboration mode. */
-async function buildCollaborationMode(client, mode, desiredModel, desiredReasoningEffort) {
-    let model = desiredModel.trim();
+ * snapshot using the Session's tracked effective model. `model/list` is a
+ * catalog and its `isDefault` marker is not the current thread setting. */
+function buildCollaborationMode(mode, desiredModel, desiredReasoningEffort) {
+    const model = desiredModel.trim();
     if (!model) {
-        let catalog;
-        try {
-            catalog = await client.modelList();
-        }
-        catch (error) {
-            throw new CodexRuntimeError(`collaboration mode requires the current model: ${error instanceof Error ? error.message : String(error)}`, 503, "collaboration_mode_model_unknown");
-        }
-        const defaults = [...new Set(catalog.data
-                .filter((candidate) => candidate.isDefault === true)
-                .map((candidate) => (candidate.model || candidate.id).trim())
-                .filter(Boolean))];
-        if (defaults.length !== 1) {
-            throw new CodexRuntimeError(`collaboration mode requires exactly one current default model; Provider advertised ${defaults.length}`, 503, "collaboration_mode_model_unknown");
-        }
-        model = defaults[0];
+        throw new CodexRuntimeError("collaboration mode requires the current model, but the Provider did not report one", 503, "collaboration_mode_model_unknown");
     }
     return {
         mode,
@@ -2958,9 +3003,18 @@ function updateLiveCodexTurnSettings(live, opts) {
     if (!sameImmutableSessionSnapshots(live.workspace, live.execution, opts)) {
         return false;
     }
+    const previousModel = live.execution.model;
+    const previousReasoningEffort = live.execution.reasoningEffort;
     live.execution = structuredClone(opts.execution);
-    live.model = opts.execution.model ?? "";
-    live.reasoningEffort = opts.execution.reasoningEffort ?? undefined;
+    // Repeated calls normally carry the same immutable Session snapshot. Preserve
+    // a newer native `/model` or effort change unless Core explicitly changed the
+    // corresponding Session setting between calls.
+    if (opts.execution.model !== previousModel) {
+        live.model = opts.execution.model?.trim() ?? "";
+    }
+    if (opts.execution.reasoningEffort !== previousReasoningEffort) {
+        live.reasoningEffort = opts.execution.reasoningEffort ?? undefined;
+    }
     return true;
 }
 /** Freeze the Session's permission choice into the explicit managed settings.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/runtime",
-  "version": "0.1.11-beta.28",
+  "version": "0.1.11-beta.29",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -27,7 +27,7 @@
     "node-pty": "1.2.0-beta.15",
     "smol-toml": "1.7.1",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.28"
+    "@rynx-ai/core": "0.1.11-beta.29"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"