@koreanhole/opencodex 2.96.0 → 2.98.0

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

@@ -1,5 +1,5 @@
 import { spawn as nodeSpawn } from "node:child_process";
-import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+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";
@@ -8,6 +8,7 @@ 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,
@@ -196,6 +197,7 @@ export function buildGeminiAcpEnv(sourceEnv: NodeJS.ProcessEnv = process.env): R
 
 export interface GeminiAcpWorkspace {
   cwd: string;
+  geminiHome: string;
   policyPath: string;
   settingsPath: string;
   catalogPath: string;
@@ -203,24 +205,63 @@ export interface GeminiAcpWorkspace {
   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 = await mkdtemp(join(tmpdir(), "ocx-gemini-acp-"));
+  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([
-    writeFile(policyPath, GEMINI_POLICY, { encoding: "utf8", mode: 0o600, flag: "wx" }),
-    writeFile(settingsPath, GEMINI_SYSTEM_SETTINGS, { encoding: "utf8", mode: 0o600, flag: "wx" }),
-    writeFile(catalogPath, JSON.stringify(catalog), { encoding: "utf8", mode: 0o600, flag: "wx" }),
+    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, "", { encoding: "utf8", mode: 0o600, flag: "wx" })]
+      ? [writeFile(capturePath, "", writeOptions)]
       : []),
   ]);
+  await linkGeminiAuth(geminiConfigDir, options.sourceEnv ?? process.env);
   return {
     cwd,
+    geminiHome,
     policyPath,
     settingsPath,
     catalogPath,
@@ -229,6 +270,30 @@ export async function stageGeminiAcpWorkspace(
   };
 }
 
+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",
@@ -247,16 +312,25 @@ export function geminiAcpArgs(policyPath: string): string[] {
 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;
 }
 
@@ -353,6 +427,7 @@ export async function runGeminiAcpTurn(
   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;
@@ -364,6 +439,10 @@ export async function runGeminiAcpTurn(
   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") {
@@ -380,8 +459,39 @@ export async function runGeminiAcpTurn(
       })
     : 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;
@@ -389,9 +499,24 @@ export async function runGeminiAcpTurn(
       } 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: () => {
+    onPermission: params => {
+      const toolCall = asRecord(params.toolCall);
+      if (toolCall) captureTool(toolCall);
       if (session) void client?.cancel(session.sessionId).catch(() => undefined);
     },
   };
@@ -412,8 +537,34 @@ export async function runGeminiAcpTurn(
       label: "Gemini ACP",
       fallbackAllowed: false,
     }, deps);
-    session = await client.newSession({ cwd: input.cwd, mcpServers: input.mcpServers });
+    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({
@@ -456,7 +607,15 @@ export async function runGeminiAcpTurn(
       }, CAPTURE_POLL_MS);
     }
 
-    const promptOutcome = client.prompt(session.sessionId, input.prompt, input.incoming.abortSignal)
+    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

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

@@ -1,12 +1,17 @@
 import { fileURLToPath } from "node:url";
 import type { AdapterEvent, IncomingMeta, OcxParsedRequest } from "../../../types";
 import { buildCodingAgentToolCatalog, CodingAgentToolCatalogError } from "../../tool-catalog";
-import { buildConversationInput, buildSystemPrompt } from "../protocol";
+import { buildConversationDelta, buildConversationInput, buildSystemPrompt } from "../protocol";
 import { whichFromPath, type WhichFn } from "../../coding-agent/profile";
 import { isStandaloneBinary } from "../../../lib/standalone";
 import type { CliAgentTurnDeps } from "../types";
 import { ToolIntentError } from "../tool-intent";
