@koreanhole/opencodex 3.2.8 → 3.2.10

package/AGENTS_INSTALL.md

@@ -48,8 +48,9 @@ or through the documented default path; unrelated Codex settings are not changed
   only exception is Cline's mode-0600 request-scoped staging copy.
 - Do not authenticate on a request path. If Cline reports `auth_required`, stop
   and ask the operator to run `ocx login cline-cli`.
-- Do not edit the operator's real Cline provider store. Read it only to create a
-  mode-0600 request-scoped copy; remove that copy after the turn.
+- Do not edit the operator's real Cline provider store or legacy
+  `globalState.json`/`secrets.json`. Read them only to create mode-0600
+  request-scoped copies; remove those copies after the turn.
 - Do not import or replay Gemini OAuth/API-key material; the Gemini CLI remains
   the authentication authority.
 - Gemini headless turns support explicit Gemini Developer API, Vertex AI GenAI,
@@ -88,9 +89,9 @@ Before claiming the proxy works, run:
 ```bash
 bun run verify:upstream
 bun run typecheck
-bun test tests/e2e/cline-only.test.ts
+bun run test:e2e
+bun run test:e2e:cline-live
 bun run test:e2e:gemini
-bun run test:e2e:gemini-oauth
 bun run test:e2e:gemini-tool
 bun run test:e2e:gemini-reasoning
 bun run test:e2e:codex-restore
@@ -99,6 +100,7 @@ bun run test:e2e:codex-restore
 Report whether each evidence path used a deterministic fixture or a real
 vendor binary/account. The Gemini command above is a hard live gate: missing
 binaries, authentication, a Flash Lite model, or cleanup evidence must fail.
-The OAuth gate additionally removes API-key/Vertex environment values and the
-vendor `.env`.
+The Cline live command is also a hard gate: missing binary, authentication,
+response, or cleanup evidence must fail. The 2.2.0 HTTP fixture must never be
+reported as a real vendor run.
 Never report a skipped or synthetic run as a real login.

package/README.md

@@ -3,8 +3,9 @@
 This distribution keeps the complete original
 [`@bitkyc08/opencodex`](https://github.com/lidge-jun/opencodex) runtime and adds
 locally installed Cline CLI and Gemini CLI as model providers. Cline turns use
-the CLI's one-shot `--json` mode after a runtime `--help` capability check;
-Gemini turns use the CLI's one-shot `-p` stream-json mode.
+the CLI's one-shot `--json` mode after a runtime `--help` capability check and
+support both the Cline 2.2.0 raw-message contract and the current structured
+contract; Gemini turns use the CLI's one-shot `-p` stream-json mode.
 
 The original package is an exact npm dependency. This repository does not copy,
 patch, delete, or rewrite upstream source files. The `ocx` entrypoint loads the
@@ -37,6 +38,9 @@ does not automate Google OAuth. OAuth reuse requires an account and tier eligibl
 for the installed Gemini CLI's service; explicit API-key or Vertex environment
 configuration takes precedence over automatic OAuth selection.
 
+Cline 2.2.0 is the minimum supported release. Newer options are used only when
+the installed binary advertises them.
+
 ## Start
 
 ```bash
@@ -51,7 +55,8 @@ through the same `ocx` command.
 
 The managed provider rows appear as `gemini-cli/...` and `cline-cli/...`.
 Cline model discovery and explicit login use ACP, while Cline model turns use
-the installed CLI's JSON transport. Gemini runtime model discovery uses the
+the installed CLI's JSON transport across the 2.2.0 and current output contracts.
+Gemini runtime model discovery uses the
 installed CLI's ACP session, while reasoning metadata and model turns use the
 installed CLI's headless transport. Parent-declared tools are exposed through a
 request-scoped capture MCP server.
@@ -131,8 +136,9 @@ the blocker.
 - Cline does not receive filesystem or terminal capability from the proxy.
 - Cline runs with request-scoped, mode-0600 settings. Its built-in tools, user
   MCP servers, hooks, plugins, telemetry, updates, and self-approval are disabled.
