@junctionpanel/server 0.1.31 → 0.1.32

package/dist/server/server/agent/providers/gemini-agent.js

@@ -1,23 +1,24 @@
-import { execSync, spawn } from "node:child_process";
-import { readdir, readFile, realpath, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { homedir, tmpdir } from "node:os";
+import * as acp from "@agentclientprotocol/sdk";
+import { execSync, spawn, spawnSync } from "node:child_process";
+import { readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
 import path from "node:path";
-import readline from "node:readline";
+import { Readable as NodeReadable, Writable as NodeWritable } from "node:stream";
 import { z } from "zod";
 import { applyProviderEnv, isProviderCommandAvailable, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
-import { writeImageAttachment } from "./image-attachments.js";
 import { ToolEditInputSchema, ToolEditOutputSchema, ToolReadInputSchema, ToolReadOutputSchema, ToolSearchInputSchema, ToolShellInputSchema, ToolShellOutputSchema, ToolWriteInputSchema, ToolWriteOutputSchema, toEditToolDetail, toReadToolDetail, toSearchToolDetail, toShellToolDetail, toWriteToolDetail, } from "./tool-call-detail-primitives.js";
 import { coerceToolCallId, nonEmptyString } from "./tool-call-mapper-utils.js";
 const GEMINI_PROVIDER = "gemini";
 const GEMINI_MODES = ["default", "auto_edit", "yolo", "plan"];
 const GEMINI_GLOBAL_DIR = path.join(homedir(), ".gemini");
 const GEMINI_TMP_DIR = path.join(GEMINI_GLOBAL_DIR, "tmp");
+const GEMINI_HISTORY_FALLBACK_IDLE_MS = 1000;
 const GEMINI_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
     supportsDynamicModes: true,
     supportsMcpServers: true,
-    supportsReasoningStream: false,
+    supportsReasoningStream: true,
     supportsToolInvocations: true,
 };
 const DEFAULT_GEMINI_MODE = "default";
@@ -91,59 +92,6 @@ const GEMINI_RUNTIME_MODES = [
         description: "Read-only planning mode",
     },
 ];
-const GeminiStreamInitSchema = z.object({
-    type: z.literal("init"),
-    session_id: z.string().trim().min(1),
-    model: z.string().trim().min(1).optional(),
-});
-const GeminiStreamMessageSchema = z.object({
-    type: z.literal("message"),
-    role: z.enum(["user", "assistant"]),
-    content: z.string(),
-    delta: z.boolean().optional(),
-});
-const GeminiStreamToolUseSchema = z.object({
-    type: z.literal("tool_use"),
-    tool_name: z.string().trim().min(1),
-    tool_id: z.string().trim().min(1),
-    parameters: z.unknown().optional(),
-});
-const GeminiStreamToolResultSchema = z.object({
-    type: z.literal("tool_result"),
-    tool_id: z.string().trim().min(1),
-    status: z.string().trim().min(1),
-    output: z.unknown().optional(),
-    error: z.unknown().optional(),
-});
-const GeminiStreamErrorSchema = z.object({
-    type: z.literal("error"),
-    severity: z.string().optional(),
-    message: z.string().trim().min(1),
-});
-const GeminiStreamResultSchema = z.object({
-    type: z.literal("result"),
-    status: z.string().trim().min(1),
-    stats: z
-        .object({
-        total_tokens: z.number().finite().optional(),
-        input_tokens: z.number().finite().optional(),
-        output_tokens: z.number().finite().optional(),
-        cached: z.number().finite().optional(),
-        input: z.number().finite().optional(),
-        duration_ms: z.number().finite().optional(),
-        tool_calls: z.number().finite().optional(),
-    })
-        .passthrough()
-        .optional(),
-});
-const GeminiStreamEventSchema = z.discriminatedUnion("type", [
-    GeminiStreamInitSchema,
-    GeminiStreamMessageSchema,
-    GeminiStreamToolUseSchema,
-    GeminiStreamToolResultSchema,
-    GeminiStreamErrorSchema,
-    GeminiStreamResultSchema,
-]);
 const GeminiRecordedThoughtSchema = z
     .object({
     thought: z.string().optional(),
@@ -180,6 +128,54 @@ const GeminiRecordedSessionSchema = z
     messages: z.array(GeminiRecordedMessageSchema),
 })
     .passthrough();
+class AsyncEventQueue {
+    constructor() {
+        this.items = [];
+        this.waiters = [];
+        this.closed = false;
+        this.error = null;
+    }
+    push(item) {
+        if (this.closed) {
+            return;
+        }
+        this.items.push(item);
+        this.waiters.shift()?.();
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        for (const notify of this.waiters.splice(0)) {
+            notify();
+        }
+    }
+    fail(error) {
+        if (this.closed) {
+            return;
+        }
+        this.error = error;
+        this.closed = true;
+        for (const notify of this.waiters.splice(0)) {
+            notify();
+        }
+    }
+    async shift() {
+        while (this.items.length === 0) {
+            if (this.closed) {
+                if (this.error) {
+                    throw this.error;
+                }
+                return null;
+            }
+            await new Promise((resolve) => {
+                this.waiters.push(resolve);
+            });
+        }
+        return this.items.shift() ?? null;
+    }
+}
 function resolveGeminiBinary() {
     try {
         const geminiPath = execSync("which gemini", { encoding: "utf8" }).trim();
@@ -192,6 +188,56 @@ function resolveGeminiBinary() {
     }
     throw new Error("Gemini CLI not found. Please install gemini globally so Junction can launch the provider.");
 }
+function assertGeminiAcpSupport(runtimeSettings) {
+    const launchPrefix = resolveProviderCommandPrefix(runtimeSettings?.command, resolveGeminiBinary);
+    const env = applyProviderEnv(process.env, runtimeSettings);
+    const result = spawnSync(launchPrefix.command, [...launchPrefix.args, "--help"], {
+        env,
+        encoding: "utf8",
+    });
+    const output = `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+    if (output.includes("--acp")) {
+        return;
+    }
+    throw new Error("Installed Gemini CLI does not support --acp. Upgrade Gemini CLI to a version that includes ACP support.");
+}
+function stringifyUnknown(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value instanceof Error) {
+        return value.message;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function formatGeminiAcpError(error) {
+    if (error instanceof acp.RequestError) {
+        const directMessage = nonEmptyString(error.message);
+        const dataRecord = asRecord(error.data);
+        const nestedMessage = nonEmptyString(asRecord(dataRecord?.error)?.message) ??
+            nonEmptyString(dataRecord?.message) ??
+            null;
+        const message = nestedMessage ?? directMessage ?? "Gemini ACP request failed";
+        if (error.code === -32002 ||
+            message.toLowerCase().includes("authentication required")) {
+            return "Gemini CLI authentication is required. Run `gemini` locally and sign in before using Gemini in Junction.";
+        }
+        return message;
+    }
+    const message = nonEmptyString(stringifyUnknown(error));
+    return message ?? "Gemini ACP request failed";
+}
 export function normalizeGeminiMode(modeId) {
     if (!modeId) {
         return DEFAULT_GEMINI_MODE;
@@ -204,62 +250,35 @@ export function normalizeGeminiMode(modeId) {
     }
     throw new Error(`Unknown Gemini mode '${modeId}'. Valid modes: ${GEMINI_MODES.join(", ")}`);
 }
-const GEMINI_IMAGE_ONLY_PROMPT = "The user attached image(s) with no additional text. Inspect them and respond to the images.";
-export async function normalizeGeminiPromptInput(prompt, options) {
-    if (typeof prompt === "string") {
-        return prompt;
-    }
-    const writeAttachment = options?.writeImageAttachment ?? writeImageAttachment;
-    const textBlocks = [];
-    const imageReferences = [];
-    for (const block of prompt) {
-        if (block.type === "text") {
-            textBlocks.push(block.text);
-            continue;
-        }
-        try {
-            const filePath = await writeAttachment(block.mimeType, block.data);
-            imageReferences.push(`@${filePath}`);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Failed to prepare Gemini image attachment: ${message}`);
-        }
-    }
-    const sections = [];
-    if (textBlocks.length > 0) {
-        sections.push(textBlocks.join("\n\n"));
-    }
-    else if (imageReferences.length > 0) {
-        sections.push(GEMINI_IMAGE_ONLY_PROMPT);
-    }
-    if (imageReferences.length > 0) {
-        sections.push([
-            imageReferences.length === 1
-                ? "Attached image file:"
-                : "Attached image files:",
-            ...imageReferences,
-        ].join("\n"));
-    }
-    return sections.join("\n\n");
-}
-function mapGeminiUsage(stats) {
-    if (!stats) {
-        return undefined;
-    }
+export function getRequestedGeminiSessionState(config) {
     return {
-        inputTokens: stats.input_tokens ?? stats.input,
-        cachedInputTokens: stats.cached,
-        outputTokens: stats.output_tokens,
+        modeId: config.modeId ? normalizeGeminiMode(config.modeId) : null,
+        modelId: typeof config.model === "string" && config.model.trim().length > 0
+            ? config.model.trim()
+            : null,
     };
 }
+export function toGeminiPromptBlocks(prompt) {
+    if (typeof prompt === "string") {
+        return [{ type: "text", text: prompt }];
+    }
+    return prompt.map((block) => block.type === "text"
+        ? { type: "text", text: block.text }
+        : {
+            type: "image",
+            data: block.data,
+            mimeType: block.mimeType,
+        });
+}
 function normalizeToolStatus(status) {
     const normalized = status?.trim().toLowerCase() ?? "";
-    if (normalized === "success" || normalized === "completed" || normalized === "done") {
+    if (normalized === "completed" ||
+        normalized === "success" ||
+        normalized === "done") {
         return "completed";
     }
-    if (normalized === "error" ||
-        normalized === "failed" ||
+    if (normalized === "failed" ||
+        normalized === "error" ||
         normalized === "failure") {
         return "failed";
     }
@@ -271,59 +290,122 @@ function normalizeToolStatus(status) {
     }
     return "running";
 }
-function toPlainTextToolDetail(toolName, output) {
-    const text = nonEmptyString(typeof output === "string" ? output : undefined) ??
-        (typeof output === "object" && output !== null && "message" in output
-            ? nonEmptyString(output.message)
-            : undefined);
-    return {
-        type: "plain_text",
-        label: toolName,
-        ...(text ? { text } : {}),
-    };
+function toolCallContentToText(content) {
+    if (!content || content.length === 0) {
+        return null;
+    }
+    const segments = [];
+    for (const part of content) {
+        if (part.type === "content" && part.content.type === "text") {
+            const text = part.content.text.trim();
+            if (text.length > 0) {
+                segments.push(text);
+            }
+        }
+    }
+    if (segments.length === 0) {
+        return null;
+    }
+    return segments.join("\n\n");
 }
-function deriveGeminiToolDetail(toolName, input, output) {
-    const normalized = toolName.trim().toLowerCase();
-    if (normalized === "run_shell_command" ||
-        normalized === "shell" ||
-        normalized === "bash" ||
-        normalized === "exec_command") {
+function detailFromAcpDiffContent(content) {
+    if (!content) {
+        return null;
+    }
+    for (const part of content) {
+        if (part.type !== "diff") {
+            continue;
+        }
+        return {
+            type: "edit",
+            filePath: part.path,
+            ...(typeof part.oldText === "string" ? { oldString: part.oldText } : {}),
+            newString: part.newText,
+        };
+    }
+    return null;
+}
+function deriveGeminiToolDetail(toolName, input, output, options) {
+    const fromDiff = detailFromAcpDiffContent(options?.content);
+    if (fromDiff) {
+        return fromDiff;
+    }
+    const normalizedKind = options?.kind?.trim().toLowerCase() ?? "";
+    const normalizedName = toolName.trim().toLowerCase();
+    const contentText = toolCallContentToText(options?.content);
+    const locationPath = options?.locations?.[0]?.path;
+    if (normalizedKind === "execute" ||
+        normalizedName === "run_shell_command" ||
+        normalizedName === "shell" ||
+        normalizedName === "bash" ||
+        normalizedName === "exec_command") {
         const parsedInput = ToolShellInputSchema.safeParse(input);
         const parsedOutput = ToolShellOutputSchema.safeParse(output);
-        return (toShellToolDetail(parsedInput.success ? parsedInput.data : null, parsedOutput.success ? parsedOutput.data : null) ?? toPlainTextToolDetail(toolName, output));
+        return (toShellToolDetail(parsedInput.success ? parsedInput.data : null, parsedOutput.success ? parsedOutput.data : null) ?? {
+            type: "shell",
+            command: toolName,
+            ...(contentText ? { output: contentText } : {}),
+        });
     }
-    if (normalized === "read_file" ||
-        normalized === "read" ||
-        normalized === "view") {
+    if (normalizedKind === "read" ||
+        normalizedName === "read_file" ||
+        normalizedName === "read" ||
+        normalizedName === "view") {
         const parsedInput = ToolReadInputSchema.safeParse(input);
         const parsedOutput = ToolReadOutputSchema.safeParse(output);
-        return (toReadToolDetail(parsedInput.success ? parsedInput.data : null, parsedOutput.success ? parsedOutput.data : null) ?? toPlainTextToolDetail(toolName, output));
+        return (toReadToolDetail(parsedInput.success ? parsedInput.data : null, parsedOutput.success ? parsedOutput.data : null) ?? {
+            type: "read",
+            filePath: locationPath ?? toolName,
+            ...(contentText ? { content: contentText } : {}),
+        });
     }
-    if (normalized === "write_file" ||
-        normalized === "write" ||
-        normalized === "create_file") {
+    if (normalizedKind === "edit" ||
+        normalizedKind === "delete" ||
+        normalizedKind === "move" ||
+        normalizedName === "replace" ||
+        normalizedName === "edit" ||
+        normalizedName === "apply_patch" ||
+        normalizedName === "apply_diff") {
+        const parsedInput = ToolEditInputSchema.safeParse(input);
+        const parsedOutput = ToolEditOutputSchema.safeParse(output);
+        return (toEditToolDetail(parsedInput.success ? parsedInput.data : null, parsedOutput.success ? parsedOutput.data : null) ?? {
+            type: "edit",
+            filePath: locationPath ?? toolName,
+            ...(contentText ? { unifiedDiff: contentText } : {}),
+        });
+    }
+    if (normalizedName === "write_file" ||
+        normalizedName === "write" ||
+        normalizedName === "create_file") {
         const parsedInput = ToolWriteInputSchema.safeParse(input);
         const parsedOutput = ToolWriteOutputSchema.safeParse(output);
-        return (toWriteToolDetail(parsedInput.success ? parsedInput.data : null, parsedOutput.success ? parsedOutput.data : null) ?? toPlainTextToolDetail(toolName, output));
+        return (toWriteToolDetail(parsedInput.success ? parsedInput.data : null, parsedOutput.success ? parsedOutput.data : null) ?? {
+            type: "write",
+            filePath: locationPath ?? toolName,
+            ...(contentText ? { content: contentText } : {}),
+        });
     }
-    if (normalized === "replace" ||
-        normalized === "edit" ||
-        normalized === "apply_patch" ||
-        normalized === "apply_diff") {
-        const parsedInput = ToolEditInputSchema.safeParse(input);
-        const parsedOutput = ToolEditOutputSchema.safeParse(output);
-        return (toEditToolDetail(parsedInput.success ? parsedInput.data : null, parsedOutput.success ? parsedOutput.data : null) ?? toPlainTextToolDetail(toolName, output));
-    }
-    if (normalized === "grep" ||
-        normalized === "glob" ||
-        normalized === "search_text" ||
-        normalized === "search" ||
-        normalized === "web_search" ||
-        normalized === "google_search" ||
-        normalized === "web_fetch") {
+    if (normalizedKind === "search" ||
+        normalizedKind === "fetch" ||
+        normalizedName === "grep" ||
+        normalizedName === "glob" ||
+        normalizedName === "search_text" ||
+        normalizedName === "search" ||
+        normalizedName === "web_search" ||
+        normalizedName === "google_search" ||
+        normalizedName === "web_fetch") {
         const parsedInput = ToolSearchInputSchema.safeParse(input);
-        return (toSearchToolDetail(parsedInput.success ? parsedInput.data : null) ??
-            toPlainTextToolDetail(toolName, output));
+        return (toSearchToolDetail(parsedInput.success ? parsedInput.data : null) ?? {
+            type: "search",
+            query: toolName,
+        });
+    }
+    if (contentText) {
+        return {
+            type: "plain_text",
+            label: toolName,
+            text: contentText,
+        };
     }
     return {
         type: "unknown",
@@ -339,7 +421,11 @@ export function toGeminiToolTimelineItem(params) {
         input: params.input,
     });
     const status = normalizeToolStatus(params.status);
-    const detail = deriveGeminiToolDetail(params.toolName, params.input ?? null, params.output ?? null);
+    const detail = deriveGeminiToolDetail(params.toolName, params.input ?? null, params.output ?? null, {
+        kind: params.kind,
+        content: params.content ?? null,
+        locations: params.locations ?? null,
+    });
     if (status === "failed") {
         return {
             type: "tool_call",
@@ -348,6 +434,9 @@ export function toGeminiToolTimelineItem(params) {
             status,
             detail,
             error: params.error ?? { message: "Tool call failed" },
+            metadata: {
+                ...(params.kind ? { kind: params.kind } : {}),
+            },
         };
     }
     return {
@@ -357,6 +446,9 @@ export function toGeminiToolTimelineItem(params) {
         status,
         detail,
         error: null,
+        metadata: {
+            ...(params.kind ? { kind: params.kind } : {}),
+        },
     };
 }
 function toGeminiModelDefinitions() {
@@ -365,66 +457,9 @@ function toGeminiModelDefinitions() {
         id: model.id,
         label: model.label,
         description: model.description,
-        ...("isDefault" in model && model.isDefault === true ? { isDefault: true } : {}),
+        ...("isDefault" in model && model.isDefault ? { isDefault: true } : {}),
     }));
 }
-async function resolveProjectTempDirForCwd(cwd) {
-    const normalizedCwd = await normalizeComparablePath(cwd);
-    let entries;
-    try {
-        entries = await readdir(GEMINI_TMP_DIR);
-    }
-    catch {
-        return null;
-    }
-    for (const entry of entries) {
-        const candidateDir = path.join(GEMINI_TMP_DIR, entry);
-        const markerPath = path.join(candidateDir, ".project_root");
-        try {
-            const marker = (await readFile(markerPath, "utf8")).trim();
-            const normalizedMarker = await normalizeComparablePath(marker);
-            if (normalizedMarker === normalizedCwd) {
-                return candidateDir;
-            }
-        }
-        catch {
-            // ignore non-project entries
-        }
-    }
-    return null;
-}
-async function listKnownGeminiProjects() {
-    let entries;
-    try {
-        entries = await readdir(GEMINI_TMP_DIR);
-    }
-    catch {
-        return [];
-    }
-    const projects = [];
-    for (const entry of entries) {
-        const tempDir = path.join(GEMINI_TMP_DIR, entry);
-        const markerPath = path.join(tempDir, ".project_root");
-        try {
-            const cwd = (await readFile(markerPath, "utf8")).trim();
-            if (cwd.length > 0) {
-                projects.push({ cwd, tempDir });
-            }
-        }
-        catch {
-            // ignore
-        }
-    }
-    return projects;
-}
-async function normalizeComparablePath(inputPath) {
-    try {
-        return await realpath(inputPath);
-    }
-    catch {
-        return path.resolve(inputPath);
-    }
-}
 async function readGeminiSessionFile(filePath) {
     try {
         const raw = await readFile(filePath, "utf8");
@@ -479,6 +514,19 @@ function getGeminiSessionTitle(session) {
     }
     return null;
 }
+function extractRecordedThoughtText(thought) {
+    const directText = nonEmptyString(thought.text) ?? nonEmptyString(thought.thought);
+    if (directText) {
+        return directText;
+    }
+    const record = thought;
+    const subject = nonEmptyString(record.subject);
+    const description = nonEmptyString(record.description);
+    if (subject && description) {
+        return `**${subject}**\n${description}`;
+    }
+    return subject ?? description ?? "";
+}
 export function buildGeminiHistoryTimeline(session) {
     const items = [];
     for (const message of session.messages) {
@@ -501,7 +549,7 @@ export function buildGeminiHistoryTimeline(session) {
             items.push({ type: "assistant_message", text: assistantText });
         }
         for (const thought of message.thoughts ?? []) {
-            const text = nonEmptyString(thought.text) ?? nonEmptyString(thought.thought);
+            const text = extractRecordedThoughtText(thought);
             if (text) {
                 items.push({ type: "reasoning", text });
             }
@@ -522,6 +570,58 @@ export function buildGeminiHistoryTimeline(session) {
     }
     return items;
 }
+async function listKnownGeminiProjects() {
+    let entries;
+    try {
+        entries = await readdir(GEMINI_TMP_DIR);
+    }
+    catch {
+        return [];
+    }
+    const projects = [];
+    for (const entry of entries) {
+        const tempDir = path.join(GEMINI_TMP_DIR, entry);
+        const markerPath = path.join(tempDir, ".project_root");
+        try {
+            const cwd = (await readFile(markerPath, "utf8")).trim();
+            if (cwd.length > 0) {
+                projects.push({ cwd, tempDir });
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return projects;
+}
+async function resolveGeminiProjectTempDirForCwd(cwd) {
+    const projects = await listKnownGeminiProjects();
+    return projects.find((project) => project.cwd === cwd)?.tempDir ?? null;
+}
+async function loadGeminiRecordedSessionForCwd(cwd, sessionId) {
+    const tempDir = await resolveGeminiProjectTempDirForCwd(cwd);
+    if (!tempDir) {
+        return null;
+    }
+    const chatsDir = path.join(tempDir, "chats");
+    let chatFiles;
+    try {
+        chatFiles = await readdir(chatsDir);
+    }
+    catch {
+        return null;
+    }
+    for (const fileName of chatFiles) {
+        if (!fileName.startsWith("session-") || !fileName.endsWith(".json")) {
+            continue;
+        }
+        const session = await readGeminiSessionFile(path.join(chatsDir, fileName));
+        if (session?.sessionId === sessionId) {
+            return session;
+        }
+    }
+    return null;
+}
 async function listGeminiSessionsForProject(params) {
     const chatsDir = path.join(params.tempDir, "chats");
     let chatFiles;
@@ -560,41 +660,281 @@ async function listGeminiSessionsForProject(params) {
         });
     }
     return sessions
-        .sort((a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime())
+        .sort((left, right) => right.lastActivityAt.getTime() - left.lastActivityAt.getTime())
         .slice(0, params.limit ?? sessions.length);
 }
-function toGeminiMcpServerConfig(config) {
+function toAcpHeaders(headers) {
+    if (!headers) {
+        return [];
+    }
+    return Object.entries(headers).map(([name, value]) => ({ name, value }));
+}
+function toAcpEnvVars(env) {
+    if (!env) {
+        return [];
+    }
+    return Object.entries(env).map(([name, value]) => ({ name, value }));
+}
+function toGeminiAcpMcpServer(name, config) {
     if (config.type === "stdio") {
         return {
+            name,
             command: config.command,
-            ...(config.args ? { args: config.args } : {}),
-            ...(config.env ? { env: config.env } : {}),
+            args: config.args ?? [],
+            env: toAcpEnvVars(config.env),
         };
     }
     return {
         type: config.type,
+        name,
         url: config.url,
-        ...(config.headers ? { headers: config.headers } : {}),
+        headers: toAcpHeaders(config.headers),
     };
 }
-async function writeGeminiOverlayConfig(modeId, mcpServers) {
-    const overlay = {};
-    if (modeId === "plan") {
-        overlay.experimental = { plan: true };
+function toGeminiAcpMcpServers(mcpServers) {
+    if (!mcpServers) {
+        return [];
     }
-    if (mcpServers && Object.keys(mcpServers).length > 0) {
-        overlay.mcpServers = Object.fromEntries(Object.entries(mcpServers).map(([name, serverConfig]) => [
-            name,
-            toGeminiMcpServerConfig(serverConfig),
-        ]));
+    return Object.entries(mcpServers).map(([name, config]) => toGeminiAcpMcpServer(name, config));
+}
+function toAgentMode(mode) {
+    return {
+        id: mode.id,
+        label: mode.name,
+        ...(nonEmptyString(mode.description) ? { description: mode.description } : {}),
+    };
+}
+function toAgentModelDefinition(model) {
+    return {
+        provider: GEMINI_PROVIDER,
+        id: model.modelId,
+        label: model.name,
+        ...(nonEmptyString(model.description) ? { description: model.description } : {}),
+    };
+}
+function toolCallTitleToInteractionSubtype(title) {
+    const normalized = title?.trim() ?? "";
+    if (normalized.startsWith("Asking user:")) {
+        return "ask_user_unsupported";
     }
-    if (Object.keys(overlay).length === 0) {
+    if (normalized.startsWith("Requesting plan approval for:")) {
+        return "exit_plan_mode_unsupported";
+    }
+    return "tool";
+}
+function extractGeminiPlanPath(title) {
+    const normalized = title?.trim() ?? "";
+    const prefix = "Requesting plan approval for:";
+    if (!normalized.startsWith(prefix)) {
         return null;
     }
-    const dir = await mkdtemp(path.join(tmpdir(), "junction-gemini-settings-"));
-    const settingsPath = path.join(dir, "settings.json");
-    await writeFile(settingsPath, JSON.stringify(overlay, null, 2), "utf8");
-    return { dir, settingsPath };
+    return nonEmptyString(normalized.slice(prefix.length).trim()) ?? null;
+}
+export function classifyGeminiPermissionRequest(params) {
+    return toolCallTitleToInteractionSubtype(params.toolCall.title);
+}
+export function toGeminiPermissionRequest(params) {
+    const interactionSubtype = classifyGeminiPermissionRequest(params);
+    const toolCallTitle = nonEmptyString(params.toolCall.title) ?? params.toolCall.toolCallId;
+    const optionMetadata = params.options.map((option) => ({
+        optionId: option.optionId,
+        name: option.name,
+        kind: option.kind,
+    }));
+    const planPath = extractGeminiPlanPath(toolCallTitle);
+    const detail = toGeminiToolTimelineItem({
+        toolName: toolCallTitle,
+        callId: params.toolCall.toolCallId,
+        status: params.toolCall.status,
+        input: params.toolCall.rawInput,
+        output: params.toolCall.rawOutput,
+        kind: params.toolCall.kind,
+        content: params.toolCall.content ?? null,
+        locations: params.toolCall.locations ?? null,
+    }).detail;
+    const metadata = {
+        geminiInteractionSubtype: interactionSubtype,
+        permissionOptions: optionMetadata,
+        toolKind: params.toolCall.kind ?? null,
+        toolCallId: params.toolCall.toolCallId,
+        toolCallTitle,
+        toolCallContent: params.toolCall.content ?? [],
+        toolCallLocations: params.toolCall.locations ?? [],
+        ...(planPath ? { geminiPlanPath: planPath } : {}),
+    };
+    if (params.toolCall.rawInput !== undefined) {
+        metadata.toolCallRawInput = params.toolCall.rawInput;
+    }
+    if (params.toolCall.rawOutput !== undefined) {
+        metadata.toolCallRawOutput = params.toolCall.rawOutput;
+    }
+    if (interactionSubtype === "ask_user_unsupported") {
+        return {
+            id: params.toolCall.toolCallId,
+            provider: GEMINI_PROVIDER,
+            name: "ask_user",
+            kind: "other",
+            title: "Gemini needs answers from ask_user",
+            description: "Gemini ACP does not include the payload needed to answer ask_user prompts from Junction.",
+            detail,
+            metadata,
+        };
+    }
+    if (interactionSubtype === "exit_plan_mode_unsupported") {
+        return {
+            id: params.toolCall.toolCallId,
+            provider: GEMINI_PROVIDER,
+            name: "exit_plan_mode",
+            kind: "other",
+            title: "Gemini requested plan approval",
+            description: "Gemini ACP does not include the payload needed to approve or revise exit_plan_mode from Junction.",
+            detail,
+            metadata,
+        };
+    }
+    return {
+        id: params.toolCall.toolCallId,
+        provider: GEMINI_PROVIDER,
+        name: toolCallTitle,
+        kind: "tool",
+        title: toolCallTitle,
+        description: "Gemini needs approval before continuing.",
+        detail,
+        metadata,
+    };
+}
+function toolStateToTimelineItem(state) {
+    return toGeminiToolTimelineItem({
+        toolName: state.title,
+        callId: state.toolCallId,
+        status: state.status,
+        input: state.rawInput,
+        output: state.rawOutput,
+        kind: state.kind,
+        content: state.content,
+        locations: state.locations,
+        error: normalizeToolStatus(state.status) === "failed"
+            ? state.rawOutput ?? { message: "Tool call failed" }
+            : null,
+    });
+}
+function sessionUpdateToEvents(update, toolStates, options) {
+    switch (update.sessionUpdate) {
+        case "user_message_chunk": {
+            if (!options?.includeUserMessages || update.content.type !== "text") {
+                return [];
+            }
+            const text = update.content.text.trim();
+            if (text.length === 0) {
+                return [];
+            }
+            return [
+                {
+                    type: "timeline",
+                    provider: GEMINI_PROVIDER,
+                    item: {
+                        type: "user_message",
+                        text,
+                    },
+                },
+            ];
+        }
+        case "agent_message_chunk": {
+            if (update.content.type !== "text") {
+                return [];
+            }
+            const text = update.content.text;
+            if (text.length === 0) {
+                return [];
+            }
+            return [
+                {
+                    type: "timeline",
+                    provider: GEMINI_PROVIDER,
+                    item: {
+                        type: "assistant_message",
+                        text,
+                    },
+                },
+            ];
+        }
+        case "agent_thought_chunk": {
+            if (update.content.type !== "text") {
+                return [];
+            }
+            const text = update.content.text;
+            if (text.length === 0) {
+                return [];
+            }
+            return [
+                {
+                    type: "timeline",
+                    provider: GEMINI_PROVIDER,
+                    item: {
+                        type: "reasoning",
+                        text,
+                    },
+                },
+            ];
+        }
+        case "tool_call": {
+            const state = {
+                toolCallId: update.toolCallId,
+                title: update.title,
+                status: update.status ?? "in_progress",
+                kind: update.kind ?? null,
+                content: update.content ?? null,
+                locations: update.locations ?? null,
+                rawInput: update.rawInput,
+                rawOutput: update.rawOutput,
+            };
+            toolStates.set(update.toolCallId, state);
+            return [
+                {
+                    type: "timeline",
+                    provider: GEMINI_PROVIDER,
+                    item: toolStateToTimelineItem(state),
+                },
+            ];
+        }
+        case "tool_call_update": {
+            const previous = toolStates.get(update.toolCallId);
+            const state = {
+                toolCallId: update.toolCallId,
+                title: nonEmptyString(update.title) ?? previous?.title ?? update.toolCallId,
+                status: update.status ?? previous?.status ?? "in_progress",
+                kind: update.kind ?? previous?.kind ?? null,
+                content: update.content ?? previous?.content ?? null,
+                locations: update.locations ?? previous?.locations ?? null,
+                rawInput: update.rawInput !== undefined ? update.rawInput : previous?.rawInput,
+                rawOutput: update.rawOutput !== undefined ? update.rawOutput : previous?.rawOutput,
+            };
+            toolStates.set(update.toolCallId, state);
+            return [
+                {
+                    type: "timeline",
+                    provider: GEMINI_PROVIDER,
+                    item: toolStateToTimelineItem(state),
+                },
+            ];
+        }
+        case "plan":
+            return [
+                {
+                    type: "timeline",
+                    provider: GEMINI_PROVIDER,
+                    item: {
+                        type: "todo",
+                        items: update.entries.map((entry) => ({
+                            text: entry.content,
+                            completed: entry.status === "completed",
+                        })),
+                    },
+                },
+            ];
+        default:
+            return [];
+    }
 }
 export class GeminiAgentClient {
     constructor(logger, runtimeSettings) {
@@ -605,7 +945,9 @@ export class GeminiAgentClient {
     }
     async createSession(config) {
         const geminiConfig = this.assertConfig(config);
-        return new GeminiAgentSession(geminiConfig, this.logger, this.runtimeSettings);
+        const session = new GeminiAgentSession(geminiConfig, this.logger, this.runtimeSettings);
+        await session.initialize();
+        return session;
     }
     async resumeSession(handle, overrides) {
         const cwd = overrides?.cwd ?? handle.metadata?.cwd;
@@ -617,7 +959,9 @@ export class GeminiAgentClient {
             cwd,
             ...overrides,
         });
-        return new GeminiAgentSession(config, this.logger, this.runtimeSettings, handle.sessionId);
+        const session = new GeminiAgentSession(config, this.logger, this.runtimeSettings, handle.sessionId);
+        await session.initialize();
+        return session;
     }
     async listModels(_options) {
         return toGeminiModelDefinitions();
@@ -630,11 +974,21 @@ export class GeminiAgentClient {
         })));
         return sessions
             .flat()
-            .sort((a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime())
+            .sort((left, right) => right.lastActivityAt.getTime() - left.lastActivityAt.getTime())
             .slice(0, options?.limit ?? 20);
     }
     async isAvailable() {
-        return isProviderCommandAvailable(this.runtimeSettings?.command, resolveGeminiBinary);
+        try {
+            const available = isProviderCommandAvailable(this.runtimeSettings?.command, resolveGeminiBinary, applyProviderEnv(process.env, this.runtimeSettings));
+            if (!available) {
+                return false;
+            }
+            assertGeminiAcpSupport(this.runtimeSettings);
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
     assertConfig(config) {
         if (config.provider !== GEMINI_PROVIDER) {
@@ -647,24 +1001,53 @@ class GeminiAgentSession {
     constructor(config, logger, runtimeSettings, sessionId) {
         this.provider = GEMINI_PROVIDER;
         this.capabilities = GEMINI_CAPABILITIES;
-        this.currentChild = null;
-        this.currentRunInterrupted = false;
-        this.overlayDir = null;
+        this.connection = null;
+        this.child = null;
+        this.closePromise = null;
+        this.initialized = false;
+        this.closed = false;
+        this.currentModeId = null;
+        this.currentModelId = null;
+        this.requestedModeId = null;
+        this.requestedModelId = null;
+        this.availableModes = GEMINI_RUNTIME_MODES;
+        this.availableModels = toGeminiModelDefinitions();
         this.pendingPermissions = new Map();
+        this.toolStates = new Map();
+        this.activeTurnQueue = null;
+        this.historyEvents = [];
+        this.historyReadyPromise = null;
+        this.resolveHistoryReady = null;
+        this.historyCaptureActive = false;
+        this.historyIdleTimer = null;
+        this.expectedHistoryEventCount = null;
+        this.capturedHistoryEventCount = 0;
+        this.currentRunInterrupted = false;
         this.config = config;
         this.logger = logger.child({ sessionProvider: GEMINI_PROVIDER });
         this.runtimeSettings = runtimeSettings;
-        this.currentMode = normalizeGeminiMode(config.modeId);
         this.sessionId = sessionId ?? null;
+        const requestedState = getRequestedGeminiSessionState(config);
+        this.requestedModeId = requestedState.modeId;
+        this.requestedModelId = requestedState.modelId;
+        this.currentModeId = requestedState.modeId;
+        this.currentModelId = requestedState.modelId;
         this.config.thinkingOptionId = undefined;
     }
     get id() {
         return this.sessionId;
     }
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        assertGeminiAcpSupport(this.runtimeSettings);
+        await this.openConnection();
+        this.initialized = true;
+    }
     async run(prompt, options) {
         const timeline = [];
         let finalText = "";
-        let usage;
         let canceled = false;
         for await (const event of this.stream(prompt, options)) {
             if (event.type === "timeline") {
@@ -673,9 +1056,6 @@ class GeminiAgentSession {
                     finalText += event.item.text;
                 }
             }
-            else if (event.type === "turn_completed") {
-                usage = event.usage;
-            }
             else if (event.type === "turn_failed") {
                 throw new Error(event.error);
             }
@@ -686,249 +1066,156 @@ class GeminiAgentSession {
         return {
             sessionId: this.sessionId ?? "",
             finalText,
-            usage,
             timeline,
             ...(canceled ? { canceled } : {}),
         };
     }
     async *stream(prompt, _options) {
-        if (this.currentChild) {
-            throw new Error("Gemini session is already running");
+        await this.initialize();
+        if (!this.connection || !this.sessionId) {
+            throw new Error("Gemini ACP session is not ready");
         }
-        const promptText = await normalizeGeminiPromptInput(prompt);
-        const modeId = this.currentMode;
-        const overlay = await writeGeminiOverlayConfig(modeId, this.config.mcpServers);
-        if (overlay) {
-            await this.cleanupOverlay();
-            this.overlayDir = overlay.dir;
+        if (this.activeTurnQueue) {
+            throw new Error("Gemini session is already running");
         }
-        const launchPrefix = resolveProviderCommandPrefix(this.runtimeSettings?.command, resolveGeminiBinary);
-        const env = applyProviderEnv(process.env, this.runtimeSettings);
-        if (overlay) {
-            env.GEMINI_CLI_SYSTEM_SETTINGS_PATH = overlay.settingsPath;
-        }
-        const args = [
-            ...launchPrefix.args,
-            "-p",
-            promptText,
-            "--output-format",
-            "stream-json",
-            "--approval-mode",
-            modeId,
-        ];
-        const modelId = typeof this.config.model === "string" && this.config.model.trim().length > 0
-            ? this.config.model.trim()
-            : null;
-        if (modelId) {
-            args.push("--model", modelId);
-        }
-        if (this.sessionId) {
-            args.push("--resume", this.sessionId);
-        }
-        const child = spawn(launchPrefix.command, args, {
-            cwd: this.config.cwd,
-            env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        this.currentChild = child;
+        const queue = new AsyncEventQueue();
+        this.activeTurnQueue = queue;
         this.currentRunInterrupted = false;
-        const stderrChunks = [];
-        child.stderr.on("data", (chunk) => {
-            const text = chunk.toString("utf8");
-            if (text.length > 0) {
-                stderrChunks.push(text);
-            }
-        });
-        const closePromise = new Promise((resolve, reject) => {
-            child.once("error", reject);
-            child.once("close", (code, signal) => resolve({ code, signal }));
-        });
-        const lineReader = readline.createInterface({
-            input: child.stdout,
-            crlfDelay: Infinity,
-        });
-        const pendingToolCalls = new Map();
-        let sawResult = false;
-        let failureMessage = null;
-        yield {
+        queue.push({
             type: "turn_started",
             provider: GEMINI_PROVIDER,
-        };
+        });
+        void this.connection
+            .prompt({
+            sessionId: this.sessionId,
+            prompt: toGeminiPromptBlocks(prompt),
+        })
+            .then((response) => {
+            if (response.stopReason === "cancelled") {
+                queue.push({
+                    type: "turn_canceled",
+                    provider: GEMINI_PROVIDER,
+                    reason: "Interrupted",
+                });
+            }
+            else {
+                queue.push({
+                    type: "turn_completed",
+                    provider: GEMINI_PROVIDER,
+                });
+            }
+            queue.close();
+        })
+            .catch((error) => {
+            queue.push({
+                type: "turn_failed",
+                provider: GEMINI_PROVIDER,
+                error: formatGeminiAcpError(error),
+            });
+            queue.close();
+        });
         try {
-            for await (const rawLine of lineReader) {
-                const line = rawLine.trim();
-                if (!line) {
-                    continue;
-                }
-                let parsedJson;
-                try {
-                    parsedJson = JSON.parse(line);
-                }
-                catch {
-                    continue;
-                }
-                const parsedEvent = GeminiStreamEventSchema.safeParse(parsedJson);
-                if (!parsedEvent.success) {
-                    continue;
-                }
-                const event = parsedEvent.data;
-                if (event.type === "init") {
-                    this.sessionId = event.session_id;
-                    if (event.model) {
-                        this.config.model = event.model;
-                    }
-                    yield {
-                        type: "thread_started",
-                        provider: GEMINI_PROVIDER,
-                        sessionId: event.session_id,
-                    };
-                    continue;
-                }
-                if (event.type === "message") {
-                    if (event.role === "assistant" && event.content.length > 0) {
-                        yield {
-                            type: "timeline",
-                            provider: GEMINI_PROVIDER,
-                            item: {
-                                type: "assistant_message",
-                                text: event.content,
-                            },
-                        };
-                    }
-                    continue;
-                }
-                if (event.type === "tool_use") {
-                    pendingToolCalls.set(event.tool_id, {
-                        toolName: event.tool_name,
-                        input: event.parameters,
-                    });
-                    yield {
-                        type: "timeline",
-                        provider: GEMINI_PROVIDER,
-                        item: toGeminiToolTimelineItem({
-                            toolName: event.tool_name,
-                            callId: event.tool_id,
-                            status: "running",
-                            input: event.parameters,
-                        }),
-                    };
-                    continue;
-                }
-                if (event.type === "tool_result") {
-                    const pending = pendingToolCalls.get(event.tool_id);
-                    const toolName = pending?.toolName ?? "tool";
-                    yield {
-                        type: "timeline",
-                        provider: GEMINI_PROVIDER,
-                        item: toGeminiToolTimelineItem({
-                            toolName,
-                            callId: event.tool_id,
-                            status: event.status,
-                            input: pending?.input,
-                            output: event.output,
-                            error: event.error,
-                        }),
-                    };
-                    pendingToolCalls.delete(event.tool_id);
-                    continue;
-                }
-                if (event.type === "error") {
-                    failureMessage = event.message;
-                    continue;
-                }
-                if (event.type === "result") {
-                    sawResult = true;
-                    if (event.status !== "success") {
-                        failureMessage = failureMessage ?? `Gemini CLI result status: ${event.status}`;
-                        yield {
-                            type: "turn_failed",
-                            provider: GEMINI_PROVIDER,
-                            error: failureMessage,
-                        };
-                        continue;
-                    }
-                    yield {
-                        type: "turn_completed",
-                        provider: GEMINI_PROVIDER,
-                        usage: mapGeminiUsage(event.stats),
-                    };
+            while (true) {
+                const nextEvent = await queue.shift();
+                if (!nextEvent) {
+                    break;
                 }
+                yield nextEvent;
             }
         }
         finally {
-            lineReader.close();
-            const { code, signal } = await closePromise.catch((error) => ({
-                code: 1,
-                signal: null,
-                error,
-            }));
-            this.currentChild = null;
-            if (!sawResult) {
-                if (this.currentRunInterrupted || signal) {
-                    yield {
-                        type: "turn_canceled",
-                        provider: GEMINI_PROVIDER,
-                        reason: "Interrupted",
-                    };
-                }
-                else {
-                    const stderr = stderrChunks.join("").trim();
-                    const message = failureMessage ??
-                        stderr ??
-                        (typeof code === "number" && code !== 0
-                            ? `Gemini CLI exited with code ${code}`
-                            : "Gemini CLI ended without a result event");
-                    yield {
-                        type: "turn_failed",
-                        provider: GEMINI_PROVIDER,
-                        error: message,
-                    };
-                    this.logger.warn({ code, signal, message }, "Gemini run failed");
-                }
+            if (this.activeTurnQueue === queue) {
+                this.activeTurnQueue = null;
             }
             this.currentRunInterrupted = false;
         }
     }
     async *streamHistory() {
-        if (!this.sessionId) {
-            return;
-        }
-        const session = await this.loadRecordedSession(this.sessionId);
-        if (!session) {
-            return;
+        await this.initialize();
+        if (this.historyReadyPromise) {
+            await this.historyReadyPromise;
         }
-        for (const item of buildGeminiHistoryTimeline(session)) {
-            yield {
-                type: "timeline",
-                provider: GEMINI_PROVIDER,
-                item,
-            };
+        for (const event of this.historyEvents) {
+            yield event;
         }
     }
     async getRuntimeInfo() {
+        await this.initialize();
         return {
             provider: GEMINI_PROVIDER,
             sessionId: this.sessionId,
-            model: this.config.model ?? null,
+            model: this.currentModelId,
             thinkingOptionId: null,
-            modeId: this.currentMode,
+            modeId: this.currentModeId,
+            extra: {
+                availableModels: this.availableModels.map((model) => ({
+                    id: model.id,
+                    label: model.label,
+                    description: model.description ?? null,
+                })),
+            },
         };
     }
     async getAvailableModes() {
-        return GEMINI_RUNTIME_MODES;
+        await this.initialize();
+        return this.availableModes;
     }
     async getCurrentMode() {
-        return this.currentMode;
+        await this.initialize();
+        return this.currentModeId;
     }
     async setMode(modeId) {
-        this.currentMode = normalizeGeminiMode(modeId);
-        this.config.modeId = this.currentMode;
+        await this.initialize();
+        const normalizedMode = normalizeGeminiMode(modeId);
+        const availableModeIds = new Set(this.availableModes.map((mode) => mode.id));
+        if (!availableModeIds.has(normalizedMode)) {
+            throw new Error(`Gemini mode '${normalizedMode}' is unavailable for this session. Available modes: ${this.availableModes
+                .map((mode) => mode.id)
+                .join(", ")}`);
+        }
+        if (!this.connection || !this.sessionId) {
+            throw new Error("Gemini ACP session is not ready");
+        }
+        await this.connection.setSessionMode({
+            sessionId: this.sessionId,
+            modeId: normalizedMode,
+        });
+        this.requestedModeId = normalizedMode;
+        this.currentModeId = normalizedMode;
+        this.config.modeId = normalizedMode;
     }
     getPendingPermissions() {
-        return Array.from(this.pendingPermissions.values());
+        return Array.from(this.pendingPermissions.values(), (entry) => entry.request);
     }
-    async respondToPermission(requestId, _response) {
-        throw new Error(`Gemini permission request '${requestId}' cannot be resumed through the headless CLI integration`);
+    async respondToPermission(requestId, response) {
+        const pending = this.pendingPermissions.get(requestId);
+        if (!pending) {
+            throw new Error(`No pending Gemini permission request with id '${requestId}'`);
+        }
+        const selectedOptionId = response.behavior === "allow"
+            ? nonEmptyString(response.updatedInput?.optionId)
+            : nonEmptyString(response.updatedInput?.optionId);
+        const option = pending.options.find((entry) => entry.optionId === selectedOptionId) ??
+            pending.options.find((entry) => response.behavior === "allow"
+                ? entry.kind.startsWith("allow")
+                : entry.kind.startsWith("reject")) ??
+            null;
+        if (!option) {
+            throw new Error(`Gemini permission '${requestId}' does not have a matching option`);
+        }
+        this.pendingPermissions.delete(requestId);
+        pending.resolve({
+            outcome: {
+                outcome: "selected",
+                optionId: option.optionId,
+            },
+        });
+        this.emitLiveEvent({
+            type: "permission_resolved",
+            provider: GEMINI_PROVIDER,
+            requestId,
+            resolution: response,
+        });
     }
     describePersistence() {
         if (!this.sessionId) {
@@ -937,65 +1224,336 @@ class GeminiAgentSession {
         return {
             provider: GEMINI_PROVIDER,
             sessionId: this.sessionId,
-            nativeHandle: this.sessionId,
             metadata: {
                 cwd: this.config.cwd,
             },
         };
     }
     async interrupt() {
-        this.currentRunInterrupted = true;
-        const child = this.currentChild;
-        if (!child) {
+        await this.initialize();
+        if (!this.connection || !this.sessionId) {
             return;
         }
-        child.kill("SIGINT");
+        this.currentRunInterrupted = true;
+        for (const [requestId, pending] of this.pendingPermissions.entries()) {
+            this.pendingPermissions.delete(requestId);
+            pending.resolve({
+                outcome: {
+                    outcome: "cancelled",
+                },
+            });
+            this.emitLiveEvent({
+                type: "permission_resolved",
+                provider: GEMINI_PROVIDER,
+                requestId,
+                resolution: {
+                    behavior: "deny",
+                    message: "Interrupted",
+                },
+            });
+        }
+        await this.connection.cancel({
+            sessionId: this.sessionId,
+        });
     }
     async close() {
-        await this.interrupt();
-        await this.cleanupOverlay();
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.finishHistoryCapture();
+        for (const [requestId, pending] of this.pendingPermissions.entries()) {
+            this.pendingPermissions.delete(requestId);
+            pending.resolve({
+                outcome: {
+                    outcome: "cancelled",
+                },
+            });
+            this.emitLiveEvent({
+                type: "permission_resolved",
+                provider: GEMINI_PROVIDER,
+                requestId,
+                resolution: {
+                    behavior: "deny",
+                    message: "Session closed",
+                },
+            });
+        }
+        this.activeTurnQueue?.close();
+        this.activeTurnQueue = null;
+        if (this.child?.stdin) {
+            this.child.stdin.end();
+        }
+        if (this.child && !this.child.killed) {
+            this.child.kill();
+        }
+        await this.closePromise?.catch(() => { });
+        this.connection = null;
+        this.child = null;
     }
     async setModel(modelId) {
-        this.config.model =
-            typeof modelId === "string" && modelId.trim().length > 0
-                ? modelId.trim()
-                : undefined;
+        await this.initialize();
+        const normalizedModelId = typeof modelId === "string" && modelId.trim().length > 0 ? modelId.trim() : null;
+        if (!normalizedModelId) {
+            throw new Error("Gemini model id cannot be empty");
+        }
+        const availableModelIds = new Set(this.availableModels.map((model) => model.id));
+        if (!availableModelIds.has(normalizedModelId)) {
+            throw new Error(`Gemini model '${normalizedModelId}' is unavailable for this session. Available models: ${this.availableModels
+                .map((model) => model.id)
+                .join(", ")}`);
+        }
+        if (!this.connection || !this.sessionId) {
+            throw new Error("Gemini ACP session is not ready");
+        }
+        await this.connection.unstable_setSessionModel({
+            sessionId: this.sessionId,
+            modelId: normalizedModelId,
+        });
+        this.requestedModelId = normalizedModelId;
+        this.currentModelId = normalizedModelId;
+        this.config.model = normalizedModelId;
     }
-    async setThinkingOption(_thinkingOptionId) {
-        this.config.thinkingOptionId = undefined;
+    async setThinkingOption(_thinkingOptionId) { }
+    async openConnection() {
+        const launchPrefix = resolveProviderCommandPrefix(this.runtimeSettings?.command, resolveGeminiBinary);
+        const env = applyProviderEnv(process.env, this.runtimeSettings);
+        const child = spawn(launchPrefix.command, [...launchPrefix.args, "--acp"], {
+            cwd: this.config.cwd,
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.child = child;
+        const stderrChunks = [];
+        child.stderr.on("data", (chunk) => {
+            const text = chunk.toString("utf8");
+            if (text.length > 0) {
+                stderrChunks.push(text);
+            }
+        });
+        this.closePromise = new Promise((resolve) => {
+            child.once("close", (code, signal) => {
+                const stderr = stderrChunks.join("").trim();
+                this.child = null;
+                this.connection = null;
+                if (!this.closed) {
+                    const message = stderr ||
+                        (typeof code === "number" && code !== 0
+                            ? `Gemini ACP process exited with code ${code}`
+                            : signal
+                                ? `Gemini ACP process exited with signal ${signal}`
+                                : "Gemini ACP process closed");
+                    if (this.activeTurnQueue) {
+                        this.activeTurnQueue.push({
+                            type: "turn_failed",
+                            provider: GEMINI_PROVIDER,
+                            error: message,
+                        });
+                        this.activeTurnQueue.close();
+                    }
+                    this.logger.warn({ code, signal, stderr }, "Gemini ACP process closed");
+                }
+                resolve();
+            });
+        });
+        const stream = acp.ndJsonStream(NodeWritable.toWeb(child.stdin), NodeReadable.toWeb(child.stdout));
+        this.connection = new acp.ClientSideConnection(() => ({
+            sessionUpdate: async (notification) => {
+                await this.handleSessionUpdate(notification);
+            },
+            requestPermission: async (request) => this.handlePermissionRequest(request),
+        }), stream);
+        try {
+            await this.connection.initialize({
+                protocolVersion: acp.PROTOCOL_VERSION,
+                clientCapabilities: {
+                    fs: {
+                        readTextFile: false,
+                        writeTextFile: false,
+                    },
+                },
+                clientInfo: {
+                    name: "junction",
+                    title: "Junction",
+                    version: "local",
+                },
+            });
+            if (this.sessionId) {
+                const recordedSession = await loadGeminiRecordedSessionForCwd(this.config.cwd, this.sessionId);
+                this.beginHistoryCapture(recordedSession ? buildGeminiHistoryTimeline(recordedSession).length : null);
+                const response = await this.connection.loadSession({
+                    sessionId: this.sessionId,
+                    cwd: this.config.cwd,
+                    mcpServers: toGeminiAcpMcpServers(this.config.mcpServers),
+                });
+                this.applySessionSetup(response);
+                if (this.expectedHistoryEventCount === 0) {
+                    this.finishHistoryCapture();
+                }
+                else {
+                    this.scheduleHistoryCaptureFinish();
+                }
+            }
+            else {
+                const response = await this.connection.newSession({
+                    cwd: this.config.cwd,
+                    mcpServers: toGeminiAcpMcpServers(this.config.mcpServers),
+                });
+                this.sessionId = response.sessionId;
+                this.applySessionSetup(response);
+            }
+            await this.applyRequestedOverrides();
+        }
+        catch (error) {
+            await this.close().catch(() => { });
+            throw new Error(formatGeminiAcpError(error));
+        }
     }
-    async loadRecordedSession(sessionId) {
-        const projectTempDir = await resolveProjectTempDirForCwd(this.config.cwd);
-        if (!projectTempDir) {
-            return null;
+    applySessionSetup(response) {
+        if (response.modes) {
+            this.availableModes = response.modes.availableModes.map((mode) => toAgentMode(mode));
+            this.currentModeId = response.modes.currentModeId;
+            this.config.modeId = response.modes.currentModeId;
         }
-        const chatsDir = path.join(projectTempDir, "chats");
-        let files;
-        try {
-            files = await readdir(chatsDir);
+        if (response.models) {
+            this.availableModels = response.models.availableModels.map((model) => toAgentModelDefinition(model));
+            this.currentModelId = response.models.currentModelId;
+            this.config.model = response.models.currentModelId;
         }
-        catch {
-            return null;
+    }
+    async applyRequestedOverrides() {
+        const requestedModeId = this.requestedModeId;
+        if (requestedModeId && requestedModeId !== this.currentModeId) {
+            const availableModeIds = new Set(this.availableModes.map((mode) => mode.id));
+            if (!availableModeIds.has(requestedModeId)) {
+                throw new Error(`Gemini mode '${requestedModeId}' is unavailable for this session. Available modes: ${this.availableModes
+                    .map((mode) => mode.id)
+                    .join(", ")}`);
+            }
+            if (!this.connection || !this.sessionId) {
+                throw new Error("Gemini ACP session is not ready");
+            }
+            await this.connection.setSessionMode({
+                sessionId: this.sessionId,
+                modeId: requestedModeId,
+            });
+            this.currentModeId = requestedModeId;
+            this.config.modeId = requestedModeId;
         }
-        for (const fileName of files) {
-            if (!fileName.startsWith("session-") || !fileName.endsWith(".json")) {
-                continue;
+        const requestedModelId = this.requestedModelId;
+        if (requestedModelId && requestedModelId !== this.currentModelId) {
+            const availableModelIds = new Set(this.availableModels.map((model) => model.id));
+            if (!availableModelIds.has(requestedModelId)) {
+                throw new Error(`Gemini model '${requestedModelId}' is unavailable for this session. Available models: ${this.availableModels
+                    .map((model) => model.id)
+                    .join(", ")}`);
             }
-            const filePath = path.join(chatsDir, fileName);
-            const session = await readGeminiSessionFile(filePath);
-            if (session?.sessionId === sessionId) {
-                return session;
+            if (!this.connection || !this.sessionId) {
+                throw new Error("Gemini ACP session is not ready");
             }
+            await this.connection.unstable_setSessionModel({
+                sessionId: this.sessionId,
+                modelId: requestedModelId,
+            });
+            this.currentModelId = requestedModelId;
+            this.config.model = requestedModelId;
         }
-        return null;
     }
-    async cleanupOverlay() {
-        if (!this.overlayDir) {
+    beginHistoryCapture(expectedEventCount) {
+        this.historyEvents = [];
+        this.expectedHistoryEventCount = expectedEventCount;
+        this.capturedHistoryEventCount = 0;
+        this.historyCaptureActive = true;
+        this.historyReadyPromise = new Promise((resolve) => {
+            this.resolveHistoryReady = resolve;
+        });
+    }
+    scheduleHistoryCaptureFinish() {
+        if (!this.historyCaptureActive) {
+            return;
+        }
+        if (this.historyIdleTimer) {
+            clearTimeout(this.historyIdleTimer);
+        }
+        this.historyIdleTimer = setTimeout(() => {
+            this.finishHistoryCapture();
+        }, GEMINI_HISTORY_FALLBACK_IDLE_MS);
+    }
+    finishHistoryCapture() {
+        if (this.historyIdleTimer) {
+            clearTimeout(this.historyIdleTimer);
+            this.historyIdleTimer = null;
+        }
+        if (!this.historyCaptureActive) {
+            return;
+        }
+        this.historyCaptureActive = false;
+        this.expectedHistoryEventCount = null;
+        this.capturedHistoryEventCount = 0;
+        this.resolveHistoryReady?.();
+        this.resolveHistoryReady = null;
+    }
+    async handleSessionUpdate(notification) {
+        if (notification.sessionId !== this.sessionId) {
+            return;
+        }
+        if (notification.update.sessionUpdate === "current_mode_update") {
+            this.currentModeId = notification.update.currentModeId;
+            return;
+        }
+        const includeUserMessages = this.historyCaptureActive;
+        const events = sessionUpdateToEvents(notification.update, this.toolStates, {
+            includeUserMessages,
+        });
+        if (events.length === 0) {
             return;
         }
-        const dir = this.overlayDir;
-        this.overlayDir = null;
-        await rm(dir, { recursive: true, force: true });
+        if (this.historyCaptureActive && !this.activeTurnQueue) {
+            this.historyEvents.push(...events);
+            this.capturedHistoryEventCount += events.length;
+            if (this.expectedHistoryEventCount !== null &&
+                this.capturedHistoryEventCount >= this.expectedHistoryEventCount) {
+                this.finishHistoryCapture();
+            }
+            else {
+                this.scheduleHistoryCaptureFinish();
+            }
+            return;
+        }
+        for (const event of events) {
+            this.emitLiveEvent(event);
+        }
+    }
+    emitLiveEvent(event) {
+        this.activeTurnQueue?.push(event);
+    }
+    async handlePermissionRequest(params) {
+        if (this.currentRunInterrupted) {
+            return {
+                outcome: {
+                    outcome: "cancelled",
+                },
+            };
+        }
+        const request = toGeminiPermissionRequest(params);
+        const options = params.options.map((option) => ({
+            optionId: option.optionId,
+            name: option.name,
+            kind: option.kind,
+        }));
+        return await new Promise((resolve, reject) => {
+            this.pendingPermissions.set(request.id, {
+                request,
+                options,
+                resolve,
+                reject,
+            });
+            this.emitLiveEvent({
+                type: "permission_requested",
+                provider: GEMINI_PROVIDER,
+                request,
+            });
+        });
     }
 }
 //# sourceMappingURL=gemini-agent.js.map