@junctionpanel/server 0.1.19 → 0.1.21

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

@@ -0,0 +1,973 @@
+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 path from "node:path";
+import readline from "node:readline";
+import { z } from "zod";
+import { applyProviderEnv, isProviderCommandAvailable, resolveProviderCommandPrefix, } from "../provider-launch-config.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_CAPABILITIES = {
+    supportsStreaming: true,
+    supportsSessionPersistence: true,
+    supportsDynamicModes: true,
+    supportsMcpServers: true,
+    supportsReasoningStream: false,
+    supportsToolInvocations: true,
+};
+const DEFAULT_GEMINI_MODE = "default";
+export const GEMINI_MODEL_CATALOG = [
+    {
+        id: "auto-gemini-2.5",
+        label: "Auto 2.5",
+        description: "Automatic routing across Gemini 2.5 models",
+        isDefault: true,
+    },
+    {
+        id: "auto-gemini-3",
+        label: "Auto 3 Preview",
+        description: "Automatic routing across Gemini 3 preview models",
+    },
+    {
+        id: "gemini-2.5-pro",
+        label: "Gemini 2.5 Pro",
+        description: "High-capability reasoning model",
+    },
+    {
+        id: "gemini-2.5-flash",
+        label: "Gemini 2.5 Flash",
+        description: "Fast general-purpose model",
+    },
+    {
+        id: "gemini-2.5-flash-lite",
+        label: "Gemini 2.5 Flash Lite",
+        description: "Low-latency lightweight model",
+    },
+    {
+        id: "gemini-3-pro-preview",
+        label: "Gemini 3 Pro Preview",
+        description: "Preview reasoning model",
+    },
+    {
+        id: "gemini-3.1-pro-preview",
+        label: "Gemini 3.1 Pro Preview",
+        description: "Preview reasoning model with updated capabilities",
+    },
+    {
+        id: "gemini-3.1-pro-preview-customtools",
+        label: "Gemini 3.1 Pro Preview Custom Tools",
+        description: "Preview custom-tools model",
+    },
+    {
+        id: "gemini-3-flash-preview",
+        label: "Gemini 3 Flash Preview",
+        description: "Preview fast model",
+    },
+];
+const GEMINI_RUNTIME_MODES = [
+    {
+        id: "default",
+        label: "Always Ask",
+        description: "Gemini CLI default approval mode",
+    },
+    {
+        id: "auto_edit",
+        label: "Auto Edit",
+        description: "Auto-approve edit tools while keeping other approvals enabled",
+    },
+    {
+        id: "yolo",
+        label: "Bypass",
+        description: "Auto-approve all tool calls",
+    },
+    {
+        id: "plan",
+        label: "Plan Mode",
+        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(),
+    text: z.string().optional(),
+})
+    .passthrough();
+const GeminiRecordedToolCallSchema = z
+    .object({
+    id: z.string().optional(),
+    name: z.string().optional(),
+    args: z.unknown().optional(),
+    result: z.unknown().optional(),
+    resultDisplay: z.string().optional(),
+    status: z.string().optional(),
+})
+    .passthrough();
+const GeminiRecordedMessageSchema = z
+    .object({
+    id: z.string().optional(),
+    type: z.string(),
+    content: z.unknown().optional(),
+    displayContent: z.unknown().optional(),
+    thoughts: z.array(GeminiRecordedThoughtSchema).optional(),
+    toolCalls: z.array(GeminiRecordedToolCallSchema).optional(),
+})
+    .passthrough();
+const GeminiRecordedSessionSchema = z
+    .object({
+    sessionId: z.string().trim().min(1),
+    startTime: z.string(),
+    lastUpdated: z.string(),
+    summary: z.string().optional(),
+    kind: z.string().optional(),
+    messages: z.array(GeminiRecordedMessageSchema),
+})
+    .passthrough();
+function resolveGeminiBinary() {
+    try {
+        const geminiPath = execSync("which gemini", { encoding: "utf8" }).trim();
+        if (geminiPath) {
+            return geminiPath;
+        }
+    }
+    catch {
+        // fall through
+    }
+    throw new Error("Gemini CLI not found. Please install gemini globally so Junction can launch the provider.");
+}
+export function normalizeGeminiMode(modeId) {
+    if (!modeId) {
+        return DEFAULT_GEMINI_MODE;
+    }
+    if (GEMINI_MODES.includes(modeId)) {
+        return modeId;
+    }
+    if (modeId === "bypassPermissions") {
+        return "yolo";
+    }
+    throw new Error(`Unknown Gemini mode '${modeId}'. Valid modes: ${GEMINI_MODES.join(", ")}`);
+}
+function normalizePromptInput(prompt) {
+    if (typeof prompt === "string") {
+        return prompt;
+    }
+    const textBlocks = prompt
+        .filter((block) => block.type === "text")
+        .map((block) => block.text);
+    if (textBlocks.length === 0) {
+        throw new Error("Gemini CLI does not currently support image-only prompts in Junction.");
+    }
+    return textBlocks.join("\n\n");
+}
+function mapGeminiUsage(stats) {
+    if (!stats) {
+        return undefined;
+    }
+    return {
+        inputTokens: stats.input_tokens ?? stats.input,
+        cachedInputTokens: stats.cached,
+        outputTokens: stats.output_tokens,
+    };
+}
+function normalizeToolStatus(status) {
+    const normalized = status?.trim().toLowerCase() ?? "";
+    if (normalized === "success" || normalized === "completed" || normalized === "done") {
+        return "completed";
+    }
+    if (normalized === "error" ||
+        normalized === "failed" ||
+        normalized === "failure") {
+        return "failed";
+    }
+    if (normalized === "canceled" ||
+        normalized === "cancelled" ||
+        normalized === "aborted" ||
+        normalized === "interrupted") {
+        return "canceled";
+    }
+    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 deriveGeminiToolDetail(toolName, input, output) {
+    const normalized = toolName.trim().toLowerCase();
+    if (normalized === "run_shell_command" ||
+        normalized === "shell" ||
+        normalized === "bash" ||
+        normalized === "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));
+    }
+    if (normalized === "read_file" ||
+        normalized === "read" ||
+        normalized === "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));
+    }
+    if (normalized === "write_file" ||
+        normalized === "write" ||
+        normalized === "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));
+    }
+    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") {
+        const parsedInput = ToolSearchInputSchema.safeParse(input);
+        return (toSearchToolDetail(parsedInput.success ? parsedInput.data : null) ??
+            toPlainTextToolDetail(toolName, output));
+    }
+    return {
+        type: "unknown",
+        input: input ?? null,
+        output: output ?? null,
+    };
+}
+export function toGeminiToolTimelineItem(params) {
+    const callId = coerceToolCallId({
+        providerPrefix: GEMINI_PROVIDER,
+        rawCallId: params.callId,
+        toolName: params.toolName,
+        input: params.input,
+    });
+    const status = normalizeToolStatus(params.status);
+    const detail = deriveGeminiToolDetail(params.toolName, params.input ?? null, params.output ?? null);
+    if (status === "failed") {
+        return {
+            type: "tool_call",
+            callId,
+            name: params.toolName,
+            status,
+            detail,
+            error: params.error ?? { message: "Tool call failed" },
+        };
+    }
+    return {
+        type: "tool_call",
+        callId,
+        name: params.toolName,
+        status,
+        detail,
+        error: null,
+    };
+}
+function toGeminiModelDefinitions() {
+    return GEMINI_MODEL_CATALOG.map((model) => ({
+        provider: GEMINI_PROVIDER,
+        id: model.id,
+        label: model.label,
+        description: model.description,
+        ...("isDefault" in model && model.isDefault === true ? { 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");
+        const parsed = JSON.parse(raw);
+        const session = GeminiRecordedSessionSchema.safeParse(parsed);
+        if (!session.success) {
+            return null;
+        }
+        if (session.data.kind === "subagent") {
+            return null;
+        }
+        return session.data;
+    }
+    catch {
+        return null;
+    }
+}
+function extractRecordedContentText(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        return content.map((entry) => extractRecordedContentText(entry)).join("");
+    }
+    if (content && typeof content === "object") {
+        const record = content;
+        const directText = nonEmptyString(record.text) ??
+            nonEmptyString(record.content) ??
+            nonEmptyString(record.displayText);
+        if (directText) {
+            return directText;
+        }
+        if ("parts" in record) {
+            return extractRecordedContentText(record.parts);
+        }
+    }
+    return "";
+}
+function getGeminiSessionTitle(session) {
+    const summary = nonEmptyString(session.summary);
+    if (summary) {
+        return summary;
+    }
+    for (const message of session.messages) {
+        if (message.type !== "user") {
+            continue;
+        }
+        const text = extractRecordedContentText(message.content ?? message.displayContent).trim();
+        if (text.length > 0) {
+            return text;
+        }
+    }
+    return null;
+}
+export function buildGeminiHistoryTimeline(session) {
+    const items = [];
+    for (const message of session.messages) {
+        if (message.type === "user") {
+            const text = extractRecordedContentText(message.content ?? message.displayContent).trim();
+            if (text.length > 0) {
+                items.push({
+                    type: "user_message",
+                    text,
+                    ...(message.id ? { messageId: message.id } : {}),
+                });
+            }
+            continue;
+        }
+        if (message.type !== "gemini") {
+            continue;
+        }
+        const assistantText = extractRecordedContentText(message.content ?? message.displayContent).trim();
+        if (assistantText.length > 0) {
+            items.push({ type: "assistant_message", text: assistantText });
+        }
+        for (const thought of message.thoughts ?? []) {
+            const text = nonEmptyString(thought.text) ?? nonEmptyString(thought.thought);
+            if (text) {
+                items.push({ type: "reasoning", text });
+            }
+        }
+        for (const toolCall of message.toolCalls ?? []) {
+            const toolName = nonEmptyString(toolCall.name) ?? "tool";
+            items.push(toGeminiToolTimelineItem({
+                toolName,
+                callId: toolCall.id,
+                status: toolCall.status,
+                input: toolCall.args,
+                output: toolCall.resultDisplay ?? toolCall.result,
+                error: normalizeToolStatus(toolCall.status) === "failed"
+                    ? toolCall.result ?? { message: "Tool call failed" }
+                    : null,
+            }));
+        }
+    }
+    return items;
+}
+async function listGeminiSessionsForProject(params) {
+    const chatsDir = path.join(params.tempDir, "chats");
+    let chatFiles;
+    try {
+        chatFiles = await readdir(chatsDir);
+    }
+    catch {
+        return [];
+    }
+    const sessions = [];
+    for (const fileName of chatFiles) {
+        if (!fileName.startsWith("session-") || !fileName.endsWith(".json")) {
+            continue;
+        }
+        const filePath = path.join(chatsDir, fileName);
+        const session = await readGeminiSessionFile(filePath);
+        if (!session) {
+            continue;
+        }
+        sessions.push({
+            provider: GEMINI_PROVIDER,
+            sessionId: session.sessionId,
+            cwd: params.cwd,
+            title: getGeminiSessionTitle(session),
+            lastActivityAt: new Date(session.lastUpdated),
+            persistence: {
+                provider: GEMINI_PROVIDER,
+                sessionId: session.sessionId,
+                nativeHandle: filePath,
+                metadata: {
+                    cwd: params.cwd,
+                    filePath,
+                },
+            },
+            timeline: buildGeminiHistoryTimeline(session),
+        });
+    }
+    return sessions
+        .sort((a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime())
+        .slice(0, params.limit ?? sessions.length);
+}
+function toGeminiMcpServerConfig(config) {
+    if (config.type === "stdio") {
+        return {
+            command: config.command,
+            ...(config.args ? { args: config.args } : {}),
+            ...(config.env ? { env: config.env } : {}),
+        };
+    }
+    return {
+        type: config.type,
+        url: config.url,
+        ...(config.headers ? { headers: config.headers } : {}),
+    };
+}
+async function writeGeminiOverlayConfig(modeId, mcpServers) {
+    const overlay = {};
+    if (modeId === "plan") {
+        overlay.experimental = { plan: true };
+    }
+    if (mcpServers && Object.keys(mcpServers).length > 0) {
+        overlay.mcpServers = Object.fromEntries(Object.entries(mcpServers).map(([name, serverConfig]) => [
+            name,
+            toGeminiMcpServerConfig(serverConfig),
+        ]));
+    }
+    if (Object.keys(overlay).length === 0) {
+        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 };
+}
+export class GeminiAgentClient {
+    constructor(logger, runtimeSettings) {
+        this.provider = GEMINI_PROVIDER;
+        this.capabilities = GEMINI_CAPABILITIES;
+        this.logger = logger.child({ module: "agent", provider: GEMINI_PROVIDER });
+        this.runtimeSettings = runtimeSettings;
+    }
+    async createSession(config) {
+        const geminiConfig = this.assertConfig(config);
+        return new GeminiAgentSession(geminiConfig, this.logger, this.runtimeSettings);
+    }
+    async resumeSession(handle, overrides) {
+        const cwd = overrides?.cwd ?? handle.metadata?.cwd;
+        if (!cwd) {
+            throw new Error("Gemini resume requires the original working directory");
+        }
+        const config = this.assertConfig({
+            provider: GEMINI_PROVIDER,
+            cwd,
+            ...overrides,
+        });
+        return new GeminiAgentSession(config, this.logger, this.runtimeSettings, handle.sessionId);
+    }
+    async listModels(_options) {
+        return toGeminiModelDefinitions();
+    }
+    async listPersistedAgents(options) {
+        const projects = await listKnownGeminiProjects();
+        const sessions = await Promise.all(projects.map((project) => listGeminiSessionsForProject({
+            ...project,
+            limit: options?.limit,
+        })));
+        return sessions
+            .flat()
+            .sort((a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime())
+            .slice(0, options?.limit ?? 20);
+    }
+    async isAvailable() {
+        return isProviderCommandAvailable(this.runtimeSettings?.command, resolveGeminiBinary);
+    }
+    assertConfig(config) {
+        if (config.provider !== GEMINI_PROVIDER) {
+            throw new Error(`GeminiAgentClient received config for provider '${config.provider}'`);
+        }
+        return { ...config, provider: GEMINI_PROVIDER };
+    }
+}
+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.pendingPermissions = new Map();
+        this.config = config;
+        this.logger = logger.child({ sessionProvider: GEMINI_PROVIDER });
+        this.runtimeSettings = runtimeSettings;
+        this.currentMode = normalizeGeminiMode(config.modeId);
+        this.sessionId = sessionId ?? null;
+        this.config.thinkingOptionId = undefined;
+    }
+    get id() {
+        return this.sessionId;
+    }
+    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") {
+                timeline.push(event.item);
+                if (event.item.type === "assistant_message") {
+                    finalText += event.item.text;
+                }
+            }
+            else if (event.type === "turn_completed") {
+                usage = event.usage;
+            }
+            else if (event.type === "turn_failed") {
+                throw new Error(event.error);
+            }
+            else if (event.type === "turn_canceled") {
+                canceled = true;
+            }
+        }
+        return {
+            sessionId: this.sessionId ?? "",
+            finalText,
+            usage,
+            timeline,
+            ...(canceled ? { canceled } : {}),
+        };
+    }
+    async *stream(prompt, _options) {
+        if (this.currentChild) {
+            throw new Error("Gemini session is already running");
+        }
+        const promptText = normalizePromptInput(prompt);
+        const modeId = this.currentMode;
+        const overlay = await writeGeminiOverlayConfig(modeId, this.config.mcpServers);
+        if (overlay) {
+            await this.cleanupOverlay();
+            this.overlayDir = overlay.dir;
+        }
+        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;
+        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 {
+            type: "turn_started",
+            provider: GEMINI_PROVIDER,
+        };
+        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),
+                    };
+                }
+            }
+        }
+        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");
+                }
+            }
+            this.currentRunInterrupted = false;
+        }
+    }
+    async *streamHistory() {
+        if (!this.sessionId) {
+            return;
+        }
+        const session = await this.loadRecordedSession(this.sessionId);
+        if (!session) {
+            return;
+        }
+        for (const item of buildGeminiHistoryTimeline(session)) {
+            yield {
+                type: "timeline",
+                provider: GEMINI_PROVIDER,
+                item,
+            };
+        }
+    }
+    async getRuntimeInfo() {
+        return {
+            provider: GEMINI_PROVIDER,
+            sessionId: this.sessionId,
+            model: this.config.model ?? null,
+            thinkingOptionId: null,
+            modeId: this.currentMode,
+        };
+    }
+    async getAvailableModes() {
+        return GEMINI_RUNTIME_MODES;
+    }
+    async getCurrentMode() {
+        return this.currentMode;
+    }
+    async setMode(modeId) {
+        this.currentMode = normalizeGeminiMode(modeId);
+        this.config.modeId = this.currentMode;
+    }
+    getPendingPermissions() {
+        return Array.from(this.pendingPermissions.values());
+    }
+    async respondToPermission(requestId, _response) {
+        throw new Error(`Gemini permission request '${requestId}' cannot be resumed through the headless CLI integration`);
+    }
+    describePersistence() {
+        if (!this.sessionId) {
+            return null;
+        }
+        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) {
+            return;
+        }
+        child.kill("SIGINT");
+    }
+    async close() {
+        await this.interrupt();
+        await this.cleanupOverlay();
+    }
+    async setModel(modelId) {
+        this.config.model =
+            typeof modelId === "string" && modelId.trim().length > 0
+                ? modelId.trim()
+                : undefined;
+    }
+    async setThinkingOption(_thinkingOptionId) {
+        this.config.thinkingOptionId = undefined;
+    }
+    async loadRecordedSession(sessionId) {
+        const projectTempDir = await resolveProjectTempDirForCwd(this.config.cwd);
+        if (!projectTempDir) {
+            return null;
+        }
+        const chatsDir = path.join(projectTempDir, "chats");
+        let files;
+        try {
+            files = await readdir(chatsDir);
+        }
+        catch {
+            return null;
+        }
+        for (const fileName of files) {
+            if (!fileName.startsWith("session-") || !fileName.endsWith(".json")) {
+                continue;
+            }
+            const filePath = path.join(chatsDir, fileName);
+            const session = await readGeminiSessionFile(filePath);
+            if (session?.sessionId === sessionId) {
+                return session;
+            }
+        }
+        return null;
+    }
+    async cleanupOverlay() {
+        if (!this.overlayDir) {
+            return;
+        }
+        const dir = this.overlayDir;
+        this.overlayDir = null;
+        await rm(dir, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=gemini-agent.js.map