-  Its turn options are used only after the installed binary's `--help` output
-  advertises them.
+  Modern provider state and legacy global/secrets state are copied privately;
+  the originals are never modified. Its turn options are used only after the
+  installed binary's `--help` output advertises them.
 - Gemini headless turns run in a request-scoped workspace with
   `GEMINI_CLI_TRUST_WORKSPACE=true`, `--skip-trust`, and
   `--approval-mode auto_edit`, but the generated isolated Gemini home settings
@@ -159,8 +165,8 @@ bun run verify:upstream
 bun run typecheck
 bun test tests
 bun run test:e2e
+bun run test:e2e:cline-live
 bun run test:e2e:gemini
-bun run test:e2e:gemini-oauth
 bun run test:e2e:gemini-slow
 bun run test:e2e:gemini-parent-tool
 bun run privacy:scan
@@ -172,9 +178,11 @@ a real Codex client and a real authenticated Gemini CLI. It runs both the minima
 completion and a 12-second pre-event slow-start regression. It fails, not skips,
 on a missing binary, authentication, Flash Lite model, response marker, timeout,
 or child cleanup assertion. `test:e2e:gemini-slow` runs only the slow-start case.
-`test:e2e:gemini-oauth` strips API-key and Vertex environment values, removes the
-vendor `.env`, and requires a real OAuth-backed completion through Codex and the
-installed Gemini CLI.
+
+`test:e2e` exercises the Cline 2.2.0-compatible contract through the real HTTP
+server. `test:e2e:cline-live` additionally requires the installed Cline CLI and
+its existing authentication, and fails rather than skipping on a missing
+binary, response marker, or cleanup assertion.
 
 Optional overrides are `CLINE_BIN_PATH`, `GEMINI_BIN_PATH`, and
 `CODEX_BIN_PATH`.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@koreanhole/opencodex",
