@koreanhole/opencodex 2.95.10 → 2.97.0

package/src/config.ts

@@ -3,10 +3,13 @@ import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 
 export const CLINE_PROVIDER_ID = "cline-cli";
+export const GEMINI_PROVIDER_ID = "gemini-cli";
 export const CLINE_BASE_URL = "https://api.cline.bot";
 export const DEFAULT_PORT = 10_100;
 export const DEFAULT_HOST = "127.0.0.1";
 
+export type ProviderId = typeof CLINE_PROVIDER_ID | typeof GEMINI_PROVIDER_ID;
+
 export interface ClineProviderConfig {
   adapter: "cline-cli";
   baseUrl: typeof CLINE_BASE_URL;
@@ -14,11 +17,19 @@ export interface ClineProviderConfig {
   models: string[];
 }
 
+export interface GeminiProviderConfig {
+  adapter: "gemini-cli";
+  defaultModel: "default";
+  models: string[];
+}
+
+export type ProviderConfig = ClineProviderConfig | GeminiProviderConfig;
+
 export interface RuntimeConfig {
   port: number;
   host: string;
-  defaultProvider: typeof CLINE_PROVIDER_ID;
-  providers: Record<typeof CLINE_PROVIDER_ID, ClineProviderConfig>;
+  defaultProvider: ProviderId;
+  providers: Record<ProviderId, ProviderConfig>;
   apiAuthToken?: string;
 }
 
@@ -67,6 +78,11 @@ export function defaultConfig(): RuntimeConfig {
         defaultModel: "default",
         models: ["default"],
       },
+      [GEMINI_PROVIDER_ID]: {
+        adapter: GEMINI_PROVIDER_ID,
+        defaultModel: "default",
+        models: ["default"],
+      },
     },
   };
 }
@@ -85,7 +101,7 @@ function validPort(value: unknown): number {
   return value;
 }
 
