@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.5fc22c6f

package/dist/resources/extensions/cursor-cli/models.js

@@ -0,0 +1,63 @@
+const ZERO_COST = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+};
+const CURSOR_INPUT = ["text"];
+export const CURSOR_AGENT_MODELS = [
+    {
+        id: "composer-2.5",
+        name: "Composer 2.5 (via Cursor)",
+        reasoning: true,
+        input: CURSOR_INPUT,
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 64_000,
+    },
+    {
+        id: "claude-sonnet-4-6",
+        name: "Claude Sonnet 4.6 (via Cursor)",
+        reasoning: true,
+        input: CURSOR_INPUT,
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 64_000,
+    },
+    {
+        id: "claude-opus-4-7",
+        name: "Claude Opus 4.7 (via Cursor)",
+        reasoning: true,
+        input: CURSOR_INPUT,
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 128_000,
+    },
+    {
+        id: "gpt-5.5",
+        name: "GPT-5.5 (via Cursor)",
+        reasoning: true,
+        input: CURSOR_INPUT,
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 128_000,
+    },
+    {
+        id: "gemini-2.5-pro",
+        name: "Gemini 2.5 Pro (via Cursor)",
+        reasoning: true,
+        input: CURSOR_INPUT,
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 65_536,
+    },
+    {
+        id: "grok-4",
+        name: "Grok 4 (via Cursor)",
+        reasoning: true,
+        input: CURSOR_INPUT,
+        cost: ZERO_COST,
+        contextWindow: 256_000,
+        maxTokens: 64_000,
+    },
+];

package/dist/resources/extensions/cursor-cli/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@gsd/cursor-cli",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "pi": {
+    "extensions": [
+      "./index.js"
+    ]
+  }
+}

package/dist/resources/extensions/cursor-cli/readiness.js

