@koreanhole/opencodex 2.95.10 → 2.97.0

package/src/server/responses.ts

@@ -6,8 +6,18 @@ import type {
   OcxTool,
   OcxToolChoice,
   OcxUsage,
+  OcxProviderModel,
 } 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 +44,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 +276,119 @@ 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 ProviderModelEntry = string | OcxProviderModel;
+export type ProviderModels = Partial<Record<ProviderId, readonly ProviderModelEntry[]>>;
+
+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] ?? []).map(modelIdOf)),
+  };
+}
+
+function modelIdOf(model: ProviderModelEntry): string {
+  return typeof model === "string" ? model : model.id;
+}
+
+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 entries = ["default", ...(known[providerId] ?? []).filter(entry => modelIdOf(entry) !== "default")];
+    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: `${providerId}/${encodeRoutedModelId(id)}`,
+        object: "model",
+        created: 0,
+        owned_by: providerId,
+        display_name: info.name ?? (id === "default" ? `${PROVIDER_LABELS[providerId]} default` : id),
+        ...(info.description ? { description: info.description } : {}),
+        ...(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;
+}
+
+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 +722,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,12 +89,26 @@ export interface OcxParsedRequest {
 export interface OcxUsage {
   inputTokens: number;
   outputTokens: number;
+  modelId?: string;
   totalTokens?: number;
   cachedInputTokens?: number;
   cacheReadInputTokens?: number;
   cacheCreationInputTokens?: number;
 }
 
+export interface OcxReasoningLevel {
+  effort: string;
+  description: string;
+}
+
+export interface OcxProviderModel {
+  id: string;
+  name?: string;
+  description?: string;
+  supportedReasoningLevels?: readonly OcxReasoningLevel[];
+  defaultReasoningLevel?: string;
+}
+
 export type AdapterEvent =
   | { type: "heartbeat" }
   | { type: "text_delta"; text: string }