-  "version": "3.2.8",
-  "description": "Full opencodex runtime with Cline JSON and Gemini CLI headless provider adapters",
+  "version": "3.2.10",
+  "description": "Full opencodex runtime with Cline 2.2.0+ JSON and Gemini CLI headless provider adapters",
   "type": "module",
   "main": "./bin/package-main.mjs",
   "exports": {
@@ -30,8 +30,8 @@
     "start": "bun run src/cli/entry.ts start",
     "test": "bun test tests",
     "test:e2e": "bun test tests/e2e/cline-only.test.ts",
+    "test:e2e:cline-live": "bun test ./tests/e2e/cline-live.live.ts",
     "test:e2e:gemini": "bun test ./tests/e2e/gemini-codex.live.ts -t \"full-stack:\"",
-    "test:e2e:gemini-oauth": "bun test ./tests/e2e/gemini-codex.live.ts -t \"uses an existing Gemini CLI OAuth login without an API key\"",
     "test:e2e:gemini-slow": "bun test ./tests/e2e/gemini-codex.live.ts -t \"full-stack: a slow Gemini start\"",
     "test:e2e:gemini-tool": "bun test ./tests/e2e/gemini-codex.live.ts -t \"one short Gemini turn leaves the workspace unchanged\"",
     "test:e2e:gemini-multiturn": "bun test ./tests/e2e/gemini-codex.live.ts -t \"reuses a live Codex multi-turn session\"",

package/src/adapter-runtime/config.ts

@@ -188,8 +188,8 @@ function isLegacyProviderRow(name: AdapterProviderId, value: unknown): boolean {
   return row?.adapter === name;
 }
 
-function uniqueModels(metadata: AdapterModelMetadata | undefined): string[] {
-  return [...new Set(["default", ...(metadata?.models ?? [])].filter(Boolean))];
+function uniqueModels(name: AdapterProviderId, metadata: AdapterModelMetadata | undefined): string[] {
+  return [...new Set([...(name === "cline-cli" ? ["default"] : []), ...(metadata?.models ?? [])].filter(Boolean))];
 }
 
 export function buildManagedProviderRow(
@@ -208,7 +208,7 @@ export function buildManagedProviderRow(
     allowPrivateNetwork: true,
     liveModels: true,
     defaultModel: "default",
-    models: uniqueModels(metadata),
+    models: uniqueModels(name, metadata),
     ...(metadata.modelDisplayNames ? { modelDisplayNames: metadata.modelDisplayNames } : {}),
     ...(metadata.modelContextWindows ? { modelContextWindows: metadata.modelContextWindows } : {}),
     ...(metadata.modelInputModalities ? { modelInputModalities: metadata.modelInputModalities } : {}),

package/src/adapters/cli-agent/cline/adapter.ts

@@ -102,12 +102,23 @@ function toolNameMap(catalog: ReturnType<typeof buildCodingAgentToolCatalog>): M
   return names;
 }
 
-function systemPromptWithToolNames(catalog: ReturnType<typeof buildCodingAgentToolCatalog>): string {
-  if (catalog.emittedNameMap.size === 0) return CLINE_SYSTEM_PROMPT;
+function systemPromptWithToolNames(
+  catalog: ReturnType<typeof buildCodingAgentToolCatalog>,
+  legacy: boolean,
+): string {
   const mappings = [...catalog.emittedNameMap]
-    .map(([vendorName, wireName]) => `- ${wireName}: call ${vendorName.replace(/^mcp__/, "")}`)
+    .map(([vendorName, wireName]) => legacy
+      ? `- ${wireName}: call server opencodex tool ${wireName}`
+      : `- ${wireName}: call ${vendorName.replace(/^mcp__/, "")}`)
     .join("\n");
-  return `${CLINE_SYSTEM_PROMPT}\nExternal tools in client instructions map to these exact callable tools:\n${mappings}`;
+  const legacyCompletion = legacy
+    ? "Cline 2.2.0 requires the final answer in an attempt_completion tool call. This completion call is an exception to the unavailable built-in tools rule; it only ends the turn and performs no external action."
+    : "";
+  return [
+    CLINE_SYSTEM_PROMPT,
+    legacyCompletion,
+    ...(mappings ? ["External tools in client instructions map to these exact callable tools:", mappings] : []),
+  ].filter(Boolean).join("\n");
 }
 
 function failure(error: unknown): Extract<AdapterEvent, { type: "error" }> {
@@ -191,7 +202,7 @@ export async function runClineTurn(
     wireName,
     wireName.startsWith("opencodex__") ? wireName : `opencodex__${wireName}`,
   ]));
-  const fixedSystem = systemPromptWithToolNames(catalog);
+  const fixedSystem = systemPromptWithToolNames(catalog, !capabilities.toolCatalogJson);
   const actualPrompt = buildClinePrompt(parsed, vendorNameByWire, fixedSystem);
   let args: string[];
   try {
@@ -215,34 +226,36 @@ export async function runClineTurn(
       ...(catalog.emittedNameMap.size > 0 ? { mcpLaunch: mcpLaunch() } : {}),
     });
     const env = buildClineChildEnv(staged, sourceEnv);
-    const preflight = deps.preflightTools ?? preflightClineTools;
-    let tools = await preflight({
-      binary,
-      env,
-      cwd: staged.workspaceDir,
-      capabilities,
-      deps,
-    });
-    if (!tools.ok && tools.enabledTools && tools.enabledTools.length > 0) {
-      await mergeClineDisabledTools(staged, tools.enabledTools.map(tool => tool.id));
-      tools = await preflight({
+    if (capabilities.toolCatalogJson) {
+      const preflight = deps.preflightTools ?? preflightClineTools;
+      let tools = await preflight({
         binary,
         env,
         cwd: staged.workspaceDir,
         capabilities,
         deps,
       });
-    }
-    if (!tools.ok) {
-      emit({
-        type: "error",
-        message: tools.detail || "Cline tool preflight failed.",
-        status: 502,
-        errorType: "upstream_error",
-        code: "cline_tool_preflight_failed",
-        retryable: false,
-      });
-      return;
+      if (!tools.ok && tools.enabledTools && tools.enabledTools.length > 0) {
+        await mergeClineDisabledTools(staged, tools.enabledTools.map(tool => tool.id));
+        tools = await preflight({
+          binary,
+          env,
+          cwd: staged.workspaceDir,
+          capabilities,
+          deps,
+        });
+      }
+      if (!tools.ok) {
+        emit({
+          type: "error",
+          message: tools.detail || "Cline tool preflight failed.",
+          status: 502,
+          errorType: "upstream_error",
+          code: "cline_tool_preflight_failed",
+          retryable: false,
+        });
+        return;
+      }
     }
 
     const promptFile = join(staged.root, "prompt.txt");

package/src/adapters/cli-agent/cline/json.ts

@@ -24,7 +24,6 @@ const MAX_PREFLIGHT_STDOUT_BYTES = 2 * 1024 * 1024;
 const MAX_STDERR_BYTES = 8 * 1024;
 const DEFAULT_TIMEOUT_MS = 300_000;
 const DEFAULT_KILL_GRACE_MS = 2_000;
-const DEFAULT_TOOL_BATCH_IDLE_MS = 250;
 const MAX_TOOL_CALLS = 16;
 
 export class ClineJsonError extends Error {
@@ -46,6 +45,7 @@ export interface ClineJsonCapabilities {
   providerFlag?: "--provider";
   modelFlag?: "--model" | "--modelid";
   systemFlag?: "--system";
+  autoApproveFlag?: "--auto-approve";
 }
 
 export interface ClineJsonTurnInput {
@@ -109,12 +109,14 @@ export function parseClineJsonHelp(
       ? "--modelid" as const
       : undefined;
   const systemFlag = optionPresent(text, "--system") ? "--system" as const : undefined;
+  const autoApproveFlag = optionPresent(text, "--auto-approve") ? "--auto-approve" as const : undefined;
   return {
     json,
     toolCatalogJson: false,
     ...(providerFlag ? { providerFlag } : {}),
     ...(modelFlag ? { modelFlag } : {}),
     ...(systemFlag ? { systemFlag } : {}),
+    ...(autoApproveFlag ? { autoApproveFlag } : {}),
   };
 }
 
@@ -240,19 +242,10 @@ export async function probeClineJsonCapabilities(
   }
   if (tools.exitCode !== 0) throw probeFailure("cline_tool_catalog_probe_failed", tools.stderr || tools.stdout);
   const toolCatalog = parseClineJsonHelp(tools.stdout + "\n" + tools.stderr, "toolCatalog");
-  if (!toolCatalog.toolCatalogJson) {
-    throw new ClineJsonError(
-      "The installed Cline CLI does not advertise config tools --json; the tool preflight cannot run safely.",
-      400,
-      "invalid_request_error",
-      "cline_tool_catalog_unsupported",
-      false,
-    );
-  }
 
   const capabilities: ClineJsonCapabilities = {
     ...turn,
-    toolCatalogJson: true,
+    toolCatalogJson: toolCatalog.toolCatalogJson,
   };
   if (fingerprint) CAPABILITY_CACHE.set(path, { ...fingerprint, capabilities: { ...capabilities } });
   return capabilities;
@@ -287,6 +280,9 @@ export function buildClineJsonArgs(input: {
   if (input.capabilities.systemFlag && input.systemPrompt) {
     args.push(input.capabilities.systemFlag, input.systemPrompt);
   }
+  if (input.capabilities.autoApproveFlag) {
+    args.push(input.capabilities.autoApproveFlag, "false");
+  }
   args.push(input.prompt);
   return args;
 }
@@ -403,7 +399,6 @@ export async function runClineJsonTurn(
   const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const killGraceMs = deps.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
   const reapTimeoutMs = deps.reapTimeoutMs ?? killGraceMs * 2 + 250;
-  const toolBatchIdleMs = deps.toolBatchIdleMs ?? DEFAULT_TOOL_BATCH_IDLE_MS;
   const state = createClineStreamState();
   const maxToolCalls = Math.min(input.maxToolCalls, MAX_TOOL_CALLS);
   const stderr: string[] = [];
@@ -417,7 +412,6 @@ export async function runClineJsonTurn(
   let exitCode: number | null = null;
   let timeoutTimer: ReturnType<typeof setTimeout> | undefined;
   let killTimer: ReturnType<typeof setTimeout> | undefined;
-  let toolIdleTimer: ReturnType<typeof setTimeout> | undefined;
 
   const deliver = (event: AdapterEvent): void => {
     const terminal = event.type === "done" && input.requireToolCall && state.toolCalls === 0
@@ -484,15 +478,6 @@ export async function runClineJsonTurn(
     });
   };
 
-  const armToolIdle = (): void => {
-    if (terminalEmitted || toolBatchStopped || state.toolCalls === 0) return;
-    if (toolIdleTimer) clearTimeout(toolIdleTimer);
-    toolIdleTimer = setTimeout(() => {
-      toolBatchStopped = true;
-      kill();
-    }, toolBatchIdleMs);
-  };
-
   let lifecycle: Promise<void> | undefined;
   try {
     const invocation = commandInvocation(input.binary, input.args, platform, { env: input.env });
@@ -588,7 +573,12 @@ export async function runClineJsonTurn(
       }
       for (const event of events) deliver(event);
       if (terminalEmitted) break;
-      armToolIdle();
+      if (state.toolCalls > 0) {
+        toolBatchStopped = true;
+        kill();
+        stopStdout();
+        break;
+      }
     }
 
     if (!terminalEmitted && !aborted && !timedOut) {
@@ -637,7 +627,6 @@ export async function runClineJsonTurn(
     if (!terminalEmitted) deliver(errorEvent(error));
   } finally {
     if (timeoutTimer) clearTimeout(timeoutTimer);
-    if (toolIdleTimer) clearTimeout(toolIdleTimer);
     input.incoming.abortSignal?.removeEventListener("abort", onAbort);
     try { child?.stdin?.destroy(); } catch { /* already closed */ }
     if (child && child.exitCode === null && !child.killed) kill();

package/src/adapters/cli-agent/cline/settings.ts

@@ -1,6 +1,6 @@
 import { link, mkdir, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { baseScopedEnv } from "../env";
 
 /** Built-in, subagent, and team tools that a model-only Cline turn must never enable. */
@@ -59,6 +59,8 @@ export interface ClineStagedTurn {
   workspaceDir: string;
   hooksDir: string;
   providerSettingsPath: string;
+  legacyGlobalStatePath: string;
+  legacySecretsPath?: string;
   globalSettingsPath: string;
   mcpSettingsPath: string;
   catalogPath: string;
@@ -292,6 +294,69 @@ function clineGlobalSettings(): Record<string, unknown> {
   };
 }
 
+function legacyClineSafetyState(value: unknown): Record<string, unknown> {
+  const state = asRecord(value) ?? {};
+  return {
+    ...state,
+    yoloModeToggled: false,
+    autoApproveAllToggled: false,
+    clineWebToolsEnabled: false,
+    subagentsEnabled: false,
+    skillsEnabled: false,
+    autoApprovalSettings: {
+      version: 1,
+      enabled: false,
+      favorites: [],
+      maxRequests: 0,
+      actions: {
+        readFiles: false,
+        readFilesExternally: false,
+        editFiles: false,
+        editFilesExternally: false,
+        executeSafeCommands: false,
+        executeAllCommands: false,
+        useBrowser: false,
+        useMcp: false,
+      },
+      enableNotifications: false,
+    },
+  };
+}
+
+async function stageLegacyClineState(
+  providerSettingsPath: string,
+  dataDir: string,
+): Promise<{ globalStatePath: string; secretsPath?: string }> {
+  const settingsDir = dirname(providerSettingsPath);
+  const sourceDataDir = basename(settingsDir) === "settings" ? dirname(settingsDir) : undefined;
+  const globalStatePath = join(dataDir, "globalState.json");
+  let sourceState: unknown;
+  if (sourceDataDir) {
+    try {
+      sourceState = JSON.parse(await readFile(join(sourceDataDir, "globalState.json"), "utf8"));
+    } catch {
+      sourceState = undefined;
+    }
+  }
+  await writeFile(globalStatePath, `${JSON.stringify(legacyClineSafetyState(sourceState), null, 2)}\n`, {
+    encoding: "utf8",
+    mode: 0o600,
+    flag: "wx",
+  });
+
+  let secretsPath: string | undefined;
+  if (sourceDataDir) {
+    try {
+      const bytes = await readFile(join(sourceDataDir, "secrets.json"));
+      secretsPath = join(dataDir, "secrets.json");
+      await writeFile(secretsPath, bytes, { mode: 0o600, flag: "wx" });
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+  return { globalStatePath, ...(secretsPath ? { secretsPath } : {}) };
+}
+
 function clineMcpArgs(launch: ClineMcpLaunch, catalogPath: string): string[] {
   return launch.kind === "module"
     ? [launch.modulePath, catalogPath]
@@ -300,13 +365,18 @@ function clineMcpArgs(launch: ClineMcpLaunch, catalogPath: string): string[] {
 
 function clineMcpSettings(launch: ClineMcpLaunch | undefined, catalogPath: string): Record<string, unknown> {
   if (!launch) return { mcpServers: {} };
+  const args = clineMcpArgs(launch, catalogPath);
   return {
     mcpServers: {
       opencodex: {
+        command: process.execPath,
+        args,
+        disabled: false,
+        autoApprove: [],
         transport: {
           type: "stdio",
           command: process.execPath,
-          args: clineMcpArgs(launch, catalogPath),
+          args,
         },
       },
     },
@@ -406,6 +476,7 @@ export async function stageClineTurn(options: {
       writeFile(mcpSettingsPath, `${JSON.stringify(clineMcpSettings(options.mcpLaunch, catalogPath), null, 2)}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" }),
       writeFile(catalogPath, JSON.stringify(options.catalog), { encoding: "utf8", mode: 0o600, flag: "wx" }),
     ]);
+    const legacyState = await stageLegacyClineState(options.providerSettingsPath, join(configDir, "data"));
     const copiedProviderStore = await copyClineProviderSettings(options.providerSettingsPath, providerSettingsPath);
     await linkClineSettings({
       dataDir,
@@ -423,6 +494,8 @@ export async function stageClineTurn(options: {
       workspaceDir,
       hooksDir,
       providerSettingsPath,
+      legacyGlobalStatePath: legacyState.globalStatePath,
+      ...(legacyState.secretsPath ? { legacySecretsPath: legacyState.secretsPath } : {}),
       globalSettingsPath,
       mcpSettingsPath,
       catalogPath,

package/src/adapters/cli-agent/cline/stream.ts

@@ -99,6 +99,121 @@ function usageFrom(value: unknown): OcxUsage | undefined {
   };
 }
 
+function legacyUsageFrom(value: unknown): OcxUsage | undefined {
+  if (typeof value !== "string") return undefined;
+  try {
+    const record = asRecord(JSON.parse(value));
+    if (!record) return undefined;
+    return usageFrom({
+      inputTokens: record.tokensIn,
+      outputTokens: record.tokensOut,
+      cacheReadTokens: record.cacheReads,
+      cacheWriteTokens: record.cacheWrites,
+    });
+  } catch {
+    return undefined;
+  }
+}
+
+function legacyDone(state: CliAgentStreamState, text?: string): AdapterEvent[] {
+  if (state.toolCalls > 0) return [];
+  state.terminal = true;
+  const events: AdapterEvent[] = [];
+  if (!state.sawThinking && state.legacyThinking) {
+    state.sawThinking = true;
+    events.push({ type: "thinking_delta", thinking: state.legacyThinking });
+  }
+  const finalText = text || state.legacyText;
+  if (!state.sawText && finalText) {
+    state.sawText = true;
+    events.push({ type: "text_delta", text: finalText });
+  }
+  events.push({ type: "done", stopReason: "stop", ...(state.usage ? { usage: state.usage } : {}) });
+  return events;
+}
+
+function legacyError(message: string, state: CliAgentStreamState): AdapterEvent[] {
+  state.lastError = message;
+  state.terminal = true;
+  return [{ type: "error", message, ...classifyError(message) }];
+}
+
+function legacyMcpRequest(
+  text: string | undefined,
+  state: CliAgentStreamState,
+  options: ClineStreamOptions,
+): AdapterEvent[] {
+  if (state.toolCalls > 0) return [];
+  let record: Record<string, unknown> | undefined;
+  if (text) {
+    try {
+      record = asRecord(JSON.parse(text));
+    } catch {
+      record = undefined;
+    }
+  }
+  if (!record || record.type !== "use_mcp_tool" || record.serverName !== "opencodex") {
+    throw new ClineStreamProtocolError("Cline requested an MCP interaction outside the isolated capture-only server.");
+  }
+  const toolName = asString(record.toolName);
+  if (!toolName) throw new ClineStreamProtocolError("Cline returned an MCP tool call without a name.");
+  return mapClineToolIntent(toolName, undefined, record.arguments, state, options);
+}
+
+function mapLegacyMessage(
+  message: Record<string, unknown>,
+  state: CliAgentStreamState,
+  options: ClineStreamOptions,
+): AdapterEvent[] {
+  if (message.partial === true) return [];
+  const type = asString(message.type);
+  if (type === "completion") {
+    const status = asString(message.status);
+    const text = asString(message.text);
+    if (status === "error") {
+      return legacyError(safeMessage(message.message ?? text ?? "Cline reported an error."), state);
+    }
+    if (status === "success") return legacyDone(state, text);
+    return [];
+  }
+  if (type === "say") {
+    const say = asString(message.say);
+    const text = asString(message.text);
+    if (say === "text") {
+      if (!text) return [];
+      state.legacyText = text;
+      return [];
+    }
+    if (say === "reasoning") {
+      const reasoning = asString(message.reasoning) ?? text;
+      if (!reasoning) return [];
+      state.legacyThinking = reasoning;
+      return [];
+    }
+    if (say === "completion_result") return legacyDone(state, text);
+    if (say === "error") return legacyError(safeMessage(text ?? "Cline reported an error."), state);
+    if (say === "use_mcp_server") return legacyMcpRequest(text, state, options);
+    if (say === "api_req_finished") {
+      state.usage = legacyUsageFrom(text) ?? state.usage;
+      return [];
+    }
+    if (say === "tool" || say === "command" || say === "command_output" || say === "browser_action"
+      || say === "browser_action_result" || say === "mcp_server_request_started" || say === "mcp_server_response") {
+      throw new ClineStreamProtocolError("Cline attempted a tool action outside the capture-only boundary.");
+    }
+    return [];
+  }
+  if (type === "ask") {
+    const ask = asString(message.ask);
+    const text = asString(message.text);
+    if (ask === "completion_result") return legacyDone(state, text);
+    if (ask === "api_req_failed") return legacyError(safeMessage(text ?? "Cline API request failed."), state);
+    if (ask === "use_mcp_server") return legacyMcpRequest(text, state, options);
+    throw new ClineStreamProtocolError("Cline requested an interactive approval that capture-only headless mode cannot grant.");
+  }
+  return [];
+}
+
 function mapAgentEvent(
   event: Record<string, unknown>,
   state: CliAgentStreamState,
@@ -187,6 +302,9 @@ export function mapClineMessage(
 ): AdapterEvent[] {
   if (state.terminal) return [];
   const type = asString(message.type);
+  if (type === "say" || type === "ask" || type === "completion" || type === "task_started") {
+    return mapLegacyMessage(message, state, options);
+  }
   if (type === "agent_event") {
     const event = asRecord(message.event);
     return event ? mapAgentEvent(event, state, options) : [];

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

@@ -204,6 +204,7 @@ export async function discoverGeminiLiveModels(options: GeminiLiveModelsOptions
   }
 
   const runtimeIds = runtime?.map(model => model.modelId) ?? [];
+  const runtimeAvailable = runtimeIds.length > 0;
   const ids = runtimeIds.length > 0 ? runtimeIds : Object.keys(metadata.capabilities);
   if (ids.length === 0) {
     failureCache.set(fingerprint, timestamp);
@@ -252,9 +253,11 @@ export async function discoverGeminiLiveModels(options: GeminiLiveModelsOptions
       loadSession: false,
     };
   });
-  const modelInfoWithDefault = [defaultModelInfo(metadata, modelInfo), ...modelInfo.filter(model => model.id !== "default")];
+  const modelInfoWithDefault = runtimeAvailable
+    ? modelInfo
+    : [defaultModelInfo(metadata, modelInfo), ...modelInfo.filter(model => model.id !== "default")];
   const warning = metadata.warning
-    ?? (runtimeError ? "Gemini runtime model discovery failed; using installed CLI metadata." : undefined);
+    ?? (runtimeAvailable ? undefined : "Gemini runtime model discovery failed; using installed CLI metadata.");
   cache.set(fingerprint, { models: ids, modelInfo: modelInfoWithDefault, source: "models", fetchedAt: timestamp, ...(warning ? { metadataWarning: warning } : {}) });
   failureCache.delete(fingerprint);
   return { ok: true, models: ids, modelInfo: modelInfoWithDefault, source: "models", fingerprint, ...(warning ? { metadataWarning: warning } : {}) };

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

@@ -15,6 +15,8 @@ export interface CliAgentStreamState {
   nextToolOrdinal: number;
   usage?: OcxUsage;
   lastError?: string;
+  legacyText?: string;
+  legacyThinking?: string;
 }
 
 export interface CliAgentTurnDeps {

package/src/lib/codex-catalog.ts

@@ -178,12 +178,14 @@ function defaultModel(): OcxProviderModel {
   return { id: "default" };
 }
 
-function normalizedModels(models: readonly OcxProviderModel[]): OcxProviderModel[] {
+function normalizedModels(models: readonly OcxProviderModel[], includeDefault = true): OcxProviderModel[] {
   const defaultInfo = models.find(model => model.id === "default");
-  const out: OcxProviderModel[] = [{ ...defaultModel(), ...(defaultInfo ?? {}), id: "default" }];
-  const seen = new Set<string>(["default"]);
+  const out: OcxProviderModel[] = includeDefault
+    ? [{ ...defaultModel(), ...(defaultInfo ?? {}), id: "default" }]
+    : [];
+  const seen = new Set<string>(includeDefault ? ["default"] : []);
   for (const model of models) {
-    if (model.id === "default" || seen.has(model.id)) continue;
+    if ((includeDefault && model.id === "default") || seen.has(model.id)) continue;
     seen.add(model.id);
     out.push(model);
   }
@@ -207,7 +209,7 @@ export async function discoverCodexCatalogModels(options: CodexCatalogDiscoveryO
   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 : []);
+  const geminiModels = normalizedModels(gemini.ok ? gemini.modelInfo : [], false);
   const geminiDefault = geminiModels.find(model => model.id === "default");
   const geminiContexts = geminiModels.flatMap(model => model.contextWindowTokens !== undefined ? [model.contextWindowTokens] : []);
   if (geminiDefault && geminiContexts.length > 0) {

package/src/server/index.ts

@@ -118,7 +118,7 @@ async function discoverModels(
   }
   if (gemini) {
     models["gemini-cli"] = gemini.ok
-      ? ["default", ...gemini.modelInfo.filter(model => model.id !== "default")]
+      ? gemini.modelInfo.map(model => model.id)
       : ["default"];
   }
   return models;

package/src/server/responses.ts

@@ -379,6 +379,16 @@ const PROVIDER_LABELS: Record<ProviderId, string> = {
   [GEMINI_PROVIDER_ID]: "Gemini CLI",
 };
 
+function listedProviderEntries(
+  known: ProviderModels,
+  providerId: ProviderId,
+): readonly ProviderModelEntry[] {
+  const entries = known[providerId] ?? [];
+  if (providerId === GEMINI_PROVIDER_ID && entries.length > 0) return entries;
+  const defaultEntry = entries.find(entry => modelIdOf(entry) === "default") ?? "default";
+  return [defaultEntry, ...entries.filter(entry => modelIdOf(entry) !== "default")];
+}
+
 export function modelList(
   known: string[] | ProviderModels,
   scope?: ProviderId,
@@ -394,8 +404,7 @@ export function modelList(
     }));
   }
   if (scope) {
-    const defaultEntry = (known[scope] ?? []).find(entry => modelIdOf(entry) === "default") ?? "default";
-    const entries = [defaultEntry, ...(known[scope] ?? []).filter(entry => modelIdOf(entry) !== "default")];
+    const entries = listedProviderEntries(known, scope);
     const rows: Array<Record<string, unknown>> = [];
     const seen = new Set<string>();
     for (const entry of entries) {
@@ -440,8 +449,7 @@ export function modelList(
     display_name: "Configured default provider",
   }];
   for (const providerId of [CLINE_PROVIDER_ID, GEMINI_PROVIDER_ID] as const) {
-    const defaultEntry = (known[providerId] ?? []).find(entry => modelIdOf(entry) === "default") ?? "default";
-    const entries = [defaultEntry, ...(known[providerId] ?? []).filter(entry => modelIdOf(entry) !== "default")];
+    const entries = listedProviderEntries(known, providerId);
     const seen = new Set<string>();
     for (const entry of entries) {
       const id = modelIdOf(entry);