@koreanhole/opencodex 2.95.10 → 2.96.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/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,10 @@ 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 { handleResponses, modelList, RequestValidationError, UnsupportedMediaError, type ProviderModels } from "./responses";
 import { handleCountTokens, handleMessages } from "./messages";
 
 const MAX_REQUEST_BYTES = 32 * 1024 * 1024;
@@ -19,6 +21,7 @@ const REQUEST_TIMEOUT_MS = 300_000;
 export interface ServerOptions {
   env?: NodeJS.ProcessEnv;
   clineDeps?: ClineTurnDeps;
+  geminiDeps?: GeminiTurnDeps;
 }
 
 export interface RunningServer {
@@ -73,11 +76,25 @@ 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,
+): Promise<ProviderModels> {
+  const [cline, gemini] = await Promise.all([
+    discoverClineLiveModels({ env, ...(clineDeps ? { deps: clineDeps } : {}) }),
+    discoverGeminiLiveModels({ env, ...(geminiDeps ? { deps: geminiDeps } : {}) }),
+  ]);
+  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.models.filter(id => id !== "default")] : ["default"],
+  };
 }
 
 export function startServer(config: RuntimeConfig | number, options: ServerOptions = {}): RunningServer {
@@ -86,6 +103,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 +112,28 @@ 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);
         return Response.json({ object: "list", data: modelList(known) });
       }
       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);
         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);
         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 +144,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({

package/src/server/responses.ts

@@ -8,6 +8,15 @@ import type {
   OcxUsage,
 } from "../types";
 import { runClineTurn, type ClineTurnDeps } from "../adapters/cli-agent/cline/adapter";
+import { runGeminiTurn, type GeminiTurnDeps } from "../adapters/cli-agent/gemini/adapter";
+import { CLINE_PROVIDER_ID, GEMINI_PROVIDER_ID, type ProviderId } from "../config";
+
+export interface ProviderTurnDeps {
+  cline?: ClineTurnDeps;
+  gemini?: GeminiTurnDeps;
+}
+
+type TurnDepsInput = ClineTurnDeps | ProviderTurnDeps;
 
 export interface DeclaredTool {
   tool: OcxTool;
@@ -34,7 +43,7 @@ export class UnsupportedMediaError extends RequestValidationError {
   readonly code = "unsupported_input_modality";
 
   constructor() {
-    super("Cline CLI is text-only; image, video, and audio input are not supported.");
+    super("The selected CLI provider is text-only; image, video, and audio input are not supported.");
     this.name = "UnsupportedMediaError";
   }
 }
@@ -266,15 +275,96 @@ export function resolveClineModel(requested: string, known: Iterable<string>): s
   return decodeRoutedModelId(suffix, known);
 }
 
-export function modelList(known: string[]): Array<Record<string, unknown>> {
-  const ids = ["default", ...known.filter(id => id !== "default")];
-  return [...new Set(ids)].map(id => ({
-    id: `cline-cli/${encodeRoutedModelId(id)}`,
+export type ProviderModels = Partial<Record<ProviderId, readonly string[]>>;
+
+export interface RoutedModel {
+  providerId: ProviderId;
+  modelId: string;
+}
+
+export function resolveRoutedModel(
+  requested: string,
+  known: ProviderModels,
+  defaultProvider: ProviderId = CLINE_PROVIDER_ID,
+): RoutedModel {
+  if (requested === "default") return { providerId: defaultProvider, modelId: "default" };
+  const providerId = requested.startsWith(`${CLINE_PROVIDER_ID}/`)
+    ? CLINE_PROVIDER_ID
+    : requested.startsWith(`${GEMINI_PROVIDER_ID}/`)
+      ? GEMINI_PROVIDER_ID
+      : defaultProvider;
+  const prefix = `${providerId}/`;
+  const suffix = requested.startsWith(prefix) ? requested.slice(prefix.length) : requested;
+  return {
+    providerId,
+    modelId: suffix === "default" ? "default" : decodeRoutedModelId(suffix, known[providerId] ?? []),
+  };
+}
+
+const PROVIDER_LABELS: Record<ProviderId, string> = {
+  [CLINE_PROVIDER_ID]: "Cline CLI",
+  [GEMINI_PROVIDER_ID]: "Gemini CLI",
+};
+
+export function modelList(known: string[] | ProviderModels): Array<Record<string, unknown>> {
+  if (Array.isArray(known)) {
+    const ids = ["default", ...known.filter(id => id !== "default")];
+    return [...new Set(ids)].map(id => ({
+      id: `${CLINE_PROVIDER_ID}/${encodeRoutedModelId(id)}`,
+      object: "model",
+      created: 0,
+      owned_by: CLINE_PROVIDER_ID,
+      display_name: id === "default" ? "Cline default" : id,
+    }));
+  }
+  const rows: Array<Record<string, unknown>> = [{
+    id: "default",
     object: "model",
     created: 0,
-    owned_by: "cline-cli",
-    display_name: id === "default" ? "Cline default" : id,
-  }));
+    owned_by: "opencodex",
+    display_name: "Configured default provider",
+  }];
+  for (const providerId of [CLINE_PROVIDER_ID, GEMINI_PROVIDER_ID] as const) {
+    const ids = ["default", ...(known[providerId] ?? []).filter(id => id !== "default")];
+    for (const id of new Set(ids)) {
+      rows.push({
+        id: `${providerId}/${encodeRoutedModelId(id)}`,
+        object: "model",
+        created: 0,
+        owned_by: providerId,
+        display_name: id === "default" ? `${PROVIDER_LABELS[providerId]} default` : id,
+      });
+    }
+  }
+  return rows;
+}
+
+function providerDeps(deps: TurnDepsInput): ProviderTurnDeps {
+  if ("cline" in deps || "gemini" in deps) return deps as ProviderTurnDeps;
+  return { cline: deps as ClineTurnDeps };
+}
+
+function providerModels(known: string[] | ProviderModels, defaultProvider: ProviderId): ProviderModels {
+  return Array.isArray(known) ? { [defaultProvider]: known } : known;
+}
+
+export function routedTurn(
+  parsed: OcxParsedRequest,
+  requestedModel: string,
+  incoming: IncomingMeta,
+  known: string[] | ProviderModels,
+  deps: TurnDepsInput,
+  defaultProvider: ProviderId = CLINE_PROVIDER_ID,
+): { providerId: ProviderId; run: (emit: (event: AdapterEvent) => void) => Promise<void> } {
+  const route = resolveRoutedModel(requestedModel, providerModels(known, defaultProvider), defaultProvider);
+  parsed.modelId = route.modelId;
+  const resolved = providerDeps(deps);
+  return {
+    providerId: route.providerId,
+    run: route.providerId === GEMINI_PROVIDER_ID
+      ? emit => runGeminiTurn(parsed, incoming, emit, resolved.gemini)
+      : emit => runClineTurn(parsed, incoming, emit, resolved.cline),
+  };
 }
 
 function usage(value: OcxUsage | undefined): Record<string, unknown> | null {
@@ -608,12 +698,12 @@ export function streamResponsesResult(
 export async function handleResponses(
   body: unknown,
   incoming: IncomingMeta,
-  knownModels: string[],
-  deps: ClineTurnDeps = {},
+  knownModels: string[] | ProviderModels,
+  deps: TurnDepsInput = {},
+  defaultProvider: ProviderId = CLINE_PROVIDER_ID,
 ): Promise<Response> {
   const parsed = parseResponsesRequest(body);
-  parsed.parsed.modelId = resolveClineModel(parsed.requestedModel, knownModels);
-  const run = (emit: (event: AdapterEvent) => void) => runClineTurn(parsed.parsed, incoming, emit, deps);
+  const { run } = routedTurn(parsed.parsed, parsed.requestedModel, incoming, knownModels, deps, defaultProvider);
   if (parsed.parsed.stream) {
     return new Response(streamResponsesResult(parsed, run, incoming.abortSignal), {
       headers: { "content-type": "text/event-stream; charset=utf-8", "cache-control": "no-cache" },

package/src/types.ts

@@ -89,6 +89,7 @@ export interface OcxParsedRequest {
 export interface OcxUsage {
   inputTokens: number;
   outputTokens: number;
+  modelId?: string;
   totalTokens?: number;
   cachedInputTokens?: number;
   cacheReadInputTokens?: number;