@bitkyc08/opencodex 1.9.5 → 2.0.1

package/src/codex-catalog.ts

@@ -1,4 +1,4 @@
-import { copyFileSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { atomicWriteFile, websocketsEnabled } from "./config";
@@ -6,6 +6,7 @@ import { CODEX_CONFIG_PATH, CODEX_MODELS_CACHE_PATH, DEFAULT_CATALOG_PATH, readR
 import { DEFAULT_MODEL_CACHE_TTL_MS, getFreshCached, getStaleCached, setCached } from "./model-cache";
 import { buildModelsRequest, resolveModelsAuthToken } from "./oauth/index";
 import type { OcxConfig, OcxProviderConfig } from "./types";
+import { CODEX_REASONING_LEVELS, configuredReasoningEfforts, sanitizeCodexReasoningEfforts } from "./reasoning-effort";
 import { getJawcodeModelMetadata, getJawcodeModelMetadataCaseInsensitive, listJawcodeModelMetadata, resolveJawcodeProvider } from "./generated/jawcode-model-metadata";
 import { shouldCaseFoldMetadataModelId } from "./providers/derive";
 
@@ -33,10 +34,34 @@ export function nativeOpenAiSlugs(): string[] {
   return live.length > 0 ? live : NATIVE_OPENAI_MODELS;
 }
 
-export interface CatalogModel { id: string; provider: string; owned_by?: string; }
+export interface CatalogModel { id: string; provider: string; owned_by?: string; reasoningEfforts?: string[]; contextWindow?: number; inputModalities?: string[]; }
 type RawEntry = Record<string, unknown>;
 const JAWCODE_CATALOG_AUGMENT_PROVIDERS = new Set(["opencode-go"]);
 
+/**
+ * Image/video GENERATION model families. opencodex routes chat/coding models into Codex; media-
+ * generation models (Grok image/video, DALL·E, Imagen, Sora, Veo, …) are useless to a coding agent
+ * and must never surface in the dashboard, /v1/models, or the routed catalog. The metadata has no
+ * output-modality field, so we classify by id. Extend this list as providers add media models.
+ */
+const MEDIA_GEN_FAMILIES = [
+  "dall-e", "dalle", "imagen", "sora", "veo", "flux", "kling",
+  "seedance", "hailuo", "stable-diffusion", "sdxl", "midjourney",
+];
+const MEDIA_GEN_ID_RE = new RegExp(
+  `(?:^|[/_-])(?:image|video)(?:[/_-]|$)|(?:^|[/_-])(?:${MEDIA_GEN_FAMILIES.join("|")})(?:[/_-]|$|\\d)`,
+  "i",
+);
+
+/**
+ * True when a model id denotes image/video GENERATION (so it should be hidden everywhere). Vision
+ * *input* chat models — `grok-2-vision`, `qwen3-vl-*`, `gpt-4o`, `gemini-3-pro-preview` — are
+ * intentionally NOT matched: they carry no `image`/`video` id segment and no generation-family token.
+ */
+export function isMediaGenerationModelId(id: string): boolean {
+  return MEDIA_GEN_ID_RE.test(id);
+}
+
 /** Resolve the `model_catalog_json` path from Codex config.toml, else the default. */
 export function readCodexCatalogPath(): string {
   try {
@@ -171,19 +196,42 @@ export function loadCatalogTemplate(): RawEntry | null {
 }
 
 /**
- * The reasoning ladder advertised for routed models in Codex's picker: low → medium → high → xhigh.
- * This matches Codex's NATIVE catalog exactly — Codex's strict parser rejects an unknown effort like
- * `max`, so it must not be advertised here. (Previously routed models were clamped down to
- * low/medium/high, which dropped the `xhigh` that Codex does support.)
+ * Codex only accepts its native labels in the catalog. Provider-specific wire values (e.g. Z.AI
+ * `max`) are mapped at request time by src/reasoning-effort.ts, never advertised directly here.
  */
-const ROUTED_REASONING_LEVELS: { effort: string; description: string }[] = [
-  { effort: "low", description: "Fast responses with lighter reasoning" },
-  { effort: "medium", description: "Balances speed and reasoning depth" },
-  { effort: "high", description: "Greater reasoning depth for complex problems" },
-  { effort: "xhigh", description: "Extended reasoning for the hardest problems" },
-];
+const ROUTED_REASONING_LEVELS = CODEX_REASONING_LEVELS;
+
+function applyCatalogModelMetadata(entry: RawEntry, model?: CatalogModel): void {
+  if (!model) return;
+  if (typeof model.contextWindow === "number" && model.contextWindow > 0) {
+    entry.context_window = model.contextWindow;
+    entry.max_context_window = model.contextWindow;
+    entry.auto_compact_token_limit = Math.floor(model.contextWindow * 0.9);
+  }
+  if (Array.isArray(model.inputModalities) && model.inputModalities.length > 0) {
+    entry.input_modalities = model.inputModalities;
+  }
+}
+
+function applyReasoningLevels(entry: RawEntry, effortsOverride?: string[]): void {
+  const efforts = sanitizeCodexReasoningEfforts(effortsOverride) ?? ROUTED_REASONING_LEVELS.map(l => l.effort);
+  const byEffort = new Map(
+    (Array.isArray(entry.supported_reasoning_levels) ? entry.supported_reasoning_levels : [])
+      .map((l: { effort?: string }) => [l.effort, l]),
+  );
+  entry.supported_reasoning_levels = efforts.map(effort => {
+    const native = byEffort.get(effort);
+    if (native) return native;
+    return ROUTED_REASONING_LEVELS.find(l => l.effort === effort) ?? { effort, description: `${effort} reasoning` };
+  });
+  if (efforts.length === 0) {
+    delete entry.default_reasoning_level;
+    return;
+  }
+  entry.default_reasoning_level = efforts.includes("medium") ? "medium" : efforts.includes("high") ? "high" : efforts[0];
+}
 
-function deriveEntry(template: RawEntry | null, slug: string, desc: string, priority: number): RawEntry {
+function deriveEntry(template: RawEntry | null, slug: string, desc: string, priority: number, model?: CatalogModel): RawEntry {
   if (template) {
     const e = JSON.parse(JSON.stringify(template)) as RawEntry;
     e.slug = slug;
@@ -203,28 +251,24 @@ function deriveEntry(template: RawEntry | null, slug: string, desc: string, prio
           `You are a coding agent powered by the ${modelName} model, served through the opencodex proxy. Do not claim to be GPT-5 or made by OpenAI.`,
         );
       }
-      // Reuse the template's level objects where they exist (correct shape/fields), synthesize the rest.
-      const byEffort = new Map(
-        (Array.isArray(e.supported_reasoning_levels) ? e.supported_reasoning_levels : [])
-          .map((l: { effort?: string }) => [l.effort, l]),
-      );
-      e.supported_reasoning_levels = ROUTED_REASONING_LEVELS.map(l => byEffort.get(l.effort) ?? { ...l });
-      e.default_reasoning_level = "medium";
+      applyReasoningLevels(e, model?.reasoningEfforts);
       normalizeRoutedCatalogEntry(e);
       applyJawcodeCatalogMetadata(e, slug);
+      applyCatalogModelMetadata(e, model);
     }
     return ensureStrictCatalogFields(normalizeServiceTiers(e));
   }
   // Fallback when no template is available (best-effort; strict parser may need more).
   const entry: RawEntry = {
     slug, display_name: slug, description: desc,
-    default_reasoning_level: "medium",
-    supported_reasoning_levels: ROUTED_REASONING_LEVELS.map(l => ({ ...l })),
     shell_type: "shell_command", visibility: "list", supported_in_api: true,
     priority, base_instructions: "You are a helpful coding assistant.",
     ...(slug.includes("/") ? { web_search_tool_type: "text_and_image", supports_search_tool: true } : {}),
   };
+  if (slug.includes("/")) applyReasoningLevels(entry, model?.reasoningEfforts);
+  else applyReasoningLevels(entry);
   applyJawcodeCatalogMetadata(entry, slug);
+  applyCatalogModelMetadata(entry, model);
   return ensureStrictCatalogFields(normalizeServiceTiers(entry));
 }
 
@@ -247,7 +291,7 @@ export function buildCatalogEntries(template: RawEntry | null, gptSlugs: string[
   }
   for (const m of goModels) {
     const slug = `${m.provider}/${m.id}`;
-    const e = deriveEntry(template, slug, `Routed via opencodex → ${m.provider} (${m.owned_by ?? m.provider}).`, 5);
+    const e = deriveEntry(template, slug, `Routed via opencodex → ${m.provider} (${m.owned_by ?? m.provider}).`, 5, m);
     if (rank.has(slug)) e.priority = rank.get(slug)!;
     out.push(e);
   }
@@ -285,6 +329,61 @@ function readNativeBaseline(): Map<string, number> {
   return out;
 }
 
+
+type ProviderModelsApiItem = {
+  id: string;
+  owned_by?: string;
+  max_model_len?: number;
+  metadata?: {
+    capabilities?: Record<string, unknown>;
+    limits?: Record<string, unknown>;
+  };
+};
+
+function catalogHintsFromProviderConfig(name: string, prov: OcxProviderConfig, id: string): Partial<CatalogModel> {
+  void name;
+  const reasoningEfforts = configuredReasoningEfforts(prov, id);
+  return {
+    ...(reasoningEfforts !== undefined ? { reasoningEfforts } : {}),
+  };
+}
+
+function applyConfigHintsToCachedModels(name: string, prov: OcxProviderConfig, models: CatalogModel[]): CatalogModel[] {
+  return models.map(model => ({
+    ...catalogHintsFromProviderConfig(name, prov, model.id),
+    ...model,
+  }));
+}
+
+function isGlm52ModelId(id: string): boolean {
+  const normalized = id.toLowerCase();
+  return normalized === "glm-5.2" || normalized === "glm-5.2[1m]";
+}
+
+function catalogHintsFromModelsApiItem(providerName: string, item: ProviderModelsApiItem): Partial<CatalogModel> {
+  const capabilities = item.metadata?.capabilities;
+  const limits = item.metadata?.limits;
+  const contextWindow =
+    typeof limits?.max_context_length === "number" ? limits.max_context_length
+      : typeof item.max_model_len === "number" ? item.max_model_len
+        : undefined;
+  const reasoningEfforts = capabilities && typeof capabilities.reasoning_effort === "boolean"
+    ? (capabilities.reasoning_effort
+      ? ((providerName === "neuralwatt" || providerName === "zai") && isGlm52ModelId(item.id)
+        ? ["low", "medium", "high", "xhigh"]
+        : ["low", "medium", "high"])
+      : [])
+    : undefined;
+  const inputModalities = capabilities && typeof capabilities.vision === "boolean"
+    ? (capabilities.vision ? ["text", "image"] : ["text"])
+    : undefined;
+  return {
+    ...(contextWindow && contextWindow > 0 ? { contextWindow } : {}),
+    ...(reasoningEfforts !== undefined ? { reasoningEfforts } : {}),
+    ...(inputModalities ? { inputModalities } : {}),
+  };
+}
+
 /**
  * Fetch a provider's `/models` (openai-chat style) with a TTL cache + stale fallback. Skips
  * forward-auth providers. Fresh cache → no network; live fetch → cache the merged result;
@@ -296,21 +395,35 @@ async function fetchProviderModels(name: string, prov: OcxProviderConfig, ttlMs:
   const apiKey = await resolveModelsAuthToken(name, prov);
   if (prov.authMode === "oauth" && !apiKey) return []; // not logged in → skip
   const fresh = getFreshCached(name, ttlMs);
-  if (fresh) return fresh; // dedups Codex's frequent /v1/models polling within the TTL
-  const configured: CatalogModel[] = (prov.models ?? []).map(id => ({ id, provider: name }));
+  if (fresh) return applyConfigHintsToCachedModels(name, prov, fresh); // dedups Codex's frequent /v1/models polling within the TTL
+  const configured: CatalogModel[] = (prov.models ?? []).map(id => ({
+    id,
+    provider: name,
+    ...catalogHintsFromProviderConfig(name, prov, id),
+  }));
   const { url, headers } = buildModelsRequest(prov, apiKey);
   try {
     const res = await fetch(url, { headers, signal: AbortSignal.timeout(8000) });
-    if (!res.ok) return getStaleCached(name) ?? configured;
-    const json = await res.json() as { data?: { id: string; owned_by?: string }[] };
-    const live = (json.data ?? []).map(m => ({ id: m.id, provider: name, owned_by: m.owned_by }));
+    if (!res.ok) {
+      const stale = getStaleCached(name);
+      return stale ? applyConfigHintsToCachedModels(name, prov, stale) : configured;
+    }
+    const json = await res.json() as { data?: ProviderModelsApiItem[] };
+    const live = (json.data ?? []).map(m => ({
+      id: m.id,
+      provider: name,
+      owned_by: m.owned_by,
+      ...catalogHintsFromProviderConfig(name, prov, m.id),
+      ...catalogHintsFromModelsApiItem(name, m),
+    }));
     const liveIds = new Set(live.map(m => m.id));
     // Merge explicit config additions (e.g. a model not in the provider's /models, like a new endpoint).
     const merged = [...live, ...configured.filter(m => !liveIds.has(m.id))];
     setCached(name, merged);
     return merged;
   } catch {
-    return getStaleCached(name) ?? configured;
+    const stale = getStaleCached(name);
+    return stale ? applyConfigHintsToCachedModels(name, prov, stale) : configured;
   }
 }
 
@@ -325,12 +438,15 @@ export async function gatherRoutedModels(config: OcxConfig): Promise<CatalogMode
   const lists = await Promise.all(
     Object.entries(config.providers).map(([name, prov]) => fetchProviderModels(name, prov, ttlMs)),
   );
-  const all = augmentRoutedModelsWithJawcodeMetadata(lists.flat(), Object.keys(config.providers));
+  const all = augmentRoutedModelsWithJawcodeMetadata(lists.flat(), Object.keys(config.providers), config.providers)
+    // Drop image/video generation models (e.g. Grok image/video) — they are not usable by Codex and
+    // must not surface in the dashboard, /v1/models, or the routed catalog. Single choke point.
+    .filter(m => !isMediaGenerationModelId(m.id));
   all.sort((a, b) => (a.provider === b.provider ? a.id.localeCompare(b.id) : a.provider.localeCompare(b.provider)));
   return all;
 }
 
-export function augmentRoutedModelsWithJawcodeMetadata(models: CatalogModel[], providerNames: string[]): CatalogModel[] {
+export function augmentRoutedModelsWithJawcodeMetadata(models: CatalogModel[], providerNames: string[], providers?: Record<string, OcxProviderConfig>): CatalogModel[] {
   const out = [...models];
   const seen = new Set(out.map(m => `${m.provider}/${m.id}`));
   for (const provider of providerNames) {
@@ -341,7 +457,7 @@ export function augmentRoutedModelsWithJawcodeMetadata(models: CatalogModel[], p
       const key = `${provider}/${meta.id}`;
       if (seen.has(key)) continue;
       seen.add(key);
-      out.push({ provider, id: meta.id, owned_by: provider });
+      out.push({ provider, id: meta.id, owned_by: provider, ...(providers?.[provider] ? catalogHintsFromProviderConfig(provider, providers[provider], meta.id) : {}) });
     }
   }
   return out;
@@ -444,12 +560,15 @@ export function restoreCodexCatalog(): { removed: number; kept: number; path: st
 }
 
 /**
- * Delete Codex's models cache ($CODEX_HOME/models_cache.json) so the next turn re-fetches /v1/models.
- * Codex caches the model list for 5 min (DEFAULT_MODEL_CACHE_TTL); invalidating makes catalog edits
- * (enable/disable, subagent reorder) apply on the next turn instead of waiting for the TTL.
+ * Refresh Codex's models cache ($CODEX_HOME/models_cache.json) from the active catalog.
+ * Codex caches the model list for 5 min (DEFAULT_MODEL_CACHE_TTL); copying the injected catalog
+ * makes catalog edits (enable/disable, subagent reorder) apply on the next turn instead of waiting.
  */
 export function invalidateCodexModelsCache(): void {
   try {
-    if (existsSync(CODEX_MODELS_CACHE_PATH)) unlinkSync(CODEX_MODELS_CACHE_PATH);
+    const catalogPath = readCodexCatalogPath();
+    if (!existsSync(catalogPath)) return;
+    const catalog = readFileSync(catalogPath, "utf8");
+    atomicWriteFile(CODEX_MODELS_CACHE_PATH, catalog.endsWith("\n") ? catalog : `${catalog}\n`);
   } catch { /* best-effort */ }
 }

package/src/codex-refresh.ts

@@ -0,0 +1,49 @@
+import { existsSync, readFileSync } from "node:fs";
+import { invalidateCodexModelsCache, syncCatalogModels } from "./codex-catalog";
+import { CODEX_MODELS_CACHE_PATH } from "./codex-paths";
+import { atomicWriteFile } from "./config";
+import type { OcxConfig } from "./types";
+
+export interface CodexCatalogRefreshResult {
+  added: number;
+  path: string;
+  catalogExists: boolean;
+  cacheSynced: boolean;
+}
+
+interface RefreshDeps {
+  syncCatalogModels: typeof syncCatalogModels;
+  invalidateCodexModelsCache: typeof invalidateCodexModelsCache;
+  syncCodexModelsCacheFromCatalog: typeof syncCodexModelsCacheFromCatalog;
+  existsSync: typeof existsSync;
+}
+
+const defaultDeps: RefreshDeps = {
+  syncCatalogModels,
+  invalidateCodexModelsCache,
+  syncCodexModelsCacheFromCatalog,
+  existsSync,
+};
+
+export function syncCodexModelsCacheFromCatalog(catalogPath: string): void {
+  const content = readFileSync(catalogPath, "utf8");
+  atomicWriteFile(CODEX_MODELS_CACHE_PATH, content);
+}
+
+/**
+ * Rebuild Codex's on-disk model catalog and keep Codex's models cache aligned
+ * when a catalog file exists. Codex Desktop can read models_cache.json directly,
+ * so deleting a stale cache is not enough: the cache must be replaced with the
+ * same catalog content the CLI debug path reads.
+ */
+export async function refreshCodexModelCatalog(
+  config: OcxConfig,
+  deps: RefreshDeps = defaultDeps,
+): Promise<CodexCatalogRefreshResult> {
+  const result = await deps.syncCatalogModels(config);
+  const catalogExists = deps.existsSync(result.path);
+  if (!catalogExists) return { ...result, catalogExists, cacheSynced: false };
+  deps.invalidateCodexModelsCache();
+  deps.syncCodexModelsCacheFromCatalog(result.path);
+  return { ...result, catalogExists, cacheSynced: true };
+}

package/src/codex-shim.ts

@@ -0,0 +1,145 @@
+import { delimiter, dirname, extname, join } from "node:path";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { getConfigDir } from "./config";
+
+const SHIM_MARKER = "opencodex codex autostart shim";
+const STATE_PATH = join(getConfigDir(), "codex-shim.json");
+
+interface ShimState {
+  platform: NodeJS.Platform;
+  wrapperPath: string;
+  originalPath: string;
+  backupPath: string;
+}
+
+function cliEntry(): { bun: string; cli: string } {
+  return { bun: process.execPath, cli: join(import.meta.dir, "cli.ts") };
+}
+
+function commandNames(name: string): string[] {
+  if (process.platform !== "win32") return [name];
+  const exts = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD;.PS1").split(";").filter(Boolean);
+  return [name, ...exts.flatMap(ext => [`${name}${ext.toLowerCase()}`, `${name}${ext.toUpperCase()}`])];
+}
+
+function isShim(path: string): boolean {
+  try {
+    return readFileSync(path, "utf8").includes(SHIM_MARKER);
+  } catch {
+    return false;
+  }
+}
+
+function findCodexOnPath(): string | null {
+  for (const dir of (process.env.PATH ?? "").split(delimiter).filter(Boolean)) {
+    for (const name of commandNames("codex")) {
+      const path = join(dir, name);
+      if (!existsSync(path) || isShim(path)) continue;
+      try {
+        if (!lstatSync(path).isDirectory()) return path;
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+
+function backupPathFor(path: string): string {
+  const ext = extname(path);
+  return ext ? `${path.slice(0, -ext.length)}.opencodex-real${ext}` : `${path}.opencodex-real`;
+}
+
+export function buildUnixCodexShim(realCodexPath: string, bunPath: string, cliPath: string): string {
+  return `#!/usr/bin/env sh
+# ${SHIM_MARKER}
+if [ -z "$OCX_SHIM_BYPASS" ]; then
+  if ! "${bunPath}" "${cliPath}" status 2>/dev/null | grep -q "Proxy running"; then
+    mkdir -p "$HOME/.opencodex"
+    nohup env OCX_SERVICE=1 "${bunPath}" "${cliPath}" start >> "$HOME/.opencodex/shim.log" 2>&1 &
+    i=0
+    while [ "$i" -lt 50 ]; do
+      if "${bunPath}" "${cliPath}" status 2>/dev/null | grep -q "Proxy running"; then
+        break
+      fi
+      sleep 0.1
+      i=$((i + 1))
+    done
+  fi
+fi
+exec "${realCodexPath}" "$@"
+`;
+}
+
+export function buildWindowsCodexShim(realCodexPath: string, bunPath: string, cliPath: string): string {
+  return `@echo off\r
+rem ${SHIM_MARKER}\r
+if not "%OCX_SHIM_BYPASS%"=="" goto run_codex\r
+"${bunPath}" "${cliPath}" status 2>nul | findstr /C:"Proxy running" >nul\r
+if %ERRORLEVEL% EQU 0 goto run_codex\r
+if not exist "%USERPROFILE%\\.opencodex" mkdir "%USERPROFILE%\\.opencodex"\r
+start "" /b cmd /c "set OCX_SERVICE=1 && ""${bunPath}"" ""${cliPath}"" start >> ""%USERPROFILE%\\.opencodex\\shim.log"" 2>&1"\r
+for /l %%i in (1,1,50) do (\r
+  "${bunPath}" "${cliPath}" status 2>nul | findstr /C:"Proxy running" >nul\r
+  if not errorlevel 1 goto run_codex\r
+  powershell -NoProfile -Command "Start-Sleep -Milliseconds 100" >nul 2>nul\r
+)\r
+:run_codex\r
+"${realCodexPath}" %*\r
+`;
+}
+
+function readState(): ShimState | null {
+  try {
+    return JSON.parse(readFileSync(STATE_PATH, "utf8")) as ShimState;
+  } catch {
+    return null;
+  }
+}
+
+function writeState(state: ShimState): void {
+  if (!existsSync(getConfigDir())) mkdirSync(getConfigDir(), { recursive: true });
+  writeFileSync(STATE_PATH, JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+
+export function installCodexShim(): { installed: boolean; message: string } {
+  const existing = readState();
+  if (existing && existsSync(existing.wrapperPath) && existsSync(existing.backupPath)) {
+    return { installed: false, message: `Codex autostart shim already installed at ${existing.wrapperPath}.` };
+  }
+
+  const originalPath = findCodexOnPath();
+  if (!originalPath) return { installed: false, message: "Could not find a codex executable on PATH." };
+
+  const backupPath = backupPathFor(originalPath);
+  if (existsSync(backupPath)) return { installed: false, message: `Refusing to overwrite existing backup: ${backupPath}` };
+
+  const { bun, cli } = cliEntry();
+  const wrapperPath = process.platform === "win32" ? join(dirname(originalPath), "codex.cmd") : originalPath;
+  renameSync(originalPath, backupPath);
+  if (process.platform === "win32") {
+    writeFileSync(wrapperPath, buildWindowsCodexShim(backupPath, bun, cli), "utf8");
+  } else {
+    writeFileSync(wrapperPath, buildUnixCodexShim(backupPath, bun, cli), "utf8");
+    chmodSync(wrapperPath, 0o755);
+  }
+  writeState({ platform: process.platform, wrapperPath, originalPath, backupPath });
+  return { installed: true, message: `Codex autostart shim installed at ${wrapperPath}. Original saved at ${backupPath}.` };
+}
+
+export function uninstallCodexShim(): { removed: boolean; message: string } {
+  const state = readState();
+  if (!state) return { removed: false, message: "Codex autostart shim is not installed." };
+  if (existsSync(state.wrapperPath) && isShim(state.wrapperPath)) unlinkSync(state.wrapperPath);
+  if (existsSync(state.backupPath) && !existsSync(state.originalPath)) renameSync(state.backupPath, state.originalPath);
+  if (existsSync(STATE_PATH)) unlinkSync(STATE_PATH);
+  return { removed: true, message: `Codex autostart shim removed. Restored ${state.originalPath}.` };
+}
+
+export function codexShimStatus(): string {
+  const state = readState();
+  if (!state) return "Codex autostart shim is not installed.";
+  const wrapper = existsSync(state.wrapperPath) ? "present" : "missing";
+  const backup = existsSync(state.backupPath) ? "present" : "missing";
+  return `Codex autostart shim: wrapper ${wrapper} at ${state.wrapperPath}; original backup ${backup} at ${state.backupPath}.`;
+}

package/src/config.ts

@@ -3,12 +3,13 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import type { OcxConfig } from "./types";
 
+let _atomicSeq = 0;
 /**
  * Write a file atomically (temp + rename) so concurrent writers — e.g. `ocx stop` and the
  * proxy's own shutdown handler both restoring Codex — can never leave a half-written file.
  */
 export function atomicWriteFile(path: string, content: string): void {
-  const tmp = `${path}.ocx.tmp`;
+  const tmp = `${path}.ocx.${process.pid}.${++_atomicSeq}.tmp`;
   writeFileSync(tmp, content, "utf-8");
   renameSync(tmp, path);
 }

package/src/oauth/index.ts

@@ -121,24 +121,40 @@ export function buildModelsRequest(prov: OcxProviderConfig, apiKey: string | und
  * Only touches providers that are registry-managed AND still `authMode: "oauth"`, and only the
  * preset fields (never apiKey/baseUrl/user toggles). Persists + returns true when anything changed.
  */
+function cloneProviderField(value: unknown): unknown {
+  if (Array.isArray(value)) return [...value];
+  if (value && typeof value === "object") return JSON.parse(JSON.stringify(value));
+  return value;
+}
+
+const OAUTH_RECONCILE_FIELDS: (keyof OcxProviderConfig)[] = [
+  "models",
+  "noReasoningModels",
+  "noVisionModels",
+  "reasoningEfforts",
+  "modelReasoningEfforts",
+  "reasoningEffortMap",
+  "modelReasoningEffortMap",
+  "noTemperatureModels",
+  "noTopPModels",
+  "noPenaltyModels",
+  "autoToolChoiceOnlyModels",
+  "preserveReasoningContentModels",
+];
+
 export function reconcileOAuthProviders(config: OcxConfig): boolean {
   let changed = false;
   for (const [name, prov] of Object.entries(config.providers)) {
     const def = OAUTH_PROVIDERS[name];
     if (!def || prov.authMode !== "oauth") continue;
     const preset = def.providerConfig;
-    if (preset.models && JSON.stringify(prov.models) !== JSON.stringify(preset.models)) {
-      prov.models = [...preset.models];
-      changed = true;
-    }
-    if (JSON.stringify(prov.noReasoningModels) !== JSON.stringify(preset.noReasoningModels)) {
-      if (preset.noReasoningModels) prov.noReasoningModels = [...preset.noReasoningModels];
-      else delete prov.noReasoningModels;
-      changed = true;
-    }
-    if (JSON.stringify(prov.noVisionModels) !== JSON.stringify(preset.noVisionModels)) {
-      if (preset.noVisionModels) prov.noVisionModels = [...preset.noVisionModels];
-      else delete prov.noVisionModels;
+    for (const field of OAUTH_RECONCILE_FIELDS) {
+      if (JSON.stringify(prov[field]) === JSON.stringify(preset[field])) continue;
+      if (preset[field] !== undefined) {
+        prov[field] = cloneProviderField(preset[field]) as never;
+      } else {
+        delete prov[field];
+      }
       changed = true;
     }
     // Heal a defaultModel that no longer exists in the refreshed list (e.g. a deprecated snapshot).

package/src/oauth/key-providers.ts

@@ -20,8 +20,17 @@ export interface KeyLoginProvider {
    * accept a reasoning param. Copied into the created provider config by `enrichProviderFromCatalog`,
    * so the classification actually gates the sidecars (matching is tolerant of an Ollama ":size" tag).
    */
+  reasoningEfforts?: string[];
+  modelReasoningEfforts?: Record<string, string[]>;
+  reasoningEffortMap?: Record<string, string>;
+  modelReasoningEffortMap?: Record<string, Record<string, string>>;
   noVisionModels?: string[];
   noReasoningModels?: string[];
+  noTemperatureModels?: string[];
+  noTopPModels?: string[];
+  noPenaltyModels?: string[];
+  autoToolChoiceOnlyModels?: string[];
+  preserveReasoningContentModels?: string[];
 }
 
 export const KEY_LOGIN_PROVIDERS: Record<string, KeyLoginProvider> = deriveKeyLoginMap();
@@ -37,8 +46,26 @@ export function enrichProviderFromCatalog(name: string, prov: OcxProviderConfig)
   if (!e) return;
   if (!prov.models && e.models) prov.models = [...e.models];
   if (!prov.defaultModel && e.defaultModel) prov.defaultModel = e.defaultModel;
+  if (!prov.reasoningEfforts && e.reasoningEfforts) prov.reasoningEfforts = [...e.reasoningEfforts];
+  if (!prov.modelReasoningEfforts && e.modelReasoningEfforts) prov.modelReasoningEfforts = cloneRecordOfArrays(e.modelReasoningEfforts);
+  if (!prov.reasoningEffortMap && e.reasoningEffortMap) prov.reasoningEffortMap = { ...e.reasoningEffortMap };
+  if (!prov.modelReasoningEffortMap && e.modelReasoningEffortMap) prov.modelReasoningEffortMap = cloneNestedRecord(e.modelReasoningEffortMap);
   if (!prov.noVisionModels && e.noVisionModels) prov.noVisionModels = [...e.noVisionModels];
   if (!prov.noReasoningModels && e.noReasoningModels) prov.noReasoningModels = [...e.noReasoningModels];
+  if (!prov.noTemperatureModels && e.noTemperatureModels) prov.noTemperatureModels = [...e.noTemperatureModels];
+  if (!prov.noTopPModels && e.noTopPModels) prov.noTopPModels = [...e.noTopPModels];
+  if (!prov.noPenaltyModels && e.noPenaltyModels) prov.noPenaltyModels = [...e.noPenaltyModels];
+  if (!prov.autoToolChoiceOnlyModels && e.autoToolChoiceOnlyModels) prov.autoToolChoiceOnlyModels = [...e.autoToolChoiceOnlyModels];
+  if (!prov.preserveReasoningContentModels && e.preserveReasoningContentModels) prov.preserveReasoningContentModels = [...e.preserveReasoningContentModels];
+}
+
+
+function cloneRecordOfArrays(input: Record<string, string[]>): Record<string, string[]> {
+  return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, [...value]]));
+}
+
+function cloneNestedRecord(input: Record<string, Record<string, string>>): Record<string, Record<string, string>> {
+  return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, { ...value }]));
 }
 
 export function isKeyLoginProvider(name: string): boolean {