@nyssance/codex-acp-v2 0.4.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## 0.6.0 — 2026-09-11
+
+### Added
+
+- Several gateways at once in catalog mode: `providers/set` takes `_meta.codex.id`
+  (default `custom-gateway`); each gateway keeps its own base URL, key, config and models,
+  writes its own `model_providers.<id>` entry, and gets its own select group in every
+  session's `model` option. Model ids must be unique across gateways (`-32602` otherwise).
+  `providers/disable` with `_meta.codex.id` removes one gateway; `providers/list` reports
+  `_meta.codex.gateways`. Route mode is unchanged (one gateway).
+- Pass-throughs: `_codex/session_rename` (`thread/name/set`), `_codex/account_read`
+  (`account/read`), `_codex/rate_limits` (`account/rateLimits/read`) and
+  `_codex/fuzzy_file_search` (`fuzzyFileSearch`); notifications
+  `_codex/rate_limits_updated`, `_codex/fuzzy_file_search_updated` and
+  `_codex/fuzzy_file_search_completed` carry Codex's payloads verbatim. Advertised as
+  `capabilities._meta.codex.rename` / `.account` / `.fuzzyFileSearch`.
+
+### Fixed
+
+- A thread moved from one gateway to another no longer keeps the previous gateway's
+  `model_providers` entry (and bearer token) in its config.
+- Re-registering one gateway no longer re-resumes sessions that sit on other gateways.
+
+## 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.6.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, gatewayGroups = []) {
   const visible = catalog.filter((model) => !model.hidden || model.id === current);
   const options = visible.map((model) => ({
     value: model.id,
@@ -23992,14 +23992,27 @@ 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 (gatewayGroups.length === 0)
+    return { ...base, options };
+  const owner = new Map;
+  for (const group of gatewayGroups)
+    for (const id of group.modelIds)
+      owner.set(id, group.id);
+  const native = options.filter((option) => !owner.has(option.value));
+  return {
+    ...base,
+    options: [
+      { groupId: "codex", name: "Codex", options: native },
+      ...gatewayGroups.map((group) => ({ groupId: group.id, name: group.name, options: options.filter((option) => owner.get(option.value) === group.id) }))
+    ]
   };
 }
 function effortConfigOption(efforts, current) {
@@ -25955,7 +25968,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.gatewayGroups),
     effortConfigOption(supportedEfforts(model), session.model.effort),
     collaborationModeConfigOption(session.collaborationMode)
   ];
@@ -26057,33 +26070,47 @@ 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";
+var GATEWAY_ID_PATTERN = /^[a-z0-9-]+$/;
 
 class ProviderRouting {
   baseConfig;
   configuredProvider;
-  gateway = null;
+  gateways = new Map;
   constructor(baseConfig, configuredProvider) {
     this.baseConfig = baseConfig;
     this.configuredProvider = configuredProvider;
   }
   copy() {
     const copy = new ProviderRouting(this.baseConfig, this.configuredProvider);
-    copy.gateway = this.gateway;
+    copy.gateways = new Map(this.gateways);
     return copy;
   }
   get active() {
-    return this.gateway;
+    return this.gateways.values().next().value ?? null;
+  }
+  gateway(id) {
+    return id === null ? null : this.gateways.get(id) ?? null;
+  }
+  hasGateway(id) {
+    return id !== null && this.gateways.has(id);
   }
   list() {
+    const first = this.active;
+    const routed = first !== null && first.mode === "route";
+    const summary = (gateway) => ({ id: gateway.id, name: gateway.name, baseUrl: gateway.baseUrl, models: gateway.models.map((model) => model.id) });
     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 && first ? { apiType: "openai", baseUrl: first.baseUrl } : { apiType: "openai", baseUrl: this.nativeBaseUrl() },
+        ...first && !routed ? { _meta: { codex: { mode: "catalog", gateway: summary(first), gateways: [...this.gateways.values()].map(summary) } } } : {}
       }]
     };
   }