@@ -0,0 +1,128 @@
+import { execFileSync } from "node:child_process";
+const VERSION_TIMEOUT_MS = 5_000;
+const STATUS_TIMEOUT_MS = 10_000;
+const CHECK_INTERVAL_MS = 30_000;
+let cachedBinaryPresent = null;
+let cachedAuthed = null;
+let lastCheckMs = 0;
+export function getCursorAgentCommand(platform = process.platform) {
+    return platform === "win32" ? "cursor-agent.cmd" : "cursor-agent";
+}
+export function getCursorAgentCommandCandidates(platform = process.platform) {
+    const command = getCursorAgentCommand(platform);
+    return platform === "win32" ? [command, "cursor-agent.exe", "cursor-agent"] : [command];
+}
+export function buildCursorAgentSpawnInvocation(command, args, platform = process.platform) {
+    if (platform === "win32") {
+        return { command: "cmd", args: ["/c", command, ...args] };
+    }
+    return { command, args };
+}
+function debugLog(...parts) {
+    if (process.env.GSD_CURSOR_DEBUG) {
+        process.stderr.write(`[cursor-readiness] ${parts.map((part) => String(part)).join(" ")}\n`);
+    }
+}
+function spawnCursorAgent(command, args, timeout) {
+    const invocation = buildCursorAgentSpawnInvocation(command, args);
+    return execFileSync(invocation.command, invocation.args, { timeout, stdio: "pipe" });
+}
+function findWorkingCommand() {
+    for (const command of getCursorAgentCommandCandidates()) {
+        try {
+            spawnCursorAgent(command, ["--version"], VERSION_TIMEOUT_MS);
+            debugLog("version probe ok via", command);
+            return command;
+        }
+        catch (error) {
+            debugLog("version probe failed for", command, error.message?.slice(0, 200));
+        }
+    }
+    return null;
+}
+export function parseCursorAgentStatus(output) {
+    const trimmed = output.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            for (const key of ["authenticated", "loggedIn", "logged_in", "isAuthenticated"]) {
+                if (typeof parsed[key] === "boolean")
+                    return parsed[key];
+            }
+        }
+        catch {
+            // Fall through to text heuristics.
+        }
+    }
+    const lower = trimmed.toLowerCase();
+    if (/not authenticated|not logged in|no credentials|logged out|unauthenticated/.test(lower))
+        return false;
+    if (/authenticated|logged in|signed in|cursor account|subscription/.test(lower))
+        return true;
+    return null;
+}
+export function isCursorAgentApiKeyValue(value) {
+    const trimmed = value?.trim();
+    return Boolean(trimmed && trimmed !== "cli");
+}
+function hasCursorApiKey() {
+    return isCursorAgentApiKeyValue(process.env.CURSOR_API_KEY);
+}
+function probeAuth(command) {
+    if (hasCursorApiKey())
+        return true;
+    for (const args of [["agent", "status", "--json"], ["status", "--json"], ["agent", "status"], ["status"]]) {
+        try {
+            const out = spawnCursorAgent(command, args, STATUS_TIMEOUT_MS).toString();
+            debugLog("status output", args.join(" "), out.slice(0, 200));
+            const parsed = parseCursorAgentStatus(out);
+            if (parsed !== null)
+                return parsed;
+        }
+        catch (error) {
+            debugLog("status failed", args.join(" "), error.message?.slice(0, 200));
+        }
+    }
+    return null;
+}
+export function isCursorAgentReadyUncached() {
+    const command = findWorkingCommand();
+    if (!command)
+        return false;
+    return probeAuth(command) === true;
+}
+function refreshCache() {
+    const now = Date.now();
+    if (cachedBinaryPresent !== null && now - lastCheckMs < CHECK_INTERVAL_MS)
+        return;
+    lastCheckMs = now;
+    const command = findWorkingCommand();
+    if (!command) {
+        cachedBinaryPresent = false;
+        cachedAuthed = false;
+        return;
+    }
+    cachedBinaryPresent = true;
+    const authed = probeAuth(command);
+    if (authed === null) {
+        if (cachedAuthed === null)
+            cachedAuthed = false;
+        return;
+    }
+    cachedAuthed = authed;
+}
+export function isCursorAgentBinaryPresent() {
+    refreshCache();
+    return cachedBinaryPresent ?? false;
+}
+export function isCursorAgentReady() {
+    refreshCache();
+    return (cachedBinaryPresent ?? false) && (cachedAuthed ?? false);
+}
+export function clearCursorAgentReadinessCache() {
+    cachedBinaryPresent = null;
+    cachedAuthed = null;
+    lastCheckMs = 0;
+}

package/dist/resources/extensions/cursor-cli/stream-adapter.js

