@koreanhole/opencodex 3.1.0 → 3.2.1

package/src/adapters/cli-agent/gemini/live-models.ts

@@ -1,26 +1,11 @@
-import {
-  AcpClient,
-  AcpError,
-  type AcpDeps,
-} from "../acp-client";
 import { geminiBinaryFingerprintSync, resolveGeminiBinary } from "./binary";
-import {
-  buildGeminiAcpEnv,
-  geminiAcpArgs,
-  geminiAcpEnabled,
-  geminiModelIds,
-  probeGeminiAcpSupport,
-  stageGeminiAcpWorkspace,
-} from "./acp";
+import { geminiHeadlessEnabled } from "./headless";
 import { discoverGeminiModelMetadata, mergeGeminiModelDescriptors } from "./model-metadata";
-import {
-  getGeminiRuntime,
-  recordGeminiCompressionThreshold,
-  recordGeminiInitialize,
-} from "./runtime";
+import { getGeminiRuntime, recordGeminiCompressionThreshold } from "./runtime";
+import type { CliAgentTurnDeps } from "../types";
 import type { OcxProviderModel } from "../../../types";
 
-export type GeminiLiveModelsFailure = "not_found" | "unsupported" | "auth_required" | "backoff" | "transport";
+export type GeminiLiveModelsFailure = "not_found" | "unsupported" | "backoff" | "transport";
 
 export type GeminiLiveModelsResult =
   | {
@@ -42,7 +27,7 @@ export type GeminiLiveModelsResult =
 export interface GeminiLiveModelsOptions {
   binary?: string;
   env?: NodeJS.ProcessEnv;
-  deps?: AcpDeps;
+  deps?: CliAgentTurnDeps;
   packageRoot?: string;
   ttlMs?: number;
   forceRefresh?: boolean;
@@ -82,14 +67,14 @@ function staleResult(fingerprint: string, entry: CacheEntry | undefined): Gemini
   };
 }
 
