@koreanhole/opencodex 3.2.9 → 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,7 +89,8 @@ 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-tool
 bun run test:e2e:gemini-reasoning
@@ -98,4 +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 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,6 +165,7 @@ 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-slow
 bun run test:e2e:gemini-parent-tool
@@ -172,5 +179,10 @@ 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` 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.9",
-  "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,6 +30,7 @@
     "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-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\"",

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/types.ts

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