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

package/dist/host.d.ts

@@ -196,6 +196,9 @@ export declare class LocalAgentHost implements CodexCapabilities {
      * remember only a successful RPC. A supplied client is already initialized
      * and remains owned by its caller (used by cold-resume preload). */
     private applyLiveCollaborationMode;
+    /** Apply pending explicit model/effort settings and, when requested, one
+     * collaboration mode in a single native update. */
+    private applyLiveThreadSettings;
     /**
      * The command to run in a session's live terminal so it co-drives the codex
      * app-server thread (Phase D). Returns `null` when live-terminal is off, the

package/dist/host.js

@@ -199,6 +199,7 @@ const CODEX_PLAN_IMPLEMENTATION_NO = "No, stay in Plan mode";
 const CODEX_PLAN_IMPLEMENTATION_CODING_MESSAGE = "Implement the plan.";
 const CODEX_PLAN_PROMPT_DISMISS_TIMEOUT_MS = 1_500;
 const CODEX_PLAN_PROMPT_DISMISS_POLL_MS = 50;
+const CODEX_SUBSCRIBE_FLUSH_RETRY_MS = 1_500;
 const CODEX_PLAN_IMPLEMENTATION_CLEAR_CONTEXT_PREFIX = "A previous agent produced the plan below to accomplish the user's task. " +
     "Implement the plan in a fresh context. Treat the plan as the source of " +
     "user intent, re-read files as needed, and carry the work through " +
@@ -525,21 +526,49 @@ export class LocalAgentHost {
      * remember only a successful RPC. A supplied client is already initialized
      * and remains owned by its caller (used by cold-resume preload). */
     async applyLiveCollaborationMode(live, threadId, mode, suppliedClient) {
-        if (live.appliedCollaborationMode === mode)
-            return;
+        await this.applyLiveThreadSettings(live, threadId, mode, suppliedClient);
+    }
+    /** Apply pending explicit model/effort settings and, when requested, one
+     * collaboration mode in a single native update. */
+    async applyLiveThreadSettings(live, threadId, mode, suppliedClient) {
         const client = suppliedClient ?? this.injectionClientFactory(live.appServerUrl);
         try {
             if (!suppliedClient)
                 await client.ensureInitialized();
-            const collaborationMode = buildCollaborationMode(mode, live.model, live.reasoningEffort);
-            await client.threadSettingsUpdate({
+            const desiredModel = live.model;
+            const desiredReasoningEffort = live.reasoningEffort;
+            const modelChanged = desiredModel !== live.appliedModel;
+            const effortChanged = desiredReasoningEffort !== live.appliedReasoningEffort;
+            const collaborationMode = mode && live.appliedCollaborationMode !== mode
+                ? await resolveLiveCollaborationMode(client, live, mode)
+                : undefined;
+            const settings = {
                 threadId,
-                collaborationMode,
-            });
-            live.appliedModel = collaborationMode.settings.model;
-            live.appliedReasoningEffort = collaborationMode.settings.reasoning_effort ?? undefined;
-            live.appliedCollaborationMode = mode;
-            live.execution = { ...live.execution, collaborationMode: mode };
+                ...(modelChanged ? { model: desiredModel || null } : {}),
+                ...(effortChanged
+                    ? { effort: desiredReasoningEffort ?? null }
+                    : {}),
+                ...(collaborationMode ? { collaborationMode } : {}),
+            };
+            if (Object.keys(settings).length === 1)
+                return;
+            await client.threadSettingsUpdate(settings);
+            if (collaborationMode) {
+                if (!live.model)
+                    live.model = collaborationMode.settings.model;
+                live.mayUseProviderDefaultModel = false;
+                live.appliedModel = collaborationMode.settings.model;
+                live.appliedReasoningEffort =
+                    collaborationMode.settings.reasoning_effort ?? undefined;
+                live.appliedCollaborationMode = mode;
+                live.execution = { ...live.execution, collaborationMode: mode };
+            }
+            else {
+                if (modelChanged)
+                    live.appliedModel = desiredModel;
+                if (effortChanged)
+                    live.appliedReasoningEffort = desiredReasoningEffort;
+            }
         }
         finally {
             if (!suppliedClient)
@@ -689,6 +718,7 @@ export class LocalAgentHost {
             this.stopLiveCodexSession(localThreadId);
         }
         const record = await this.sessionStore.get(localThreadId);
+        const coldResume = Boolean(record?.codexSessionId);
         const retargetMirror = opts.retargetMirror;
         const workspace = structuredClone(opts.workspace);
         const execution = structuredClone(opts.execution);
@@ -755,7 +785,7 @@ export class LocalAgentHost {
         // files or confusing `model/list.isDefault` with this Session's model.
         let configModel;
         let configReasoningEffort;
-        if (!execution.model || !execution.reasoningEffort) {
+        if (!coldResume && (!execution.model || !execution.reasoningEffort)) {
             try {
                 const effective = await appServerOwner.configRead({
                     includeLayers: false,
@@ -792,7 +822,6 @@ export class LocalAgentHost {
         // its observer starts in the background only after the replacement TUI has
         // launched and is never part of the resume admission boundary.
         const forwarderClient = this.forwarderClientFactory(appServerUrl);
-        const coldResume = Boolean(record?.codexSessionId);
         if (!coldResume) {
             try {
                 await forwarderClient.ensureInitialized();
@@ -803,8 +832,9 @@ export class LocalAgentHost {
                 return abandon();
             }
         }
-        const model = execution.model?.trim() || configModel || "";
-        const reasoningEffort = execution.reasoningEffort ?? configReasoningEffort;
+        const model = execution.model?.trim() || (!coldResume ? configModel : undefined) || "";
+        const reasoningEffort = execution.reasoningEffort ??
+            (!coldResume ? configReasoningEffort : undefined);
         let markReady;
         const ready = new Promise((resolve) => {
             markReady = resolve;
@@ -829,8 +859,9 @@ export class LocalAgentHost {
             approvalPolicy,
             model,
             reasoningEffort,
-            appliedModel: model,
-            appliedReasoningEffort: reasoningEffort,
+            mayUseProviderDefaultModel: !coldResume && !model,
+            appliedModel: coldResume ? "" : model,
+            appliedReasoningEffort: coldResume ? undefined : reasoningEffort,
             appliedCollaborationMode: undefined,
             ...(execution.instructions ? { instructions: execution.instructions } : {}),
             threadId: record?.codexSessionId ?? null,
@@ -851,6 +882,7 @@ export class LocalAgentHost {
             rotationPending: false,
             stopped: false,
             observerAvailable: !coldResume,
+            threadActive: false,
             skillsCleanup: snapshotSkills.skillsCleanup,
             canonicalInteractions: new Set(),
             settledInteractions: new Set(),
@@ -1055,7 +1087,7 @@ export class LocalAgentHost {
                         const client = this.injectionClientFactory(live.appServerUrl);
                         try {
                             await client.ensureInitialized();
-                            const collaborationMode = buildCollaborationMode("default", live.model, live.reasoningEffort);
+                            const collaborationMode = await resolveLiveCollaborationMode(client, live, "default");
                             let threadId = prompt.threadId;
                             let text = CODEX_PLAN_IMPLEMENTATION_CODING_MESSAGE;
                             if (choice === CODEX_PLAN_IMPLEMENTATION_CLEAR_CONTEXT) {
@@ -1087,6 +1119,12 @@ export class LocalAgentHost {
                                 approvalPolicy: live.approvalPolicy,
                                 collaborationMode,
                             });
+                            if (!live.model)
+                                live.model = collaborationMode.settings.model;
+                            live.mayUseProviderDefaultModel = false;
+                            live.appliedModel = collaborationMode.settings.model;
+                            live.appliedReasoningEffort =
+                                collaborationMode.settings.reasoning_effort ?? undefined;
                             live.execution = { ...live.execution, collaborationMode: "default" };
                             live.appliedCollaborationMode = "default";
                             emitCurrent({
@@ -1313,7 +1351,10 @@ export class LocalAgentHost {
             // A resumed TUI may rebroadcast `thread/started`; binding is idempotent.
             shouldIgnoreThreadStarted: (threadId, forkedFromId) => this.shouldIgnoreManagedForkThreadStarted(live, threadId, forkedFromId),
             onThreadStarted: (threadId, forkedFromId) => this.onLiveThreadStarted(live, localThreadId, threadId, forkedFromId),
-            onThreadActive: () => live.releaseActive?.(),
+            onThreadActive: () => {
+                live.threadActive = true;
+                live.releaseActive?.();
+            },
             onCollaborationModeChanged: (mode) => {
                 live.appliedCollaborationMode = mode;
                 live.execution = { ...live.execution, collaborationMode: mode };
@@ -1327,6 +1368,7 @@ export class LocalAgentHost {
                 if (reportedModel) {
                     live.model = reportedModel;
                     live.appliedModel = reportedModel;
+                    live.mayUseProviderDefaultModel = false;
                 }
                 if (reportedEffort !== undefined) {
                     live.reasoningEffort = reportedEffort ?? undefined;
@@ -1442,9 +1484,7 @@ export class LocalAgentHost {
                             excludeTurns: true,
                         });
                         adoptResumedThreadSettings(live, resumed);
-                        if (execution.collaborationMode) {
-                            await this.applyLiveCollaborationMode(live, resumed.threadId, execution.collaborationMode, preloadClient);
-                        }
+                        await this.applyLiveThreadSettings(live, resumed.threadId, execution.collaborationMode, preloadClient);
                     }
                     finally {
                         await preloadClient.stop().catch((error) => {
@@ -1466,6 +1506,7 @@ export class LocalAgentHost {
                     // not classified here because it does not prove the history is empty.
                     await this.sessionStore.delete(localThreadId);
                     live.threadId = null;
+                    live.mayUseProviderDefaultModel = !live.model;
                     try {
                         await forwarderClient.ensureInitialized();
                     }
@@ -1503,6 +1544,11 @@ export class LocalAgentHost {
      *  it, unblock injection, and kick off the resume-subscribe loop (once). */
     onLiveThreadStarted(live, localThreadId, threadId, forkedFromId) {
         const previousThreadId = live.threadId;
+        if (previousThreadId !== threadId) {
+            live.threadActive = false;
+            if (!live.model)
+                live.mayUseProviderDefaultModel = true;
+        }
         if (previousThreadId && previousThreadId !== threadId) {
             live.threadId = threadId;
             live.subscribing = true;
@@ -1654,13 +1700,20 @@ export class LocalAgentHost {
                     return false;
                 }
                 sawNotReady = true;
-                // Park until the thread goes active (its first turn materializes the
-                // rollout); a short poll covers the flush race after "active".
-                await new Promise((resolve) => {
-                    live.releaseActive = resolve;
-                    setTimeout(resolve, 1500);
-                });
-                live.releaseActive = undefined;
+                if (!live.threadActive) {
+                    // An idle fresh thread has no rollout until its first Turn. Wait only
+                    // for live activity instead of polling the app-server indefinitely.
+                    await new Promise((resolve) => {
+                        live.releaseActive = resolve;
+                    });
+                    live.releaseActive = undefined;
+                }
+                else {
+                    // Activity can precede rollout persistence by a short interval.
+                    await new Promise((resolve) => {
+                        setTimeout(resolve, CODEX_SUBSCRIBE_FLUSH_RETRY_MS);
+                    });
+                }
             }
         }
         return false;
@@ -1891,7 +1944,7 @@ export class LocalAgentHost {
                 const desiredCollaborationMode = options?.collaborationMode ?? live.execution.collaborationMode;
                 const collaborationMode = desiredCollaborationMode &&
                     desiredCollaborationMode !== live.appliedCollaborationMode
-                    ? buildCollaborationMode(desiredCollaborationMode, desiredModel, desiredReasoningEffort)
+                    ? await resolveLiveCollaborationMode(injectionClient, live, desiredCollaborationMode)
                     : undefined;
                 const settings = {
                     threadId,
@@ -1908,8 +1961,15 @@ export class LocalAgentHost {
                     // Record exactly what this RPC carried. A concurrent settings save may
                     // already have advanced the desired fields and must remain pending for
                     // the following new Turn.
-                    live.appliedModel = desiredModel;
-                    live.appliedReasoningEffort = desiredReasoningEffort;
+                    if (collaborationMode && !live.model) {
+                        live.model = collaborationMode.settings.model;
+                    }
+                    if (collaborationMode)
+                        live.mayUseProviderDefaultModel = false;
+                    live.appliedModel = collaborationMode?.settings.model ?? desiredModel;
+                    live.appliedReasoningEffort = collaborationMode
+                        ? collaborationMode.settings.reasoning_effort ?? undefined
+                        : desiredReasoningEffort;
                     if (desiredCollaborationMode) {
                         live.appliedCollaborationMode = desiredCollaborationMode;
                         live.execution = {
@@ -2944,6 +3004,7 @@ function raceReady(ready, timeoutMs, failed) {
 function adoptResumedThreadSettings(live, settings) {
     const model = settings.model?.trim();
     if (model) {
+        live.mayUseProviderDefaultModel = false;
         live.appliedModel = model;
         if (!live.execution.model)
             live.model = model;
@@ -2955,9 +3016,32 @@ function adoptResumedThreadSettings(live, settings) {
         }
     }
 }
+/** Resolve the model required by a full collaboration-mode snapshot. Only a
+ * fresh thread with no explicit/config model may use the catalog default; a
+ * resumed thread must report its own authoritative model. */
+async function resolveLiveCollaborationMode(client, live, mode) {
+    let model = live.model.trim();
+    if (!model && live.mayUseProviderDefaultModel) {
+        let catalog;
+        try {
+            catalog = await client.modelList();
+        }
+        catch (error) {
+            throw new CodexRuntimeError(`collaboration mode requires the Provider default 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 Provider default model; Provider advertised ${defaults.length}`, 503, "collaboration_mode_model_unknown");
+        }
+        model = defaults[0];
+    }
+    return buildCollaborationMode(mode, model, live.reasoningEffort);
+}
 /** Expand the public mode enum into the App Server's required settings
- * snapshot using the Session's tracked effective model. `model/list` is a
- * catalog and its `isDefault` marker is not the current thread setting. */
+ * snapshot using the Session's tracked effective model. */
 function buildCollaborationMode(mode, desiredModel, desiredReasoningEffort) {
     const model = desiredModel.trim();
     if (!model) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/runtime",
-  "version": "0.1.11-beta.29",
+  "version": "0.1.11-beta.30",
   "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.29"
+    "@rynx-ai/core": "0.1.11-beta.30"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"