@koreanhole/opencodex 2.99.0 → 3.1.0

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);
+}

package/src/upstream/package.ts

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+
+export const UPSTREAM_PACKAGE_NAME = "@bitkyc08/opencodex";
+export const UPSTREAM_PACKAGE_VERSION = "2.94.0";
+export const UPSTREAM_CLI_RELATIVE_PATH = "src/cli/index.ts";
+
+export interface UpstreamPackage {
+  name: string;
+  version: string;
+  root: string;
+  cliEntry: string;
+}
+
+export class UpstreamPackageError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "UpstreamPackageError";
+  }
+}
+
+export interface ResolveUpstreamPackageDeps {
+  resolvePackageJson?: () => string;
+  readJson?: (path: string) => unknown;
+  exists?: (path: string) => boolean;
+}
+
+/** Resolve the exact immutable upstream package without importing its runtime. */
+export function resolveUpstreamPackage(
+  deps: ResolveUpstreamPackageDeps = {},
+): UpstreamPackage {
+  const resolvePackageJson = deps.resolvePackageJson
+    ?? (() => createRequire(import.meta.url).resolve(UPSTREAM_PACKAGE_NAME + "/package.json"));
+  const readJson = deps.readJson
+    ?? (path => JSON.parse(readFileSync(path, "utf8")) as unknown);
+  const exists = deps.exists ?? existsSync;
+
+  let packageJsonPath: string;
+  try {
+    packageJsonPath = resolvePackageJson();
+  } catch {
+    throw new UpstreamPackageError(
+      UPSTREAM_PACKAGE_NAME + " is not installed. Reinstall this package with its dependencies.",
+    );
+  }
+  let parsed: unknown;
+  try {
+    parsed = readJson(packageJsonPath);
+  } catch {
+    throw new UpstreamPackageError("The installed opencodex package metadata is unreadable.");
+  }
+  const packageJson = parsed && typeof parsed === "object" && !Array.isArray(parsed)
+    ? parsed as Record<string, unknown>
+    : undefined;
+  if (packageJson?.name !== UPSTREAM_PACKAGE_NAME || packageJson.version !== UPSTREAM_PACKAGE_VERSION) {
+    throw new UpstreamPackageError(
+      "Expected " + UPSTREAM_PACKAGE_NAME + "@" + UPSTREAM_PACKAGE_VERSION
+        + ", found " + String(packageJson?.name ?? "unknown") + "@" + String(packageJson?.version ?? "unknown") + ".",
+    );
+  }
+  const root = dirname(packageJsonPath);
+  const cliEntry = join(root, UPSTREAM_CLI_RELATIVE_PATH);
+  if (!exists(cliEntry)) {
+    throw new UpstreamPackageError(
+      UPSTREAM_PACKAGE_NAME + "@" + UPSTREAM_PACKAGE_VERSION + " does not contain " + UPSTREAM_CLI_RELATIVE_PATH + ".",
+    );
+  }
+  return {
+    name: UPSTREAM_PACKAGE_NAME,
+    version: UPSTREAM_PACKAGE_VERSION,
+    root,
+    cliEntry,
+  };
+}