@nyssance/codex-acp-v2 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.5.0 — 2026-09-11
+
+### Added
+
+- `providers/set` hints `_meta.codex.bearerToken` (written as `experimental_bearer_token`)
+  and `_meta.codex.config` (top-level Codex thread-config overrides that ride with the
+  gateway; a `model_catalog_json` file is read so gateway models carry their real reasoning
+  levels and modalities). `providers/disable` removes both from live threads.
+- Catalog mode (`_meta.codex.mode: "catalog"`): the gateway's models are offered next to
+  Codex's in every session's `model` option as their own select group; selecting one moves
+  only that session to the gateway (unsubscribe + resume, materializing an empty thread
+  first), selecting a Codex model moves it back. `session/new` / `session/fork` honour
+  `_meta.alwith.model`; `session/resume` follows the provider Codex recorded for the thread.
+  Advertised as `capabilities._meta.codex.providerCatalog`.
+
+### Fixed
+
+- A thread another Codex client is writing ("already has an active writer", a file lock
+  across the Codex home) opens as a read-only session through `thread/read`, like Codex's
+  TUI: history replays, the response carries `_meta.codex.readOnly`, prompts and config
+  changes are refused with `-32600`, and a later resume retries the real thing.
+
 ## 0.4.0 — 2026-09-10
 
 ### Added

package/dist/index.js