-function normalizeProvider(value: unknown): ClineProviderConfig {
+function normalizeClineProvider(value: unknown): ClineProviderConfig {
   const row = asRecord(value);
   if (!row) throw new ConfigError("config.providers.cline-cli must be an object.");
   if (row.adapter !== undefined && row.adapter !== CLINE_PROVIDER_ID) {
@@ -106,17 +122,42 @@ function normalizeProvider(value: unknown): ClineProviderConfig {
   };
 }
 
+function normalizeGeminiProvider(value: unknown): GeminiProviderConfig {
+  const row = asRecord(value);
+  if (!row) throw new ConfigError("config.providers.gemini-cli must be an object.");
+  if (row.adapter !== undefined && row.adapter !== GEMINI_PROVIDER_ID) {
+    throw new ConfigError("config.providers.gemini-cli.adapter must be gemini-cli.");
+  }
+  const models = Array.isArray(row.models)
+    ? [...new Set(row.models.filter((item): item is string => typeof item === "string" && item.length > 0))]
+    : ["default"];
+  if (!models.includes("default")) models.unshift("default");
+  return {
+    adapter: GEMINI_PROVIDER_ID,
+    defaultModel: "default",
+    models,
+  };
+}
+
+function providerId(value: unknown): ProviderId | undefined {
+  return value === CLINE_PROVIDER_ID || value === GEMINI_PROVIDER_ID ? value : undefined;
+}
+
 export function normalizeConfig(input: unknown): RuntimeConfig {
   const row = asRecord(input);
   if (!row) throw new ConfigError("config.json must contain a JSON object.");
-  if (row.defaultProvider !== undefined && row.defaultProvider !== CLINE_PROVIDER_ID) {
+  let defaultProvider = providerId(row.defaultProvider);
+  if (row.defaultProvider !== undefined && !defaultProvider) {
     console.warn(`[opencodex] ignoring unsupported defaultProvider ${JSON.stringify(row.defaultProvider)}; using cline-cli.`);
+    defaultProvider = CLINE_PROVIDER_ID;
   }
   const providers = asRecord(row.providers);
   for (const key of Object.keys(providers ?? {})) {
-    if (key !== CLINE_PROVIDER_ID) console.warn(`[opencodex] ignoring unsupported provider ${JSON.stringify(key)}.`);
+    if (!providerId(key)) console.warn(`[opencodex] ignoring unsupported provider ${JSON.stringify(key)}.`);
   }
-  const provider = normalizeProvider(providers?.[CLINE_PROVIDER_ID] ?? defaultConfig().providers[CLINE_PROVIDER_ID]);
+  const defaults = defaultConfig().providers;
+  const cline = normalizeClineProvider(providers?.[CLINE_PROVIDER_ID] ?? defaults[CLINE_PROVIDER_ID]);
+  const gemini = normalizeGeminiProvider(providers?.[GEMINI_PROVIDER_ID] ?? defaults[GEMINI_PROVIDER_ID]);
   const host = typeof row.host === "string" && row.host.trim() ? row.host.trim() : DEFAULT_HOST;
   const apiAuthToken = typeof row.apiAuthToken === "string" && row.apiAuthToken.trim()
     ? row.apiAuthToken.trim()
@@ -124,8 +165,8 @@ export function normalizeConfig(input: unknown): RuntimeConfig {
   return {
     port: row.port === undefined ? DEFAULT_PORT : validPort(row.port),
     host,
-    defaultProvider: CLINE_PROVIDER_ID,
-    providers: { [CLINE_PROVIDER_ID]: provider },
+    defaultProvider: defaultProvider ?? CLINE_PROVIDER_ID,
+    providers: { [CLINE_PROVIDER_ID]: cline, [GEMINI_PROVIDER_ID]: gemini },
     ...(apiAuthToken ? { apiAuthToken } : {}),
   };
 }
@@ -143,7 +184,7 @@ export async function loadConfig(env: NodeJS.ProcessEnv = process.env): Promise<
   try {
     parsed = JSON.parse(text);
   } catch {
-    throw new ConfigError(`${path} is not valid JSON. Repair it or remove it to recreate the Cline-only default.`);
+    throw new ConfigError(`${path} is not valid JSON. Repair it or remove it to recreate the default config.`);
   }
   return normalizeConfig(parsed);
 }

package/src/index.ts

@@ -1,6 +1,7 @@
 export { startServer, type RunningServer, type ServerOptions } from "./server";
 export { loadConfig, saveConfig, defaultConfig } from "./config";
 export { runClineTurn } from "./adapters/cli-agent/cline/adapter";
+export { runGeminiTurn } from "./adapters/cli-agent/gemini/adapter";
 export type {
   AdapterEvent,
   IncomingMeta,

package/src/lib/codex-catalog.ts

@@ -0,0 +1,318 @@
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import type { OcxProviderModel } from "../types";
+import { discoverClineLiveModels } from "../adapters/cli-agent/cline/live-models";
+import { discoverGeminiLiveModels } from "../adapters/cli-agent/gemini/live-models";
+import type { ClineTurnDeps } from "../adapters/cli-agent/cline/adapter";
+import type { GeminiTurnDeps } from "../adapters/cli-agent/gemini/adapter";
+
+const CATALOG_FALLBACK_CONTEXT = 128_000;
+const BASE_INSTRUCTIONS = "You are a helpful coding assistant.";
+const MANAGED_PREFIXES = ["cline-cli/", "gemini-cli/"] as const;
+
+export interface CodexCatalogModel {
+  slug: string;
+  display_name: string;
+  description: string;
+  default_reasoning_level: string;
+  supported_reasoning_levels: Array<{ effort: string; description: string }>;
+  shell_type: "unified_exec";
+  visibility: "list";
+  supported_in_api: true;
+  priority: number;
+  base_instructions: string;
+  web_search_tool_type: "text_and_image";
+  supports_search_tool: false;
+  tool_mode: "code_mode_only";
+  context_window: number;
+  max_context_window: number;
+  auto_compact_token_limit: number;
+  input_modalities: ["text"];
+  node_repl_disabled: false;
+  node_repl_auto_review_required: false;
+  include_plugin_usage_instructions: false;
+  include_apps_usage_instructions: false;
+  include_skills_usage_instructions: false;
+  supports_reasoning_summaries: boolean;
+  default_reasoning_summary: string;
+  support_verbosity: true;
+  default_verbosity: "low";
+  apply_patch_tool_type: "freeform";
+  truncation_policy: { mode: "tokens"; limit: number };
+  supports_parallel_tool_calls: true;
+  supports_image_detail_original: false;
+  experimental_supported_tools: [];
+  effective_context_window_percent: 95;
+  comp_hash: null;
+  multi_agent_version: "v1";
+  auto_review_model_override: null;
+  supports_reasoning_effort_updates: false;
+  use_responses_lite: false;
+  additional_speed_tiers: [];
+  service_tiers: [];
+  availability_nux: null;
+  upgrade: null;
+}
+
+export interface CodexCatalogDocument {
+  fetched_at: string;
+  etag: null;
+  client_version: string;
+  identity: string;
+  models: CodexCatalogModel[];
+}
+
+export interface CodexCatalogDiscoveryOptions {
+  env?: NodeJS.ProcessEnv;
+  clineDeps?: ClineTurnDeps;
+  geminiDeps?: GeminiTurnDeps;
+  geminiBinary?: string;
+  geminiPackageRoot?: string;
+  now?: Date;
+  forceRefresh?: boolean;
+}
+
+export interface CodexCatalogModels {
+  models: CodexCatalogModel[];
+  warnings: string[];
+}
+
+export type CodexCatalogSyncResult =
+  | {
+      ok: true;
+      path: string;
+      configured: boolean;
+      written: boolean;
+      modelCount: number;
+      geminiModelCount: number;
+      reasoningModelCount: number;
+      reloadRequired: true;
+      warnings: string[];
+    }
+  | {
+      ok: false;
+      path?: string;
+      reason: "unsafe_path" | "malformed_catalog" | "write_failed" | "discovery_failed";
+      message: string;
+    };
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+function encodeRoutedId(id: string): string {
+  return id.replaceAll("/", "-");
+}
+
+export function buildCodexCatalogModel(providerId: "cline-cli" | "gemini-cli", model: OcxProviderModel, index: number): CodexCatalogModel {
+  const levels = (model.supportedReasoningLevels ?? []).map(level => ({
+    effort: level.effort,
+    description: level.description,
+  }));
+  const defaultLevel = model.defaultReasoningLevel ?? levels[0]?.effort ?? "low";
+  const isDefault = model.id === "default";
+  const providerLabel = providerId === "gemini-cli" ? "Gemini CLI" : "Cline CLI";
+  return {
+    slug: `${providerId}/${encodeRoutedId(model.id)}`,
+    display_name: model.name ?? (isDefault ? `${providerLabel} default` : model.id),
+    description: model.description ?? `Routed via opencodex -> ${providerLabel}.`,
+    default_reasoning_level: levels.length > 0 ? defaultLevel : "low",
+    supported_reasoning_levels: levels,
+    shell_type: "unified_exec",
+    visibility: "list",
+    supported_in_api: true,
+    priority: 10 + index,
+    base_instructions: BASE_INSTRUCTIONS,
+    web_search_tool_type: "text_and_image",
+    supports_search_tool: false,
+    tool_mode: "code_mode_only",
+    context_window: CATALOG_FALLBACK_CONTEXT,
+    max_context_window: CATALOG_FALLBACK_CONTEXT,
+    auto_compact_token_limit: Math.floor(CATALOG_FALLBACK_CONTEXT * 0.9),
+    input_modalities: ["text"],
+    node_repl_disabled: false,
+    node_repl_auto_review_required: false,
+    include_plugin_usage_instructions: false,
+    include_apps_usage_instructions: false,
+    include_skills_usage_instructions: false,
+    supports_reasoning_summaries: levels.length > 0,
+    default_reasoning_summary: levels.length > 0 ? "auto" : "none",
+    support_verbosity: true,
+    default_verbosity: "low",
+    apply_patch_tool_type: "freeform",
+    truncation_policy: { mode: "tokens", limit: 10_000 },
+    supports_parallel_tool_calls: true,
+    supports_image_detail_original: false,
+    experimental_supported_tools: [],
+    effective_context_window_percent: 95,
+    comp_hash: null,
+    multi_agent_version: "v1",
+    auto_review_model_override: null,
+    supports_reasoning_effort_updates: false,
+    use_responses_lite: false,
+    additional_speed_tiers: [],
+    service_tiers: [],
+    availability_nux: null,
+    upgrade: null,
+  };
+}
+
+function defaultModel(): OcxProviderModel {
+  return { id: "default" };
+}
+
+function normalizedModels(models: readonly OcxProviderModel[]): OcxProviderModel[] {
+  const seen = new Set<string>();
+  const out: OcxProviderModel[] = [];
+  for (const model of [defaultModel(), ...models]) {
+    if (!seen.has(model.id)) {
+      seen.add(model.id);
+      out.push(model);
+    }
+  }
+  return out;
+}
+
+export async function discoverCodexCatalogModels(options: CodexCatalogDiscoveryOptions = {}): Promise<CodexCatalogModels> {
+  const env = options.env ?? process.env;
+  const [cline, gemini] = await Promise.all([
+    discoverClineLiveModels({ env, ...(options.clineDeps ? { deps: options.clineDeps } : {}) }),
+    discoverGeminiLiveModels({
+      env,
+      ...(options.geminiBinary ? { binary: options.geminiBinary } : {}),
+      ...(options.geminiDeps ? { deps: options.geminiDeps } : {}),
+      ...(options.geminiPackageRoot ? { packageRoot: options.geminiPackageRoot } : {}),
+      ...(options.forceRefresh ? { forceRefresh: true } : {}),
+    }),
+  ]);
+  const warnings: string[] = [];
+  if (!cline.ok && cline.reason !== "not_found" && env.OPENCODEX_CLINE_ACP?.trim() !== "0") warnings.push(`Cline: ${cline.detail}`);
+  if (!gemini.ok && gemini.reason !== "not_found" && env.OPENCODEX_GEMINI_ACP?.trim() !== "0") warnings.push(`Gemini: ${gemini.detail}`);
+  if (gemini.ok && gemini.metadataWarning) warnings.push(`Gemini metadata: ${gemini.metadataWarning}`);
+  const clineModels = normalizedModels(cline.ok ? cline.models.map(id => ({ id })) : []);
+  const geminiModels = normalizedModels(gemini.ok ? gemini.modelInfo : []);
+  return {
+    models: [
+      ...clineModels.map((model, index) => buildCodexCatalogModel("cline-cli", model, index)),
+      ...geminiModels.map((model, index) => buildCodexCatalogModel("gemini-cli", model, clineModels.length + index)),
+    ],
+    warnings,
+  };
+}
+
+export function buildCodexCatalogDocument(
+  models: CodexCatalogModel[],
+  now = new Date(),
+  preserved: CodexCatalogModel[] = [],
+): CodexCatalogDocument {
+  return {
+    fetched_at: now.toISOString(),
+    etag: null,
+    client_version: "0.165.0",
+    identity: "opencodex",
+    models: [...preserved, ...models],
+  };
+}
+
+function readRootTomlString(text: string, key: string): string | undefined {
+  const firstTable = text.search(/^\s*\[/m);
+  const root = firstTable < 0 ? text : text.slice(0, firstTable);
+  const match = new RegExp(`^\\s*${key}\\s*=\\s*"([^"]+)"`, "m").exec(root);
+  return match?.[1]?.trim() || undefined;
+}
+
+export async function writeCodexCatalog(
+  path: string,
+  document: CodexCatalogDocument,
+): Promise<void> {
+  const parent = dirname(path);
+  await mkdir(parent, { recursive: true, mode: 0o700 });
+  const temporary = `${path}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, `${JSON.stringify(document, null, 2)}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" });
+    await chmod(temporary, 0o600);
+    await rename(temporary, path);
+    await chmod(path, 0o600).catch(() => undefined);
+  } finally {
+    await rm(temporary, { force: true }).catch(() => undefined);
+  }
+}
+
+function managedSlug(slug: unknown): boolean {
+  return typeof slug === "string" && MANAGED_PREFIXES.some(prefix => slug.startsWith(prefix));
+}
+
+export async function syncCodexCatalog(
+  options: CodexCatalogDiscoveryOptions & {
+    path?: string;
+    discover?: typeof discoverCodexCatalogModels;
+  } = {},
+): Promise<CodexCatalogSyncResult> {
+  const env = options.env ?? process.env;
+  const codexHome = env.CODEX_HOME?.trim() || join(homedir(), ".codex");
+  let configuredPath: string | undefined;
+  try {
+    configuredPath = readRootTomlString(await readFile(join(codexHome, "config.toml"), "utf8"), "model_catalog_json");
+  } catch {
+    configuredPath = undefined;
+  }
+  const configured = configuredPath !== undefined;
+  const selected = options.path
+    ? (isAbsolute(options.path) ? options.path : resolve(options.path))
+    : configuredPath
+      ? resolve(codexHome, configuredPath)
+      : join(codexHome, "opencodex-catalog.json");
+  if (configured && basename(selected) !== "opencodex-catalog.json") {
+    return { ok: false, path: selected, reason: "unsafe_path", message: "Configured model_catalog_json is not an opencodex catalog; refusing to overwrite it." };
+  }
+
+  let existing: Record<string, unknown> = {};
+  try {
+    const parsed = asRecord(JSON.parse(await readFile(selected, "utf8")));
+    if (!parsed) return { ok: false, path: selected, reason: "malformed_catalog", message: "Existing Codex catalog is not a JSON object." };
+    existing = parsed;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+      return { ok: false, path: selected, reason: "malformed_catalog", message: "Existing Codex catalog could not be parsed; it was preserved." };
+    }
+  }
+
+  let discovered: CodexCatalogModels;
+  try {
+    discovered = await (options.discover ?? discoverCodexCatalogModels)({ ...options, forceRefresh: true });
+  } catch (error) {
+    return { ok: false, reason: "discovery_failed", message: error instanceof Error ? error.message : String(error) };
+  }
+  const existingModels = Array.isArray(existing.models) ? existing.models : [];
+  if (existing.models !== undefined && !Array.isArray(existing.models)) {
+    return { ok: false, path: selected, reason: "malformed_catalog", message: "Existing Codex catalog models field is not an array; it was preserved." };
+  }
+  if (existingModels.some(model => !asRecord(model))) {
+    return { ok: false, path: selected, reason: "malformed_catalog", message: "Existing Codex catalog contains a non-object model row; it was preserved." };
+  }
+  const preserved = existingModels.filter(model => !managedSlug(asRecord(model)?.slug));
+  const document = buildCodexCatalogDocument(
+    discovered.models,
+    options.now ?? new Date(),
+    preserved as CodexCatalogModel[],
+  );
+  try {
+    await writeCodexCatalog(selected, document);
+  } catch (error) {
+    return { ok: false, path: selected, reason: "write_failed", message: error instanceof Error ? error.message : String(error) };
+  }
+  return {
+    ok: true,
+    path: selected,
+    configured,
+    written: true,
+    modelCount: document.models.length,
+    geminiModelCount: document.models.filter(model => model.slug.startsWith("gemini-cli/")).length,
+    reasoningModelCount: document.models.filter(model => model.slug.startsWith("gemini-cli/") && (model.supported_reasoning_levels?.length ?? 0) > 0).length,
+    reloadRequired: true,
+    warnings: discovered.warnings,
+  };
+}

package/src/lib/redact.ts

@@ -2,7 +2,10 @@
 export function redactSecretString(value: string): string {
   return value
     .replace(/\bsk-[A-Za-z0-9_-]{6,}\b/g, "[redacted]")
-    .replace(/(authorization\s*[:=]\s*)\S+/gi, "$1[redacted]")
+    .replace(/\bAIza[0-9A-Za-z_-]{20,}\b/g, "[redacted]")
+    .replace(/\bya29\.[0-9A-Za-z._-]{20,}\b/g, "[redacted]")
+    .replace(/(authorization\s*[:=]\s*)(?:bearer\s+)?\S+/gi, "$1[redacted]")
     .replace(/(x-api-key\s*[:=]\s*)\S+/gi, "$1[redacted]")
+    .replace(/((?:api[_-]?key|token)\s*[:=]\s*)\S+/gi, "$1[redacted]")
     .slice(0, 4_096);
 }

package/src/server/index.ts

@@ -9,8 +9,11 @@ import {
 } from "../config";
 import type { IncomingMeta } from "../types";
 import type { ClineTurnDeps } from "../adapters/cli-agent/cline/adapter";
+import type { GeminiTurnDeps } from "../adapters/cli-agent/gemini/adapter";
 import { discoverClineLiveModels } from "../adapters/cli-agent/cline/live-models";
-import { handleResponses, modelList, RequestValidationError, UnsupportedMediaError } from "./responses";
+import { discoverGeminiLiveModels } from "../adapters/cli-agent/gemini/live-models";
+import { buildCodexCatalogDocument, discoverCodexCatalogModels } from "../lib/codex-catalog";
+import { handleResponses, modelList, RequestValidationError, UnsupportedMediaError, type ProviderModels } from "./responses";
 import { handleCountTokens, handleMessages } from "./messages";
 
 const MAX_REQUEST_BYTES = 32 * 1024 * 1024;
@@ -19,6 +22,8 @@ const REQUEST_TIMEOUT_MS = 300_000;
 export interface ServerOptions {
   env?: NodeJS.ProcessEnv;
   clineDeps?: ClineTurnDeps;
+  geminiDeps?: GeminiTurnDeps;
+  geminiPackageRoot?: string;
 }
 
 export interface RunningServer {
@@ -73,11 +78,28 @@ function errorResponse(error: unknown): Response {
   return Response.json({ error: { message: "Proxy request failed.", type: "proxy_error", code: "proxy_error" } }, { status: 500 });
 }
 
-async function discoverModels(env: NodeJS.ProcessEnv, deps: ClineTurnDeps | undefined): Promise<string[]> {
-  const live = await discoverClineLiveModels({ env, ...(deps ? { deps } : {}) });
-  if (live.ok) return ["default", ...live.models.filter(id => id !== "default")];
-  if (live.reason !== "not_found") console.warn(`[opencodex] Cline model discovery degraded [${live.reason}]: ${live.detail}`);
-  return ["default"];
+async function discoverModels(
+  env: NodeJS.ProcessEnv,
+  clineDeps: ClineTurnDeps | undefined,
+  geminiDeps: GeminiTurnDeps | undefined,
+  geminiPackageRoot: string | undefined,
+): Promise<ProviderModels> {
+  const [cline, gemini] = await Promise.all([
+    discoverClineLiveModels({ env, ...(clineDeps ? { deps: clineDeps } : {}) }),
+    discoverGeminiLiveModels({ env, ...(geminiDeps ? { deps: geminiDeps } : {}), ...(geminiPackageRoot ? { packageRoot: geminiPackageRoot } : {}) }),
+  ]);
+  if (!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") {
+    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
+      ? ["default", ...gemini.modelInfo.filter(model => model.id !== "default")]
+      : ["default"],
+  };
 }
 
 export function startServer(config: RuntimeConfig | number, options: ServerOptions = {}): RunningServer {
@@ -86,6 +108,8 @@ export function startServer(config: RuntimeConfig | number, options: ServerOptio
     : normalizeConfig(config);
   const env = options.env ?? process.env;
   const clineDeps = { ...options.clineDeps, env: options.clineDeps?.env ?? env };
+  const geminiDeps = { ...options.geminiDeps, env: options.geminiDeps?.env ?? env };
+  const turnDeps = { cline: clineDeps, gemini: geminiDeps };
   assertSafeListener(config, env);
   const token = apiToken(config, env);
   let server: ReturnType<typeof Bun.serve>;
@@ -93,28 +117,37 @@ export function startServer(config: RuntimeConfig | number, options: ServerOptio
   const fetch = async (req: Request): Promise<Response> => {
     const url = new URL(req.url);
     if (url.pathname === "/healthz") {
-      return Response.json({ ok: true, service: "opencodex-cline", version: packageInfo.version });
+      return Response.json({ ok: true, service: "opencodex", version: packageInfo.version });
     }
     if (!authorized(req, token)) {
       return Response.json({ error: { message: "Unauthorized", type: "authentication_error", code: "unauthorized" } }, { status: 401 });
     }
     try {
       if (req.method === "GET" && url.pathname === "/v1/models") {
-        const known = await discoverModels(env, options.clineDeps);
+        const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot);
         return Response.json({ object: "list", data: modelList(known) });
       }
+      if (req.method === "GET" && url.pathname === "/v1/model-catalog") {
+        const discovered = await discoverCodexCatalogModels({
+          env,
+          ...(options.clineDeps ? { clineDeps: options.clineDeps } : {}),
+          ...(options.geminiDeps ? { geminiDeps: options.geminiDeps } : {}),
+          ...(options.geminiPackageRoot ? { geminiPackageRoot: options.geminiPackageRoot } : {}),
+        });
+        return Response.json(buildCodexCatalogDocument(discovered.models));
+      }
       if (req.method === "POST" && url.pathname === "/v1/responses") {
         const body = await boundedJson(req);
-        const known = await discoverModels(env, options.clineDeps);
+        const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot);
         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, clineDeps);
+        return await handleResponses(body, incoming, known, turnDeps, config.defaultProvider);
       }
       if (req.method === "POST" && url.pathname === "/v1/messages") {
         const body = await boundedJson(req);
-        const known = await discoverModels(env, options.clineDeps);
+        const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot);
         const signal = AbortSignal.any([req.signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)]);
-        return await handleMessages(body, { headers: req.headers, abortSignal: signal }, known, clineDeps);
+        return await handleMessages(body, { headers: req.headers, abortSignal: signal }, known, turnDeps, config.defaultProvider);
       }
       if (req.method === "POST" && url.pathname === "/v1/messages/count_tokens") {
         return handleCountTokens(await boundedJson(req));
@@ -125,7 +158,7 @@ export function startServer(config: RuntimeConfig | number, options: ServerOptio
     }
   };
 
-  server = Bun.serve({ hostname: config.host, port: config.port, fetch });
+  server = Bun.serve({ hostname: config.host, port: config.port, idleTimeout: 255, fetch });
   return {
     port: server.port ?? config.port,
     host: config.host,

package/src/server/messages.ts

@@ -1,12 +1,15 @@
 import type { AdapterEvent, IncomingMeta, OcxMessage, OcxParsedRequest, OcxTool, OcxToolChoice } from "../types";
-import { runClineTurn, type ClineTurnDeps } from "../adapters/cli-agent/cline/adapter";
+import type { ClineTurnDeps } from "../adapters/cli-agent/cline/adapter";
+import { CLINE_PROVIDER_ID, type ProviderId } from "../config";
 import {
   collectResponsesResult,
   RequestValidationError,
-  resolveClineModel,
+  routedTurn,
   UnsupportedMediaError,
   type DeclaredTool,
   type ParsedResponsesRequest,
+  type ProviderModels,
+  type ProviderTurnDeps,
 } from "./responses";
 
 function record(value: unknown): Record<string, unknown> | undefined {
@@ -210,14 +213,12 @@ function anthropicUsage(value: unknown): { input_tokens: number; output_tokens:
 export async function handleMessages(
   body: unknown,
   incoming: IncomingMeta,
-  knownModels: string[],
-  deps: ClineTurnDeps = {},
+  knownModels: string[] | ProviderModels,
+  deps: ClineTurnDeps | ProviderTurnDeps = {},
+  defaultProvider: ProviderId = CLINE_PROVIDER_ID,
 ): Promise<Response> {
   const parsed = parseMessagesRequest(body);
-  parsed.parsed.modelId = parsed.requestedModel.startsWith("cline-cli/")
-    ? resolveClineModel(parsed.requestedModel, knownModels)
-    : "default";
-  const run = (emit: (event: AdapterEvent) => void) => runClineTurn(parsed.parsed, incoming, emit, deps);
+  const { run } = routedTurn(parsed.parsed, parsed.requestedModel, incoming, knownModels, deps, defaultProvider);
   const result = await collectResponsesResult(parsed, run);
   if (result.failure) {
     return Response.json({