@koreanhole/opencodex 2.98.0 → 3.0.0

package/src/lib/codex-inject.ts

@@ -0,0 +1,467 @@
+import { createHash } from "node:crypto";
+import { chmod, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { getConfigDir, isLoopbackHost, type RuntimeConfig } from "../config";
+import {
+  codexHome,
+  removeManagedCodexCatalogRows,
+  resolveCodexCatalogPath,
+} from "./codex-catalog";
+
+const JOURNAL_VERSION = 1;
+const MANAGED_MARKER = "# Managed by opencodex: provider routing";
+const LOCK_STALE_MS = 30_000;
+
+export class CodexInjectionError extends Error {
+  constructor(message: string, readonly code: string) {
+    super(message);
+    this.name = "CodexInjectionError";
+  }
+}
+
+export interface CodexInjectionEndpoint {
+  host: string;
+  port: number;
+}
+
+export interface CodexInjectionResult {
+  success: boolean;
+  action: "inject" | "restore" | "restore-back";
+  changed: boolean;
+  config: { state: "ok" | "skipped" | "failed"; changed: boolean; message: string };
+  catalog: { state: "ok" | "skipped" | "failed"; changed: boolean; removed: number; message: string };
+}
+
+interface CodexJournal {
+  version: 1;
+  codexHome: string;
+  configPath: string;
+  originalConfigBase64: string | null;
+  injectedConfigHash: string;
+  catalogPath: string | null;
+  originalCatalogBase64: string | null;
+  managedCatalogHash: string | null;
+  createdAt: string;
+}
+
+interface MaybeFile {
+  exists: boolean;
+  bytes: Buffer | null;
+}
+
+function configPath(env: NodeJS.ProcessEnv): string {
+  return join(codexHome(env), "config.toml");
+}
+
+function journalPath(env: NodeJS.ProcessEnv): string {
+  return join(getConfigDir(env), "codex", "inject-journal.json");
+}
+
+function lockPath(env: NodeJS.ProcessEnv): string {
+  return join(getConfigDir(env), "codex", "inject.lock");
+}
+
+function hash(bytes: string | Buffer): string {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+
+function b64(bytes: Buffer | null): string | null {
+  return bytes ? bytes.toString("base64") : null;
+}
+
+function unb64(value: string | null): Buffer | null {
+  return value ? Buffer.from(value, "base64") : null;
+}
+
+async function readMaybe(path: string): Promise<MaybeFile> {
+  try {
+    return { exists: true, bytes: await readFile(path) };
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return { exists: false, bytes: null };
+    throw error;
+  }
+}
+
+async function writeAtomic(path: string, bytes: string | Buffer, mode = 0o600): Promise<void> {
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  const temporary = `${path}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, bytes, { mode, flag: "wx" });
+    await chmod(temporary, mode);
+    await rename(temporary, path);
+    await chmod(path, mode).catch(() => undefined);
+  } finally {
+    await rm(temporary, { force: true }).catch(() => undefined);
+  }
+}
+
+function alive(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+async function withLock<T>(env: NodeJS.ProcessEnv, fn: () => Promise<T>): Promise<T> {
+  const path = lockPath(env);
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  const acquire = async (): Promise<boolean> => {
+    try {
+      await writeFile(path, JSON.stringify({ pid: process.pid, at: Date.now() }), { mode: 0o600, flag: "wx" });
+      return true;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+      let stale = false;
+      try {
+        const info = await stat(path);
+        let pid = 0;
+        try { pid = (JSON.parse(await readFile(path, "utf8")) as { pid?: number }).pid ?? 0; } catch { /* malformed */ }
+        stale = Date.now() - info.mtimeMs > LOCK_STALE_MS || (pid > 0 && !alive(pid));
+      } catch {
+        stale = true;
+      }
+      if (stale) {
+        await rm(path, { force: true }).catch(() => undefined);
+        return await acquire();
+      }
+      return false;
+    }
+  };
+  if (!await acquire()) throw new CodexInjectionError("Another Codex configuration change is in progress; retry after it finishes.", "codex_config_busy");
+  try {
+    return await fn();
+  } finally {
+    await rm(path, { force: true }).catch(() => undefined);
+  }
+}
+
+function isProviderHeader(line: string): boolean {
+  return /^\s*\[\s*model_providers\.opencodex(?:\s*\.|\s*\])/.test(line);
+}
+
+function isTableHeader(line: string): boolean {
+  return /^\s*\[/.test(line);
+}
+
+function rootEnd(lines: readonly string[]): number {
+  const index = lines.findIndex(isTableHeader);
+  return index < 0 ? lines.length : index;
+}
+
+function rootValue(text: string, key: string): string | undefined {
+  const lines = text.split(/\r?\n/);
+  const end = rootEnd(lines);
+  const re = new RegExp(`^\\s*${key}\\s*=\\s*"([^"]*)"`, "m");
+  for (let index = 0; index < end; index++) {
+    const match = re.exec(lines[index]!);
+    if (match) return match[1] ?? "";
+  }
+  return undefined;
+}
+
+function setRootValue(text: string, key: string, value: string | undefined): string {
+  const lines = text.split(/\r?\n/);
+  let end = rootEnd(lines);
+  let found = false;
+  const re = new RegExp(`^\\s*${key}\\s*=`);
+  for (let index = 0; index < end; index++) {
+    if (!re.test(lines[index]!)) continue;
+    found = true;
+    if (value === undefined) {
+      lines.splice(index, 1);
+      end -= 1;
+    } else {
+      lines[index] = `${key} = ${JSON.stringify(value)}`;
+    }
+    break;
+  }
+  if (!found && value !== undefined) {
+    lines.splice(end, 0, `${key} = ${JSON.stringify(value)}`);
+    end += 1;
+  }
+  return lines.join("\n");
+}
+
+function hasUnmarkedProviderTable(text: string): boolean {
+  const lines = text.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index++) {
+    if (!isProviderHeader(lines[index]!)) continue;
+    let previous = index - 1;
+    while (previous >= 0 && lines[previous]!.trim() === "") previous--;
+    if (lines[previous]?.trim() !== MANAGED_MARKER) return true;
+  }
+  return false;
+}
+
+function stripProviderTables(text: string): string {
+  const lines = text.split(/\r?\n/);
+  const out: string[] = [];
+  let skipping = false;
+  for (const line of lines) {
+    if (isTableHeader(line)) {
+      if (isProviderHeader(line)) {
+        skipping = true;
+        while (out.length > 0 && out[out.length - 1]!.trim() === MANAGED_MARKER) out.pop();
+        continue;
+      }
+      skipping = false;
+    }
+    if (skipping) continue;
+    if (line.trim() === MANAGED_MARKER) continue;
+    out.push(line);
+  }
+  return out.join("\n");
+}
+
+function providerBlock(endpoint: CodexInjectionEndpoint): string {
+  const base = `http://${endpoint.host}:${endpoint.port}/v1`;
+  return [
+    MANAGED_MARKER,
+    "[model_providers.opencodex]",
+    'name = "opencodex (Cline or Gemini CLI)"',
+    `base_url = ${JSON.stringify(base)}`,
+    'wire_api = "responses"',
+    "requires_openai_auth = false",
+    `model_catalog_url = ${JSON.stringify(`${base}/model-catalog`)}`,
+  ].join("\n");
+}
+
+function routedModel(original: string, config: RuntimeConfig): string {
+  const current = rootValue(original, "model");
+  if (current?.startsWith("cline-cli/") || current?.startsWith("gemini-cli/")) return current;
+  return `${config.defaultProvider}/${config.providers[config.defaultProvider].defaultModel}`;
+}
+
+function injectedConfig(text: string, endpoint: CodexInjectionEndpoint, config: RuntimeConfig): string {
+  if (hasUnmarkedProviderTable(text)) {
+    throw new CodexInjectionError(
+      "Codex config already defines a different [model_providers.opencodex] table; refusing to overwrite it.",
+      "codex_provider_conflict",
+    );
+  }
+  let next = stripProviderTables(text);
+  next = setRootValue(next, "model_provider", "opencodex");
+  next = setRootValue(next, "model", routedModel(text, config));
+  const body = next.trimEnd();
+  return `${body}${body ? "\n\n" : ""}${providerBlock(endpoint)}\n`;
+}
+
+function restoreRoots(current: string, original: string | null): string {
+  let next = stripProviderTables(current);
+  for (const key of ["model_provider", "model"] as const) {
+    next = setRootValue(next, key, original === null ? undefined : rootValue(original, key));
+  }
+  return next;
+}
+
+async function readJournal(env: NodeJS.ProcessEnv): Promise<CodexJournal | null> {
+  let raw: string;
+  try {
+    raw = await readFile(journalPath(env), "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
+    throw error;
+  }
+  let parsed: Partial<CodexJournal>;
+  try {
+    parsed = JSON.parse(raw) as Partial<CodexJournal>;
+  } catch {
+    throw new CodexInjectionError("The Codex restore journal is malformed; it was preserved.", "codex_journal_malformed");
+  }
+  if (parsed.version !== JOURNAL_VERSION || typeof parsed.configPath !== "string" || typeof parsed.injectedConfigHash !== "string") {
+    throw new CodexInjectionError("The Codex restore journal is invalid; it was preserved.", "codex_journal_invalid");
+  }
+  return parsed as CodexJournal;
+}
+
+async function writeJournal(env: NodeJS.ProcessEnv, journal: CodexJournal): Promise<void> {
+  await writeAtomic(journalPath(env), `${JSON.stringify(journal, null, 2)}\n`);
+}
+
+function endpointError(endpoint: CodexInjectionEndpoint): void {
+  if (!Number.isInteger(endpoint.port) || endpoint.port < 1 || endpoint.port > 65_535) {
+    throw new CodexInjectionError("The Codex proxy endpoint port is invalid.", "codex_endpoint_invalid");
+  }
+  if (!isLoopbackHost(endpoint.host)) {
+    throw new CodexInjectionError("Codex injection requires a loopback proxy endpoint.", "codex_endpoint_non_loopback");
+  }
+}
+
+function validateToml(text: string): void {
+  if (!text.trim()) return;
+  try {
+    Bun.TOML.parse(text);
+  } catch {
+    throw new CodexInjectionError("Codex config is not valid TOML; it was preserved.", "codex_config_malformed");
+  }
+}
+
+/** Inject routing and persist the pre-image before touching Codex config. */
+export async function injectCodexConfig(options: {
+  env: NodeJS.ProcessEnv;
+  endpoint: CodexInjectionEndpoint;
+  config: RuntimeConfig;
+}): Promise<CodexInjectionResult> {
+  endpointError(options.endpoint);
+  return await withLock(options.env, async () => {
+    const path = configPath(options.env);
+    const current = await readMaybe(path);
+    if (current.exists) validateToml(current.bytes!.toString("utf8"));
+    const existing = await readJournal(options.env);
+    const originalConfig = existing ? unb64(existing.originalConfigBase64) : current.bytes;
+    const originalCatalog = existing ? unb64(existing.originalCatalogBase64) : null;
+    const catalogPath = existing?.catalogPath ?? await resolveCodexCatalogPath(options.env) ?? null;
+    const catalog = catalogPath ? await readMaybe(catalogPath) : { exists: false, bytes: null };
+    const before = current.bytes?.toString("utf8") ?? "";
+    if (existing && !hasManagedProvider(before)) {
+      throw new CodexInjectionError(
+        "A Codex restore journal exists but Codex routing is already native; run `ocx restore` before starting again.",
+        "codex_journal_state_conflict",
+      );
+    }
+    const next = injectedConfig(before, options.endpoint, options.config);
+    const journal: CodexJournal = {
+      version: JOURNAL_VERSION,
+      codexHome: codexHome(options.env),
+      configPath: path,
+      originalConfigBase64: b64(originalConfig),
+      injectedConfigHash: hash(next),
+      catalogPath: existing?.catalogPath ?? catalogPath,
+      originalCatalogBase64: existing ? existing.originalCatalogBase64 : b64(catalog.bytes),
+      managedCatalogHash: existing?.managedCatalogHash ?? null,
+      createdAt: existing?.createdAt ?? new Date().toISOString(),
+    };
+    await writeJournal(options.env, journal);
+    try {
+      await writeAtomic(path, next);
+    } catch (error) {
+      if (!existing) await rm(journalPath(options.env), { force: true }).catch(() => undefined);
+      throw error;
+    }
+    return {
+      success: true,
+      action: "inject",
+      changed: true,
+      config: { state: "ok", changed: true, message: "Codex routing is pointed at the local proxy." },
+      catalog: { state: "ok", changed: false, removed: 0, message: originalCatalog ? "Original catalog is journaled." : "Catalog state is journaled." },
+    };
+  });
+}
+
+function hasManagedProvider(text: string): boolean {
+  return text.includes(MANAGED_MARKER);
+}
+
+async function restoreCatalog(journal: CodexJournal): Promise<CodexInjectionResult["catalog"]> {
+  const path = journal.catalogPath;
+  if (!path) return { state: "skipped", changed: false, removed: 0, message: "No managed catalog path was journaled." };
+  const current = await readMaybe(path);
+  if (!current.exists) return { state: "skipped", changed: false, removed: 0, message: "No managed catalog file was present." };
+  const currentHash = hash(current.bytes!);
+  const original = unb64(journal.originalCatalogBase64);
+  if (journal.managedCatalogHash && currentHash === journal.managedCatalogHash) {
+    if (original === null) {
+      await rm(path, { force: true });
+      return { state: "ok", changed: true, removed: 0, message: "Removed the opencodex-owned catalog file." };
+    }
+    await writeAtomic(path, original);
+    return { state: "ok", changed: true, removed: 0, message: "Restored the original Codex catalog." };
+  }
+  try {
+    const removed = await removeManagedCodexCatalogRows(path);
+    return { state: "ok", changed: removed.changed, removed: removed.removed, message: removed.message };
+  } catch (error) {
+    return { state: "failed", changed: false, removed: 0, message: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+/** Restore native Codex config/catalog; no-op when nothing was managed. */
+export async function restoreCodexConfig(options: {
+  env: NodeJS.ProcessEnv;
+  removeProviderTable?: boolean;
+}): Promise<CodexInjectionResult> {
+  return await withLock(options.env, async () => {
+    const journal = await readJournal(options.env);
+    const path = configPath(options.env);
+    const current = await readMaybe(path);
+    if (current.exists) validateToml(current.bytes!.toString("utf8"));
+    if (!journal) {
+      let catalog: CodexInjectionResult["catalog"] = {
+        state: "skipped", changed: false, removed: 0, message: "No journal was present.",
+      };
+      const catalogPath = await resolveCodexCatalogPath(options.env);
+      if (catalogPath) {
+        try {
+          const removed = await removeManagedCodexCatalogRows(catalogPath);
+          catalog = { state: "ok", changed: removed.changed, removed: removed.removed, message: removed.message };
+        } catch (error) {
+          catalog = { state: "failed", changed: false, removed: 0, message: error instanceof Error ? error.message : String(error) };
+        }
+      }
+      if (!current.exists) {
+        return {
+          success: catalog.state !== "failed", action: "restore", changed: catalog.changed,
+          config: { state: "skipped", changed: false, message: "Codex config was not present." },
+          catalog,
+        };
+      }
+      const text = current.bytes!.toString("utf8");
+      if (hasUnmarkedProviderTable(text) && !options.removeProviderTable) {
+        throw new CodexInjectionError("Codex contains an unmarked opencodex provider table; refusing to remove it.", "codex_provider_conflict");
+      }
+      if (!hasManagedProvider(text) && !options.removeProviderTable) {
+        return {
+          success: catalog.state !== "failed", action: "restore", changed: catalog.changed,
+          config: { state: "skipped", changed: false, message: "Codex is already using its native configuration." },
+          catalog,
+        };
+      }
+      const restored = restoreRoots(text, null);
+      await writeAtomic(path, restored);
+      return {
+        success: catalog.state !== "failed", action: "restore", changed: true || catalog.changed,
+        config: { state: "ok", changed: true, message: "Removed managed Codex routing; no pre-image journal was available." },
+        catalog,
+      };
+    }
+    const original = unb64(journal.originalConfigBase64);
+    const text = current.bytes?.toString("utf8") ?? "";
+    let changed = false;
+    let message = "Codex config was already native.";
+    if (current.exists && hash(current.bytes!) === journal.injectedConfigHash) {
+      if (original === null) await rm(path, { force: true });
+      else await writeAtomic(path, original);
+      changed = true;
+      message = original === null ? "Removed the managed Codex config." : "Restored the original Codex config.";
+    } else if (hasManagedProvider(text)) {
+      if (hasUnmarkedProviderTable(text) && !options.removeProviderTable) {
+        throw new CodexInjectionError("Codex contains an unmarked opencodex provider table; refusing to remove it.", "codex_provider_conflict");
+      }
+      await writeAtomic(path, restoreRoots(text, original?.toString("utf8") ?? null));
+      changed = true;
+      message = "Removed managed Codex routing while preserving unrelated edits.";
+    }
+    const catalog = await restoreCatalog(journal);
+    if (catalog.state === "failed") {
+      return {
+        success: false, action: "restore", changed,
+        config: { state: "ok", changed, message },
+        catalog,
+      };
+    }
+    await rm(journalPath(options.env), { force: true });
+    return {
+      success: true, action: "restore", changed: changed || catalog.changed,
+      config: { state: changed ? "ok" : "skipped", changed, message },
+      catalog,
+    };
+  });
+}
+
+/** Record the post-sync catalog hash so a later exact restore can remove it. */
+export async function recordCodexCatalogState(env: NodeJS.ProcessEnv): Promise<void> {
+  await withLock(env, async () => {
+    const journal = await readJournal(env);
+    if (!journal?.catalogPath) return;
+    const current = await readMaybe(journal.catalogPath);
+    journal.managedCatalogHash = current.exists ? hash(current.bytes!) : null;
+    await writeJournal(env, journal);
+  });
+}

package/src/server/index.ts

@@ -5,6 +5,7 @@ import {
   assertSafeListener,
   defaultConfig,
   normalizeConfig,
+  type ProviderId,
   type RuntimeConfig,
 } from "../config";
 import type { IncomingMeta } from "../types";
@@ -29,6 +30,7 @@ export interface ServerOptions {
   clineDeps?: ClineTurnDeps;
   geminiDeps?: GeminiTurnDeps;
   geminiPackageRoot?: string;
+  providerScope?: ProviderId;
   onWebSocketRequest?: (observation: WebSocketRequestObservation) => void;
 }
 
@@ -92,23 +94,32 @@ async function discoverModels(
   clineDeps: ClineTurnDeps | undefined,
   geminiDeps: GeminiTurnDeps | undefined,
   geminiPackageRoot: string | undefined,
+  providerScope?: ProviderId,
 ): Promise<ProviderModels> {
   const [cline, gemini] = await Promise.all([
-    discoverClineLiveModels({ env, ...(clineDeps ? { deps: clineDeps } : {}) }),
-    discoverGeminiLiveModels({ env, ...(geminiDeps ? { deps: geminiDeps } : {}), ...(geminiPackageRoot ? { packageRoot: geminiPackageRoot } : {}) }),
+    !providerScope || providerScope === "cline-cli"
+      ? discoverClineLiveModels({ env, ...(clineDeps ? { deps: clineDeps } : {}) })
+      : undefined,
+    !providerScope || providerScope === "gemini-cli"
+      ? discoverGeminiLiveModels({ env, ...(geminiDeps ? { deps: geminiDeps } : {}), ...(geminiPackageRoot ? { packageRoot: geminiPackageRoot } : {}) })
+      : undefined,
   ]);
-  if (!cline.ok && cline.reason !== "not_found" && env.OPENCODEX_CLINE_ACP?.trim() !== "0") {
+  if (cline && !cline.ok && cline.reason !== "not_found" && env.OPENCODEX_CLINE_ACP?.trim() !== "0") {
     console.warn(`[opencodex] Cline model discovery degraded [${cline.reason}]: ${cline.detail}`);
   }
-  if (!gemini.ok && gemini.reason !== "not_found" && env.OPENCODEX_GEMINI_ACP?.trim() !== "0") {
+  if (gemini && !gemini.ok && gemini.reason !== "not_found" && env.OPENCODEX_GEMINI_ACP?.trim() !== "0") {
     console.warn(`[opencodex] Gemini model discovery degraded [${gemini.reason}]: ${gemini.detail}`);
   }
-  return {
-    "cline-cli": cline.ok ? ["default", ...cline.models.filter(id => id !== "default")] : ["default"],
-    "gemini-cli": gemini.ok
+  const models: ProviderModels = {};
+  if (cline) {
+    models["cline-cli"] = cline.ok ? ["default", ...cline.models.filter(id => id !== "default")] : ["default"];
+  }
+  if (gemini) {
+    models["gemini-cli"] = gemini.ok
       ? ["default", ...gemini.modelInfo.filter(model => model.id !== "default")]
-      : ["default"],
-  };
+      : ["default"];
+  }
+  return models;
 }
 
 export function startServer(config: RuntimeConfig | number, options: ServerOptions = {}): RunningServer {
@@ -138,8 +149,8 @@ export function startServer(config: RuntimeConfig | number, options: ServerOptio
     }
     try {
       if (req.method === "GET" && url.pathname === "/v1/models") {
-        const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot);
-        return Response.json({ object: "list", data: modelList(known) });
+        const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot, options.providerScope);
+        return Response.json({ object: "list", data: modelList(known, options.providerScope) });
       }
       if (req.method === "GET" && url.pathname === "/v1/model-catalog") {
         const discovered = await discoverCodexCatalogModels({
@@ -152,16 +163,16 @@ export function startServer(config: RuntimeConfig | number, options: ServerOptio
       }
       if (req.method === "POST" && url.pathname === "/v1/responses") {
         const body = await boundedJson(req);
-        const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot);
+        const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot, options.providerScope);
         const signal = AbortSignal.any([req.signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)]);
         const incoming: IncomingMeta = { headers: req.headers, abortSignal: signal };
-        return await handleResponses(body, incoming, known, turnDeps, config.defaultProvider);
+        return await handleResponses(body, incoming, known, turnDeps, options.providerScope ?? config.defaultProvider);
       }
       if (req.method === "POST" && url.pathname === "/v1/messages") {
         const body = await boundedJson(req);
-        const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot);
+        const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot, options.providerScope);
         const signal = AbortSignal.any([req.signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)]);
-        return await handleMessages(body, { headers: req.headers, abortSignal: signal }, known, turnDeps, config.defaultProvider);
+        return await handleMessages(body, { headers: req.headers, abortSignal: signal }, known, turnDeps, options.providerScope ?? config.defaultProvider);
       }
       if (req.method === "POST" && url.pathname === "/v1/messages/count_tokens") {
         return handleCountTokens(await boundedJson(req));
@@ -173,9 +184,9 @@ export function startServer(config: RuntimeConfig | number, options: ServerOptio
   };
 
   const websocketContext = {
-    knownModels: () => discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot),
+    knownModels: () => discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot, options.providerScope),
     deps: turnDeps,
-    defaultProvider: config.defaultProvider,
+    defaultProvider: options.providerScope ?? config.defaultProvider,
     timeoutMs: REQUEST_TIMEOUT_MS,
     ...(options.onWebSocketRequest ? { onRequest: options.onWebSocketRequest } : {}),
   };

package/src/server/responses.ts

@@ -379,7 +379,10 @@ const PROVIDER_LABELS: Record<ProviderId, string> = {
   [GEMINI_PROVIDER_ID]: "Gemini CLI",
 };
 
-export function modelList(known: string[] | ProviderModels): Array<Record<string, unknown>> {
+export function modelList(
+  known: string[] | ProviderModels,
+  scope?: ProviderId,
+): Array<Record<string, unknown>> {
   if (Array.isArray(known)) {
     const ids = ["default", ...known.filter(id => id !== "default")];
     return [...new Set(ids)].map(id => ({
@@ -390,6 +393,44 @@ export function modelList(known: string[] | ProviderModels): Array<Record<string
       display_name: id === "default" ? "Cline default" : id,
     }));
   }
+  if (scope) {
+    const entries = ["default", ...(known[scope] ?? []).filter(entry => modelIdOf(entry) !== "default")];
+    const rows: Array<Record<string, unknown>> = [];
+    const seen = new Set<string>();
+    for (const entry of entries) {
+      const id = modelIdOf(entry);
+      if (seen.has(id)) continue;
+      seen.add(id);
+      const info = typeof entry === "string" ? { id: entry } as OcxProviderModel : entry;
+      const reasoning = info.supportedReasoningLevels ?? [];
+      rows.push({
+        id: encodeRoutedModelId(id),
+        object: "model",
+        created: 0,
+        owned_by: scope,
+        display_name: info.name ?? (id === "default" ? PROVIDER_LABELS[scope] + " default" : id),
+        ...(info.description ? { description: info.description } : {}),
+        ...(info.contextWindowTokens !== undefined
+          ? {
+              context_window: info.contextWindowTokens,
+              max_context_window: info.maxContextWindowTokens ?? info.contextWindowTokens,
+            }
+          : {}),
+        ...(info.inputModalities ? { input_modalities: [...info.inputModalities] } : {}),
+        ...(info.loadSession !== undefined ? { load_session: info.loadSession } : {}),
+        ...(reasoning.length > 0
+          ? {
+              supported_reasoning_levels: reasoning.map(level => ({
+                effort: level.effort,
+                description: level.description,
+              })),
+              default_reasoning_level: info.defaultReasoningLevel ?? reasoning[0]!.effort,
+            }
+          : { supported_reasoning_levels: [] }),
+      });
+    }
+    return rows;
+  }
   const rows: Array<Record<string, unknown>> = [{
     id: "default",
     object: "model",

package/src/upstream/cli.ts

@@ -0,0 +1,12 @@
+import { pathToFileURL } from "node:url";
+import { resolveUpstreamPackage, type UpstreamPackage } from "./package";
+
+export type UpstreamModuleImporter = (url: string) => Promise<unknown>;
+
+/** Load the immutable upstream CLI into this process so service ownership stays ours. */
+export async function loadUpstreamCli(
+  pkg: UpstreamPackage = resolveUpstreamPackage(),
+  importer: UpstreamModuleImporter = url => import(url),
+): Promise<void> {
+  await importer(pathToFileURL(pkg.cliEntry).href);
+}