@koreanhole/opencodex 3.0.0 → 3.2.0

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

@@ -1,788 +0,0 @@
-import { spawn as nodeSpawn } from "node:child_process";
-import { link, lstat, mkdir, mkdtemp, readFile, rm, stat, symlink, writeFile } from "node:fs/promises";
-import { homedir, tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import * as acp from "@agentclientprotocol/sdk";
-import type { AdapterEvent, IncomingMeta, OcxUsage } from "../../../types";
-import { commandInvocation } from "../../../lib/win-exec";
-import { baseScopedEnv } from "../env";
-import type { CliAgentStreamState, CliAgentTurnDeps } from "../types";
-import { mapToolIntent, ToolIntentError } from "../tool-intent";
-import { recordGeminiInitialize, recordGeminiUsage } from "./runtime";
-import {
-  AcpClient,
-  AcpError,
-  parseAcpInitialize,
-  parseAcpSession,
-  safeAcpMessage,
-  type AcpDeps,
-  type AcpHooks,
-  type AcpInitialize,
-  type AcpModel,
-  type AcpSessionInfo,
-} from "../acp-client";
-
-const DEFAULT_TIMEOUT_MS = 300_000;
-const MAX_STDERR_BYTES = 8 * 1024;
-const MAX_CAPTURE_FILE_BYTES = 4 * 1024 * 1024;
-const CAPTURE_POLL_MS = 25;
-const GEMINI_POLICY = [
-  "[[rule]]",
-  'toolName = "mcp_*"',
-  'decision = "allow"',
-  "priority = 999",
-  "",
-  "[[rule]]",
-  'toolName = "*"',
-  'decision = "deny"',
-  "priority = 998",
-  "",
-].join("\n");
-
-const GEMINI_SYSTEM_SETTINGS = JSON.stringify({
-  hooksConfig: { enabled: false },
-  skills: { enabled: false },
-  admin: {
-    secureModeEnabled: true,
-    extensions: { enabled: false },
-    skills: { enabled: false },
-  },
-}, null, 2) + "\n";
-
-const FORWARDED_ENV_KEYS = [
-  "XDG_CONFIG_HOME",
-  "XDG_CACHE_HOME",
-  "APPDATA",
-  "LOCALAPPDATA",
-  "GEMINI_API_KEY",
-  "GOOGLE_API_KEY",
-  "GOOGLE_GENAI_USE_VERTEXAI",
-  "GOOGLE_GENAI_USE_GCA",
-  "GOOGLE_CLOUD_PROJECT",
-  "GOOGLE_CLOUD_LOCATION",
-  "GOOGLE_APPLICATION_CREDENTIALS",
-  "GOOGLE_GEMINI_BASE_URL",
-  "GEMINI_API_KEY_AUTH_MECHANISM",
-  "GOOGLE_GENAI_API_VERSION",
-  "GEMINI_SYSTEM_MD",
-  "HTTP_PROXY",
-  "HTTPS_PROXY",
-  "ALL_PROXY",
-  "NO_PROXY",
-  "http_proxy",
-  "https_proxy",
-  "no_proxy",
-] as const;
-
-export { AcpError as GeminiAcpError };
-export type GeminiAcpModel = AcpModel;
-export type GeminiAcpSessionInfo = AcpSessionInfo;
-export type GeminiAcpInitialize = AcpInitialize;
-export type GeminiAcpHooks = AcpHooks;
-export type GeminiAcpDeps = AcpDeps;
-
-export interface GeminiAcpMode {
-  acp: boolean;
-}
-const MODE_CACHE = new Map<string, { mtimeMs: number; size: number; acp: boolean }>();
-
-function nonEmpty(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-  return value && typeof value === "object" && !Array.isArray(value)
-    ? value as Record<string, unknown>
-    : undefined;
-}
-
-export function geminiAcpEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
-  return env.OPENCODEX_GEMINI_ACP?.trim() !== "0";
-}
-
-export function parseGeminiAcpSession(response: unknown): GeminiAcpSessionInfo {
-  return parseAcpSession(response, "Gemini ACP", false);
-}
-
-export function parseGeminiAcpInitialize(value: unknown): GeminiAcpInitialize {
-  return parseAcpInitialize(value, "Gemini ACP", false);
-}
-
-export function geminiModelIds(session: GeminiAcpSessionInfo): string[] {
-  return session.availableModels.length > 0
-    ? [...new Set(session.availableModels.map(model => model.modelId))]
-    : ["default"];
-}
-
-/** Probe Gemini's documented ACP switch with a bounded help command. */
-export async function probeGeminiAcpSupport(
-  binary: string,
-  env: Record<string, string>,
-  deps: GeminiAcpDeps = {},
-): Promise<GeminiAcpMode> {
-  if (!geminiAcpEnabled(deps.env ?? process.env)) return { acp: false };
-  const key = resolve(binary);
-  let mtimeMs: number | undefined;
-  let size: number | undefined;
-  try {
-    const value = await stat(key);
-    mtimeMs = value.mtimeMs;
-    size = value.size;
-  } catch {
-    return { acp: false };
-  }
-  const cached = MODE_CACHE.get(key);
-  if (cached && cached.mtimeMs === mtimeMs && cached.size === size) return { acp: cached.acp };
-  const help = await runGeminiHelp(binary, env, deps);
-  const supported = /(?:^|\s)--acp(?:\s|,|<|$)/.test(help);
-  MODE_CACHE.set(key, { mtimeMs, size, acp: supported });
-  return { acp: supported };
-}
-
-async function runGeminiHelp(binary: string, env: Record<string, string>, deps: GeminiAcpDeps): Promise<string> {
-  return await new Promise((resolvePromise, reject) => {
-    const invocation = commandInvocation(binary, ["--help"], deps.platform ?? process.platform, { env });
-    const spawnFn = deps.spawn ?? (nodeSpawn as unknown as NonNullable<CliAgentTurnDeps["spawn"]>);
-    const child = spawnFn(invocation.file, invocation.args, {
-      ...invocation.options,
-      cwd: homedir(),
-      env,
-      stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true,
-    });
-    const chunks: string[] = [];
-    let bytes = 0;
-    let settled = false;
-    const finish = (fn: () => void): void => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      fn();
-    };
-    const timer = setTimeout(() => {
-      try { child.kill("SIGKILL"); } catch { /* ignore */ }
-      finish(() => reject(new Error("Gemini --help probe timed out.")));
-    }, deps.timeoutMs ?? 15_000);
-    const collect = (chunk: Buffer): void => {
-      if (bytes >= MAX_STDERR_BYTES) return;
-      const admitted = chunk.subarray(0, MAX_STDERR_BYTES - bytes);
-      chunks.push(admitted.toString("utf8"));
-      bytes += admitted.byteLength;
-    };
-    child.stdout?.on("data", collect);
-    child.stderr?.on("data", collect);
-    child.once("error", error => finish(() => reject(error)));
-    child.once("close", () => finish(() => resolvePromise(chunks.join(""))));
-  });
-}
-
-/** Build the Gemini ACP environment while leaving vendor auth in its real home. */
-export function buildGeminiAcpEnv(sourceEnv: NodeJS.ProcessEnv = process.env): Record<string, string> {
-  const env = baseScopedEnv();
-  const realHome = nonEmpty(sourceEnv.HOME) ?? nonEmpty(sourceEnv.USERPROFILE) ?? homedir();
-  env.HOME = realHome;
-  env.USERPROFILE = realHome;
-  for (const key of FORWARDED_ENV_KEYS) {
-    const value = nonEmpty(sourceEnv[key]);
-    if (value) env[key] = value;
-  }
-  Object.assign(env, {
-    GEMINI_CLI_NO_RELAUNCH: "1",
-    GEMINI_TELEMETRY_ENABLED: "false",
-    NO_UPDATE_NOTIFIER: "1",
-    NO_COLOR: "1",
-  });
-  return env;
-}
-
-export interface GeminiAcpWorkspace {
-  cwd: string;
-  geminiHome: string;
-  policyPath: string;
-  settingsPath: string;
-  catalogPath: string;
-  capturePath?: string;
-  cleanup: () => Promise<void>;
-}
-
-export interface GeminiReasoningSelection {
-  modelId: string;
-  thinkingConfig: {
-    thinkingLevel?: string;
-    thinkingBudget?: number;
-    includeThoughts?: boolean;
-  };
-}
-
-function geminiSystemSettings(reasoning?: GeminiReasoningSelection): string {
-  const settings = JSON.parse(GEMINI_SYSTEM_SETTINGS) as Record<string, unknown>;
-  if (reasoning) {
-    settings.modelConfigs = {
-      customOverrides: [{
-        match: { model: reasoning.modelId },
-        modelConfig: {
-          generateContentConfig: {
-            thinkingConfig: reasoning.thinkingConfig,
-          },
-        },
-      }],
-    };
-  }
-  return `${JSON.stringify(settings, null, 2)}\n`;
-}
-
-export async function stageGeminiAcpWorkspace(
-  catalog: readonly Record<string, unknown>[] = [],
-  reasoning?: GeminiReasoningSelection,
-  options: {
-    root?: string;
-    sourceEnv?: NodeJS.ProcessEnv;
-  } = {},
-): Promise<GeminiAcpWorkspace> {
-  const cwd = options.root ?? await mkdtemp(join(tmpdir(), "ocx-gemini-acp-"));
-  await mkdir(cwd, { recursive: true, mode: 0o700 });
-  const geminiHome = join(cwd, "gemini-home");
-  const policyPath = join(cwd, "policy.toml");
-  const settingsPath = join(cwd, "system-settings.json");
-  const catalogPath = join(cwd, "tool-catalog.json");
-  const capturePath = join(cwd, "tool-intents.ndjson");
-  const geminiConfigDir = join(geminiHome, ".gemini");
-  const exclusive = options.root === undefined;
-  const writeOptions = { encoding: "utf8" as const, mode: 0o600, ...(exclusive ? { flag: "wx" as const } : {}) };
-  await Promise.all([
-    mkdir(geminiConfigDir, { recursive: true, mode: 0o700 }),
-    writeFile(policyPath, GEMINI_POLICY, writeOptions),
-    writeFile(settingsPath, geminiSystemSettings(reasoning), writeOptions),
-    writeFile(catalogPath, JSON.stringify(catalog), writeOptions),
-    ...(catalog.length > 0
-      ? [writeFile(capturePath, "", writeOptions)]
-      : []),
-  ]);
-  await linkGeminiAuth(geminiConfigDir, options.sourceEnv ?? process.env);
-  return {
-    cwd,
-    geminiHome,
-    policyPath,
-    settingsPath,
-    catalogPath,
-    ...(catalog.length > 0 ? { capturePath } : {}),
-    cleanup: async () => { await rm(cwd, { recursive: true, force: true }).catch(() => undefined); },
-  };
-}
-
-async function linkGeminiAuth(targetDir: string, sourceEnv: NodeJS.ProcessEnv): Promise<void> {
-  const realHome = nonEmpty(sourceEnv.HOME) ?? nonEmpty(sourceEnv.USERPROFILE) ?? homedir();
-  const realGemini = join(realHome, ".gemini");
-  const names = ["oauth_creds.json", "google_accounts.json", ".env", "settings.json", "trustedFolders.json"];
-  await Promise.all(names.map(async name => {
-    const target = join(realGemini, name);
-    try {
-      await lstat(target);
-    } catch {
-      return;
-    }
-    const path = join(targetDir, name);
-    try {
-      await symlink(resolve(target), path);
-    } catch {
-      try {
-        await link(resolve(target), path);
-      } catch {
-        // Best-effort; environment-provided auth remains the primary contract.
-      }
-    }
-  }));
-}
-
-export function geminiAcpArgs(policyPath: string): string[] {
-  return [
-    "--acp",
-    "--skip-trust",
-    "--approval-mode",
-    "default",
-    "--policy",
-    policyPath,
-    "--allowed-mcp-server-names",
-    "opencodex",
-    "-e",
-    "none",
-  ];
-}
-
-export interface GeminiAcpTurnInput {
-  binary: string;
-  env: Record<string, string>;
-  runtimeEnv?: NodeJS.ProcessEnv;
-  cwd: string;
-  args: readonly string[];
-  modelId: string;
-  fingerprint?: string;
-  prompt: string;
-  deltaPrompt?: string;
-  resumeSessionId?: string;
-  sessionKeySource?: string;
-  hadPreviousResponseId?: boolean;
-  images?: readonly { mimeType: string; data: string }[];
-  toolNames: ReadonlyMap<string, string>;
-  mcpServers: readonly Record<string, unknown>[];
-  capturePath?: string;
-  maxToolCalls: number;
-  requireToolCall: boolean;
-  incoming: IncomingMeta;
-  onVendorSession?: (sessionId: string) => void;
-  onResumeFailed?: () => void;
-  deps?: GeminiAcpDeps;
-}
-
-function createGeminiStreamState(): CliAgentStreamState {
-  return {
-    sawText: false,
-    sawThinking: false,
-    terminal: false,
-    toolCalls: 0,
-    nextToolOrdinal: 0,
-  };
-}
-
-function usageFrom(value: unknown, observedModelId?: string): OcxUsage | undefined {
-  const record = asRecord(value);
-  if (!record) return undefined;
-  const count = (input: unknown): number =>
-    typeof input === "number" && Number.isFinite(input) && input >= 0 ? Math.floor(input) : 0;
-  const inputTokens = count(record.inputTokens);
-  const outputTokens = count(record.outputTokens);
-  const cacheRead = count(record.cachedReadTokens);
-  if (inputTokens === 0 && outputTokens === 0 && cacheRead === 0) return undefined;
-  return {
-    inputTokens,
-    outputTokens,
-    totalTokens: inputTokens + outputTokens,
-    ...(cacheRead > 0 ? { cachedInputTokens: cacheRead, cacheReadInputTokens: cacheRead } : {}),
-    ...(observedModelId ? { modelId: observedModelId } : {}),
-  };
-}
-
-function observedModelId(response: acp.PromptResponse, expected: string): string | undefined {
-  const meta = asRecord(response._meta);
-  const quota = asRecord(meta?.quota);
-  const usage = Array.isArray(quota?.model_usage) ? quota.model_usage : [];
-  const ids = [...new Set(usage.flatMap(item => {
-    const model = nonEmpty(asRecord(item)?.model);
-    return model ? [model] : [];
-  }))];
-  return ids.includes(expected) ? expected : ids.length === 1 ? ids[0] : ids[0];
-}
-
-function unsupportedModel(modelId: string): AcpError {
-  return new AcpError(
-    `Gemini ACP cannot select model "${modelId}".`,
-    400,
-    "invalid_request_error",
-    "gemini_model_unsupported",
-    false,
-    false,
-  );
-}
-
-export async function applyGeminiModel(
-  client: AcpClient,
-  session: GeminiAcpSessionInfo,
-  modelId: string,
-): Promise<void> {
-  if (modelId === "default") return;
-  if (!session.availableModels.some(model => model.modelId === modelId)) throw unsupportedModel(modelId);
-  try {
-    await client.setModel(session.sessionId, modelId);
-  } catch (error) {
-    if (error instanceof AcpError && error.code === "timeout") throw error;
-    throw unsupportedModel(modelId);
-  }
-}
-
-async function readCapturedIntents(path: string): Promise<unknown[]> {
-  let bytes: Buffer;
-  try {
-    bytes = await readFile(path);
-  } catch {
-    return [];
-  }
-  if (bytes.byteLength > MAX_CAPTURE_FILE_BYTES) {
-    throw new ToolIntentError("Gemini tool-intent capture exceeded the byte limit.");
-  }
-  const text = bytes.toString("utf8");
-  if (!text.endsWith("\n")) return [];
-  return text.split("\n").filter(Boolean).flatMap(line => {
-    try {
-      const value = JSON.parse(line) as unknown;
-      return value && typeof value === "object" && !Array.isArray(value) ? [value] : [];
-    } catch {
-      throw new ToolIntentError("Gemini returned a malformed captured tool intent.");
-    }
-  });
-}
-
-/** Run one Gemini ACP turn and return any tool intent to the external client. */
-export async function runGeminiAcpTurn(
-  input: GeminiAcpTurnInput,
-  emit: (event: AdapterEvent) => void,
-): Promise<void> {
-  const deps = input.deps ?? {};
-  const fingerprint = input.fingerprint ?? "unknown";
-  const state = createGeminiStreamState();
-  let client: AcpClient | undefined;
-  let session: GeminiAcpSessionInfo | undefined;
-  let terminalEmitted = false;
-  let aborted = false;
-  let timedOut = false;
-  let pollTimer: ReturnType<typeof setInterval> | undefined;
-  let turnTimer: ReturnType<typeof setTimeout> | undefined;
-  let captureResolve: ((records: unknown[]) => void) | undefined;
-  let captureReject: ((error: unknown) => void) | undefined;
-  let resolveAbort: (() => void) | undefined;
-  let loadingSession = false;
-  let resumed = false;
-  let sentPromptChars = input.prompt.length;
-  const seenToolCalls = new Set<string>();
-
-  const deliver = (event: AdapterEvent): void => {
-    if (event.type === "done" || event.type === "error" || event.type === "incomplete") {
-      if (terminalEmitted) return;
-      terminalEmitted = true;
-    }
-    emit(event);
-  };
-
-  const capturePromise = input.capturePath
-    ? new Promise<unknown[]>((resolvePromise, reject) => {
-        captureResolve = resolvePromise;
-        captureReject = reject;
-      })
-    : new Promise<never>(() => undefined);
-
-  const captureTool = (toolCall: Record<string, unknown>): void => {
-    const id = nonEmpty(toolCall.toolCallId);
-    if (id && seenToolCalls.has(id)) return;
-    if (id) seenToolCalls.add(id);
-    const name = nonEmpty(toolCall.name);
-    if (!name) return;
-    try {
-      const events = mapToolIntent("Gemini", name, id, toolCall.rawInput, state, {
-        toolNames: input.toolNames,
-        maxToolCalls: input.maxToolCalls,
-      });
-      for (const event of events) deliver(event);
-      if (pollTimer) {
-        clearInterval(pollTimer);
-        pollTimer = undefined;
-      }
-      if (session) void client?.cancel(session.sessionId).catch(() => undefined);
-    } catch (error) {
-      deliver({
-        type: "error",
-        message: safeAcpMessage(error, "Gemini returned an invalid tool call."),
-        status: 502,
-        errorType: "upstream_error",
-        code: "cli_protocol_error",
-        retryable: false,
-      });
-      if (session) void client?.cancel(session.sessionId).catch(() => undefined);
-    }
-  };
-
-  const hooks: GeminiAcpHooks = {
-    onSessionUpdate: notification => {
-      if (loadingSession) return;
-      const update = notification.update;
-      if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text" && update.content.text) {
-        state.sawText = true;
-        deliver({ type: "text_delta", text: update.content.text });
-      } else if (update.sessionUpdate === "agent_thought_chunk" && update.content.type === "text" && update.content.text) {
-        state.sawThinking = true;
-        deliver({ type: "thinking_delta", thinking: update.content.text });
-      } else if (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") {
-        captureTool(update as unknown as Record<string, unknown>);
-      } else if (update.sessionUpdate === "usage_update") {
-        if (typeof update.used === "number" && typeof update.size === "number") {
-          void recordGeminiUsage(
-            fingerprint,
-            input.modelId,
-            update.used,
-            update.size,
-            sentPromptChars,
-            input.runtimeEnv ?? process.env,
-          );
-        }
-      }
-    },
-    onPermission: params => {
-      const toolCall = asRecord(params.toolCall);
-      if (toolCall) captureTool(toolCall);
-      if (session) void client?.cancel(session.sessionId).catch(() => undefined);
-    },
-  };
-
-  const onAbort = (): void => {
-    aborted = true;
-    resolveAbort?.();
-    if (session) void client?.cancel(session.sessionId).catch(() => undefined);
-  };
-
-  try {
-    client = await AcpClient.connect({
-      binary: input.binary,
-      env: input.env,
-      cwd: input.cwd,
-      args: input.args,
-      hooks,
-      label: "Gemini ACP",
-      fallbackAllowed: false,
-    }, deps);
-    if (client.initializeResult) {
-      await recordGeminiInitialize(
-        fingerprint,
-        client.initializeResult,
-        input.runtimeEnv ?? process.env,
-      );
-    }
-    loadingSession = Boolean(input.resumeSessionId && client.initializeResult?.capabilities.loadSession);
-    if (loadingSession) {
-      try {
-        session = await client.loadSession({
-          sessionId: input.resumeSessionId!,
-          cwd: input.cwd,
-          mcpServers: input.mcpServers,
-        });
-        resumed = true;
-      } catch {
-        input.onResumeFailed?.();
-        session = undefined;
-      } finally {
-        loadingSession = false;
-      }
-    }
-    if (!session) session = await client.newSession({ cwd: input.cwd, mcpServers: input.mcpServers });
-    await applyGeminiModel(client, session, input.modelId);
-    input.onVendorSession?.(session.sessionId);
-    const promptText = resumed && input.deltaPrompt ? input.deltaPrompt : input.prompt;
-    sentPromptChars = promptText.length;
-
-    if (input.incoming.abortSignal?.aborted) {
-      deliver({
-        type: "error",
-        message: "Gemini ACP turn was aborted before the prompt.",
-        status: 499,
-        errorType: "invalid_request_error",
-        code: "client_cancelled",
-        retryable: false,
-      });
-      return;
-    }
-
-    const abortOutcome = new Promise<{ kind: "abort" }>(resolvePromise => {
-      resolveAbort = () => resolvePromise({ kind: "abort" });
-      if (input.incoming.abortSignal?.aborted) resolveAbort();
-      else input.incoming.abortSignal?.addEventListener("abort", onAbort, { once: true });
-    });
-    if (input.capturePath) {
-      let reading = false;
-      pollTimer = setInterval(() => {
-        if (reading || terminalEmitted) return;
-        reading = true;
-        void readCapturedIntents(input.capturePath!)
-          .then(records => {
-            if (records.length > 0 && captureResolve) {
-              clearInterval(pollTimer);
-              pollTimer = undefined;
-              captureResolve(records);
-            }
-          })
-          .catch(error => {
-            if (captureReject) {
-              clearInterval(pollTimer);
-              pollTimer = undefined;
-              captureReject(error);
-            }
-          })
-          .finally(() => { reading = false; });
-      }, CAPTURE_POLL_MS);
-    }
-
-    const promptContent: acp.ContentBlock[] = [
-      { type: "text", text: promptText },
-      ...(input.images ?? []).map(image => ({
-        type: "image" as const,
-        data: image.data,
-        mimeType: image.mimeType,
-      })),
-    ];
-    const promptOutcome = client.prompt(session.sessionId, promptContent, input.incoming.abortSignal)
-      .then(response => ({ kind: "prompt" as const, response }))
-      .catch(error => ({ kind: "error" as const, error }));
-    const captureOutcome = capturePromise
-      .then(records => ({ kind: "capture" as const, records }))
-      .catch(error => ({ kind: "error" as const, error }));
-    const timeoutOutcome = new Promise<{ kind: "timeout" }>(resolvePromise => {
-      turnTimer = setTimeout(() => {
-        timedOut = true;
-        resolvePromise({ kind: "timeout" });
-      }, deps.timeoutMs ?? DEFAULT_TIMEOUT_MS);
-    });
-
-    const outcome = await Promise.race([promptOutcome, captureOutcome, abortOutcome, timeoutOutcome]);
-    if (pollTimer) clearInterval(pollTimer);
-    pollTimer = undefined;
-
-    if (outcome.kind === "capture") {
-      try {
-        for (const raw of outcome.records) {
-          const record = asRecord(raw);
-          const name = nonEmpty(record?.name);
-          const id = nonEmpty(record?.id);
-          if (!name || !id) throw new ToolIntentError("Gemini returned a malformed captured tool intent.");
-          const events = mapToolIntent("Gemini", name, id, record?.arguments, state, {
-            toolNames: input.toolNames,
-            maxToolCalls: input.maxToolCalls,
-          });
-          for (const event of events) deliver(event);
-        }
-        if (state.toolCalls > 0) {
-          deliver({ type: "done", stopReason: "tool_use", ...(state.usage ? { usage: state.usage } : {}) });
-        } else if (input.requireToolCall) {
-          deliver({
-            type: "error",
-            message: "Gemini ACP returned no tool call for a request that requires one.",
-            status: 502,
-            errorType: "upstream_error",
-            code: "tool_call_required",
-            retryable: false,
-          });
-        }
-      } catch (error) {
-        deliver({
-          type: "error",
-          message: safeAcpMessage(error, "Gemini returned an invalid tool call."),
-          status: 502,
-          errorType: "upstream_error",
-          code: "cli_protocol_error",
-          retryable: false,
-        });
-      }
-      if (session) void client.cancel(session.sessionId).catch(() => undefined);
-      return;
-    }
-
-    if (outcome.kind === "abort" || aborted) {
-      deliver({
-        type: "error",
-        message: timedOut ? "Gemini ACP turn timed out." : "Gemini ACP turn was cancelled.",
-        status: timedOut ? 504 : 499,
-        errorType: timedOut ? "upstream_error" : "invalid_request_error",
-        code: timedOut ? "timeout" : "client_cancelled",
-        retryable: timedOut,
-      });
-      return;
-    }
-
-    if (outcome.kind === "timeout") {
-      deliver({
-        type: "error",
-        message: "Gemini ACP turn timed out.",
-        status: 504,
-        errorType: "upstream_error",
-        code: "timeout",
-        retryable: true,
-      });
-      return;
-    }
-
-    if (outcome.kind === "error") {
-      const error = outcome.error;
-      const failure = error instanceof AcpError
-        ? error
-        : new AcpError(safeAcpMessage(error, "Gemini ACP failed."), 502, "upstream_error", "acp_transport_error", false, false);
-      deliver({
-        type: "error",
-        message: failure.message,
-        status: timedOut ? 504 : aborted ? 499 : failure.status,
-        errorType: timedOut || aborted ? (timedOut ? "upstream_error" : "invalid_request_error") : failure.errorType,
-        code: timedOut ? "timeout" : aborted ? "client_cancelled" : failure.code,
-        retryable: timedOut || failure.retryable,
-      });
-      return;
-    }
-
-    const response = outcome.response;
-    const actualModel = observedModelId(response, input.modelId);
-    const usage = usageFrom(response.usage, actualModel) ?? state.usage;
-    if (usage) state.usage = usage;
-    if (aborted) {
-      deliver({
-        type: "error",
-        message: "Gemini ACP turn was cancelled.",
-        status: 499,
-        errorType: "invalid_request_error",
-        code: "client_cancelled",
-        retryable: false,
-      });
-    } else if (timedOut) {
-      deliver({
-        type: "error",
-        message: "Gemini ACP turn timed out.",
-        status: 504,
-        errorType: "upstream_error",
-        code: "timeout",
-        retryable: true,
-      });
-    } else if (state.toolCalls > 0) {
-      deliver({ type: "done", stopReason: "tool_use", ...(usage ? { usage } : {}) });
-    } else if (input.requireToolCall) {
-      deliver({
-        type: "error",
-        message: "Gemini ACP returned no tool call for a request that requires one.",
-        status: 502,
-        errorType: "upstream_error",
-        code: "tool_call_required",
-        retryable: false,
-      });
-    } else if (response.stopReason === "end_turn") {
-      deliver({ type: "done", stopReason: "stop", ...(usage ? { usage } : {}) });
-    } else if (response.stopReason === "cancelled") {
-      deliver({
-        type: "error",
-        message: "Gemini ACP cancelled the turn.",
-        status: 502,
-        errorType: "upstream_error",
-        code: "acp_cancelled",
-        retryable: false,
-      });
-    } else {
-      deliver({
-        type: "error",
-        message: `Gemini ACP finished with ${response.stopReason}.`,
-        status: response.stopReason === "max_tokens" ? 400 : 502,
-        errorType: response.stopReason === "max_tokens" ? "invalid_request_error" : "upstream_error",
-        code: "cli_protocol_error",
-        retryable: false,
-      });
-    }
-  } catch (error) {
-    if (!terminalEmitted) {
-      const failure = error instanceof AcpError
-        ? error
-        : new AcpError(safeAcpMessage(error, "Gemini ACP failed."), 502, "upstream_error", "acp_transport_error", false, false);
-      deliver({
-        type: "error",
-        message: aborted && !timedOut ? "Gemini ACP turn was cancelled." : failure.message,
-        status: timedOut ? 504 : aborted ? 499 : failure.status,
-        errorType: timedOut || aborted ? (timedOut ? "upstream_error" : "invalid_request_error") : failure.errorType,
-        code: timedOut ? "timeout" : aborted ? "client_cancelled" : failure.code,
-        retryable: timedOut || failure.retryable,
-      });
-    }
-  } finally {
-    if (pollTimer) clearInterval(pollTimer);
-    if (turnTimer) clearTimeout(turnTimer);
-    input.incoming.abortSignal?.removeEventListener("abort", onAbort);
-    await client?.terminate();
-  }
-}