@@ -26099,42 +26126,133 @@ class ProviderRouting {
       throw RequestError.invalidParams({ baseUrl: request.baseUrl }, "baseUrl must be an http(s) URL");
     }
     const hints = readHints(request._meta);
-    this.gateway = {
+    if (hints.id === OPENAI_PROVIDER_ID || hints.id === this.configuredProvider) {
+      throw RequestError.invalidParams({ id: hints.id }, `_meta.codex.id "${hints.id}" is Codex's own provider; pick another gateway id`);
+    }
+    if (hints.mode === "route" || this.mode !== hints.mode)
+      this.gateways.clear();
+    for (const other of this.gateways.values()) {
+      if (other.id === hints.id)
+        continue;
+      const duplicate = hints.models.find((model) => other.models.some((candidate) => candidate.id === model.id));
+      if (duplicate) {
+        throw RequestError.invalidParams({ id: hints.id, model: duplicate.id }, `Model "${duplicate.id}" is already served by gateway "${other.id}"; model ids must be unique across gateways`);
+      }
+    }
+    this.gateways.set(hints.id, {
+      id: hints.id,
       baseUrl,
       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.active?.mode ?? "route";
+  }
+  gatewayFor(modelId) {
+    for (const gateway of this.gateways.values()) {
+      if (gateway.models.some((model) => model.id === modelId))
+        return gateway;
+    }
+    return null;
+  }
+  gatewayIdFor(modelId) {
+    return this.gatewayFor(modelId)?.id ?? null;
+  }
+  isGatewayModel(modelId) {
+    return this.gatewayFor(modelId) !== null;
+  }
+  gatewayGroups() {
+    if (this.mode !== "catalog")
+      return [];
+    return [...this.gateways.values()].filter((gateway) => gateway.models.length > 0).map((gateway) => ({ id: gateway.id, name: gateway.name, modelIds: gateway.models.map((model) => model.id) }));
   }
   disable(request) {
-    if (request.providerId === OPENAI_PROVIDER_ID)
-      this.gateway = null;
+    if (request.providerId !== OPENAI_PROVIDER_ID)
+      return;
+    const id = readGatewayId(request._meta);
+    if (id === null)
+      this.gateways.clear();
+    else
+      this.gateways.delete(id);
   }
   modelProvider() {
-    return this.gateway ? GATEWAY_MODEL_PROVIDER : this.configuredProvider;
+    return this.defaultGatewayId() ?? this.configuredProvider;
+  }
+  routesByDefault() {
+    return this.defaultGatewayId() !== null;
   }
-  threadConfig() {
-    if (!this.gateway)
+  defaultGatewayId() {
+    const first = this.active;
+    return first !== null && first.mode === "route" ? first.id : null;
+  }
+  threadConfig(gatewayId = this.defaultGatewayId()) {
+    const gateway = this.gateway(gatewayId);
+    if (!gateway)
       return this.baseConfig;
-    const existing = isRecord2(this.baseConfig["model_providers"]) ? this.baseConfig["model_providers"] : {};
+    return this.applyGateway(this.baseConfig, gateway);
+  }
+  routeConfig(config2, gatewayId) {
+    return this.rebind(config2, this, gatewayId);
+  }
+  overrideKeys() {
+    const keys = new Set;
+    for (const gateway of this.gateways.values())
+      for (const key of Object.keys(gateway.config))
+        keys.add(key);
+    return [...keys];
+  }
+  rebind(config2, previous, gatewayId = this.defaultGatewayId()) {
+    const next = { ...config2 };
+    for (const key of previous.overrideKeys()) {
+      if (key in this.baseConfig)
+        next[key] = this.baseConfig[key];
+      else
+        delete next[key];
+    }
+    delete next["model_providers"];
+    if (isRecord2(this.baseConfig["model_providers"]))
+      next["model_providers"] = this.baseConfig["model_providers"];
+    const gateway = this.gateway(gatewayId);
+    return gateway ? this.applyGateway(next, gateway) : next;
+  }
+  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.id]: entry }
     };
   }
   catalog(codexCatalog) {
-    if (!this.gateway || this.gateway.models.length === 0)
+    const first = this.active;
+    if (first === null)
       return codexCatalog;
-    return this.gateway.models.map((model, index) => gatewayModel(model, index === 0, codexCatalog[0]));
+    if (first.mode === "route") {
+      if (first.models.length === 0)
+        return codexCatalog;
+      return first.models.map((model, index) => gatewayModel(model, index === 0, codexCatalog[0], first.catalogEntries.get(model.id)));
+    }
+    const own = [];
+    for (const gateway of this.gateways.values()) {
+      for (const model of gateway.models)
+        own.push(gatewayModel(model, false, codexCatalog[0], gateway.catalogEntries.get(model.id)));
+    }
+    return [...codexCatalog, ...own];
   }
   nativeBaseUrl() {
     const providers = this.baseConfig["model_providers"];
@@ -26151,6 +26269,7 @@ function readHints(meta) {
   const root = isRecord2(meta) ? meta : {};
   const alwith = isRecord2(root["alwith"]) ? root["alwith"] : {};
   const codex = isRecord2(root["codex"]) ? root["codex"] : {};
+  const id = readGatewayId(meta) ?? GATEWAY_MODEL_PROVIDER;
   const models = [];
   if (Array.isArray(alwith["models"])) {
     for (const entry of alwith["models"]) {
@@ -26165,22 +26284,91 @@ 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 { id, models, model, name, bearerToken, config: config2, mode, catalogEntries };
+}
+function readGatewayId(meta) {
+  const root = isRecord2(meta) ? meta : {};
+  const codex = isRecord2(root["codex"]) ? root["codex"] : {};
+  const raw = codex["id"];
+  if (raw === undefined)
+    return null;
+  if (typeof raw !== "string" || !GATEWAY_ID_PATTERN.test(raw)) {
+    throw RequestError.invalidParams({ id: raw }, "_meta.codex.id must match [a-z0-9-]+");
+  }
+  return raw;
+}
+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: [],
@@ -26287,6 +26475,12 @@ class CodexAgent {
       }
       if (notification.method === "account/updated")
         this.refreshAccounts().catch((error40) => logger.error("refreshing account failed", error40));
+      if (notification.method === "account/rateLimits/updated")
+        this.forward("_codex/rate_limits_updated", notification.params);
+      if (notification.method === "fuzzyFileSearch/sessionUpdated")
+        this.forward("_codex/fuzzy_file_search_updated", notification.params);
+      if (notification.method === "fuzzyFileSearch/sessionCompleted")
+        this.forward("_codex/fuzzy_file_search_completed", notification.params);
     });
     this.codex.disconnectSignal.addEventListener("abort", stopObserving, { once: true });
   }
