@bridge4dev/runner 0.51.0 → 0.52.0

package/dist/adapters/codex.js

@@ -284,6 +284,12 @@ class CodexSession {
                     sessionId: this.spec.sessionId,
                 });
             }
+            // Before the thread, not after: a model this CLI no longer offers is
+            // refused by `thread/start` itself, and the pin is stored — so the same
+            // session would fail again on every relaunch (#374).
+            await this.dropModelTheCliNoLongerHas();
+            if (this.stopped)
+                return;
             const thread = await this.openThread();
             if (this.stopped)
                 return;
@@ -1915,6 +1921,93 @@ class CodexSession {
         };
         this.emit({ type: 'capabilities', capabilities });
     }
+    /**
+     * A pinned model the installed CLI does not have is dropped before it can
+     * fail the session (#374).
+     *
+     * The pin is chosen from a catalogue that was measured the last time an agent
+     * ran on this machine, and the CLI moves underneath it: codex 0.153.4 gained
+     * `gpt-6-astra` and lost `gpt-5.3-codex-spark`, so a machine that had not run
+     * a session since the update was offering — and storing — a model that no
+     * longer exists. `turn/start` does not warn about that, it refuses, and since
+     * the pin is persisted the refusal repeats on every relaunch.
+     *
+     * Asked of `model/list` rather than recognised in an error message: matching
+     * on text is what the retry rules were explicitly moved away from in 0.44.1,
+     * because the wording is the vendor's to change.
+     *
+     * A probe that itself fails changes nothing. Diagnosing the start must not be
+     * able to prevent it — an unreachable `model/list` on a CLI that would have
+     * accepted the model would otherwise cost the user their choice.
+     */
+    async dropModelTheCliNoLongerHas() {
+        const pinned = this.model;
+        if (!pinned)
+            return;
+        let known;
+        try {
+            known = await this.probeModelIds();
+        }
+        catch (error) {
+            log.warn('codex: could not check the pinned model — leaving it alone', {
+                sessionId: this.spec.sessionId,
+                error: describe(error),
+            });
+            return;
+        }
+        // Only a COMPLETE list can convict a model. An empty answer means this build
+        // does not really implement `model/list`; a truncated one means the answer
+        // continues on a page we did not ask for. Both must read as «no verdict»,
+        // or the check invents an absence and takes the user's choice away.
+        if (!known.complete || known.ids.size === 0)
+            return;
+        if (known.ids.has(pinned))
+            return;
+        delete this.model;
+        // Said out loud, because the session is about to run on a different model
+        // than the one that was picked — silently substituting it would be worse
+        // than the failure this replaces.
+        this.notice('warn', `This server's codex no longer offers ${pinned} — starting on the agent's own default instead.`);
+        // Cleared everywhere, not just here: the API stores the pin and hands it
+        // back in the next relaunch descriptor, so a pin dropped only in memory
+        // comes back on the next restart (the same trap as QA-100 MAJOR-5).
+        //
+        // What the column ends up holding is «nothing pinned» only until the thread
+        // opens: the capabilities frame right after it reports `currentModel`, and
+        // with no pin that is the thread's own model. Either way the invariant the
+        // clearing exists for holds — what is stored is a model this CLI has.
+        this.emit({ type: 'settings', model: null });
+        if (this.effort) {
+            // The level was chosen for a model that is not there. Keeping it would
+            // apply «Ultra» to whatever the CLI defaults to, which may not have it.
+            delete this.effort;
+            this.emit({ type: 'settings', effort: null });
+        }
+    }
+    /**
+     * Every model id this CLI knows, for the pin check only — including the ones
+     * `listModels()` filters out of the PICKER.
+     *
+     * `hidden` means «do not offer this», not «this does not exist»: codex ships
+     * internal entries like `codex-auto-review` that way, and a pin is not an
+     * offer. Judging a stored pin by the picker's list would delete a model the
+     * CLI still accepts.
+     *
+     * `complete` is false when the answer is paged, and a paged answer proves
+     * nothing about what is missing.
+     */
+    async probeModelIds() {
+        const result = asRecord(await this.client.request('model/list', { limit: 50 }, 15_000));
+        const data = Array.isArray(result['data']) ? result['data'] : [];
+        const ids = new Set();
+        for (const entry of data) {
+            const row = asRecord(entry);
+            const id = str(row['id']) ?? str(row['model']);
+            if (id)
+                ids.add(id);
+        }
+        return { ids, complete: !str(result['nextCursor']) };
+    }
     async listModels() {
         const result = asRecord(await this.client.request('model/list', { limit: 50 }, 15_000));
         const data = Array.isArray(result['data']) ? result['data'] : [];

package/dist/adapters/types.d.ts

@@ -406,9 +406,16 @@ export type AgentEvent = {
 } | {
     type: 'capabilities';
     capabilities: AgentCapabilities;
-} | {
+}
+/**
+ * `model: null` — the pin is GONE, not merely unchanged: the installed CLI
+ * stopped offering it (#374). Spelled like `effort: null` and read the same
+ * way by the API, which clears the stored column instead of handing the dead
+ * pin back in the next descriptor.
+ */
+ | {
     type: 'settings';
-    model?: string;
+    model?: string | null;
     mode?: AgentMode;
     effort?: string | null;
 } | {

package/dist/supervisor.js

@@ -2456,7 +2456,13 @@ export class Supervisor {
             case 'settings':
                 if (event.mode)
                     running.mode = event.mode;
-                if (event.model)
+                // null = the agent dropped the pinned MODEL, because the installed CLI
+                // stopped offering it (#374). Dropped from the local record too: this
+                // object is what a relaunch inside the same runner process starts from,
+                // so keeping it would re-pin the model the adapter just refused.
+                if (event.model === null)
+                    delete running.model;
+                else if (event.model)
                     running.model = event.model;
                 // null = the agent dropped the pinned level (model without it) — the
                 // API must clear its column, so the value is forwarded as-is.
@@ -2465,7 +2471,7 @@ export class Supervisor {
                 else if (event.effort)
                     running.effort = event.effort;
                 this.sendEvent(running, 'settings', {
-                    model: event.model,
+                    ...(event.model === undefined ? {} : { model: event.model }),
                     mode: event.mode,
                     ...(event.effort === undefined ? {} : { effort: event.effort }),
                 });

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const RUNNER_VERSION = "0.51.0";
+export declare const RUNNER_VERSION = "0.52.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1,3 +1,3 @@
 // Kept in sync with package.json by the release script (manual for now).
-export const RUNNER_VERSION = '0.51.0';
+export const RUNNER_VERSION = '0.52.0';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bridge4dev/runner",
-  "version": "0.51.0",
+  "version": "0.52.0",
   "description": "DevBridge dev runner — connects a dev server to DevBridge and runs agent sessions (Claude Code / Codex)",
   "homepage": "https://bridge4.dev",
   "license": "MIT",