@@ -3406,8 +3406,8 @@ var require_main = __commonJS(function(exports) {
   exports.createMessageConnection = createMessageConnection;
   var ril_1 = __importDefault(require_ril());
   ril_1.default.install();
-  var path7 = __importStar(__require("path"));
-  var os2 = __importStar(__require("os"));
+  var path8 = __importStar(__require("path"));
+  var os3 = __importStar(__require("os"));
   var fs7 = __importStar(__require("fs"));
   var crypto_1 = __require("crypto");
   var net_1 = __require("net");
@@ -3555,7 +3555,7 @@ var require_main = __commonJS(function(exports) {
     }
     let randomLength = 32;
     const fixedLength = "/lsp-.sock".length;
-    const tmpDir = fs7.realpathSync(XDG_RUNTIME_DIR ?? os2.tmpdir());
+    const tmpDir = fs7.realpathSync(XDG_RUNTIME_DIR ?? os3.tmpdir());
     const limit = safeIpcPathLengths.get(process.platform);
     if (limit !== undefined) {
       randomLength = Math.min(limit - tmpDir.length - fixedLength, randomLength);
@@ -3564,7 +3564,7 @@ var require_main = __commonJS(function(exports) {
       throw new Error(`Unable to generate a random pipe name with ${randomLength} characters.`);
     }
     const randomSuffix = (0, crypto_1.randomBytes)(Math.floor(randomLength / 2)).toString("hex");
-    return path7.join(tmpDir, `lsp-${randomSuffix}.sock`);
+    return path8.join(tmpDir, `lsp-${randomSuffix}.sock`);
   }
   function createClientPipeTransport(pipeName, encoding = "utf-8") {
     let connectResolve;
@@ -21721,7 +21721,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "0.4.0",
+  version: "0.5.0",
   description: "Native ACP v2 agent for the OpenAI Codex app-server",
   packageManager: "bun@1.4.0",
   engines: {
@@ -21838,7 +21838,7 @@ function classifyTurnError(info) {
 }
 
 // src/agent/CodexAgent.ts
-import path6 from "path";
+import path7 from "path";
 
 // src/util/logger.ts
 import fs from "fs";
@@ -23982,7 +23982,7 @@ function modelLacksReasoning(model) {
   const options = supportedEfforts(model);
   return options.length > 0 && options.every((option) => option.reasoningEffort === "none");
 }
-function modelConfigOption(catalog, current) {
+function modelConfigOption(catalog, current, gatewayGroup = null) {
   const visible = catalog.filter((model) => !model.hidden || model.id === current);
   const options = visible.map((model) => ({
     value: model.id,
@@ -23992,14 +23992,25 @@ function modelConfigOption(catalog, current) {
   if (!options.some((option) => option.value === current)) {
     options.unshift({ value: current, name: current, description: null });
   }
-  return {
+  const base = {
     configId: MODEL_CONFIG_ID,
     name: "Model",
     description: "Model Codex uses for this session",
     category: "model",
     type: "select",
-    currentValue: current,
-    options
+    currentValue: current
+  };
+  if (gatewayGroup === null)
+    return { ...base, options };
+  const gatewayIds = new Set(gatewayGroup.modelIds);
+  const native = options.filter((option) => !gatewayIds.has(option.value));
+  const gateway = options.filter((option) => gatewayIds.has(option.value));
+  return {
+    ...base,
+    options: [
+      { groupId: "codex", name: "Codex", options: native },
+      { groupId: "custom-gateway", name: gatewayGroup.name, options: gateway }
+    ]
   };
 }
 function effortConfigOption(efforts, current) {
@@ -25955,7 +25966,7 @@ function sessionConfigOptions(session) {
   const model = findModel(session.catalog, session.model.model);
   const options = [
     modeConfigOption(session.mode),
-    modelConfigOption(session.catalog, session.model.model),
+    modelConfigOption(session.catalog, session.model.model, session.gatewayGroup),
     effortConfigOption(supportedEfforts(model), session.model.effort),
     collaborationModeConfigOption(session.collaborationMode)
   ];
@@ -26057,10 +26068,12 @@ function firstLine(text2) {
 }
 
 // src/agent/providers.ts
+import { readFileSync } from "fs";
+import os2 from "os";
+import path6 from "path";
 var OPENAI_PROVIDER_ID = "openai";
 var GATEWAY_MODEL_PROVIDER = "custom-gateway";
 var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
-
 class ProviderRouting {
   baseConfig;
   configuredProvider;
@@ -26078,12 +26091,14 @@ class ProviderRouting {
     return this.gateway;
   }
   list() {
+    const routed = this.gateway !== null && this.gateway.mode === "route";
     return {
       providers: [{
         providerId: OPENAI_PROVIDER_ID,
         supported: ["openai"],
         required: false,
-        current: this.gateway ? { apiType: "openai", baseUrl: this.gateway.baseUrl } : { apiType: "openai", baseUrl: this.nativeBaseUrl() }
+        current: routed && this.gateway ? { apiType: "openai", baseUrl: this.gateway.baseUrl } : { apiType: "openai", baseUrl: this.nativeBaseUrl() },
+        ...this.gateway && !routed ? { _meta: { codex: { mode: "catalog", gateway: { name: this.gateway.name, baseUrl: this.gateway.baseUrl, models: this.gateway.models.map((model) => model.id) } } } } : {}
       }]
     };
   }
@@ -26104,37 +26119,83 @@ class ProviderRouting {
       headers: { ...request.headers ?? {} },
       name: hints.name ?? "Client-configured gateway",
       models: hints.models,
-      model: hints.model
+      model: hints.model,
+      bearerToken: hints.bearerToken,
+      config: hints.config,
+      mode: hints.mode,
+      catalogEntries: hints.catalogEntries
     };
   }
+  get mode() {
+    return this.gateway?.mode ?? "route";
+  }
+  isGatewayModel(modelId) {
+    return this.gateway !== null && this.gateway.models.some((model) => model.id === modelId);
+  }
+  gatewayGroup() {
+    if (!this.gateway || this.gateway.mode !== "catalog" || this.gateway.models.length === 0)
+      return null;
+    return { name: this.gateway.name, modelIds: this.gateway.models.map((model) => model.id) };
+  }
   disable(request) {
     if (request.providerId === OPENAI_PROVIDER_ID)
       this.gateway = null;
   }
   modelProvider() {
-    return this.gateway ? GATEWAY_MODEL_PROVIDER : this.configuredProvider;
+    return this.gateway && this.gateway.mode === "route" ? GATEWAY_MODEL_PROVIDER : this.configuredProvider;
+  }
+  routesByDefault() {
+    return this.gateway !== null && this.gateway.mode === "route";
   }
-  threadConfig() {
-    if (!this.gateway)
+  threadConfig(onGateway = this.routesByDefault()) {
+    if (!this.gateway || !onGateway)
       return this.baseConfig;
-    const existing = isRecord2(this.baseConfig["model_providers"]) ? this.baseConfig["model_providers"] : {};
+    return this.applyGateway(this.baseConfig, this.gateway);
+  }
+  routeConfig(config2, onGateway) {
+    return this.rebind(config2, this, onGateway);
+  }
+  overrideKeys() {
+    return this.gateway ? Object.keys(this.gateway.config) : [];
+  }
+  rebind(config2, previous, onGateway = this.routesByDefault()) {
+    const next = { ...config2 };
+    for (const key of previous.overrideKeys()) {
+      if (key in this.baseConfig)
+        next[key] = this.baseConfig[key];
+      else
+        delete next[key];
+    }
+    if (!this.gateway || !onGateway) {
+      delete next["model_providers"];
+      if (isRecord2(this.baseConfig["model_providers"]))
+        next["model_providers"] = this.baseConfig["model_providers"];
+      return next;
+    }
+    return this.applyGateway(next, this.gateway);
+  }
+  applyGateway(config2, gateway) {
+    const existing = isRecord2(config2["model_providers"]) ? config2["model_providers"] : {};
+    const entry = {
+      name: gateway.name,
+      base_url: gateway.baseUrl,
+      wire_api: "responses",
+      http_headers: { "X-Client-Feature-ID": "codex", ...gateway.headers }
+    };
+    if (gateway.bearerToken !== null)
+      entry["experimental_bearer_token"] = gateway.bearerToken;
     return {
-      ...this.baseConfig,
-      model_providers: {
-        ...existing,
-        [GATEWAY_MODEL_PROVIDER]: {
-          name: this.gateway.name,
-          base_url: this.gateway.baseUrl,
-          wire_api: "responses",
-          http_headers: { "X-Client-Feature-ID": "codex", ...this.gateway.headers }
-        }
-      }
+      ...config2,
+      ...gateway.config,
+      model_providers: { ...existing, [GATEWAY_MODEL_PROVIDER]: entry }
     };
   }
   catalog(codexCatalog) {
     if (!this.gateway || this.gateway.models.length === 0)
       return codexCatalog;
-    return this.gateway.models.map((model, index) => gatewayModel(model, index === 0, codexCatalog[0]));
+    const gateway = this.gateway;
+    const own = gateway.models.map((model, index) => gatewayModel(model, gateway.mode === "route" && index === 0, codexCatalog[0], gateway.catalogEntries.get(model.id)));
+    return gateway.mode === "catalog" ? [...codexCatalog, ...own] : own;
   }
   nativeBaseUrl() {
     const providers = this.baseConfig["model_providers"];
@@ -26165,22 +26226,80 @@ function readHints(meta) {
   }
   const model = typeof alwith["model"] === "string" && alwith["model"].length > 0 ? alwith["model"] : null;
   const name = typeof codex["name"] === "string" && codex["name"].length > 0 ? codex["name"] : null;
-  return { models, model, name };
+  const bearerToken = typeof codex["bearerToken"] === "string" && codex["bearerToken"].length > 0 ? codex["bearerToken"] : null;
+  const rawConfig = codex["config"];
+  if (rawConfig !== undefined && !isRecord2(rawConfig)) {
+    throw RequestError.invalidParams({ config: rawConfig }, "_meta.codex.config must be an object of top-level Codex config keys");
+  }
+  const config2 = {};
+  if (isRecord2(rawConfig)) {
+    for (const [key, value] of Object.entries(rawConfig)) {
+      if (key === "model_providers")
+        throw RequestError.invalidParams({ config: rawConfig }, "_meta.codex.config cannot set model_providers; that entry is derived from baseUrl and headers");
+      config2[key] = value;
+    }
+  }
+  const rawMode = codex["mode"];
+  if (rawMode !== undefined && rawMode !== "route" && rawMode !== "catalog") {
+    throw RequestError.invalidParams({ mode: rawMode }, '_meta.codex.mode must be "route" or "catalog"');
+  }
+  const mode = rawMode === "catalog" ? "catalog" : "route";
+  if (mode === "catalog" && models.length === 0) {
+    throw RequestError.invalidParams(undefined, `_meta.codex.mode "catalog" needs _meta.alwith.models: the models offered next to Codex's`);
+  }
+  const catalogPath = config2["model_catalog_json"];
+  const catalogEntries = typeof catalogPath === "string" ? readCatalogFile(catalogPath) : new Map;
+  return { models, model, name, bearerToken, config: config2, mode, catalogEntries };
+}
+function readCatalogFile(catalogPath) {
+  const resolved = catalogPath.startsWith("~/") ? path6.join(os2.homedir(), catalogPath.slice(2)) : catalogPath;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(resolved, "utf8"));
+  } catch (error40) {
+    throw RequestError.invalidParams({ model_catalog_json: catalogPath }, `model_catalog_json could not be read as JSON: ${error40 instanceof Error ? error40.message : String(error40)}`);
+  }
+  const models = isRecord2(parsed) && Array.isArray(parsed["models"]) ? parsed["models"] : null;
+  if (models === null)
+    throw RequestError.invalidParams({ model_catalog_json: catalogPath }, "model_catalog_json must be {models: [...]} as Codex expects");
+  const entries = new Map;
+  for (const entry of models) {
+    if (!isRecord2(entry) || typeof entry["slug"] !== "string")
+      continue;
+    const levels = Array.isArray(entry["supported_reasoning_levels"]) ? entry["supported_reasoning_levels"] : [];
+    const efforts = [];
+    for (const level of levels) {
+      if (!isRecord2(level) || typeof level["effort"] !== "string")
+        continue;
+      efforts.push({ reasoningEffort: level["effort"], description: typeof level["description"] === "string" ? level["description"] : "" });
+    }
+    const modalities = Array.isArray(entry["input_modalities"]) ? entry["input_modalities"].filter((value) => value === "text" || value === "image") : null;
+    entries.set(entry["slug"], {
+      displayName: typeof entry["display_name"] === "string" ? entry["display_name"] : null,
+      description: typeof entry["description"] === "string" ? entry["description"] : null,
+      efforts,
+      defaultEffort: typeof entry["default_reasoning_level"] === "string" ? entry["default_reasoning_level"] : null,
+      inputModalities: modalities
+    });
+  }
+  return entries;
 }
-function gatewayModel(model, isDefault, template) {
+function gatewayModel(model, isDefault, template, entry) {
+  const efforts = entry && entry.efforts.length > 0 ? entry.efforts : template?.supportedReasoningEfforts ?? [];
+  const defaultEffort = entry?.defaultEffort ?? template?.defaultReasoningEffort ?? "medium";
   return {
     id: model.id,
     model: model.id,
     upgrade: null,
     upgradeInfo: null,
     availabilityNux: null,
-    displayName: model.name,
-    description: model.description ?? "",
+    displayName: model.name !== model.id ? model.name : entry?.displayName ?? model.name,
+    description: model.description ?? entry?.description ?? "",
     modelSpecialty: null,
     hidden: false,
-    supportedReasoningEfforts: template?.supportedReasoningEfforts ?? [],
-    defaultReasoningEffort: template?.defaultReasoningEffort ?? "medium",
-    inputModalities: ["text", "image"],
+    supportedReasoningEfforts: efforts,
+    defaultReasoningEffort: defaultEffort,
+    inputModalities: entry?.inputModalities ?? ["text", "image"],
     supportsPersonality: false,
     multiAgentVersion: null,
     additionalSpeedTiers: [],
@@ -26323,7 +26442,7 @@ class CodexAgent {
           additionalDirectories: {}
         },
         providers: {},
-        _meta: { codex: { archive: true, seedHistory: true, skills: true, plugins: true } }
+        _meta: { codex: { archive: true, seedHistory: true, skills: true, plugins: true, providerCatalog: true } }
       },
       authMethods: authMethods(this.capabilities, this.env)
     };
@@ -26408,23 +26527,27 @@ class CodexAgent {
       try {
         change(candidate);
         const catalog = await this.withCodex(() => this.codex.allModels(true));
-        const modelProvider = await this.resolveModelProvider(candidate);
-        for (const runtime of this.sessions.values()) {
+        const nativeProvider = await this.resolveModelProvider(candidate);
+        const wholesale = this.providers.active !== null && this.providers.mode === "route" || candidate.active !== null && candidate.mode === "route";
+        const moving = [...this.sessions.values()].filter((runtime) => wholesale || runtime.modelProvider === GATEWAY_MODEL_PROVIDER);
+        const targets = new Map(moving.map((runtime) => [runtime, candidate.active !== null && (candidate.mode === "route" || runtime.modelProvider === GATEWAY_MODEL_PROVIDER)]));
+        for (const runtime of moving) {
           try {
             await this.codex.threadTurnsList({ threadId: runtime.session.id, limit: 1, itemsView: "notLoaded" });
           } catch (error40) {
-            throw RequestError.invalidRequest({ sessionId: runtime.session.id, details: errorMessage(error40) }, "Cannot reload this session's history for a provider change; close empty sessions and configure the provider before creating them, or retry after history is available");
+            if (wholesale) {
+              throw RequestError.invalidRequest({ sessionId: runtime.session.id, details: errorMessage(error40) }, "Cannot reload this session's history for a provider change; close empty sessions and configure the provider before creating them, or retry after history is available");
+            }
+            await this.withCodex(() => this.codex.threadInjectItems({ threadId: runtime.session.id, items: [providerChangeNote()] }));
           }
         }
-        for (const runtime of this.sessions.values()) {
-          const config2 = { ...runtime.config };
-          const providers = candidate.threadConfig()["model_providers"];
-          if (providers === undefined)
-            delete config2["model_providers"];
-          else
-            config2["model_providers"] = providers;
-          const nextCatalog = candidate.catalog(catalog);
-          const requestedModel = candidate.active?.model ?? (findModel(nextCatalog, runtime.session.model.model) ? runtime.session.model.model : null);
+        const nextCatalog = candidate.catalog(catalog);
+        for (const runtime of moving) {
+          const onGateway = targets.get(runtime) === true;
+          const config2 = candidate.rebind(runtime.config, this.providers, onGateway);
+          const modelProvider = onGateway ? GATEWAY_MODEL_PROVIDER : nativeProvider;
+          const keep = findModel(nextCatalog, runtime.session.model.model) && candidate.isGatewayModel(runtime.session.model.model) === onGateway;
+          const requestedModel = candidate.mode === "route" ? candidate.active?.model ?? (keep ? runtime.session.model.model : null) : keep ? runtime.session.model.model : null;
           const selection = resolveModelSelection(nextCatalog, requestedModel, requestedModel === runtime.session.model.model ? runtime.session.model.effort : null);
           attempted.push(runtime);
           await this.codex.threadUnsubscribe({ threadId: runtime.session.id });
@@ -26436,15 +26559,21 @@ class CodexAgent {
             model: selection.model,
             excludeTurns: true
           }));
-          staged.set(runtime, { config: config2, catalog: nextCatalog, model: resolveModelSelection(nextCatalog, candidate.active?.model ?? thread.model, thread.reasoningEffort) });
+          staged.set(runtime, { config: config2, catalog: nextCatalog, model: resolveModelSelection(nextCatalog, requestedModel ?? thread.model, thread.reasoningEffort) });
         }
         this.providers = candidate;
-        for (const [runtime, next] of staged) {
-          runtime.config = next.config;
-          runtime.modelProvider = modelProvider;
-          runtime.session.catalog = next.catalog;
-          runtime.session.model = next.model;
-          runtime.stale = false;
+        for (const runtime of this.sessions.values()) {
+          const next = staged.get(runtime);
+          if (next) {
+            runtime.config = next.config;
+            runtime.modelProvider = targets.get(runtime) === true ? GATEWAY_MODEL_PROVIDER : nativeProvider;
+            runtime.session.model = next.model;
+            runtime.stale = false;
+          }
+          runtime.session.catalog = nextCatalog;
+          runtime.session.gatewayGroup = candidate.gatewayGroup();
+          if (!next)
+            runtime.session.model = resolveModelSelection(nextCatalog, findModel(nextCatalog, runtime.session.model.model) ? runtime.session.model.model : null, runtime.session.model.effort);
           runtime.client.update({ sessionUpdate: "config_option_update", configOptions: sessionConfigOptions(runtime.session), _meta: { codex: { routing: { stale: false } } } }).catch((error40) => logger.error("Provider config notification failed", error40));
         }
       } catch (error40) {
@@ -26483,7 +26612,8 @@ class CodexAgent {
   }
   async resumeSession(params, signal) {
     const runtime = await this.openSession({ kind: "resume", request: params }, signal);
-    return { configOptions: sessionConfigOptions(runtime.session) };
+    const configOptions = sessionConfigOptions(runtime.session);
+    return runtime.readOnly ? { configOptions, _meta: { codex: { readOnly: true, reason: "active_writer" } } } : { configOptions };
   }
   async forkSession(params, signal) {
     const runtime = await this.openSession({ kind: "fork", request: params }, signal);
@@ -26519,7 +26649,7 @@ class CodexAgent {
     if (open2.kind !== "new")
       this.assertUnsubscribeSettled(open2.request.sessionId);
     const { request } = open2;
-    if (typeof request.cwd !== "string" || !path6.isAbsolute(request.cwd)) {
+    if (typeof request.cwd !== "string" || !path7.isAbsolute(request.cwd)) {
       throw RequestError.invalidParams({ cwd: request.cwd }, "cwd must be an absolute path");
     }
     if (open2.kind === "resume" && open2.request.replayFrom != null && open2.request.replayFrom.type !== "start") {
@@ -26532,25 +26662,44 @@ class CodexAgent {
       this.assertUnsubscribeSettled(open2.request.sessionId);
     }
     const mcpServers = request.mcpServers ?? [];
+    const requestedModel = requestedModelOf(request._meta);
+    let onGateway = this.providers.routesByDefault();
+    if (this.providers.active !== null && this.providers.mode === "catalog") {
+      if (requestedModel !== null)
+        onGateway = this.providers.isGatewayModel(requestedModel);
+      else if (open2.kind === "resume") {
+        const known = await this.withCodex(() => this.codex.threadRead({ threadId: open2.request.sessionId, includeTurns: false }));
+        onGateway = known.thread.modelProvider === GATEWAY_MODEL_PROVIDER;
+      }
+    }
     let accountVersion = this.accountGeneration;
     const account = await this.withCodex(() => this.codex.accountRead({ refreshToken: false }));
-    if (this.providers.active === null && account.requiresOpenaiAuth && account.account === null) {
+    if (!onGateway && account.requiresOpenaiAuth && account.account === null) {
       throw RequestError.authRequired(undefined, "Log in to Codex first (auth/login)");
     }
     const existingMcp = mcpServers.length > 0 ? await this.withCodex(() => this.configuredMcpServerNames(request.cwd)) : new Set;
-    const config2 = buildThreadConfig(this.providers.threadConfig(), request.cwd, additionalDirectories, mcpServers, existingMcp);
+    const config2 = buildThreadConfig(this.providers.threadConfig(onGateway), request.cwd, additionalDirectories, mcpServers, existingMcp);
     const mcpStartupGeneration = this.codex.mcpStartupGeneration;
-    const modelProvider = await this.withCodex(() => this.resolveModelProvider());
+    const modelProvider = onGateway ? GATEWAY_MODEL_PROVIDER : await this.withCodex(() => this.resolveModelProvider());
+    const startModel = onGateway ? requestedModel ?? this.providers.active?.model ?? null : requestedModel;
+    let readOnly = false;
     const { thread, skills } = await this.withSkillsContext(request.cwd, additionalDirectories, async (skills2) => ({ skills: skills2, thread: await this.withCodex(async () => {
       if (signal?.aborted)
         throw RequestError.requestCancelled(undefined, "Session opening was cancelled");
       switch (open2.kind) {
         case "new":
-          return await this.codex.threadStart({ config: config2, cwd: request.cwd, modelProvider });
+          return await this.codex.threadStart({ config: config2, cwd: request.cwd, modelProvider, model: startModel });
         case "resume":
-          return await this.codex.threadResume({ threadId: open2.request.sessionId, config: config2, cwd: request.cwd, modelProvider, excludeTurns: true });
+          try {
+            return await this.codex.threadResume({ threadId: open2.request.sessionId, config: config2, cwd: request.cwd, modelProvider, model: startModel, excludeTurns: true });
+          } catch (error40) {
+            if (!errorMessage(error40).includes("already has an active writer"))
+              throw error40;
+            readOnly = true;
+            return readOnlyThread((await this.codex.threadRead({ threadId: open2.request.sessionId, includeTurns: false })).thread, request.cwd);
+          }
         case "fork":
-          return await this.codex.threadFork({ threadId: open2.request.sessionId, config: config2, cwd: request.cwd, modelProvider, excludeTurns: true });
+          return await this.codex.threadFork({ threadId: open2.request.sessionId, config: config2, cwd: request.cwd, modelProvider, model: startModel, excludeTurns: true });
       }
     }) }));
     const sessionId = thread.thread.id;
@@ -26578,15 +26727,15 @@ class CodexAgent {
         accountVersion = this.accountGeneration;
         openedAccount = (await this.withCodex(() => this.codex.accountRead({ refreshToken: false }))).account;
       }
-      const gateway = this.providers.active;
       const catalog = this.providers.catalog(codexCatalog);
-      const model = resolveModelSelection(catalog, gateway?.model ?? thread.model, thread.reasoningEffort);
+      const model = resolveModelSelection(catalog, startModel ?? thread.model, thread.reasoningEffort);
       const session = {
         id: sessionId,
         cwd: request.cwd,
         additionalDirectories,
         mcpServerNames: mcpServerNames(mcpServers).filter((name) => !existingMcp.has(name)),
         catalog,
+        gatewayGroup: this.providers.gatewayGroup(),
         model,
         mode: initialAgentMode(this.env),
         collaborationMode: DEFAULT_COLLABORATION_MODE,
@@ -26599,7 +26748,7 @@ class CodexAgent {
         contextWindow: null,
         closed: false
       };
-      const runtime = this.installRuntime(session, capabilities, config2, thread.modelProvider);
+      const runtime = this.installRuntime(session, capabilities, config2, onGateway ? GATEWAY_MODEL_PROVIDER : thread.modelProvider, readOnly);
       const cancelOpening = () => {
         runtime.session.closed = true;
         runtime.lifetime.abort();
@@ -26646,7 +26795,7 @@ class CodexAgent {
       stopObservingOpen();
     }
   }
-  installRuntime(session, capabilities, config2, modelProvider) {
+  installRuntime(session, capabilities, config2, modelProvider, readOnly = false) {
     const client = new ClientSession(session.id, this.link, capabilities);
     const bridge = new EventBridge(client, session);
     const turnContext = new TurnContext(session.id);
@@ -26656,7 +26805,7 @@ class CodexAgent {
     };
     const approval = new CodexApprovalHandler(client, turnContext, signal);
     const elicitation = new CodexElicitationHandler(client, turnContext, signal);
-    const runtime = { config: config2, modelProvider, stale: false, session, client, bridge, turnContext, elicitation, lifetime: new AbortController, queue: Promise.resolve() };
+    const runtime = { config: config2, modelProvider, stale: false, readOnly, session, client, bridge, turnContext, elicitation, lifetime: new AbortController, queue: Promise.resolve() };
     const drained = (operation) => async (params) => {
       await abortable(this.drain(runtime), this.codex.disconnectSignal);
       return await operation(params);
@@ -26923,7 +27072,7 @@ class CodexAgent {
       runtime.session.activeTurn = null;
       turn.resolveFinished();
     }
-    const unsubscribe = this.unsubscribeThread(sessionId);
+    const unsubscribe = runtime.readOnly ? Promise.resolve() : this.unsubscribeThread(sessionId);
     let remoteUnsubscribe = "confirmed";
     try {
       if (!await within(unsubscribe, Math.max(0, deadline - performance.now()))) {
@@ -26952,11 +27101,46 @@ class CodexAgent {
   }
   async setSessionConfigOptionInternal(params) {
     const runtime = this.runtime(params.sessionId, "session/set_config_option");
+    assertWritable(runtime);
+    if (params.configId === MODEL_CONFIG_ID && this.providers.mode === "catalog" && typeof params.value === "string") {
+      const toGateway = this.providers.isGatewayModel(params.value);
+      if (toGateway !== (runtime.modelProvider === GATEWAY_MODEL_PROVIDER))
+        await this.rerouteSession(runtime, toGateway, params.value);
+    }
     await this.withCodex(() => applyConfigOption(runtime.session, this.codex, params));
     const configOptions = sessionConfigOptions(runtime.session);
     await runtime.client.update({ sessionUpdate: "config_option_update", configOptions });
     return { configOptions };
   }
+  async rerouteSession(runtime, toGateway, modelId) {
+    const { session } = runtime;
+    this.assertRoutingAvailable();
+    if (session.activeTurn !== null) {
+      throw RequestError.invalidRequest({ sessionId: session.id }, "The model provider cannot change while a turn is running; cancel it or wait for idle");
+    }
+    try {
+      await this.codex.threadTurnsList({ threadId: session.id, limit: 1, itemsView: "notLoaded" });
+    } catch {
+      await this.withCodex(() => this.codex.threadInjectItems({ threadId: session.id, items: [providerChangeNote()] }));
+    }
+    const config2 = this.providers.routeConfig(runtime.config, toGateway);
+    const modelProvider = toGateway ? GATEWAY_MODEL_PROVIDER : await this.withCodex(() => this.resolveModelProvider());
+    await this.codex.threadUnsubscribe({ threadId: session.id });
+    try {
+      await this.withCodex(() => this.codex.threadResume({ threadId: session.id, cwd: session.cwd, config: config2, modelProvider, model: modelId, excludeTurns: true }));
+    } catch (error40) {
+      try {
+        await this.codex.threadResume({ threadId: session.id, cwd: session.cwd, config: runtime.config, modelProvider: runtime.modelProvider, model: session.model.model, excludeTurns: true });
+      } catch (rollbackError) {
+        runtime.stale = true;
+        logger.error("Provider rollback failed", rollbackError, { sessionId: session.id });
+      }
+      throw RequestError.internalError({ sessionId: session.id, stale: runtime.stale }, `Could not move the session to ${toGateway ? "the gateway" : "Codex's provider"}: ${errorMessage(error40)}`);
+    }
+    runtime.config = config2;
+    runtime.modelProvider = modelProvider;
+    runtime.stale = false;
+  }
   runtime(sessionId, method) {
     this.requireInitialized(method);
     const runtime = this.sessions.get(sessionId);
@@ -26972,6 +27156,7 @@ class CodexAgent {
     if (!allowReentry && this.sessionMutations.has(params.sessionId))
       throw RequestError.invalidRequest({ sessionId: params.sessionId }, "Session lifecycle or configuration work is in progress; retry when it finishes");
     const runtime = this.runtime(params.sessionId, "session/prompt");
+    assertWritable(runtime);
     if (runtime.stale)
       throw RequestError.invalidRequest({ sessionId: params.sessionId, _meta: { codex: { routing: { stale: true } } } }, "Session routing is stale; resume the session or successfully change providers before prompting");
     if (!Array.isArray(params.prompt) || params.prompt.length === 0) {
@@ -27270,7 +27455,7 @@ ${error40.additionalDetails}` : error40.message;
   }
   withSkillsContext(cwd, additionalDirectories, operation) {
     const run = async () => {
-      const roots = additionalDirectories.map((root) => path6.join(root, ".agents", "skills"));
+      const roots = additionalDirectories.map((root) => path7.join(root, ".agents", "skills"));
       if (roots.length !== this.skillRoots.length || roots.some((root, index) => root !== this.skillRoots[index])) {
         this.changingSkillRoots = true;
         try {
@@ -27304,7 +27489,7 @@ ${error40.additionalDetails}` : error40.message;
   }
   async refreshAvailableCommands(runtime) {
     const run = async () => {
-      const roots = runtime.session.additionalDirectories.map((root) => path6.join(root, ".agents", "skills"));
+      const roots = runtime.session.additionalDirectories.map((root) => path7.join(root, ".agents", "skills"));
       if (runtime.session.closed || roots.length !== this.skillRoots.length || roots.some((root, i) => root !== this.skillRoots[i]))
         return;
       return await this.loadSkills(runtime.session.cwd, runtime.session.additionalDirectories);
@@ -27428,6 +27613,34 @@ function archivedFilter(meta) {
   const codex = meta?.codex;
   return codex?.archived === true;
 }
+function providerChangeNote() {
+  return { type: "message", role: "developer", content: [{ type: "input_text", text: "The user changed this conversation's model before sending a message." }] };
+}
+function assertWritable(runtime) {
+  if (!runtime.readOnly)
+    return;
+  throw RequestError.invalidRequest({ codex: { readOnly: true } }, "Thread is open in another Codex client");
+}
+function readOnlyThread(thread, cwd) {
+  return {
+    thread,
+    model: thread.model ?? "",
+    modelProvider: thread.modelProvider,
+    serviceTier: null,
+    cwd,
+    instructionSources: [],
+    approvalPolicy: "on-request",
+    approvalsReviewer: "user",
+    sandbox: { type: "readOnly", networkAccess: false },
+    reasoningEffort: thread.reasoningEffort,
+    turnsBackwardsCursor: null,
+    itemsBackwardsCursor: null
+  };
+}
+function requestedModelOf(meta) {
+  const raw = meta?.alwith?.model;
+  return typeof raw === "string" && raw.length > 0 ? raw : null;
+}
 function seedHistoryOf(meta) {
   const raw = meta?.codex?.seedHistory;
   if (raw === undefined || raw === null)
@@ -27922,7 +28135,7 @@ function threadIdOf(notification) {
 
 // src/codex/process.ts
 import { existsSync } from "fs";
-import path7 from "path";
+import path8 from "path";
 import { spawn, spawnSync } from "child_process";
 import { createRequire } from "module";
 
@@ -28215,11 +28428,11 @@ function resolveCodexLauncher(codexPath) {
     const target = targets[platform2];
     if (!target)
       throw new Error(`Unsupported Codex platform: ${platform2}`);
-    let vendor = path7.resolve(path7.dirname(launcher), "..", "vendor");
+    let vendor = path8.resolve(path8.dirname(launcher), "..", "vendor");
     try {
-      vendor = path7.join(path7.dirname(platformRequire.resolve(`@openai/codex-${platform2}/package.json`)), "vendor");
+      vendor = path8.join(path8.dirname(platformRequire.resolve(`@openai/codex-${platform2}/package.json`)), "vendor");
     } catch {}
-    const command = path7.join(vendor, target, "bin", process.platform === "win32" ? "codex.exe" : "codex");
+    const command = path8.join(vendor, target, "bin", process.platform === "win32" ? "codex.exe" : "codex");
     if (!existsSync(command))
       throw new Error(`Missing Codex platform binary: ${command}`);
     return { command, prefixArgs: [], shell: false };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Native ACP v2 agent for the OpenAI Codex app-server",
   "packageManager": "bun@1.4.0",
   "engines": {