@@ -26323,7 +26517,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, rename: true, account: true, fuzzyFileSearch: true } }
       },
       authMethods: authMethods(this.capabilities, this.env)
     };
@@ -26408,23 +26602,33 @@ 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 || this.providers.hasGateway(runtime.modelProvider) && candidate.gateway(runtime.modelProvider) !== this.providers.gateway(runtime.modelProvider));
+        const targets = new Map(moving.map((runtime) => {
+          if (candidate.active === null)
+            return [runtime, null];
+          if (candidate.mode === "route")
+            return [runtime, candidate.defaultGatewayId()];
+          return [runtime, candidate.hasGateway(runtime.modelProvider) ? runtime.modelProvider : null];
+        }));
+        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 target = targets.get(runtime) ?? null;
+          const config2 = candidate.rebind(runtime.config, this.providers, target);
+          const modelProvider = target ?? nativeProvider;
+          const keep = findModel(nextCatalog, runtime.session.model.model) && candidate.gatewayIdFor(runtime.session.model.model) === target;
+          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 +26640,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) ?? nativeProvider;
+            runtime.session.model = next.model;
+            runtime.stale = false;
+          }
+          runtime.session.catalog = nextCatalog;
+          runtime.session.gatewayGroups = candidate.gatewayGroups();
+          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 +26693,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 +26730,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 +26743,45 @@ class CodexAgent {
       this.assertUnsubscribeSettled(open2.request.sessionId);
     }
     const mcpServers = request.mcpServers ?? [];