@@ -0,0 +1,353 @@
+import { spawn } from "node:child_process";
+import { createAssistantMessageEventStream } from "@gsd/pi-ai";
+import { buildCursorAgentSpawnInvocation } from "./readiness.js";
+const ZERO_USAGE = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+function textBlocks(content) {
+    return content
+        .map((block) => block.type === "text" ? block.text : `[${block.type} omitted]`)
+        .join("\n");
+}
+function messageToText(message) {
+    if (message.role === "user") {
+        const content = typeof message.content === "string" ? message.content : textBlocks(message.content);
+        return `User:\n${content}`;
+    }
+    if (message.role === "assistant") {
+        const text = message.content
+            .map((block) => {
+            if (block.type === "text")
+                return block.text;
+            if (block.type === "thinking")
+                return "[thinking omitted]";
+            if (block.type === "toolCall")
+                return `[tool call: ${block.name}]`;
+            if (block.type === "serverToolUse")
+                return `[server tool: ${block.name}]`;
+            if (block.type === "webSearchResult")
+                return "[web search result omitted]";
+            return `[${block.type} omitted]`;
+        })
+            .join("\n");
+        return `Assistant:\n${text}`;
+    }
+    return `Tool result (${message.toolName}):\n${textBlocks(message.content)}`;
+}
+export function buildCursorPrompt(context) {
+    const parts = [];
+    if (context.systemPrompt?.trim())
+        parts.push(`System instructions:\n${context.systemPrompt.trim()}`);
+    if (context.messages.length > 0)
+        parts.push(context.messages.map(messageToText).join("\n\n"));
+    if (context.tools?.length) {
+        parts.push(`The external Cursor agent may execute its own tools. ` +
+            `GSD will not redispatch Cursor-owned internal tool events locally. ` +
+            `Requested GSD tools: ${context.tools.map((tool) => tool.name).join(", ")}`);
+    }
+    return parts.join("\n\n").trim();
+}
+export function buildCursorSpawnInvocation(command, args, platform = process.platform) {
+    return buildCursorAgentSpawnInvocation(command, args, platform);
+}
+export function buildCursorAgentRunPlan(modelId, prompt, cwd, platform = process.platform) {
+    return buildCursorSpawnInvocation(process.env.CURSOR_AGENT_BIN?.trim() || "cursor-agent", ["-p", prompt, "--output-format", "stream-json", "--model", modelId, "--workspace", cwd, "--trust"], platform);
+}
+function emitCompleteLines(chunk, pending, onLine) {
+    pending.value += chunk;
+    const lines = pending.value.split(/\r?\n/);
+    pending.value = lines.pop() ?? "";
+    for (const line of lines)
+        onLine(line);
+}
+function flushPendingLine(pending, onLine) {
+    if (!pending.value)
+        return;
+    onLine(pending.value);
+    pending.value = "";
+}
+function runCursorAgent(plan, options, onLine) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(plan.command, plan.args, {
+            cwd: options?.cwd || process.cwd(),
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const pendingStdout = { value: "" };
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            options?.signal?.removeEventListener("abort", onAbort);
+            fn();
+        };
+        const onAbort = () => {
+            child.kill("SIGTERM");
+            settle(() => reject(new Error("Request was aborted")));
+        };
+        if (options?.signal?.aborted) {
+            onAbort();
+            return;
+        }
+        options?.signal?.addEventListener("abort", onAbort);
+        child.stdout?.setEncoding("utf8");
+        child.stderr?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk;
+            try {
+                emitCompleteLines(chunk, pendingStdout, onLine);
+            }
+            catch (error) {
+                child.kill("SIGTERM");
+                settle(() => reject(error));
+            }
+        });
+        child.stderr?.on("data", (chunk) => { stderr += chunk; });
+        child.on("error", (error) => settle(() => reject(error)));
+        child.on("close", (code, signal) => settle(() => {
+            try {
+                flushPendingLine(pendingStdout, onLine);
+            }
+            catch (error) {
+                reject(error);
+                return;
+            }
+            resolve({ stdout, stderr, code, signal });
+        }));
+    });
+}
+function stringValue(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.length > 0)
+            return value;
+    }
+    return undefined;
+}
+function objectValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function extractText(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => stringValue(objectValue(item)?.text, objectValue(item)?.content, item))
+            .filter((item) => Boolean(item))
+            .join("\n");
+    }
+    const obj = objectValue(value);
+    if (!obj)
+        return "";
+    return stringValue(obj.text, obj.content, obj.message, obj.result) ?? "";
+}
+function mapUsage(raw) {
+    const input = Number(raw.input_tokens ?? raw.input ?? raw.prompt_tokens ?? 0);
+    const output = Number(raw.output_tokens ?? raw.output ?? raw.completion_tokens ?? 0);
+    const cacheRead = Number(raw.cache_read_input_tokens ?? raw.cacheRead ?? 0);
+    const cacheWrite = Number(raw.cache_creation_input_tokens ?? raw.cacheWrite ?? 0);
+    return {
+        input,
+        output,
+        cacheRead,
+        cacheWrite,
+    };
+}
+function normalizeToolArguments(input) {
+    return objectValue(input) ?? { input };
+}
+function normalizeToolResult(raw) {
+    const text = extractText(raw.content ?? raw.result ?? raw.output);
+    return {
+        content: text ? [{ type: "text", text }] : [],
+        isError: Boolean(raw.is_error ?? raw.isError ?? raw.error),
+    };
+}
+export function parseCursorAgentLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return { type: "ignore" };
+    let event;
+    try {
+        event = JSON.parse(trimmed);
+    }
+    catch {
+        return { type: "text", text: trimmed };
+    }
+    const type = stringValue(event.type, event.event) ?? "";
+    if (type === "error") {
+        return { type: "error", message: stringValue(event.message, event.error) ?? "cursor_agent_error" };
+    }
+    if (type === "tool_call") {
+        if (event.call_id || event.subtype || event.tool_call)
+            return { type: "ignore" };
+        const id = stringValue(event.id, event.tool_call_id) ?? `cursor_tool_${Date.now()}`;
+        const name = stringValue(event.name, event.tool_name) ?? "cursor_tool";
+        return {
+            type: "tool_call",
+            toolCall: { type: "toolCall", id, name, arguments: normalizeToolArguments(event.input ?? event.arguments) },
+        };
+    }
+    if (type === "tool_result") {
+        return {
+            type: "tool_result",
+            toolCallId: stringValue(event.tool_call_id, event.id) ?? "",
+            result: normalizeToolResult(event),
+        };
+    }
+    if (type === "result") {
+        const usage = objectValue(event.usage);
+        return usage ? { type: "usage", usage: mapUsage(usage) } : { type: "ignore" };
+    }
+    const text = extractText(event.delta ?? event.text ?? event.content ?? objectValue(event.message)?.content ?? event.message);
+    if (text)
+        return { type: "text", text };
+    const usage = objectValue(event.usage);
+    if (usage)
+        return { type: "usage", usage: mapUsage(usage) };
+    return { type: "ignore" };
+}
+function createUsage(partial) {
+    const input = partial?.input ?? 0;
+    const output = partial?.output ?? 0;
+    const cacheRead = partial?.cacheRead ?? 0;
+    const cacheWrite = partial?.cacheWrite ?? 0;
+    return {
+        ...ZERO_USAGE,
+        input,
+        output,
+        cacheRead,
+        cacheWrite,
+        totalTokens: input + output + cacheWrite,
+        cost: { ...ZERO_USAGE.cost },
+    };
+}
+function buildAssistantMessage(model, content, usage, stopReason = "stop", errorMessage) {
+    return {
+        role: "assistant",
+        content,
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        usage: createUsage(usage),
+        stopReason,
+        ...(errorMessage ? { errorMessage } : {}),
+        timestamp: Date.now(),
+    };
+}
+function emitDone(stream, message, text) {
+    stream.push({ type: "start", partial: { ...message, content: [] } });
+    if (text) {
+        stream.push({ type: "text_start", contentIndex: 0, partial: message });
+        stream.push({ type: "text_delta", contentIndex: 0, delta: text, partial: message });
+        stream.push({ type: "text_end", contentIndex: 0, content: text, partial: message });
+    }
+    message.content.forEach((block, index) => {
+        if (block.type !== "toolCall")
+            return;
+        stream.push({ type: "toolcall_start", contentIndex: index, partial: message });
+        stream.push({ type: "toolcall_end", contentIndex: index, toolCall: block, partial: message });
+    });
+    stream.push({ type: "done", reason: "stop", message });
+    stream.end(message);
+}
+function emitError(stream, model, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const output = buildAssistantMessage(model, [], undefined, "error", message);
+    stream.push({ type: "error", reason: "error", error: output });
+    stream.end(output);
+}
+export function streamViaCursorAgent(model, context, options) {
+    const stream = createAssistantMessageEventStream();
+    queueMicrotask(async () => {
+        try {
+            const cwd = options?.cwd || process.cwd();
+            const prompt = buildCursorPrompt(context);
+            const plan = buildCursorAgentRunPlan(model.id, prompt, cwd);
+            const runForTest = options?._cursorAgentRunnerForTest;
+            let text = "";
+            let usage;
+            let streamStarted = false;
+            let textStarted = false;
+            const toolCalls = new Map();
+            const content = [];
+            const partialMessage = () => {
+                const partialContent = text ? [{ type: "text", text }, ...content] : [...content];
+                return buildAssistantMessage(model, partialContent, usage);
+            };
+            const ensureStart = () => {
+                if (streamStarted)
+                    return;
+                streamStarted = true;
+                stream.push({ type: "start", partial: buildAssistantMessage(model, []) });
+            };
+            const handleLine = (line) => {
+                const parsed = parseCursorAgentLine(line);
+                if (parsed.type === "ignore")
+                    return;
+                if (parsed.type === "error")
+                    throw new Error(parsed.message);
+                if (parsed.type === "text") {
+                    ensureStart();
+                    if (!textStarted) {
+                        textStarted = true;
+                        stream.push({ type: "text_start", contentIndex: 0, partial: partialMessage() });
+                    }
+                    text += parsed.text;
+                    stream.push({ type: "text_delta", contentIndex: 0, delta: parsed.text, partial: partialMessage() });
+                    return;
+                }
+                if (parsed.type === "usage") {
+                    usage = { ...(usage ?? {}), ...parsed.usage };
+                    return;
+                }
+                if (parsed.type === "tool_call") {
+                    ensureStart();
+                    toolCalls.set(parsed.toolCall.id, parsed.toolCall);
+                    content.push(parsed.toolCall);
+                    const index = text ? content.length : content.length - 1;
+                    const partial = partialMessage();
+                    stream.push({ type: "toolcall_start", contentIndex: index, partial });
+                    stream.push({ type: "toolcall_end", contentIndex: index, toolCall: parsed.toolCall, partial });
+                    return;
+                }
+                if (parsed.type === "tool_result") {
+                    const toolCall = toolCalls.get(parsed.toolCallId);
+                    if (toolCall)
+                        toolCall.externalResult = parsed.result;
+                }
+            };
+            const result = runForTest
+                ? await runForTest(plan, options, handleLine)
+                : await runCursorAgent(plan, options, handleLine);
+            if (runForTest) {
+                for (const line of result.stdout.split(/\r?\n/))
+                    handleLine(line);
+            }
+            if (result.code !== 0) {
+                throw new Error((result.stderr || result.stdout || `cursor-agent exited with code ${result.code}`).trim());
+            }
+            const finalContent = text ? [{ type: "text", text }, ...content] : content;
+            const finalMessage = buildAssistantMessage(model, finalContent, usage);
+            if (!streamStarted) {
+                emitDone(stream, finalMessage, text);
+                return;
+            }
+            if (textStarted)
+                stream.push({ type: "text_end", contentIndex: 0, content: text, partial: finalMessage });
+            stream.push({ type: "done", reason: "stop", message: finalMessage });
+            stream.end(finalMessage);
+        }
+        catch (error) {
+            emitError(stream, model, error);
+        }
+    });
+    return stream;
+}