-/** Discover Gemini's advertised model roster without a paid completion. */
+/** Discover the installed Gemini CLI roster from local package metadata. */
 export async function discoverGeminiLiveModels(options: GeminiLiveModelsOptions = {}): Promise<GeminiLiveModelsResult> {
   const sourceEnv = options.env ?? process.env;
   const now = options.now ?? Date.now;
   const ttlMs = options.ttlMs ?? 5 * 60_000;
   const failureBackoffMs = options.failureBackoffMs ?? 60_000;
-  if (!geminiAcpEnabled(sourceEnv)) {
-    return { ok: false, reason: "unsupported", detail: "ACP is disabled by OPENCODEX_GEMINI_ACP=0." };
+  if (!geminiHeadlessEnabled(sourceEnv)) {
+    return { ok: false, reason: "unsupported", detail: "Gemini provider is disabled by OPENCODEX_GEMINI_ACP=0." };
   }
   const binary = options.binary ?? resolveGeminiBinary(undefined, sourceEnv);
   if (!binary) return { ok: false, reason: "not_found", detail: "Gemini CLI not found on PATH." };
@@ -105,33 +90,7 @@ export async function discoverGeminiLiveModels(options: GeminiLiveModelsOptions
       ?? { ok: false, reason: "backoff", detail: "Gemini model discovery is cooling down after a failure.", fingerprint };
   }
 
-  const env = buildGeminiAcpEnv(sourceEnv, options.deps?.platform ?? process.platform);
-  const mode = await probeGeminiAcpSupport(binary, env, { ...options.deps, env: sourceEnv });
-  if (!mode.acp) {
-    failureCache.set(fingerprint, timestamp);
-    if (current) current.lastFailureAt = timestamp;
-    return staleResult(fingerprint, current)
-      ?? { ok: false, reason: "unsupported", detail: "Gemini --help does not advertise --acp.", fingerprint };
-  }
-  const workspace = await stageGeminiAcpWorkspace([], undefined, { sourceEnv });
-  const sessionEnv = {
-    ...env,
-    GEMINI_CLI_HOME: workspace.geminiHome,
-    GEMINI_CLI_SYSTEM_SETTINGS_PATH: workspace.settingsPath,
-  };
-  let client: AcpClient | undefined;
   try {
-    client = await AcpClient.connect({
-      binary,
-      env: sessionEnv,
-      cwd: workspace.cwd,
-      args: geminiAcpArgs(workspace.policyPath),
-      label: "Gemini ACP",
-      fallbackAllowed: false,
-    }, options.deps);
-    if (client.initializeResult) await recordGeminiInitialize(fingerprint, client.initializeResult, sourceEnv);
-    const session = await client.newSession({ cwd: workspace.cwd, mcpServers: [] });
-    const models = geminiModelIds(session);
     const metadata = await discoverGeminiModelMetadata({
       binary,
       env: sourceEnv,
@@ -139,9 +98,16 @@ export async function discoverGeminiLiveModels(options: GeminiLiveModelsOptions
       ...(options.now ? { now: options.now } : {}),
       ...(options.forceRefresh ? { ttlMs: 0 } : {}),
     });
+    const ids = Object.keys(metadata.capabilities);
+    if (ids.length === 0) {
+      failureCache.set(fingerprint, timestamp);
+      if (current) current.lastFailureAt = timestamp;
+      return staleResult(fingerprint, current)
+        ?? { ok: false, reason: "transport", detail: metadata.warning ?? "Gemini model metadata was not found.", fingerprint };
+    }
     await recordGeminiCompressionThreshold(fingerprint, metadata.compressionThreshold, sourceEnv);
     const runtime = await getGeminiRuntime(fingerprint, sourceEnv);
-    const modelInfo = mergeGeminiModelDescriptors(session.availableModels, metadata).map(model => {
+    const modelInfo = mergeGeminiModelDescriptors(ids.map(modelId => ({ modelId })), metadata).map(model => {
       const observed = runtime.models[model.id];
       const contextWindow = observed?.contextSize ?? model.contextWindowTokens;
       return {
@@ -152,32 +118,21 @@ export async function discoverGeminiLiveModels(options: GeminiLiveModelsOptions
         ...(runtime.compressionThreshold !== undefined
           ? { compressionThreshold: runtime.compressionThreshold }
           : {}),
-        inputModalities: [
-          "text" as const,
-          ...(runtime.prompt.image ? ["image" as const] : []),
-        ],
-        loadSession: runtime.loadSession,
+        inputModalities: ["text" as const],
+        loadSession: false,
       };
     });
-    const source = session.availableModels.length > 0 ? "models" : "default";
-    cache.set(fingerprint, { models, modelInfo, source, fetchedAt: timestamp, ...(metadata.warning ? { metadataWarning: metadata.warning } : {}) });
+    cache.set(fingerprint, { models: ids, modelInfo, source: "models", fetchedAt: timestamp, ...(metadata.warning ? { metadataWarning: metadata.warning } : {}) });
     failureCache.delete(fingerprint);
-    return { ok: true, models, modelInfo, source, fingerprint, ...(metadata.warning ? { metadataWarning: metadata.warning } : {}) };
+    return { ok: true, models: ids, modelInfo, source: "models", fingerprint, ...(metadata.warning ? { metadataWarning: metadata.warning } : {}) };
   } catch (error) {
     failureCache.set(fingerprint, timestamp);
     if (current) current.lastFailureAt = timestamp;
-    const stale = staleResult(fingerprint, current);
-    if (error instanceof AcpError && error.authRequired) {
-      return stale ?? { ok: false, reason: "auth_required", detail: error.message, fingerprint };
-    }
-    return stale ?? {
+    return staleResult(fingerprint, current) ?? {
       ok: false,
       reason: "transport",
       detail: error instanceof Error ? error.message : String(error),
       fingerprint,
     };
-  } finally {
-    await client?.terminate();
-    await workspace.cleanup();
   }
 }

package/src/adapters/cli-agent/gemini/runtime.ts

@@ -1,7 +1,6 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { getConfigDir } from "../../../config";
-import type { AcpInitialize } from "../acp-client";
 
 export interface GeminiModelRuntime {
   contextSize?: number;
@@ -12,12 +11,6 @@ export interface GeminiModelRuntime {
 }
 
 export interface GeminiRuntime {
-  loadSession: boolean;
-  prompt: {
-    image: boolean;
-    audio: boolean;
-    embeddedContext: boolean;
-  };
   compressionThreshold?: number;
   models: Record<string, GeminiModelRuntime>;
 }
@@ -38,19 +31,12 @@ function runtimePath(env: NodeJS.ProcessEnv): string {
 }
 
 function emptyRuntime(): GeminiRuntime {
-  return {
-    loadSession: false,
-    prompt: { image: false, audio: false, embeddedContext: false },
-    models: {},
-  };
+  return { models: {} };
 }
 
 function parseRuntime(value: unknown): GeminiRuntime | undefined {
   if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
   const row = value as Record<string, unknown>;
-  const prompt = row.prompt && typeof row.prompt === "object" && !Array.isArray(row.prompt)
-    ? row.prompt as Record<string, unknown>
-    : {};
   const models: Record<string, GeminiModelRuntime> = {};
   if (row.models && typeof row.models === "object" && !Array.isArray(row.models)) {
     for (const [modelId, raw] of Object.entries(row.models as Record<string, unknown>)) {
@@ -67,12 +53,6 @@ function parseRuntime(value: unknown): GeminiRuntime | undefined {
   }
   const threshold = positive(row.compressionThreshold);
   return {
-    loadSession: row.loadSession === true,
-    prompt: {
-      image: prompt.image === true,
-      audio: prompt.audio === true,
-      embeddedContext: prompt.embeddedContext === true,
-    },
     ...(threshold !== undefined && threshold <= 1 ? { compressionThreshold: threshold } : {}),
     models,
   };
@@ -123,47 +103,6 @@ export async function getGeminiRuntime(
   return runtimeCache.get(fingerprint) ?? emptyRuntime();
 }
 
-export async function recordGeminiInitialize(
-  fingerprint: string,
-  initialize: AcpInitialize,
-  env: NodeJS.ProcessEnv = process.env,
-): Promise<void> {
-  await readDisk(env);
-  const current = runtimeCache.get(fingerprint) ?? emptyRuntime();
-  runtimeCache.set(fingerprint, {
-    ...current,
-    loadSession: initialize.capabilities.loadSession,
-    prompt: { ...initialize.capabilities.prompt },
-  });
-  await persist(env).catch(() => undefined);
-}
-
-export async function recordGeminiUsage(
-  fingerprint: string,
-  modelId: string,
-  usedTokens: number,
-  contextSize: number,
-  promptChars: number,
-  env: NodeJS.ProcessEnv = process.env,
-): Promise<void> {
-  if (!positive(contextSize) || !nonNegative(usedTokens) || !nonNegative(promptChars)) return;
-  await readDisk(env);
-  const current = runtimeCache.get(fingerprint) ?? emptyRuntime();
-  const previous = current.models[modelId];
-  const charsPerToken = usedTokens > 0 && promptChars > 0
-    ? promptChars / usedTokens
-    : previous?.charsPerToken;
-  current.models[modelId] = {
-    contextSize,
-    usedTokens,
-    promptChars,
-    ...(charsPerToken !== undefined ? { charsPerToken } : {}),
-    observedAt: Date.now(),
-  };
-  runtimeCache.set(fingerprint, current);
-  await persist(env).catch(() => undefined);
-}
-
 export async function recordGeminiCompressionThreshold(
   fingerprint: string,
   threshold: number | undefined,

package/src/adapters/cli-agent/protocol.ts

@@ -19,6 +19,7 @@ export type StreamMessage = Record<string, unknown>;
 export async function* readJsonLines(
   chunks: AsyncIterable<Uint8Array>,
   limits: { maxLineBytes?: number; maxTotalBytes?: number } = {},
+  label = "Cline",
 ): AsyncGenerator<StreamMessage> {
   const maxLineBytes = limits.maxLineBytes ?? MAX_STREAM_LINE_BYTES;
   const maxTotalBytes = limits.maxTotalBytes ?? MAX_STREAM_TOTAL_BYTES;
@@ -34,10 +35,10 @@ export async function* readJsonLines(
     try {
       parsed = JSON.parse(trimmed);
     } catch {
-      throw new CodingAgentProtocolError(`Malformed Cline JSON frame: ${trimmed.slice(0, 64)}`);
+      throw new CodingAgentProtocolError(`Malformed ${label} JSON frame: ${trimmed.slice(0, 64)}`);
     }
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new CodingAgentProtocolError(`Non-object Cline JSON frame: ${trimmed.slice(0, 64)}`);
+      throw new CodingAgentProtocolError(`Non-object ${label} JSON frame: ${trimmed.slice(0, 64)}`);
     }
     yield parsed as StreamMessage;
   };
@@ -49,7 +50,7 @@ export async function* readJsonLines(
       const end = newline < 0 ? text.length : newline;
       const part = text.slice(start, end);
       lineBytes += Buffer.byteLength(part);
-      if (lineBytes > maxLineBytes) throw new CodingAgentProtocolError("Cline stream line exceeded the byte limit");
+      if (lineBytes > maxLineBytes) throw new CodingAgentProtocolError(`${label} stream line exceeded the byte limit`);
       if (part) parts.push(part);
       if (newline < 0) break;
       const line = parts.join("");
@@ -62,7 +63,7 @@ export async function* readJsonLines(
 
   for await (const chunk of chunks) {
     totalBytes += chunk.byteLength;
-    if (totalBytes > maxTotalBytes) throw new CodingAgentProtocolError("Cline stream exceeded the total byte limit");
+    if (totalBytes > maxTotalBytes) throw new CodingAgentProtocolError(`${label} stream exceeded the total byte limit`);
     yield* consume(decoder.decode(chunk, { stream: true }));
   }
   yield* consume(decoder.decode());

package/src/server/index.ts

@@ -31,6 +31,8 @@ export interface ServerOptions {
   geminiDeps?: GeminiTurnDeps;
   geminiPackageRoot?: string;
   providerScope?: ProviderId;
+  /** Test seam for exercising Bun's idle timeout; production uses 255 seconds. */
+  idleTimeoutSeconds?: number;
   onWebSocketRequest?: (observation: WebSocketRequestObservation) => void;
 }
 
@@ -148,6 +150,9 @@ export function startServer(config: RuntimeConfig | number, options: ServerOptio
       return new Response("WebSocket upgrade failed.", { status: 400 });
     }
     try {
+      if (req.method === "POST" && (url.pathname === "/v1/responses" || url.pathname === "/v1/messages")) {
+        try { bunServer.timeout(req, 0); } catch { /* request already closed */ }
+      }
       if (req.method === "GET" && url.pathname === "/v1/models") {
         const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot, options.providerScope);
         return Response.json({ object: "list", data: modelList(known, options.providerScope) });
@@ -193,7 +198,7 @@ export function startServer(config: RuntimeConfig | number, options: ServerOptio
   server = Bun.serve({
     hostname: config.host,
     port: config.port,
-    idleTimeout: 255,
+    idleTimeout: options.idleTimeoutSeconds ?? 255,
     fetch,
     websocket: createWebSocketHandlers(websocketContext),
   });

package/src/server/websocket.ts

@@ -146,6 +146,10 @@ async function forwardStream(
   const reader = stream.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
+  const ping = setInterval(() => {
+    if (ws.data.closed) return;
+    try { ws.ping(); } catch { /* client gone */ }
+  }, 5_000);
   try {
     while (!ws.data.closed && !signal.aborted) {
       const { done, value } = await reader.read();
@@ -165,6 +169,7 @@ async function forwardStream(
       }
     }
   } finally {
+    clearInterval(ping);
     try { await reader.cancel(); } catch { /* client gone */ }
   }
 }