+    const requestedModel = requestedModelOf(request._meta);
+    let gatewayId = this.providers.defaultGatewayId();
+    if (this.providers.active !== null && this.providers.mode === "catalog") {
+      if (requestedModel !== null)
+        gatewayId = this.providers.gatewayIdFor(requestedModel);
+      else if (open2.kind === "resume") {
+        const known = await this.withCodex(() => this.codex.threadRead({ threadId: open2.request.sessionId, includeTurns: false }));
+        gatewayId = this.providers.hasGateway(known.thread.modelProvider) ? known.thread.modelProvider : null;
+      }
+    }
+    const onGateway = gatewayId !== null;
     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(gatewayId), request.cwd, additionalDirectories, mcpServers, existingMcp);
     const mcpStartupGeneration = this.codex.mcpStartupGeneration;
-    const modelProvider = await this.withCodex(() => this.resolveModelProvider());
+    const modelProvider = gatewayId ?? await this.withCodex(() => this.resolveModelProvider());
+    const startModel = onGateway ? requestedModel ?? this.providers.gateway(gatewayId)?.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 +26809,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,
+        gatewayGroups: this.providers.gatewayGroups(),
         model,
         mode: initialAgentMode(this.env),
         collaborationMode: DEFAULT_COLLABORATION_MODE,
@@ -26599,7 +26830,7 @@ class CodexAgent {
         contextWindow: null,
         closed: false
       };