-import { resolveGeminiBinary } from "./binary";
+import { geminiBinaryFingerprintSync, resolveGeminiBinary } from "./binary";
+import {
+  discoverGeminiModelMetadata,
+  reasoningLevelForEffort,
+  type GeminiMetadataResult,
+} from "./model-metadata";
 import {
   GeminiAcpError,
   buildGeminiAcpEnv,
@@ -17,6 +22,18 @@ import {
   type GeminiAcpDeps,
   type GeminiAcpTurnInput,
 } from "./acp";
+import { getGeminiRuntime } from "./runtime";
+import {
+  deleteGeminiSession,
+  findGeminiSessionByKeyHash,
+  findGeminiSessionByResponseId,
+  geminiSessionWorkspace,
+  hashConversationKey,
+  hashMessages,
+  reclaimGeminiSessions,
+  saveGeminiSession,
+  type GeminiSessionRecord,
+} from "./session-store";
 
 export const GEMINI_MCP_SERVER_NAME = "opencodex";
 const GEMINI_MCP_SERVER_PATH = fileURLToPath(new URL("../mcp-server.ts", import.meta.url));
@@ -35,6 +52,7 @@ export interface GeminiTurnDeps extends CliAgentTurnDeps {
   env?: NodeJS.ProcessEnv;
   probeAcp?: typeof probeGeminiAcpSupport;
   stageAcp?: typeof stageGeminiAcpWorkspace;
+  metadata?: typeof discoverGeminiModelMetadata;
   runAcp?: (input: GeminiAcpTurnInput, emit: (event: AdapterEvent) => void, deps?: GeminiAcpDeps) => Promise<void>;
   acpDeps?: GeminiAcpDeps;
 }
@@ -42,12 +60,43 @@ export interface GeminiTurnDeps extends CliAgentTurnDeps {
 function hasUnsupportedMedia(parsed: OcxParsedRequest): boolean {
   return parsed.context.messages.some(message =>
     Array.isArray(message.content)
-      && message.content.some(part => part.type === "image" || part.type === "video" || part.type === "audio"),
+      && message.content.some(part => part.type === "video" || part.type === "audio"),
   );
 }
 
-function conversationText(parsed: OcxParsedRequest, vendorNameByWire: ReadonlyMap<string, string>): string {
-  const first = buildConversationInput(parsed, { vendorNameByWire })[0];
+interface CollectedImage {
+  mimeType: string;
+  data: string;
+}
+
+function collectImages(parsed: OcxParsedRequest, env: NodeJS.ProcessEnv): { images: CollectedImage[]; error?: string } {
+  const images: CollectedImage[] = [];
+  const maxBytes = Number(env.OPENCODEX_MAX_IMAGE_BYTES ?? "") || 4 * 1024 * 1024;
+  const allowed = new Set(["image/png", "image/jpeg", "image/webp", "image/gif"]);
+  for (const message of parsed.context.messages) {
+    if (!Array.isArray(message.content)) continue;
+    for (const part of message.content) {
+      if (part.type !== "image") continue;
+      const match = part.imageUrl?.match(/^data:([^;,]+);base64,([A-Za-z0-9+/=\s]+)$/);
+      if (!match || !allowed.has(match[1]!) || !match[1]!.startsWith("image/")) {
+        return { images: [], error: "Image input must be a supported base64 data URL." };
+      }
+      const data = match[2]!.replaceAll(/\s+/g, "");
+      if (Math.floor(data.length * 3 / 4) > maxBytes) {
+        return { images: [], error: "Image input exceeds the configured byte limit." };
+      }
+      images.push({ mimeType: match[1]!, data });
+    }
+  }
+  return { images };
+}
+
+function conversationText(
+  parsed: OcxParsedRequest,
+  vendorNameByWire: ReadonlyMap<string, string>,
+  maxChars: number,
+): string {
+  const first = buildConversationInput(parsed, { vendorNameByWire, maxChars })[0];
   if (!first) return "";
   try {
     const frame = JSON.parse(first) as { message?: { content?: Array<{ type?: string; text?: string }> } };
@@ -64,16 +113,26 @@ export function buildGeminiPrompt(
   parsed: OcxParsedRequest,
   vendorNameByWire: ReadonlyMap<string, string>,
   fixedSystem = GEMINI_SYSTEM_PROMPT,
+  maxChars?: number,
 ): string {
   return [
     "SYSTEM AND DEVELOPER INSTRUCTIONS:",
     fixedSystem,
     buildSystemPrompt(parsed),
     "CONVERSATION REPLAY:",
-    conversationText(parsed, vendorNameByWire),
+    conversationText(parsed, vendorNameByWire, maxChars ?? Number.POSITIVE_INFINITY),
   ].filter(Boolean).join("\n\n");
 }
 
+function buildGeminiDeltaPrompt(
+  parsed: OcxParsedRequest,
+  startIndex: number,
+  vendorNameByWire: ReadonlyMap<string, string>,
+): string | undefined {
+  const text = buildConversationDelta(parsed, startIndex, { vendorNameByWire });
+  return text.trim() ? text : undefined;
+}
+
 function toolNameMap(catalog: ReturnType<typeof buildCodingAgentToolCatalog>): Map<string, string> {
   const names = new Map<string, string>();
   for (const [vendorName, wireName] of catalog.emittedNameMap) {
@@ -127,6 +186,31 @@ function failure(error: unknown): Extract<AdapterEvent, { type: "error" }> {
   };
 }
 
+async function resolveSession(
+  parsed: OcxParsedRequest,
+  incoming: IncomingMeta,
+  env: NodeJS.ProcessEnv,
+): Promise<{ keyHash?: string; prior?: GeminiSessionRecord; source?: string }> {
+  if (parsed.previousResponseId) {
+    const prior = await findGeminiSessionByResponseId(parsed.previousResponseId, env);
+    if (prior) return { keyHash: prior.keyHash, prior, source: "previous_response_id" };
+  }
+  const cacheKey = parsed.promptCacheKey ?? incoming.headers.get("x-opencodex-conversation") ?? undefined;
+  if (cacheKey) {
+    const keyHash = hashConversationKey(`key:${cacheKey}`);
+    return {
+      keyHash,
+      prior: await findGeminiSessionByKeyHash(keyHash, env),
+      source: parsed.promptCacheKey ? "prompt_cache_key" : "header",
+    };
+  }
+  // Codex may send only previous_response_id on later turns. Seed the first
+  // session under the response id so the next turn has a stable mapping.
+  return parsed.responseId
+    ? { keyHash: hashConversationKey(`response:${parsed.responseId}`), source: "response_id" }
+    : {};
+}
+
 export async function runGeminiTurn(
   parsed: OcxParsedRequest,
   incoming: IncomingMeta,
@@ -138,11 +222,6 @@ export async function runGeminiTurn(
     emit({ type: "error", message: "Gemini CLI requires a model selector.", status: 400, errorType: "invalid_request_error", code: "model_not_found", retryable: false });
     return;
   }
-  if (hasUnsupportedMedia(parsed)) {
-    emit({ type: "error", message: "Gemini CLI provider is text-only; image, video, and audio input are not enabled.", status: 400, errorType: "invalid_request_error", code: "unsupported_input_modality", retryable: false });
-    return;
-  }
-
   let catalog: ReturnType<typeof buildCodingAgentToolCatalog>;
   try {
     catalog = buildCodingAgentToolCatalog(parsed, GEMINI_MCP_SERVER_NAME);
@@ -153,12 +232,51 @@ export async function runGeminiTurn(
   }
 
   const sourceEnv = deps.env ?? process.env;
+  await reclaimGeminiSessions(sourceEnv).catch(() => undefined);
   const binary = resolveGeminiBinary(deps.which ?? whichFromPath, sourceEnv);
   if (!binary) {
     emit({ type: "error", message: "Gemini CLI not found on PATH. Install it and verify `gemini --help`, or set GEMINI_BIN_PATH.", status: 500, errorType: "upstream_error", code: "cli_not_found", retryable: false });
     return;
   }
 
+  const fingerprint = geminiBinaryFingerprintSync(binary);
+  let metadata: GeminiMetadataResult | undefined;
+  let reasoning;
+  try {
+    metadata = await (deps.metadata ?? discoverGeminiModelMetadata)({ binary, env: sourceEnv });
+    const capability = metadata.capabilities[requestedModel];
+    reasoning = reasoningLevelForEffort(capability, parsed.options.reasoning);
+    if (capability?.thinkingSupported && parsed.options.reasoning && !reasoning) {
+      emit({
+        type: "error",
+        message: `Gemini model "${requestedModel}" does not support reasoning effort "${parsed.options.reasoning}". Advertised levels: ${capability.reasoningLevels.map(level => level.effort).join(", ") || "none"}.`,
+        status: 400,
+        errorType: "invalid_request_error",
+        code: "reasoning_effort_unsupported",
+        retryable: false,
+      });
+      return;
+    }
+  } catch {
+    metadata = undefined;
+    reasoning = undefined;
+  }
+
+  const runtime = await getGeminiRuntime(fingerprint, sourceEnv);
+  const media = collectImages(parsed, sourceEnv);
+  if (media.error) {
+    emit({ type: "error", message: media.error, status: 400, errorType: "invalid_request_error", code: "unsupported_input_modality", retryable: false });
+    return;
+  }
+  if (hasUnsupportedMedia(parsed)) {
+    emit({ type: "error", message: "Gemini CLI provider does not support video or audio input.", status: 400, errorType: "invalid_request_error", code: "unsupported_input_modality", retryable: false });
+    return;
+  }
+  if (media.images.length > 0 && !runtime.prompt.image) {
+    emit({ type: "error", message: "The installed Gemini CLI does not advertise image input for this model.", status: 400, errorType: "invalid_request_error", code: "unsupported_input_modality", retryable: false });
+    return;
+  }
+
   const acpDeps: GeminiAcpDeps = {
     ...deps.acpDeps,
     env: sourceEnv,
@@ -183,9 +301,58 @@ export async function runGeminiTurn(
 
   const vendorNames = toolNameMap(catalog);
   const vendorNameByWire = new Map([...catalog.emittedNameMap.values()].map(wireName => [wireName, wireName]));
-  const workspace = await (deps.stageAcp ?? stageGeminiAcpWorkspace)(catalog.tools);
+  const observed = runtime.models[requestedModel];
+  const contextWindow = observed?.contextSize
+    ?? metadata?.tokenLimits[requestedModel]
+    ?? metadata?.defaultTokenLimit;
+  const threshold = runtime.compressionThreshold ?? metadata?.compressionThreshold;
+  const charsPerToken = observed?.charsPerToken;
+  const maxChars = contextWindow !== undefined && threshold !== undefined && charsPerToken !== undefined
+    ? Math.max(1, Math.floor(contextWindow * threshold * charsPerToken))
+    : undefined;
+  const system = systemPromptWithToolNames(catalog);
+  const fullPrompt = buildGeminiPrompt(parsed, vendorNameByWire, system, maxChars);
+  const sessionMessages = parsed.context.messages.filter(message => message.role !== "developer");
+  const resolved = await resolveSession(parsed, incoming, sourceEnv);
+  const sessionKey = resolved.prior?.keyHash ?? resolved.keyHash;
+  let prior = resolved.prior;
+  let reuse = false;
+  let deltaPrompt: string | undefined;
+  if (prior && prior.fingerprint === fingerprint && prior.modelId === requestedModel) {
+    const prefix = sessionMessages.slice(0, prior.historyCount);
+    if (prefix.length === prior.historyCount && hashMessages(prefix) === prior.historyHash) {
+      let deltaStart = prior.historyCount;
+      while (deltaStart < sessionMessages.length && sessionMessages[deltaStart]!.role === "assistant") deltaStart++;
+      if (deltaStart < sessionMessages.length) {
+        deltaPrompt = buildGeminiDeltaPrompt(parsed, deltaStart, vendorNameByWire);
+        reuse = Boolean(deltaPrompt);
+      }
+    } else if (parsed.previousResponseId && sessionMessages.length > 0) {
+      // A previous_response_id client sends only the new turn, not the replay.
+      deltaPrompt = buildGeminiDeltaPrompt(parsed, 0, vendorNameByWire);
+      reuse = Boolean(deltaPrompt);
+    }
+  }
+  if (prior && !reuse) {
+    await deleteGeminiSession(prior.keyHash, sourceEnv).catch(() => undefined);
+    prior = undefined;
+  }
+  const workspace = await (deps.stageAcp ?? stageGeminiAcpWorkspace)(
+    catalog.tools,
+    reasoning ? { modelId: requestedModel, thinkingConfig: reasoning.thinkingConfig } : undefined,
+    {
+      ...(reuse && prior ? { root: prior.workspace } : sessionKey ? { root: geminiSessionWorkspace(sessionKey, sourceEnv) } : {}),
+      sourceEnv,
+    },
+  );
+  let vendorSessionId: string | undefined;
+  let terminal: AdapterEvent | undefined;
   try {
-    const turnEnv = { ...acpEnv, GEMINI_CLI_SYSTEM_SETTINGS_PATH: workspace.settingsPath };
+    const turnEnv = {
+      ...acpEnv,
+      GEMINI_CLI_HOME: workspace.geminiHome,
+      GEMINI_CLI_SYSTEM_SETTINGS_PATH: workspace.settingsPath,
+    };
     const mcpServers = workspace.capturePath && catalog.emittedNameMap.size > 0
       ? [{
           type: "stdio",
@@ -200,21 +367,48 @@ export async function runGeminiTurn(
     await (deps.runAcp ?? runGeminiAcpTurn)({
       binary,
       env: turnEnv,
+      runtimeEnv: sourceEnv,
       cwd: workspace.cwd,
       args: geminiAcpArgs(workspace.policyPath),
       modelId: requestedModel,
-      prompt: buildGeminiPrompt(parsed, vendorNameByWire, systemPromptWithToolNames(catalog)),
+      fingerprint,
+      prompt: fullPrompt,
+      ...(reuse && prior && deltaPrompt ? { deltaPrompt, resumeSessionId: prior.vendorSessionId } : {}),
+      ...(resolved.source ? { sessionKeySource: resolved.source } : {}),
+      hadPreviousResponseId: Boolean(parsed.previousResponseId),
+      ...(media.images.length > 0 ? { images: media.images } : {}),
       toolNames: vendorNames,
       mcpServers,
       ...(workspace.capturePath ? { capturePath: workspace.capturePath } : {}),
       maxToolCalls: 16,
       requireToolCall: catalog.requireToolCall,
       incoming,
+      onVendorSession: sessionId => { vendorSessionId = sessionId; },
       deps: acpDeps,
-    }, emit, acpDeps);
+    }, event => {
+      if ((event.type === "done" || event.type === "error" || event.type === "incomplete") && !terminal) terminal = event;
+      emit(event);
+    }, acpDeps);
+    const reusable = terminal?.type === "done" && terminal.stopReason !== "tool_use";
+    if (sessionKey && vendorSessionId && reusable) {
+      await saveGeminiSession({
+        keyHash: sessionKey,
+        vendorSessionId,
+        fingerprint,
+        modelId: requestedModel,
+        workspace: workspace.cwd,
+        historyCount: sessionMessages.length,
+        historyHash: hashMessages(sessionMessages),
+        lastUsed: Date.now(),
+        turnCount: (resolved.prior?.turnCount ?? 0) + 1,
+      }, parsed.responseId, sourceEnv);
+    } else {
+      if (sessionKey) await deleteGeminiSession(sessionKey, sourceEnv).catch(() => undefined);
+      await workspace.cleanup();
+    }
   } catch (error) {
-    emit(failure(error));
-  } finally {
+    if (!terminal) emit(failure(error));
+    if (sessionKey) await deleteGeminiSession(sessionKey, sourceEnv).catch(() => undefined);
     await workspace.cleanup();
   }
 }