package/dist/resources/extensions/google-cli/stream-adapter.js

@@ -8,6 +8,64 @@ const ZERO_USAGE = {
     totalTokens: 0,
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
 };
+const WINDOWS_CHILD_ENV_KEYS = new Set([
+    "ALLUSERSPROFILE",
+    "APPDATA",
+    "COMSPEC",
+    "COMMONPROGRAMFILES",
+    "COMMONPROGRAMFILES(X86)",
+    "FORCE_COLOR",
+    "HOME",
+    "HOMEDRIVE",
+    "HOMEPATH",
+    "LANG",
+    "LC_ALL",
+    "LOCALAPPDATA",
+    "NODE_EXTRA_CA_CERTS",
+    "NO_COLOR",
+    "NO_PROXY",
+    "PATHEXT",
+    "PATH",
+    "PROGRAMDATA",
+    "PROGRAMFILES",
+    "PROGRAMFILES(X86)",
+    "SSL_CERT_FILE",
+    "SYSTEMROOT",
+    "TEMP",
+    "TERM",
+    "TMP",
+    "TMPDIR",
+    "USER",
+    "USERNAME",
+    "USERPROFILE",
+    "WINDIR",
+    "XDG_CACHE_HOME",
+    "XDG_CONFIG_HOME",
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+]);
+const WINDOWS_CHILD_ENV_PREFIXES = [
+    "AGY_",
+    "ANTIGRAVITY_",
+    "CLOUDSDK_",
+    "GEMINI_",
+    "GOOGLE_",
+];
+export function buildGoogleCliChildEnv(env = process.env, platform = process.platform) {
+    if (platform !== "win32")
+        return env;
+    const childEnv = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (typeof value !== "string")
+            continue;
+        const upperKey = key.toUpperCase();
+        if (WINDOWS_CHILD_ENV_KEYS.has(upperKey) ||
+            WINDOWS_CHILD_ENV_PREFIXES.some((prefix) => upperKey.startsWith(prefix))) {
+            childEnv[key] = value;
+        }
+    }
+    return childEnv;
+}
 function textBlocks(content) {
     return content
         .map((block) => block.type === "text" ? block.text : `[${block.type} omitted]`)
@@ -87,16 +145,16 @@ function extractGeminiJsonResponse(raw) {
 function commandForProvider(provider) {
     return provider === "google-gemini-cli" ? "gemini" : "agy";
 }
-function argsForProvider(provider, model, prompt) {
+function argsForProvider(provider, modelId, prompt) {
     if (provider === "google-gemini-cli") {
-        const args = ["-p", prompt, "--output-format", "json"];
-        if (model.id !== "default")
-            args.unshift("-m", model.id);
+        const args = prompt === undefined ? ["--output-format", "json"] : ["-p", prompt, "--output-format", "json"];
+        if (modelId !== "default")
+            args.unshift("-m", modelId);
         return args;
     }
-    const args = ["-p", prompt];
-    if (model.id !== "default")
-        args.unshift("-m", model.id);
+    const args = prompt === undefined ? [] : ["-p", prompt];
+    if (modelId !== "default")
+        args.unshift("-m", modelId);
     return args;
 }
 export function buildGoogleCliSpawnInvocation(command, args, platform = process.platform) {
@@ -105,13 +163,20 @@ export function buildGoogleCliSpawnInvocation(command, args, platform = process.
     }
     return { command, args };
 }
-function runCli(command, args, options) {
+export function buildGoogleCliRunPlan(provider, modelId, prompt, platform = process.platform) {
+    const pipePrompt = platform === "win32";
+    const args = argsForProvider(provider, modelId, pipePrompt ? undefined : prompt);
+    return {
+        ...buildGoogleCliSpawnInvocation(commandForProvider(provider), args, platform),
+        ...(pipePrompt ? { stdin: prompt } : {}),
+    };
+}
+function runCli(plan, options) {
     return new Promise((resolve, reject) => {
-        const invocation = buildGoogleCliSpawnInvocation(command, args);
-        const child = spawn(invocation.command, invocation.args, {
+        const child = spawn(plan.command, plan.args, {
             cwd: options?.cwd || process.cwd(),
-            env: process.env,
-            stdio: ["ignore", "pipe", "pipe"],
+            env: buildGoogleCliChildEnv(),
+            stdio: [plan.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
         });
         let stdout = "";
         let stderr = "";
@@ -132,6 +197,10 @@ function runCli(command, args, options) {
             return;
         }
         options?.signal?.addEventListener("abort", onAbort);
+        if (plan.stdin !== undefined) {
+            child.stdin?.on("error", () => { });
+            child.stdin?.end(plan.stdin);
+        }
         child.stdout.setEncoding("utf8");
         child.stderr.setEncoding("utf8");
         child.stdout.on("data", (chunk) => {
@@ -185,9 +254,7 @@ export function streamViaGoogleCli(model, context, options) {
     queueMicrotask(async () => {
         try {
             const prompt = buildGoogleCliPrompt(context);
-            const command = commandForProvider(provider);
-            const args = argsForProvider(provider, model, prompt);
-            const result = await runCli(command, args, options);
+            const result = await runCli(buildGoogleCliRunPlan(provider, model.id, prompt), options);
             if (result.code !== 0) {
                 const detail = (result.stderr || result.stdout || `CLI exited with code ${result.code}`).trim();
                 throw new Error(formatGoogleCliError(detail, provider));