-      const runtime = this.installRuntime(session, capabilities, config2, thread.modelProvider);
+      const runtime = this.installRuntime(session, capabilities, config2, gatewayId ?? thread.modelProvider, readOnly);
       const cancelOpening = () => {
         runtime.session.closed = true;
         runtime.lifetime.abort();
@@ -26646,7 +26877,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 +26887,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);
@@ -26897,6 +27128,27 @@ class CodexAgent {
   notifySkillsChanged() {
     this.link.notify("_codex/skills_changed", {}).catch((error40) => logger.error("skills change notification failed", error40));
   }
+  forward(method, params) {
+    this.link.notify(method, params).catch((error40) => logger.error(`${method} notification failed`, error40));
+  }
+  async sessionRename(params) {
+    this.requireInitialized("_codex/session_rename");
+    await this.withCodex(() => this.codex.threadSetName({ threadId: params.sessionId, name: params.name }));
+    return {};
+  }
+  async accountRead() {
+    this.requireInitialized("_codex/account_read");
+    return await this.withCodex(() => this.codex.accountRead({ refreshToken: false }));
+  }
+  async rateLimits() {
+    this.requireInitialized("_codex/rate_limits");
+    return await this.withCodex(() => this.codex.accountRateLimitsRead());
+  }
+  async fuzzyFileSearch(params) {
+    this.requireInitialized("_codex/fuzzy_file_search");
+    const request = { query: params.query, roots: params.roots, cancellationToken: params.cancellationToken };
+    return await this.withCodex(() => this.codex.fuzzyFileSearch(request));
+  }
   async closeRuntime(sessionId) {
     const deadline = performance.now() + this.closeGraceMs;
     const runtime = this.sessions.get(sessionId);
@@ -26923,7 +27175,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 +27204,47 @@ 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 target = this.providers.gatewayIdFor(params.value);
+      const current = this.providers.hasGateway(runtime.modelProvider) ? runtime.modelProvider : null;
+      if (target !== current)
+        await this.rerouteSession(runtime, target, 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, gatewayId, 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, gatewayId);
+    const modelProvider = gatewayId ?? 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 ${gatewayId !== null ? `gateway "${gatewayId}"` : "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 +27260,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 +27559,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 +27593,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);
@@ -27407,6 +27696,28 @@ function interruptedTurn(threadId) {
     turn: { id: "", items: [], itemsView: "notLoaded", status: "interrupted", error: null, startedAt: null, completedAt: null, durationMs: null }
   };
 }
+function parseSessionRenameParams(raw) {
+  const params = objectParams()(raw);
+  if (typeof params.sessionId !== "string" || params.sessionId.length === 0) {
+    throw RequestError.invalidParams({ sessionId: params.sessionId }, "sessionId must be a non-empty string");
+  }
+  if (typeof params.name !== "string")
+    throw RequestError.invalidParams({ name: params.name }, "name must be a string");
+  return { sessionId: params.sessionId, name: params.name };
+}
+function parseFuzzyFileSearchParams(raw) {
+  const params = objectParams()(raw);
+  if (typeof params.query !== "string")
+    throw RequestError.invalidParams({ query: params.query }, "query must be a string");
+  if (!Array.isArray(params.roots) || !params.roots.every((root) => typeof root === "string")) {
+    throw RequestError.invalidParams({ roots: params.roots }, "roots must be an array of directory paths");
+  }
+  const token = params.cancellationToken;
+  if (token !== undefined && token !== null && typeof token !== "string") {
+    throw RequestError.invalidParams({ cancellationToken: token }, "cancellationToken must be a string when given");
+  }
+  return { query: params.query, roots: params.roots, cancellationToken: typeof token === "string" ? token : null };
+}
 function objectParams() {
   return (raw) => {
     if (raw === undefined || raw === null)
@@ -27428,6 +27739,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)
@@ -27474,7 +27813,7 @@ function createAgentApp(options) {
   };
   return agent({ name: options.info.name }).onConnect((connection) => {
     agent2 = new CodexAgent(connection.client, options);
-  }).onRequest(methods.agent.initialize, (ctx) => current().initialize(ctx.params)).onRequest(methods.agent.auth.login, (ctx) => current().login(ctx.params, ctx.requestId)).onRequest(methods.agent.auth.logout, (ctx) => current().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => current().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => current().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => current().disableProvider(ctx.params)).onRequest(methods.agent.session.new, (ctx) => current().newSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.resume, (ctx) => current().resumeSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.fork, (ctx) => current().forkSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.list, (ctx) => current().listSessions(ctx.params)).onRequest(methods.agent.session.close, (ctx) => current().closeSession(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => current().deleteSession(ctx.params)).onRequest("_codex/session_archive", { parse: parseSessionIdParams }, (ctx) => current().archiveSession(ctx.params)).onRequest("_codex/session_unarchive", { parse: parseSessionIdParams }, (ctx) => current().unarchiveSession(ctx.params)).onRequest("_codex/skills_list", { parse: objectParams() }, (ctx) => current().skillsList(ctx.params)).onRequest("_codex/skills_config_write", { parse: objectParams() }, (ctx) => current().skillsConfigWrite(ctx.params)).onRequest("_codex/plugin_list", { parse: objectParams() }, (ctx) => current().pluginList(ctx.params)).onRequest("_codex/plugin_installed", { parse: objectParams() }, (ctx) => current().pluginInstalled(ctx.params)).onRequest("_codex/plugin_install", { parse: objectParams() }, (ctx) => current().pluginInstall(ctx.params)).onRequest("_codex/plugin_uninstall", { parse: objectParams() }, (ctx) => current().pluginUninstall(ctx.params)).onRequest("_codex/plugin_read", { parse: objectParams() }, (ctx) => current().pluginRead(ctx.params)).onRequest("_codex/marketplace_add", { parse: objectParams() }, (ctx) => current().marketplaceAdd(ctx.params)).onRequest("_codex/marketplace_remove", { parse: objectParams() }, (ctx) => current().marketplaceRemove(ctx.params)).onRequest("_codex/marketplace_upgrade", { parse: objectParams() }, (ctx) => current().marketplaceUpgrade(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => current().setSessionConfigOption(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => current().prompt(ctx.params)).onNotification(methods.agent.session.cancel, (ctx) => current().cancel(ctx.params));
+  }).onRequest(methods.agent.initialize, (ctx) => current().initialize(ctx.params)).onRequest(methods.agent.auth.login, (ctx) => current().login(ctx.params, ctx.requestId)).onRequest(methods.agent.auth.logout, (ctx) => current().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => current().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => current().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => current().disableProvider(ctx.params)).onRequest(methods.agent.session.new, (ctx) => current().newSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.resume, (ctx) => current().resumeSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.fork, (ctx) => current().forkSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.list, (ctx) => current().listSessions(ctx.params)).onRequest(methods.agent.session.close, (ctx) => current().closeSession(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => current().deleteSession(ctx.params)).onRequest("_codex/session_archive", { parse: parseSessionIdParams }, (ctx) => current().archiveSession(ctx.params)).onRequest("_codex/session_unarchive", { parse: parseSessionIdParams }, (ctx) => current().unarchiveSession(ctx.params)).onRequest("_codex/skills_list", { parse: objectParams() }, (ctx) => current().skillsList(ctx.params)).onRequest("_codex/skills_config_write", { parse: objectParams() }, (ctx) => current().skillsConfigWrite(ctx.params)).onRequest("_codex/plugin_list", { parse: objectParams() }, (ctx) => current().pluginList(ctx.params)).onRequest("_codex/plugin_installed", { parse: objectParams() }, (ctx) => current().pluginInstalled(ctx.params)).onRequest("_codex/plugin_install", { parse: objectParams() }, (ctx) => current().pluginInstall(ctx.params)).onRequest("_codex/plugin_uninstall", { parse: objectParams() }, (ctx) => current().pluginUninstall(ctx.params)).onRequest("_codex/plugin_read", { parse: objectParams() }, (ctx) => current().pluginRead(ctx.params)).onRequest("_codex/marketplace_add", { parse: objectParams() }, (ctx) => current().marketplaceAdd(ctx.params)).onRequest("_codex/marketplace_remove", { parse: objectParams() }, (ctx) => current().marketplaceRemove(ctx.params)).onRequest("_codex/marketplace_upgrade", { parse: objectParams() }, (ctx) => current().marketplaceUpgrade(ctx.params)).onRequest("_codex/session_rename", { parse: parseSessionRenameParams }, (ctx) => current().sessionRename(ctx.params)).onRequest("_codex/account_read", { parse: objectParams() }, () => current().accountRead()).onRequest("_codex/rate_limits", { parse: objectParams() }, () => current().rateLimits()).onRequest("_codex/fuzzy_file_search", { parse: parseFuzzyFileSearchParams }, (ctx) => current().fuzzyFileSearch(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => current().setSessionConfigOption(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => current().prompt(ctx.params)).onNotification(methods.agent.session.cancel, (ctx) => current().cancel(ctx.params));
 }
 
 // src/codex/AppServerClient.ts
@@ -27887,6 +28226,15 @@ class AppServerClient {
   accountRead(params) {
     return this.send({ method: "account/read", params });
   }
+  accountRateLimitsRead() {
+    return this.send({ method: "account/rateLimits/read", params: undefined });
+  }
+  threadSetName(params) {
+    return this.send({ method: "thread/name/set", params });
+  }
+  fuzzyFileSearch(params) {
+    return this.send({ method: "fuzzyFileSearch", params });
+  }
   accountLogin(params) {
     return this.send({ method: "account/login/start", params });
   }
@@ -27922,7 +28270,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 +28563,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.6.0",
   "description": "Native ACP v2 agent for the OpenAI Codex app-server",
   "packageManager": "bun@1.4.0",
   "engines": {