nolo-cli 0.148.0-alpha.1 → 0.151.0-alpha.2

package/{chunk-4XEYAFLY.js → chunk-VL5KOY2C.js}

@@ -1,17 +1,517 @@
 import {
+  buildCliProcessEnv,
   resolveLaunchableCodexCommand
-} from "./chunk-JBTJAPUF.js";
+} from "./chunk-ZEZC7IIM.js";
 import {
   buildCliPrompt
 } from "./chunk-ATNTHIZI.js";
 
 // packages/ai/agent/cliExecutor.ts
-import { exec, execSync, spawn } from "child_process";
-import { randomUUID } from "node:crypto";
+import { exec, spawn as spawn2 } from "child_process";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { isAbsolute, join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { StringDecoder } from "node:string_decoder";
+
+// packages/ai/agent/executors/opencodeExecutor.ts
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+function terminateProcessGroup(proc, signal = "SIGTERM") {
+  const pid = proc.pid;
+  if (!pid || pid <= 0) return;
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-pid, signal);
+    } catch {
+    }
+  } else {
+    try {
+      const killer = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+        stdio: "ignore",
+        windowsHide: true
+      });
+      killer.on("error", () => {
+      });
+      killer.unref?.();
+    } catch {
+    }
+  }
+  try {
+    proc.kill(signal);
+  } catch {
+  }
+}
+async function killProcessGroupEscalating(proc, graceMs = 1200) {
+  const pid = proc.pid;
+  if (!pid || pid <= 0) return;
+  terminateProcessGroup(proc, "SIGTERM");
+  const start = Date.now();
+  while (Date.now() - start < graceMs) {
+    let alive = false;
+    if (process.platform !== "win32") {
+      try {
+        process.kill(-pid, 0);
+        alive = true;
+      } catch {
+        try {
+          process.kill(pid, 0);
+          alive = true;
+        } catch {
+          alive = false;
+        }
+      }
+    } else {
+      try {
+        process.kill(pid, 0);
+        alive = true;
+      } catch {
+        alive = false;
+      }
+    }
+    if (!alive) {
+      return;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 50));
+  }
+  terminateProcessGroup(proc, "SIGKILL");
+}
+async function executeOpenCodeStreaming(prompt, options) {
+  if (options.imageInputs && options.imageInputs.length > 0) {
+    throw new Error("OpenCode executor does not support imageInputs (unsupported)");
+  }
+  const startTime = Date.now();
+  const timeoutMs = options.timeout ?? 12e4;
+  const deadline = startTime + timeoutMs;
+  if (options.signal?.aborted) {
+    throw new DOMException("Execution was aborted before start", "AbortError");
+  }
+  if (timeoutMs <= 0 || deadline <= startTime) {
+    throw new Error(`OpenCode timed out after ${timeoutMs}ms`);
+  }
+  const internalAbortController = new AbortController();
+  let abortReason = null;
+  const onExternalAbort = () => {
+    abortReason = options.signal?.reason || new DOMException("OpenCode execution was aborted", "AbortError");
+    internalAbortController.abort(abortReason);
+  };
+  if (options.signal) {
+    options.signal.addEventListener("abort", onExternalAbort, { once: true });
+  }
+  const remainingTimeout = deadline - Date.now();
+  let deadlineTimer = null;
+  if (remainingTimeout <= 0) {
+    abortReason = new Error(`OpenCode execution timed out after ${timeoutMs}ms`);
+    internalAbortController.abort(abortReason);
+  } else {
+    deadlineTimer = setTimeout(() => {
+      deadlineTimer = null;
+      abortReason = new Error(`OpenCode execution timed out after ${timeoutMs}ms`);
+      internalAbortController.abort(abortReason);
+    }, remainingTimeout);
+    deadlineTimer?.unref?.();
+  }
+  const getAbortError = () => {
+    return abortReason || internalAbortController.signal.reason || new DOMException("OpenCode execution was aborted", "AbortError");
+  };
+  const env = buildCliProcessEnv(options.env);
+  const binPath = options.env?.OPENCODE_BIN || process.env.OPENCODE_BIN || "opencode";
+  const cwd = options.cwd || process.cwd();
+  const serveProc = spawn(
+    binPath,
+    ["serve", "--port", "0", "--hostname", "127.0.0.1"],
+    {
+      cwd,
+      env,
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe"]
+    }
+  );
+  let serverBaseUrl = null;
+  let activeSessionId = null;
+  let hasCleanedUp = false;
+  const onProcExit = (code, sig) => {
+    if (hasCleanedUp) return;
+    const err = new Error(
+      serverBaseUrl ? `OpenCode serve process exited prematurely (code: ${code}, signal: ${sig})` : `opencode serve exited before address detected (code: ${code}, signal: ${sig})`
+    );
+    if (!internalAbortController.signal.aborted) {
+      abortReason = err;
+      internalAbortController.abort(err);
+    }
+  };
+  serveProc.on("exit", onProcExit);
+  serveProc.on("error", (err) => {
+    if (hasCleanedUp) return;
+    const procErr = new Error(`Failed to spawn opencode serve: ${err.message}`);
+    if (!internalAbortController.signal.aborted) {
+      abortReason = procErr;
+      internalAbortController.abort(procErr);
+    }
+  });
+  const cleanup = async () => {
+    if (hasCleanedUp) return;
+    hasCleanedUp = true;
+    try {
+      if (!internalAbortController.signal.aborted) {
+        internalAbortController.abort();
+      }
+    } catch {
+    }
+    if (activeSessionId && serverBaseUrl) {
+      try {
+        const cleanupAbortController = new AbortController();
+        const abortTimeout = setTimeout(() => cleanupAbortController.abort(), 800);
+        try {
+          await fetch(`${serverBaseUrl}/session/${activeSessionId}/abort`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: "{}",
+            signal: cleanupAbortController.signal
+          });
+        } finally {
+          clearTimeout(abortTimeout);
+        }
+      } catch {
+      }
+    }
+    await killProcessGroupEscalating(serveProc);
+  };
+  try {
+    const portPromise = new Promise((resolve2, reject) => {
+      let buffer = "";
+      const checkUrl = (chunk) => {
+        buffer += chunk.toString();
+        const match = buffer.match(/http:\/\/127\.0\.0\.1:(\d+)/);
+        if (match) {
+          cleanupStartup();
+          resolve2(match[0]);
+          return;
+        }
+        const nonLoopback = buffer.match(/http:\/\/(?!127\.0\.0\.1)[a-zA-Z0-9.-]+:\d+/);
+        if (nonLoopback) {
+          cleanupStartup();
+          reject(new Error(`Rejected untrusted non-loopback OpenCode server url: ${nonLoopback[0]}`));
+        }
+      };
+      const onAbort = () => {
+        cleanupStartup();
+        reject(getAbortError());
+      };
+      const cleanupStartup = () => {
+        serveProc.stdout?.off("data", checkUrl);
+        serveProc.stderr?.off("data", checkUrl);
+        internalAbortController.signal.removeEventListener("abort", onAbort);
+      };
+      if (internalAbortController.signal.aborted) {
+        cleanupStartup();
+        reject(getAbortError());
+        return;
+      }
+      serveProc.stdout?.on("data", checkUrl);
+      serveProc.stderr?.on("data", checkUrl);
+      internalAbortController.signal.addEventListener("abort", onAbort, { once: true });
+    });
+    serverBaseUrl = await portPromise;
+    if (internalAbortController.signal.aborted || Date.now() > deadline) {
+      throw getAbortError();
+    }
+    const sseResponse = await fetch(`${serverBaseUrl}/event`, {
+      method: "GET",
+      headers: { Accept: "text/event-stream" },
+      signal: internalAbortController.signal
+    }).catch((err) => {
+      if (internalAbortController.signal.aborted) {
+        throw getAbortError();
+      }
+      throw new Error(`Failed to connect to OpenCode SSE stream: ${err.message}`);
+    });
+    if (!sseResponse.ok || !sseResponse.body) {
+      throw new Error(`OpenCode /event returned HTTP ${sseResponse.status}: ${sseResponse.statusText}`);
+    }
+    let sessionModel;
+    let promptModel;
+    if (options.model) {
+      const slashIndex = options.model.indexOf("/");
+      if (slashIndex > 0) {
+        const providerID = options.model.slice(0, slashIndex);
+        const id = options.model.slice(slashIndex + 1);
+        sessionModel = {
+          id,
+          providerID,
+          ...options.reasoningEffort ? { variant: options.reasoningEffort } : {}
+        };
+        promptModel = { modelID: id, providerID };
+      } else {
+        sessionModel = {
+          id: options.model,
+          ...options.reasoningEffort ? { variant: options.reasoningEffort } : {}
+        };
+        promptModel = { modelID: options.model };
+      }
+    }
+    const sessionTitle = `nolo-opencode-${randomUUID().slice(0, 8)}`;
+    const createSessionResp = await fetch(`${serverBaseUrl}/session`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        title: sessionTitle,
+        ...sessionModel ? { model: sessionModel } : {}
+      }),
+      signal: internalAbortController.signal
+    }).catch((err) => {
+      if (internalAbortController.signal.aborted) {
+        throw getAbortError();
+      }
+      throw err;
+    });
+    if (!createSessionResp.ok) {
+      const errText = await createSessionResp.text().catch(() => "");
+      throw new Error(`Failed to create OpenCode session (HTTP ${createSessionResp.status}): ${errText}`);
+    }
+    const sessionData = await createSessionResp.json();
+    if (!sessionData.id) {
+      throw new Error("OpenCode create session response did not return an id");
+    }
+    const sessionId = sessionData.id;
+    activeSessionId = sessionId;
+    let fullText = "";
+    let hasBeenBusy = false;
+    let isCompleted = false;
+    const seenPartTexts = /* @__PURE__ */ new Map();
+    const emittedToolCalls = /* @__PURE__ */ new Set();
+    const emittedToolResults = /* @__PURE__ */ new Set();
+    const emittedToolErrors = /* @__PURE__ */ new Set();
+    const streamPromise = new Promise((resolve2, reject) => {
+      let buffer = "";
+      const reader = sseResponse.body.getReader();
+      const decoder = new TextDecoder("utf-8");
+      const markCompleted = () => {
+        isCompleted = true;
+        resolve2();
+      };
+      const handleEventJson = (parsed) => {
+        const type = parsed?.type;
+        const properties = parsed?.properties || parsed?.data || {};
+        if (properties.sessionID && properties.sessionID !== sessionId) {
+          return;
+        }
+        if (properties.part?.sessionID && properties.part.sessionID !== sessionId) {
+          return;
+        }
+        if (parsed?.sessionID && parsed.sessionID !== sessionId) {
+          return;
+        }
+        if (type === "permission.asked" || type === "permission.v2.asked") {
+          reject(new Error(`OpenCode requested unsupported permission: ${properties.permission || properties.action || properties.id || "unsupported"}`));
+          return;
+        }
+        if (type === "session.error") {
+          const errDetail = properties.error ? JSON.stringify(properties.error) : "Session error";
+          reject(new Error(`OpenCode session error: ${errDetail}`));
+          return;
+        }
+        if (type === "session.status") {
+          const statusType = properties.status?.type;
+          if (statusType === "busy") {
+            hasBeenBusy = true;
+          } else if (statusType === "idle") {
+            if (hasBeenBusy) {
+              markCompleted();
+              return;
+            }
+          }
+        }
+        if (type === "session.idle") {
+          if (hasBeenBusy) {
+            markCompleted();
+            return;
+          }
+        }
+        if (type === "message.part.delta") {
+          const field = properties.field;
+          const delta = properties.delta;
+          if (field === "text" && typeof delta === "string" && delta.length > 0) {
+            hasBeenBusy = true;
+            const partId = properties.partID || "default";
+            const currentSeen = seenPartTexts.get(partId) || "";
+            seenPartTexts.set(partId, currentSeen + delta);
+            fullText += delta;
+            options.onChunk?.(delta);
+          }
+          return;
+        }
+        if (type === "message.part.updated") {
+          const part = properties.part;
+          if (!part) return;
+          if (part.type === "tool") {
+            hasBeenBusy = true;
+            const callId = part.callID || part.id || `tool-${randomUUID().slice(0, 6)}`;
+            const toolName = part.tool || "unknown";
+            const state = part.state;
+            const round = options.toolEventRound ?? 1;
+            if (state?.status === "pending" || state?.status === "running") {
+              if (!emittedToolCalls.has(callId)) {
+                emittedToolCalls.add(callId);
+                options.onToolEvent?.({
+                  type: "tool-call",
+                  round,
+                  toolCallId: callId,
+                  toolName,
+                  summary: `Tool call: ${toolName}`,
+                  metadata: { source: "cli-external", cliProvider: "opencode" }
+                });
+              }
+            } else if (state?.status === "completed") {
+              if (!emittedToolResults.has(callId)) {
+                emittedToolResults.add(callId);
+                options.onToolEvent?.({
+                  type: "tool-result",
+                  round,
+                  toolCallId: callId,
+                  toolName,
+                  summary: `Tool completed: ${toolName}`,
+                  metadata: { source: "cli-external", cliProvider: "opencode" }
+                });
+              }
+            } else if (state?.status === "error") {
+              if (!emittedToolErrors.has(callId)) {
+                emittedToolErrors.add(callId);
+                options.onToolEvent?.({
+                  type: "tool-error",
+                  round,
+                  toolCallId: callId,
+                  toolName,
+                  message: "Tool execution failed",
+                  summary: `Tool error: ${toolName}`,
+                  metadata: { source: "cli-external", cliProvider: "opencode" }
+                });
+              }
+            }
+          } else if (part.type === "text") {
+            hasBeenBusy = true;
+            const partId = part.id || part.partID || "default";
+            const fullPartText = typeof part.text === "string" ? part.text : "";
+            const seen = seenPartTexts.get(partId) || "";
+            if (fullPartText.length > seen.length) {
+              const diff = fullPartText.slice(seen.length);
+              if (diff.length > 0) {
+                seenPartTexts.set(partId, seen + diff);
+                fullText += diff;
+                options.onChunk?.(diff);
+              }
+            }
+          }
+        }
+      };
+      const pump = async () => {
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              if (!isCompleted) {
+                reject(new Error("OpenCode SSE stream disconnected prematurely (unexpected EOF)"));
+              }
+              break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(/\r?\n/);
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              const trimmed = line.trim();
+              if (trimmed.startsWith("data:")) {
+                const payload = trimmed.slice(5).trim();
+                if (payload === "[DONE]") {
+                  markCompleted();
+                  return;
+                }
+                let parsed;
+                try {
+                  parsed = JSON.parse(payload);
+                } catch {
+                  continue;
+                }
+                handleEventJson(parsed);
+                if (isCompleted) {
+                  return;
+                }
+              }
+            }
+          }
+        } catch (err) {
+          if (isCompleted) {
+            return;
+          }
+          if (internalAbortController.signal.aborted) {
+            reject(getAbortError());
+            return;
+          }
+          if (err?.name === "AbortError") {
+            reject(getAbortError());
+            return;
+          }
+          reject(err);
+        }
+      };
+      pump();
+    });
+    const promptPayload = {
+      parts: [{ type: "text", text: prompt }],
+      ...promptModel ? { model: promptModel } : {},
+      ...options.systemPrompt ? { system: options.systemPrompt } : {}
+    };
+    const promptResp = await fetch(`${serverBaseUrl}/session/${sessionId}/prompt_async`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(promptPayload),
+      signal: internalAbortController.signal
+    }).catch((err) => {
+      if (internalAbortController.signal.aborted) {
+        throw getAbortError();
+      }
+      throw err;
+    });
+    if (!promptResp.ok) {
+      const errText = await promptResp.text().catch(() => "");
+      throw new Error(`Failed to send prompt to OpenCode session (HTTP ${promptResp.status}): ${errText}`);
+    }
+    let abortListener = null;
+    const abortPromise = new Promise((_, reject) => {
+      if (internalAbortController.signal.aborted) {
+        reject(getAbortError());
+        return;
+      }
+      abortListener = () => reject(getAbortError());
+      internalAbortController.signal.addEventListener("abort", abortListener, { once: true });
+    });
+    try {
+      await Promise.race([streamPromise, abortPromise]);
+    } finally {
+      if (abortListener) {
+        internalAbortController.signal.removeEventListener("abort", abortListener);
+        abortListener = null;
+      }
+    }
+    const elapsed = Date.now() - startTime;
+    return {
+      text: fullText,
+      raw: fullText,
+      elapsed
+    };
+  } finally {
+    if (deadlineTimer) {
+      clearTimeout(deadlineTimer);
+      deadlineTimer = null;
+    }
+    if (options.signal) {
+      options.signal.removeEventListener("abort", onExternalAbort);
+    }
+    serveProc.off("exit", onProcExit);
+    await cleanup();
+  }
+}
+
+// packages/ai/agent/cliExecutor.ts
 var CliProviderQuotaError = class extends Error {
   provider;
   constructor(provider, message) {
@@ -59,9 +559,7 @@ var DEFAULT_GROK_TIMEOUT_MS = 6e5;
 var BUFFERED_STREAMING_PROVIDERS = /* @__PURE__ */ new Set([
   "codex",
   "claude",
-  "agy",
   "qoder",
-  "opencode",
   "grok",
   "kimi"
 ]);
@@ -69,54 +567,6 @@ function isBufferedCliStreamingProvider(provider) {
   return BUFFERED_STREAMING_PROVIDERS.has(provider);
 }
 var cliSessions = /* @__PURE__ */ new Map();
-function readMacSystemProxyEnv() {
-  if (process.platform !== "darwin") return {};
-  try {
-    const raw = String(execSync("scutil --proxy", { encoding: "utf8" }) || "");
-    const values = /* @__PURE__ */ new Map();
-    for (const line of raw.split("\n")) {
-      const match = line.match(/^\s*([A-Za-z0-9_]+)\s*:\s*(.+?)\s*$/);
-      if (!match) continue;
-      values.set(match[1], match[2].replace(/^"|"$/g, ""));
-    }
-    const httpEnabled = values.get("HTTPEnable") === "1";
-    const httpsEnabled = values.get("HTTPSEnable") === "1";
-    const httpHost = values.get("HTTPProxy")?.trim();
-    const httpsHost = values.get("HTTPSProxy")?.trim();
-    const httpPort = values.get("HTTPPort")?.trim();
-    const httpsPort = values.get("HTTPSPort")?.trim();
-    const noProxy = values.get("ExceptionsList")?.trim();
-    const httpProxy = httpEnabled && httpHost && httpPort ? `http://${httpHost}:${httpPort}` : "";
-    const httpsProxy = httpsEnabled && httpsHost && httpsPort ? `http://${httpsHost}:${httpsPort}` : "";
-    const allProxy = httpsProxy || httpProxy;
-    return {
-      ...httpProxy ? { HTTP_PROXY: httpProxy, http_proxy: httpProxy } : {},
-      ...httpsProxy ? { HTTPS_PROXY: httpsProxy, https_proxy: httpsProxy } : {},
-      ...allProxy ? { ALL_PROXY: allProxy, all_proxy: allProxy } : {},
-      ...noProxy ? { NO_PROXY: noProxy, no_proxy: noProxy } : {}
-    };
-  } catch {
-    return {};
-  }
-}
-function normalizeProxyEnv(env) {
-  const explicitHttp = env.HTTP_PROXY?.trim() || env.http_proxy?.trim() || "";
-  const explicitHttps = env.HTTPS_PROXY?.trim() || env.https_proxy?.trim() || "";
-  const explicitAll = env.ALL_PROXY?.trim() || env.all_proxy?.trim() || "";
-  const explicitNoProxy = env.NO_PROXY?.trim() || env.no_proxy?.trim() || "";
-  const fallback = explicitHttp || explicitHttps || explicitAll ? {} : readMacSystemProxyEnv();
-  const httpProxy = explicitHttp || fallback.HTTP_PROXY || fallback.http_proxy || "";
-  const httpsProxy = explicitHttps || fallback.HTTPS_PROXY || fallback.https_proxy || httpProxy;
-  const allProxy = explicitAll || fallback.ALL_PROXY || fallback.all_proxy || httpsProxy || httpProxy;
-  const noProxy = explicitNoProxy || fallback.NO_PROXY || fallback.no_proxy || "";
-  return {
-    ...env,
-    ...httpProxy ? { HTTP_PROXY: httpProxy, http_proxy: httpProxy } : {},
-    ...httpsProxy ? { HTTPS_PROXY: httpsProxy, https_proxy: httpsProxy } : {},
-    ...allProxy ? { ALL_PROXY: allProxy, all_proxy: allProxy } : {},
-    ...noProxy ? { NO_PROXY: noProxy, no_proxy: noProxy } : {}
-  };
-}
 var CLI_PROBE_BINARIES = {
   copilot: ["gh", "copilot"],
   gemini: ["gemini"],
@@ -128,39 +578,6 @@ var CLI_PROBE_BINARIES = {
   grok: ["grok"],
   kimi: ["kimi"]
 };
-function buildCliProcessEnv(extraEnv) {
-  const baseEnv = {
-    ...process.env,
-    ...extraEnv,
-    NO_COLOR: "1"
-  };
-  if (process.platform === "darwin") {
-    const defaultMacPaths = [
-      `${process.env.HOME || ""}/.local/bin`,
-      "/opt/homebrew/bin",
-      "/opt/homebrew/sbin",
-      "/usr/local/bin",
-      "/usr/local/sbin",
-      `${process.env.HOME || ""}/.bun/bin`,
-      `${process.env.HOME || ""}/Library/pnpm`,
-      `${process.env.HOME || ""}/.npm-global/bin`,
-      `${process.env.HOME || ""}/bin`
-    ];
-    const existingPath = baseEnv.PATH || "/usr/bin:/bin:/usr/sbin:/sbin";
-    const paths = existingPath.split(":");
-    for (const p of defaultMacPaths) {
-      if (p && !paths.includes(p)) {
-        paths.unshift(p);
-      }
-    }
-    baseEnv.PATH = paths.join(":");
-  }
-  return Object.fromEntries(
-    Object.entries(normalizeProxyEnv(baseEnv)).filter(
-      (entry) => typeof entry[1] === "string"
-    )
-  );
-}
 function getCliProviderLabel(provider) {
   switch (provider) {
     case "claude":
@@ -187,7 +604,7 @@ function supportsNativeSystemPrompt(provider) {
   return provider === "claude";
 }
 function supportsModel(provider) {
-  return provider !== "agy" && provider !== "codex";
+  return provider !== "codex";
 }
 function supportsReasoningEffort(provider) {
   return provider === "claude" || provider === "copilot" || provider === "qoder" || provider === "opencode" || provider === "grok";
@@ -667,7 +1084,7 @@ function terminateCliProcessGroup(proc, signal) {
   }
   if (pid > 0 && process.platform === "win32") {
     try {
-      const killer = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+      const killer = spawn2("taskkill", ["/pid", String(pid), "/T", "/F"], {
         stdio: "ignore",
         windowsHide: true
       });
@@ -710,7 +1127,7 @@ function attachCliAbortSignal(proc, signal, onAbort) {
 }
 function spawnCliProcess(executable, args, options) {
   const { signal, ...spawnOptions } = options;
-  const proc = spawn(executable, args, {
+  const proc = spawn2(executable, args, {
     ...spawnOptions,
     ...signal ? { detached: true } : {}
   });
@@ -749,6 +1166,7 @@ function executeAgy(prompt, options) {
       "--print-timeout",
       formatCliTimeout(timeout)
     ];
+    if (options.model) args.push("--model", options.model);
     if (yolo) {
       args.push("--dangerously-skip-permissions");
     }
@@ -821,6 +1239,108 @@ stderr: ${stderrText}`));
     });
   });
 }
+function executeAgyStreaming(prompt, options) {
+  const {
+    cwd = process.cwd(),
+    timeout = DEFAULT_AGY_TIMEOUT_MS,
+    yolo = true,
+    model,
+    onChunk
+  } = options;
+  return new Promise((resolve2, reject) => {
+    const args = [
+      "--add-dir",
+      cwd,
+      "--print=" + prompt,
+      "--output-format",
+      "stream-json",
+      "--print-timeout",
+      formatCliTimeout(timeout)
+    ];
+    if (model) args.push("--model", model);
+    if (yolo) args.push("--dangerously-skip-permissions");
+    const start = Date.now();
+    const proc = spawnCliProcess("agy", args, {
+      cwd,
+      env: buildCliProcessEnv(options.env),
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32",
+      signal: options.signal
+    });
+    const stdout = createUtf8Collector();
+    const stderr = createUtf8Collector();
+    let pending = "";
+    let answer = "";
+    let settled = false;
+    let timer;
+    let detachAbort = () => {
+    };
+    const finish = (callback) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      detachAbort();
+      callback();
+    };
+    const fail = (error) => {
+      if (settled) return;
+      terminateCliProcessGroupEscalating(proc);
+      finish(() => reject(error));
+    };
+    detachAbort = attachCliAbortSignal(proc, options.signal, (error) => {
+      finish(() => reject(error));
+    });
+    if (!settled && timeout > 0) {
+      timer = setTimeout(() => {
+        fail(buildAgyTimeoutError(timeout, stdout.end(), stderr.end()));
+      }, timeout + 1e3);
+    }
+    const consumeLine = (line) => {
+      if (settled || !line.trim()) return;
+      let event;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        return;
+      }
+      if (event?.event !== "step_update" || event.step_update?.step_type !== "agent_response" || typeof event.step_update.text_delta !== "string") return;
+      const delta = event.step_update.text_delta;
+      if (!delta) return;
+      answer += delta;
+      try {
+        onChunk(delta);
+      } catch (error) {
+        fail(error);
+      }
+    };
+    proc.stdout.on("data", (data) => {
+      if (settled) return;
+      pending += stdout.write(data);
+      const lines = pending.split("\n");
+      pending = lines.pop() ?? "";
+      for (const line of lines) consumeLine(line);
+    });
+    proc.stderr.on("data", (data) => {
+      if (!settled) stderr.write(data);
+    });
+    proc.on("close", (code, signal) => {
+      if (settled) return;
+      pending += stdout.finish();
+      consumeLine(pending);
+      if (settled) return;
+      const raw = stdout.end();
+      const stderrText = stderr.end();
+      if (code !== 0 || signal) {
+        const quota = detectCliProviderQuotaLimit("agy", raw, stderrText, code);
+        finish(() => reject(quota.limited ? new CliProviderQuotaError("agy", quota.message || "Agy reported quota/limit") : new Error(`Antigravity CLI exited with ${signal ? `signal ${signal}` : `code ${code}`}
+stderr: ${stderrText}`)));
+        return;
+      }
+      finish(() => resolve2({ text: answer.trim(), raw, elapsed: Date.now() - start }));
+    });
+    proc.on("error", (error) => fail(error));
+  });
+}
 function executeQoder(prompt, options) {
   const {
     model,
@@ -1272,7 +1792,7 @@ function startCliSession(provider, options = {}) {
   if (!EXECUTORS[provider]) {
     throw new Error(`Unknown CLI provider: "${provider}". Supported: ${Object.keys(EXECUTORS).join(", ")}`);
   }
-  const sessionId = randomUUID();
+  const sessionId = randomUUID2();
   cliSessions.set(sessionId, {
     sessionId,
     provider,
@@ -1382,7 +1902,17 @@ function executeCliStreaming(provider, prompt, options) {
       })
     );
   }
-  if (provider === "agy" || provider === "qoder" || provider === "opencode" || provider === "grok" || provider === "kimi") {
+  if (provider === "agy") {
+    return withCleanup(
+      executeAgyStreaming(resolved.prompt, resolved.options).then((result) => ({ ...result, warnings: [...resolved.warnings, ...result.warnings ?? []] }))
+    );
+  }
+  if (provider === "opencode") {
+    return withCleanup(
+      executeOpenCodeStreaming(resolved.prompt, resolved.options).then((result) => ({ ...result, warnings: [...resolved.warnings, ...result.warnings ?? []] }))
+    );
+  }
+  if (provider === "qoder" || provider === "grok" || provider === "kimi") {
     return withCleanup(
       executor(resolved.prompt, resolved.options).then((result) => {
         const merged = { ...result, warnings: [...resolved.warnings, ...result.warnings ?? []] };
@@ -1421,7 +1951,7 @@ function executeCliStreaming(provider, prompt, options) {
     }
     if (yolo) args.push("--yolo");
     const start = Date.now();
-    const proc = spawn("gh", args, {
+    const proc = spawn2("gh", args, {
       cwd,
       env: buildCliProcessEnv(resolved.options.env),
       ...resolved.options.signal ? { detached: true } : {}
@@ -1486,7 +2016,7 @@ function executeGeminiStreaming(prompt, options) {
     if (yolo) args.push("--yolo");
     args.push("-e", "none");
     const start = Date.now();
-    const proc = spawn("gemini", args, {
+    const proc = spawn2("gemini", args, {
       cwd,
       env: buildCliProcessEnv({
         ...options.env,
@@ -1580,7 +2110,6 @@ export {
   detectCliProviderQuotaLimit,
   isBufferedCliStreamingProvider,
   CLI_PROBE_BINARIES,
-  buildCliProcessEnv,
   materializeCliImageInputs,
   executeCli,
   startCliSession,