nolo-cli 0.7.0 → 0.8.0-alpha.11

package/chunk-X7W4TNB4.js

@@ -0,0 +1,1550 @@
+import {
+  buildCliPrompt
+} from "./chunk-ATNTHIZI.js";
+import {
+  resolveLaunchableCodexCommand
+} from "./chunk-JBTJAPUF.js";
+
+// packages/ai/agent/cliExecutor.ts
+import { exec, execSync, spawn } from "child_process";
+import { randomUUID } 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";
+var CliProviderQuotaError = class extends Error {
+  provider;
+  constructor(provider, message) {
+    super(`[QUOTA_LIMITED:${provider}] ${message}`);
+    this.name = "CliProviderQuotaError";
+    this.provider = provider;
+  }
+};
+function detectCliProviderQuotaLimit(provider, stdout, stderr, exitCode) {
+  const stderrText = String(stderr || "");
+  const stdoutText = String(stdout || "");
+  const combined = stderrText + "\n" + stdoutText;
+  const isQuotaText = (text) => {
+    const t = text.toLowerCase();
+    const strongPatterns = [
+      /quota (exceeded|reached|limit|used up|insufficient|hit)/i,
+      /usage limit (reached|exceeded|hit)/i,
+      /weekly usage limit/i,
+      /rate.?limit (exceeded|reached|hit)/i,
+      /\b429\b.*(limit|quota|rate)/i,
+      /too many request/i,
+      /no (more|remaining) (credit|quota|usage)/i,
+      /plan limit|membership limit/i,
+      /daily limit|hourly limit reached/i,
+      /limit reached.*reset/i,
+      /resets in .* days/i
+      // from real opencode error
+    ];
+    for (const re of strongPatterns) {
+      if (re.test(t)) return true;
+    }
+    return false;
+  };
+  if (isQuotaText(stderrText)) {
+    return { limited: true, message: `quota/rate limit signal from ${provider} (stderr)` };
+  }
+  if (isQuotaText(combined)) {
+    return { limited: true, message: `quota/rate limit signal from ${provider}` };
+  }
+  return { limited: false };
+}
+var DEFAULT_AGY_TIMEOUT_MS = 6e5;
+var DEFAULT_OPENCODE_TIMEOUT_MS = 6e5;
+var DEFAULT_GROK_TIMEOUT_MS = 6e5;
+var BUFFERED_STREAMING_PROVIDERS = /* @__PURE__ */ new Set([
+  "codex",
+  "claude",
+  "agy",
+  "qoder",
+  "opencode",
+  "grok",
+  "kimi"
+]);
+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"],
+  codex: ["codex"],
+  claude: ["claude"],
+  agy: ["agy"],
+  qoder: ["qoder"],
+  opencode: ["opencode"],
+  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":
+      return "Claude CLI";
+    case "codex":
+      return "Codex CLI";
+    case "copilot":
+      return "Copilot CLI";
+    case "agy":
+      return "Antigravity CLI";
+    case "qoder":
+      return "Qoder CLI";
+    case "gemini":
+      return "Gemini CLI";
+    case "opencode":
+      return "OpenCode CLI";
+    case "grok":
+      return "Grok CLI";
+    case "kimi":
+      return "Kimi Code CLI";
+  }
+}
+function supportsNativeSystemPrompt(provider) {
+  return provider === "claude";
+}
+function supportsModel(provider) {
+  return provider !== "agy" && provider !== "codex";
+}
+function supportsReasoningEffort(provider) {
+  return provider === "claude" || provider === "copilot" || provider === "qoder" || provider === "opencode" || provider === "grok";
+}
+function shouldPassClaudeModel(options) {
+  return (options.env?.NOLO_CLAUDE_CLI_ALLOW_MODEL ?? process.env.NOLO_CLAUDE_CLI_ALLOW_MODEL) === "1";
+}
+var DATA_URL_RE = /^data:image\/([\w.+-]+);base64,([A-Za-z0-9+/=]+)$/;
+var MIME_EXT = {
+  "png": ".png",
+  "jpeg": ".jpg",
+  "jpg": ".jpg",
+  "gif": ".gif",
+  "webp": ".webp",
+  "svg+xml": ".svg",
+  "bmp": ".bmp",
+  "tiff": ".tiff",
+  "avif": ".avif"
+};
+function inferExtFromMime(extPart) {
+  return MIME_EXT[extPart.toLowerCase().trim()] ?? ".bin";
+}
+var FILE_URL_RE = /^file:\/\/(.+)$/;
+function writeDataUrlToTempImage(dataUrl, tempDir, index) {
+  const match = dataUrl.match(DATA_URL_RE);
+  if (!match) {
+    throw new Error(`Invalid data URL format for image #${index + 1}; expected data:image/<type>;base64,<data>`);
+  }
+  const [, mimeExt, b64] = match;
+  const ext = inferExtFromMime(mimeExt);
+  const filePath = join(tempDir, `image-${index + 1}${ext}`);
+  writeFileSync(filePath, Buffer.from(b64, "base64"));
+  return filePath;
+}
+function materializeCliImageInputs(imageInputs, cwd) {
+  let tempDir = null;
+  const materialized = imageInputs.map((input, index) => {
+    const src = input.source.trim();
+    if (src.startsWith("http://") || src.startsWith("https://")) {
+      return { ...input, materializedPath: void 0 };
+    }
+    const fileUrlMatch = src.match(FILE_URL_RE);
+    if (fileUrlMatch) {
+      const localPath = fileUrlMatch[1];
+      return {
+        ...input,
+        materializedPath: isAbsolute(localPath) ? localPath : resolve(cwd, localPath)
+      };
+    }
+    if (src.startsWith("data:")) {
+      if (!tempDir) {
+        tempDir = mkdtempSync(join(tmpdir(), "nolo-cli-assets-"));
+      }
+      const filePath = writeDataUrlToTempImage(src, tempDir, index);
+      return { ...input, materializedPath: filePath };
+    }
+    return {
+      ...input,
+      materializedPath: isAbsolute(src) ? src : resolve(cwd, src)
+    };
+  });
+  return { materialized, tempDir };
+}
+function buildImageReferencePromptBlock(provider, materialized) {
+  const label = getCliProviderLabel(provider);
+  const localPaths = materialized.filter((img) => img.materializedPath).map((img) => img.materializedPath);
+  const httpUrls = materialized.filter((img) => !img.materializedPath).map((img) => img.source);
+  const lines = [];
+  if (localPaths.length > 0) {
+    lines.push(
+      `[User attached image(s) - local file references (accessible at these paths):]`,
+      ...localPaths.map((p) => `  - ${p}`),
+      `Please read and analyze these image files as part of the user's request.`
+    );
+  }
+  if (httpUrls.length > 0) {
+    lines.push(
+      `[User attached image(s) - remote URLs (content not available locally):]`,
+      ...httpUrls.map((u) => `  - ${u}`),
+      `These remote URLs could not be downloaded automatically. If you cannot access them, describe what you can infer from context.`
+    );
+  }
+  const warning = materialized.length > 0 ? `${label} image input is passed as local file references; native image flags are not available in this wrapper.` : null;
+  return {
+    promptSuffix: lines.length > 0 ? lines.join("\n") + "\n\n" : "",
+    warning
+  };
+}
+function collectCliCapabilityWarnings(provider, options) {
+  const warnings = [];
+  const label = getCliProviderLabel(provider);
+  if (options.reasoningEffort !== void 0 && !supportsReasoningEffort(provider)) {
+    warnings.push(`${label} does not support reasoning_effort; ignored.`);
+  }
+  if (provider === "claude" && options.model !== void 0 && !shouldPassClaudeModel(options)) {
+    warnings.push(
+      "Claude CLI model selection is disabled by default because current installs can reject --model; set NOLO_CLAUDE_CLI_ALLOW_MODEL=1 to pass it through."
+    );
+  } else if (options.model !== void 0 && !supportsModel(provider)) {
+    warnings.push(`${label} does not support model selection; ignored.`);
+  }
+  const unsupportedFields = [
+    ["temperature", options.temperature],
+    ["top_p", options.topP],
+    ["frequency_penalty", options.frequencyPenalty],
+    ["presence_penalty", options.presencePenalty],
+    ["max_tokens", options.maxTokens],
+    ["enableThinking", options.enableThinking ? true : void 0],
+    ["thinkingBudget", options.thinkingBudget]
+  ];
+  for (const [field, value] of unsupportedFields) {
+    if (value !== void 0) {
+      warnings.push(`${label} does not support ${field}; ignored.`);
+    }
+  }
+  return warnings;
+}
+function resolveCliExecution(provider, prompt, options) {
+  const warnings = collectCliCapabilityWarnings(provider, options);
+  const imageInputs = options.imageInputs ?? [];
+  let resolvedPrompt = prompt;
+  let resolvedOptions = options;
+  let imageTempDir;
+  if (imageInputs.length > 0) {
+    const { materialized, tempDir } = materializeCliImageInputs(
+      imageInputs,
+      options.cwd ?? process.cwd()
+    );
+    imageTempDir = tempDir ?? void 0;
+    if (provider === "codex") {
+      resolvedOptions = {
+        ...resolvedOptions,
+        imageInputs: materialized
+      };
+    } else {
+      const block = buildImageReferencePromptBlock(provider, materialized);
+      if (block.promptSuffix) {
+        resolvedPrompt = block.promptSuffix + resolvedPrompt;
+      }
+      if (block.warning) {
+        warnings.push(block.warning);
+      }
+    }
+  }
+  if (supportsNativeSystemPrompt(provider) || !options.systemPrompt?.trim()) {
+    return { prompt: resolvedPrompt, options: resolvedOptions, warnings, imageTempDir };
+  }
+  return {
+    prompt: buildCliPrompt(options.systemPrompt, resolvedPrompt),
+    options: {
+      ...resolvedOptions,
+      systemPrompt: void 0
+    },
+    warnings,
+    imageTempDir
+  };
+}
+function executeCopilot(prompt, options) {
+  const {
+    model,
+    reasoningEffort,
+    timeout = 12e4,
+    cwd = process.cwd(),
+    yolo = true
+  } = options;
+  return new Promise((resolve2, reject) => {
+    const args = [
+      "NO_COLOR=1",
+      "gh copilot --",
+      `-p ${JSON.stringify(prompt)}`,
+      "--silent",
+      "--disable-builtin-mcps",
+      "--stream off",
+      "--no-color"
+    ];
+    if (model) args.push(`--model ${model}`);
+    if (reasoningEffort) args.push(`--reasoning-effort ${reasoningEffort}`);
+    if (yolo) args.push("--yolo");
+    const cmd = args.join(" ");
+    const start = Date.now();
+    exec(
+      cmd,
+      { timeout, cwd, env: buildCliProcessEnv(options.env) },
+      (error, stdout, stderr) => {
+        if (error) {
+          if (error.killed && error.signal === "SIGTERM") {
+            return reject(new Error(`Copilot CLI timed out after ${timeout}ms`));
+          }
+          return reject(
+            new Error(`Copilot CLI failed: ${error.message}
+stderr: ${stderr}`)
+          );
+        }
+        const text = stdout.split("\n").filter((l) => !l.includes("A new release of gh is available")).filter((l) => !l.includes("To upgrade, run:")).filter((l) => !l.includes("https://github.com/cli/cli/releases")).join("\n").trim();
+        resolve2({ text, raw: stdout, elapsed: Date.now() - start });
+      }
+    );
+  });
+}
+function normalizeGeminiContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (typeof part === "string") return part;
+      if (part && typeof part === "object" && typeof part.text === "string") {
+        return part.text;
+      }
+      return "";
+    }).join("");
+  }
+  if (content && typeof content === "object" && typeof content.text === "string") {
+    return content.text;
+  }
+  return "";
+}
+function extractGeminiEventText(event) {
+  if (event?.type === "message" && event.role === "assistant") {
+    return normalizeGeminiContent(event.content);
+  }
+  if (event?.type === "result" && typeof event.result === "string") {
+    return event.result;
+  }
+  return "";
+}
+function parseGeminiStreamJson(stdout) {
+  const parts = [];
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const event = JSON.parse(trimmed);
+      const text = extractGeminiEventText(event);
+      if (text) parts.push(text);
+    } catch {
+    }
+  }
+  return parts.join("");
+}
+function executeGemini(prompt, options) {
+  const {
+    model = "gemini-3.6-flash",
+    timeout = 12e4,
+    cwd = process.cwd(),
+    yolo = true
+  } = options;
+  return new Promise((resolve2, reject) => {
+    const args = [
+      "NO_COLOR=1",
+      "NODE_OPTIONS='--no-deprecation'",
+      "gemini",
+      `-p ${JSON.stringify(prompt)}`,
+      "--output-format stream-json",
+      `-m ${JSON.stringify(model)}`
+    ];
+    if (yolo) args.push("--yolo");
+    args.push("-e none");
+    const cmd = args.join(" ");
+    const start = Date.now();
+    exec(
+      cmd,
+      { timeout, cwd, env: buildCliProcessEnv(options.env) },
+      (error, stdout, stderr) => {
+        if (error) {
+          if (error.killed && error.signal === "SIGTERM") {
+            return reject(new Error(`Gemini CLI timed out after ${timeout}ms`));
+          }
+          return reject(
+            new Error(`Gemini CLI failed: ${error.message}
+stderr: ${stderr}`)
+          );
+        }
+        resolve2({
+          text: parseGeminiStreamJson(stdout),
+          raw: stdout,
+          elapsed: Date.now() - start
+        });
+      }
+    );
+  });
+}
+function executeCodex(prompt, options) {
+  const {
+    cwd = process.cwd(),
+    yolo = true
+  } = options;
+  const imagePaths = (options.imageInputs ?? []).map((img) => img.materializedPath).filter((p) => Boolean(p));
+  return new Promise((resolve2, reject) => {
+    const tempDir = mkdtempSync(join(tmpdir(), "codex-exec-"));
+    const outputFile = join(tempDir, "last-message.txt");
+    const executable = resolveLaunchableCodexCommand(options.env);
+    const args = [
+      "exec",
+      "--skip-git-repo-check",
+      "--ephemeral",
+      "--color",
+      "never",
+      "--output-last-message",
+      outputFile,
+      "--cd",
+      cwd
+    ];
+    if (yolo) {
+      args.push("--sandbox");
+      args.push("danger-full-access");
+    }
+    for (const imgPath of imagePaths) {
+      args.push("-i", imgPath);
+    }
+    const start = Date.now();
+    const proc = spawn(executable, [...args, prompt], {
+      cwd,
+      env: buildCliProcessEnv(options.env),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdout = createUtf8Collector();
+    const stderr = createUtf8Collector();
+    proc.stdout.on("data", (data) => {
+      stdout.write(data);
+    });
+    proc.stderr.on("data", (data) => {
+      stderr.write(data);
+    });
+    proc.on("close", (code) => {
+      const stdoutText = stdout.end();
+      const stderrText = stderr.end();
+      if (code !== 0 && code !== null) {
+        rmSync(tempDir, { recursive: true, force: true });
+        const quota = detectCliProviderQuotaLimit("codex", stdoutText, stderrText, code);
+        if (quota.limited) {
+          reject(new CliProviderQuotaError("codex", quota.message || "Codex reported quota/limit"));
+          return;
+        }
+        reject(new Error(`Codex CLI exited with code ${code}
+stderr: ${stderrText}`));
+        return;
+      }
+      let text = stdoutText.trim();
+      try {
+        const lastMessage = readFileSync(outputFile, "utf8").trim();
+        if (lastMessage) text = lastMessage;
+      } catch {
+      } finally {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+      resolve2({
+        text,
+        raw: stdoutText,
+        elapsed: Date.now() - start
+      });
+    });
+    proc.on("error", (err) => {
+      rmSync(tempDir, { recursive: true, force: true });
+      reject(err);
+    });
+  });
+}
+function executeClaude(prompt, options) {
+  const {
+    model,
+    systemPrompt,
+    reasoningEffort,
+    timeout = 12e4,
+    cwd = process.cwd(),
+    yolo = true
+  } = options;
+  return new Promise((resolve2, reject) => {
+    const args = ["--add-dir", cwd, "-p", prompt];
+    if (model && shouldPassClaudeModel(options)) {
+      args.push("--model");
+      args.push(model);
+    }
+    if (systemPrompt?.trim()) {
+      args.push("--system-prompt");
+      args.push(systemPrompt.trim());
+    }
+    if (reasoningEffort) {
+      args.push("--effort");
+      args.push(reasoningEffort);
+    }
+    if (yolo) {
+      args.push("--permission-mode");
+      args.push("bypassPermissions");
+    }
+    const start = Date.now();
+    const proc = spawn("claude", args, {
+      cwd,
+      env: buildCliProcessEnv(options.env),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdout = createUtf8Collector();
+    const stderr = createUtf8Collector();
+    let timer;
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        proc.kill("SIGTERM");
+        reject(new Error(`Claude CLI timed out after ${timeout}ms`));
+      }, timeout);
+    }
+    proc.stdout.on("data", (data) => {
+      stdout.write(data);
+    });
+    proc.stderr.on("data", (data) => {
+      stderr.write(data);
+    });
+    proc.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      const stdoutText = stdout.end();
+      const stderrText = stderr.end();
+      if (code !== 0 && code !== null) {
+        const quota = detectCliProviderQuotaLimit("claude", stdoutText, stderrText, code);
+        if (quota.limited) {
+          reject(new CliProviderQuotaError("claude", quota.message || "Claude reported quota/limit"));
+          return;
+        }
+        reject(new Error(`Claude CLI exited with code ${code}
+stderr: ${stderrText}`));
+        return;
+      }
+      resolve2({
+        text: stdoutText.trim(),
+        raw: stdoutText,
+        elapsed: Date.now() - start
+      });
+    });
+    proc.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+function formatCliTimeout(timeoutMs) {
+  return `${Math.max(1, Math.ceil(timeoutMs / 1e3))}s`;
+}
+function tailText(value, maxChars = 1200) {
+  if (value.length <= maxChars) return value;
+  return value.slice(value.length - maxChars);
+}
+function createUtf8Collector() {
+  const decoder = new StringDecoder("utf8");
+  let text = "";
+  let ended = false;
+  const finish = () => {
+    if (ended) return "";
+    ended = true;
+    const chunk = decoder.end();
+    if (chunk) text += chunk;
+    return chunk;
+  };
+  return {
+    write(data) {
+      if (ended) return "";
+      const chunk = decoder.write(data);
+      text += chunk;
+      return chunk;
+    },
+    finish,
+    end() {
+      finish();
+      return text;
+    },
+    get text() {
+      return text;
+    }
+  };
+}
+function terminateCliProcessGroup(proc, signal) {
+  const pid = typeof proc.pid === "number" ? proc.pid : 0;
+  if (pid > 0 && process.platform !== "win32") {
+    try {
+      process.kill(-pid, signal);
+      return;
+    } catch {
+    }
+  }
+  try {
+    proc.kill(signal);
+  } catch {
+  }
+}
+function createCliAbortError(message = "CLI execution aborted") {
+  return new DOMException(message, "AbortError");
+}
+function attachCliAbortSignal(proc, signal, onAbort) {
+  if (!signal) return () => {
+  };
+  if (signal.aborted) {
+    terminateCliProcessGroup(proc, "SIGTERM");
+    onAbort(createCliAbortError());
+    return () => {
+    };
+  }
+  const handleAbort = () => {
+    terminateCliProcessGroup(proc, "SIGTERM");
+    onAbort(createCliAbortError());
+  };
+  signal.addEventListener("abort", handleAbort, { once: true });
+  return () => signal.removeEventListener("abort", handleAbort);
+}
+function buildAgyTimeoutError(timeout, stdout, stderr) {
+  const parts = [
+    `Antigravity CLI timed out after ${timeout}ms.`,
+    "agy print mode is agentic and can keep waiting for the conversation to become fully idle; prefer shorter scoped prompts or split the task into multiple turns."
+  ];
+  const stdoutTail = tailText(stdout).trim();
+  const stderrTail = tailText(stderr).trim();
+  if (stdoutTail) parts.push(`stdout tail:
+${stdoutTail}`);
+  if (stderrTail) parts.push(`stderr tail:
+${stderrTail}`);
+  return new Error(parts.join("\n"));
+}
+function executeAgy(prompt, options) {
+  const {
+    timeout = DEFAULT_AGY_TIMEOUT_MS,
+    cwd = process.cwd(),
+    yolo = true
+  } = options;
+  return new Promise((resolve2, reject) => {
+    const args = [
+      "--add-dir",
+      cwd,
+      "--print",
+      prompt,
+      "--print-timeout",
+      formatCliTimeout(timeout)
+    ];
+    if (yolo) {
+      args.push("--dangerously-skip-permissions");
+    }
+    const start = Date.now();
+    const proc = spawn("agy", args, {
+      cwd,
+      env: buildCliProcessEnv(options.env),
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32"
+    });
+    const stdout = createUtf8Collector();
+    const stderr = createUtf8Collector();
+    let timer;
+    let forceTimer;
+    let settled = false;
+    const clearTimers = () => {
+      if (timer) clearTimeout(timer);
+      if (forceTimer) clearTimeout(forceTimer);
+    };
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        terminateCliProcessGroup(proc, "SIGTERM");
+        forceTimer = setTimeout(() => {
+          terminateCliProcessGroup(proc, "SIGKILL");
+        }, 3e3);
+        reject(buildAgyTimeoutError(timeout, stdout.end(), stderr.end()));
+      }, timeout + 1e3);
+    }
+    proc.stdout.on("data", (data) => {
+      stdout.write(data);
+    });
+    proc.stderr.on("data", (data) => {
+      stderr.write(data);
+    });
+    proc.on("close", (code) => {
+      if (settled) {
+        clearTimers();
+        return;
+      }
+      settled = true;
+      clearTimers();
+      const stdoutText = stdout.end();
+      const stderrText = stderr.end();
+      if (code !== 0 && code !== null) {
+        console.error("[cliExecutor] agy process exited with non-zero code:", code, "stderr:", stderrText);
+        const quota = detectCliProviderQuotaLimit("agy", stdoutText, stderrText, code);
+        if (quota.limited) {
+          reject(new CliProviderQuotaError("agy", quota.message || "Agy reported quota/limit"));
+          return;
+        }
+        reject(new Error(`Antigravity CLI exited with code ${code}
+stderr: ${stderrText}`));
+        return;
+      }
+      resolve2({
+        text: stdoutText.trim(),
+        raw: stdoutText,
+        elapsed: Date.now() - start
+      });
+    });
+    proc.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimers();
+      console.error("[cliExecutor] agy process error event:", err);
+      reject(err);
+    });
+  });
+}
+function executeQoder(prompt, options) {
+  const {
+    model,
+    reasoningEffort,
+    timeout = 12e4,
+    cwd = process.cwd(),
+    yolo = true
+  } = options;
+  return new Promise((resolve2, reject) => {
+    const args = ["-p", prompt, "--cwd", cwd];
+    if (model) {
+      args.push("--model");
+      args.push(model);
+    }
+    if (reasoningEffort) {
+      args.push("--reasoning-effort");
+      args.push(reasoningEffort);
+    }
+    if (yolo) {
+      args.push("--dangerously-skip-permissions");
+    }
+    const start = Date.now();
+    const proc = spawn("qoder", args, {
+      cwd,
+      env: buildCliProcessEnv(options.env),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdout = createUtf8Collector();
+    const stderr = createUtf8Collector();
+    let timer;
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        const partial = stdout.end() + "\n" + stderr.end();
+        const q = detectCliProviderQuotaLimit("qoder", "", partial, null);
+        if (q.limited) {
+          proc.kill("SIGTERM");
+          reject(new CliProviderQuotaError("qoder", q.message || "Qoder quota signal seen before timeout"));
+          return;
+        }
+        proc.kill("SIGTERM");
+        reject(new Error(`Qoder CLI timed out after ${timeout}ms`));
+      }, timeout);
+    }
+    proc.stdout.on("data", (data) => {
+      stdout.write(data);
+    });
+    proc.stderr.on("data", (data) => {
+      stderr.write(data);
+      const currentStderr = stderr.text;
+      if (detectCliProviderQuotaLimit("qoder", "", currentStderr, null).limited) {
+        if (timer) clearTimeout(timer);
+        proc.kill("SIGTERM");
+        reject(new CliProviderQuotaError("qoder", "quota signal detected incrementally in stderr"));
+        return;
+      }
+    });
+    proc.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      const stdoutText = stdout.end();
+      const stderrText = stderr.end();
+      const quota = detectCliProviderQuotaLimit("qoder", stdoutText, stderrText, code);
+      const hasRealErrorSignal = code !== 0 || /error|fail|quota|limit|429|rate limit|exceeded/i.test(stderrText);
+      if (quota.limited && hasRealErrorSignal) {
+        reject(new CliProviderQuotaError("qoder", quota.message || "Qoder reported quota/limit"));
+        return;
+      }
+      if (code !== 0 && code !== null) {
+        console.error("[cliExecutor] qoder process exited with non-zero code:", code, "stderr:", stderrText);
+        reject(new Error(`Qoder CLI exited with code ${code}
+stderr: ${stderrText}`));
+        return;
+      }
+      resolve2({
+        text: stdoutText.trim(),
+        raw: stdoutText,
+        elapsed: Date.now() - start
+      });
+    });
+    proc.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      console.error("[cliExecutor] qoder process error event:", err);
+      reject(err);
+    });
+  });
+}
+function parseOpenCodeJsonlEvents(stdout) {
+  const parts = [];
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const event = JSON.parse(trimmed);
+      if (event.type === "text" && event.part?.type === "text" && typeof event.part.text === "string") {
+        parts.push(event.part.text);
+      }
+    } catch {
+    }
+  }
+  return parts.join("");
+}
+function executeOpenCode(prompt, options) {
+  const {
+    model,
+    reasoningEffort,
+    timeout = DEFAULT_OPENCODE_TIMEOUT_MS,
+    cwd = process.cwd(),
+    yolo = true
+  } = options;
+  return new Promise((resolve2, reject) => {
+    const args = [
+      "run",
+      "--format",
+      "json",
+      "--dir",
+      cwd,
+      "--print-logs"
+      // surface stream errors / quota / limit messages to stderr for fast detection
+    ];
+    if (model) {
+      args.push("--model");
+      args.push(model);
+    }
+    if (reasoningEffort) {
+      args.push("--variant");
+      args.push(reasoningEffort);
+    }
+    if (yolo) {
+      args.push("--dangerously-skip-permissions");
+    }
+    args.push(prompt);
+    const start = Date.now();
+    const proc = spawn("opencode", args, {
+      cwd,
+      env: buildCliProcessEnv(options.env),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdout = createUtf8Collector();
+    const stderr = createUtf8Collector();
+    let timer;
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        const stdoutPartial = stdout.end();
+        const stderrPartial = stderr.end();
+        const q = detectCliProviderQuotaLimit("opencode", stdoutPartial, stderrPartial, null);
+        if (q.limited) {
+          proc.kill("SIGTERM");
+          reject(new CliProviderQuotaError("opencode", q.message || "OpenCode quota signal seen before timeout"));
+          return;
+        }
+        proc.kill("SIGTERM");
+        reject(new Error(`OpenCode CLI timed out after ${timeout}ms`));
+      }, timeout);
+    }
+    proc.stdout.on("data", (data) => {
+      stdout.write(data);
+    });
+    proc.stderr.on("data", (data) => {
+      stderr.write(data);
+      const currentStderr = stderr.text;
+      if (detectCliProviderQuotaLimit("opencode", "", currentStderr, null).limited) {
+        if (timer) clearTimeout(timer);
+        proc.kill("SIGTERM");
+        reject(new CliProviderQuotaError("opencode", "quota signal detected incrementally in stderr"));
+        return;
+      }
+    });
+    proc.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      const stdoutText = stdout.end();
+      const stderrText = stderr.end();
+      const quota = detectCliProviderQuotaLimit("opencode", stdoutText, stderrText, code);
+      const hasRealErrorSignal = code !== 0 || /error|fail|quota|limit|429|rate limit|exceeded/i.test(stderrText);
+      if (quota.limited && hasRealErrorSignal) {
+        reject(new CliProviderQuotaError("opencode", quota.message || "OpenCode reported quota/limit"));
+        return;
+      }
+      if (code !== 0 && code !== null) {
+        console.error("[cliExecutor] opencode process exited with non-zero code:", code, "stderr:", stderrText);
+        reject(new Error(`OpenCode CLI exited with code ${code}
+stderr: ${stderrText}`));
+        return;
+      }
+      resolve2({
+        text: parseOpenCodeJsonlEvents(stdoutText).trim(),
+        raw: stdoutText,
+        elapsed: Date.now() - start
+      });
+    });
+    proc.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      console.error("[cliExecutor] opencode process error event:", err);
+      reject(err);
+    });
+  });
+}
+function parseGrokJsonOutput(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return "";
+  const parsed = JSON.parse(trimmed);
+  if (parsed.type === "error") {
+    throw new Error(typeof parsed.message === "string" ? parsed.message : "Grok CLI failed");
+  }
+  return typeof parsed.text === "string" ? parsed.text : "";
+}
+function buildGrokProcessEnv(extraEnv) {
+  return buildCliProcessEnv({
+    GROK_TELEMETRY_TRACE_UPLOAD: "0",
+    GROK_TELEMETRY_ENABLED: "0",
+    GROK_FEEDBACK_ENABLED: "0",
+    GROK_TELEMETRY_MIXPANEL_ENABLED: "0",
+    ...extraEnv
+  });
+}
+function executeGrok(prompt, options) {
+  const {
+    model,
+    reasoningEffort,
+    timeout = DEFAULT_GROK_TIMEOUT_MS,
+    cwd = process.cwd(),
+    yolo = true
+  } = options;
+  return new Promise((resolve2, reject) => {
+    const args = ["-p", prompt, "--cwd", cwd, "--output-format", "json"];
+    if (model) {
+      args.push("-m", model);
+    }
+    if (reasoningEffort) {
+      args.push("--effort", reasoningEffort);
+    }
+    if (yolo) {
+      args.push("--yolo");
+    }
+    const start = Date.now();
+    const proc = spawn("grok", args, {
+      cwd,
+      env: buildGrokProcessEnv(options.env),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdout = createUtf8Collector();
+    const stderr = createUtf8Collector();
+    let timer;
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        const partial = stdout.end() + "\n" + stderr.end();
+        const q = detectCliProviderQuotaLimit("grok", "", partial, null);
+        if (q.limited) {
+          proc.kill("SIGTERM");
+          reject(new CliProviderQuotaError("grok", q.message || "Grok quota signal seen before timeout"));
+          return;
+        }
+        proc.kill("SIGTERM");
+        reject(new Error(`Grok CLI timed out after ${timeout}ms`));
+      }, timeout);
+    }
+    proc.stdout.on("data", (data) => {
+      stdout.write(data);
+    });
+    proc.stderr.on("data", (data) => {
+      stderr.write(data);
+      const currentStderr = stderr.text;
+      if (detectCliProviderQuotaLimit("grok", "", currentStderr, null).limited) {
+        if (timer) clearTimeout(timer);
+        proc.kill("SIGTERM");
+        reject(new CliProviderQuotaError("grok", "quota signal detected incrementally in stderr"));
+        return;
+      }
+    });
+    proc.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      const stdoutText = stdout.end();
+      const stderrText = stderr.end();
+      const quota = detectCliProviderQuotaLimit("grok", stdoutText, stderrText, code);
+      const hasRealErrorSignal = code !== 0 || /error|fail|quota|limit|429|rate limit|exceeded/i.test(stderrText);
+      if (quota.limited && hasRealErrorSignal) {
+        reject(new CliProviderQuotaError("grok", quota.message || "Grok reported quota/limit"));
+        return;
+      }
+      if (code !== 0 && code !== null) {
+        console.error("[cliExecutor] grok process exited with non-zero code:", code, "stderr:", stderrText);
+        reject(new Error(`Grok CLI exited with code ${code}
+stderr: ${stderrText}`));
+        return;
+      }
+      try {
+        resolve2({
+          text: parseGrokJsonOutput(stdoutText).trim(),
+          raw: stdoutText,
+          elapsed: Date.now() - start
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+    proc.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      console.error("[cliExecutor] grok process error event:", err);
+      reject(err);
+    });
+  });
+}
+function parseKimiStreamJson(stdout) {
+  const parts = [];
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const event = JSON.parse(trimmed);
+      if (event.role === "assistant" && typeof event.content === "string" && event.content.length > 0) {
+        parts.push(event.content);
+      }
+    } catch {
+    }
+  }
+  return parts.join("");
+}
+function executeKimi(prompt, options) {
+  const {
+    model,
+    timeout = 12e4,
+    cwd = process.cwd()
+  } = options;
+  return new Promise((resolve2, reject) => {
+    const args = ["-p", prompt, "--output-format", "stream-json"];
+    if (model) {
+      args.push("-m", model);
+    }
+    const start = Date.now();
+    const proc = spawn("kimi", args, {
+      cwd,
+      env: buildCliProcessEnv(options.env),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdout = createUtf8Collector();
+    const stderr = createUtf8Collector();
+    let timer;
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        const partial = stdout.end() + "\n" + stderr.end();
+        const q = detectCliProviderQuotaLimit("kimi", "", partial, null);
+        if (q.limited) {
+          proc.kill("SIGTERM");
+          reject(new CliProviderQuotaError("kimi", q.message || "Kimi quota signal seen before timeout"));
+          return;
+        }
+        proc.kill("SIGTERM");
+        reject(new Error(`Kimi CLI timed out after ${timeout}ms`));
+      }, timeout);
+    }
+    proc.stdout.on("data", (data) => {
+      stdout.write(data);
+    });
+    proc.stderr.on("data", (data) => {
+      stderr.write(data);
+      const currentStderr = stderr.text;
+      if (detectCliProviderQuotaLimit("kimi", "", currentStderr, null).limited) {
+        if (timer) clearTimeout(timer);
+        proc.kill("SIGTERM");
+        reject(new CliProviderQuotaError("kimi", "quota signal detected incrementally in stderr"));
+        return;
+      }
+    });
+    proc.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      const stdoutText = stdout.end();
+      const stderrText = stderr.end();
+      const quota = detectCliProviderQuotaLimit("kimi", stdoutText, stderrText, code);
+      const hasRealErrorSignal = code !== 0 || /error|fail|quota|limit|429|rate limit|exceeded/i.test(stderrText);
+      if (quota.limited && hasRealErrorSignal) {
+        reject(new CliProviderQuotaError("kimi", quota.message || "Kimi reported quota/limit"));
+        return;
+      }
+      if (code !== 0 && code !== null) {
+        console.error("[cliExecutor] kimi process exited with non-zero code:", code, "stderr:", stderrText);
+        reject(new Error(`Kimi CLI exited with code ${code}
+stderr: ${stderrText}`));
+        return;
+      }
+      resolve2({
+        text: parseKimiStreamJson(stdoutText).trim(),
+        raw: stdoutText,
+        elapsed: Date.now() - start
+      });
+    });
+    proc.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      console.error("[cliExecutor] kimi process error event:", err);
+      reject(err);
+    });
+  });
+}
+var EXECUTORS = {
+  copilot: executeCopilot,
+  gemini: executeGemini,
+  codex: executeCodex,
+  claude: executeClaude,
+  agy: executeAgy,
+  qoder: executeQoder,
+  opencode: executeOpenCode,
+  grok: executeGrok,
+  kimi: executeKimi
+};
+function formatCliSessionTask(messages) {
+  return messages.map((message, index) => {
+    const speaker = message.role === "user" ? "\u7528\u6237" : "\u52A9\u624B";
+    return `[${index + 1}] ${speaker}
+${message.content.trim()}`;
+  }).join("\n\n");
+}
+function buildCliSessionPrompt(session, userInput) {
+  const transcript = formatCliSessionTask([
+    ...session.messages,
+    { role: "user", content: userInput }
+  ]);
+  return [
+    "\u4EE5\u4E0B\u662F\u5F53\u524D\u5BF9\u8BDD\uFF0C\u8BF7\u57FA\u4E8E\u5B8C\u6574\u4E0A\u4E0B\u6587\u7EE7\u7EED\u56DE\u7B54\u6700\u540E\u4E00\u6761\u7528\u6237\u6D88\u606F\u3002",
+    transcript
+  ].join("\n\n");
+}
+function getCliSessionOrThrow(sessionId) {
+  const session = cliSessions.get(sessionId);
+  if (!session) {
+    throw new Error(`Unknown CLI session: "${sessionId}"`);
+  }
+  return session;
+}
+async function executeCli(provider, prompt, options = {}) {
+  const executor = EXECUTORS[provider];
+  if (!executor) {
+    throw new Error(`Unknown CLI provider: "${provider}". Supported: ${Object.keys(EXECUTORS).join(", ")}`);
+  }
+  const resolved = resolveCliExecution(provider, prompt, options);
+  try {
+    const result = await executor(resolved.prompt, resolved.options);
+    return {
+      ...result,
+      warnings: [...resolved.warnings, ...result.warnings ?? []]
+    };
+  } finally {
+    if (resolved.imageTempDir) {
+      rmSync(resolved.imageTempDir, { recursive: true, force: true });
+    }
+  }
+}
+function startCliSession(provider, options = {}) {
+  if (!EXECUTORS[provider]) {
+    throw new Error(`Unknown CLI provider: "${provider}". Supported: ${Object.keys(EXECUTORS).join(", ")}`);
+  }
+  const sessionId = randomUUID();
+  cliSessions.set(sessionId, {
+    sessionId,
+    provider,
+    systemPrompt: options.systemPrompt,
+    options: {
+      model: options.model,
+      timeout: options.timeout,
+      cwd: options.cwd,
+      env: options.env,
+      yolo: options.yolo,
+      systemPrompt: options.systemPrompt,
+      reasoningEffort: options.reasoningEffort,
+      temperature: options.temperature,
+      topP: options.topP,
+      frequencyPenalty: options.frequencyPenalty,
+      presencePenalty: options.presencePenalty,
+      maxTokens: options.maxTokens,
+      enableThinking: options.enableThinking,
+      thinkingBudget: options.thinkingBudget
+    },
+    messages: [],
+    createdAt: Date.now(),
+    updatedAt: Date.now()
+  });
+  return { sessionId, provider };
+}
+function getCliSession(sessionId) {
+  return cliSessions.get(sessionId) ?? null;
+}
+function closeCliSession(sessionId) {
+  return cliSessions.delete(sessionId);
+}
+async function executeCliSessionTurn(sessionId, userInput, options = {}) {
+  const trimmedInput = userInput.trim();
+  if (!trimmedInput) {
+    throw new Error("CLI session turn requires non-empty user input.");
+  }
+  const session = getCliSessionOrThrow(sessionId);
+  const prompt = buildCliSessionPrompt(session, trimmedInput);
+  const result = await executeCli(session.provider, prompt, {
+    ...session.options,
+    ...options
+  });
+  session.messages.push(
+    { role: "user", content: trimmedInput },
+    { role: "assistant", content: result.text }
+  );
+  session.updatedAt = Date.now();
+  return {
+    ...result,
+    sessionId: session.sessionId
+  };
+}
+async function executeCliSessionTurnStreaming(sessionId, userInput, options) {
+  const trimmedInput = userInput.trim();
+  if (!trimmedInput) {
+    throw new Error("CLI session turn requires non-empty user input.");
+  }
+  const session = getCliSessionOrThrow(sessionId);
+  const prompt = buildCliSessionPrompt(session, trimmedInput);
+  const result = await executeCliStreaming(session.provider, prompt, {
+    ...session.options,
+    ...options
+  });
+  session.messages.push(
+    { role: "user", content: trimmedInput },
+    { role: "assistant", content: result.text }
+  );
+  session.updatedAt = Date.now();
+  return {
+    ...result,
+    sessionId: session.sessionId
+  };
+}
+function filterNoiseLine(line) {
+  return !line.includes("A new release of gh is available") && !line.includes("To upgrade, run:") && !line.includes("https://github.com/cli/cli/releases");
+}
+function executeCliStreaming(provider, prompt, options) {
+  const resolved = resolveCliExecution(provider, prompt, options);
+  const executor = EXECUTORS[provider];
+  const cleanupImageTempDir = () => {
+    if (resolved.imageTempDir) {
+      rmSync(resolved.imageTempDir, { recursive: true, force: true });
+    }
+  };
+  const withCleanup = (promise) => promise.finally(cleanupImageTempDir);
+  if (provider === "gemini") {
+    return withCleanup(
+      executeGeminiStreaming(resolved.prompt, resolved.options).then((result) => ({ ...result, warnings: [...resolved.warnings, ...result.warnings ?? []] }))
+    );
+  }
+  if (provider === "codex") {
+    return withCleanup(
+      executor(resolved.prompt, resolved.options).then((result) => {
+        const merged = { ...result, warnings: [...resolved.warnings, ...result.warnings ?? []] };
+        if (merged.text) options.onChunk(merged.text);
+        return merged;
+      })
+    );
+  }
+  if (provider === "claude") {
+    return withCleanup(
+      executor(resolved.prompt, resolved.options).then((result) => {
+        const merged = { ...result, warnings: [...resolved.warnings, ...result.warnings ?? []] };
+        if (merged.text) options.onChunk(merged.text);
+        return merged;
+      })
+    );
+  }
+  if (provider === "agy" || provider === "qoder" || provider === "opencode" || provider === "grok" || provider === "kimi") {
+    return withCleanup(
+      executor(resolved.prompt, resolved.options).then((result) => {
+        const merged = { ...result, warnings: [...resolved.warnings, ...result.warnings ?? []] };
+        if (merged.text) options.onChunk(merged.text);
+        return merged;
+      })
+    );
+  }
+  if (provider !== "copilot") {
+    return withCleanup(
+      executor(resolved.prompt, resolved.options).then((result) => ({
+        ...result,
+        warnings: [...resolved.warnings, ...result.warnings ?? []]
+      }))
+    );
+  }
+  const {
+    model,
+    timeout = 12e4,
+    cwd = process.cwd(),
+    yolo = true,
+    onChunk
+  } = resolved.options;
+  return withCleanup(new Promise((resolve2, reject) => {
+    const args = [
+      "copilot",
+      "--",
+      "-p",
+      resolved.prompt,
+      "--silent",
+      "--disable-builtin-mcps"
+    ];
+    if (model) {
+      args.push("--model");
+      args.push(model);
+    }
+    if (yolo) args.push("--yolo");
+    const start = Date.now();
+    const proc = spawn("gh", args, {
+      cwd,
+      env: buildCliProcessEnv(resolved.options.env)
+    });
+    const stdout = createUtf8Collector();
+    let timer;
+    let settled = false;
+    const finish = (cb) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      detachAbort();
+      cb();
+    };
+    const detachAbort = attachCliAbortSignal(
+      proc,
+      resolved.options.signal,
+      (error) => finish(() => reject(error))
+    );
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        terminateCliProcessGroup(proc, "SIGTERM");
+        finish(() => reject(new Error(`Copilot CLI timed out after ${timeout}ms`)));
+      }, timeout);
+    }
+    proc.stdout.on("data", (data) => {
+      const chunk = stdout.write(data);
+      const cleaned = chunk.split("\n").filter(filterNoiseLine).join("\n");
+      if (cleaned) onChunk(cleaned);
+    });
+    proc.on("close", (code) => {
+      const raw = stdout.end();
+      if (code !== 0 && code !== null) {
+        finish(() => reject(new Error(`Copilot CLI exited with code ${code}`)));
+        return;
+      }
+      const text = raw.split("\n").filter(filterNoiseLine).join("\n").trim();
+      finish(
+        () => resolve2({
+          text,
+          raw,
+          elapsed: Date.now() - start,
+          warnings: [...resolved.warnings]
+        })
+      );
+    });
+    proc.on("error", (err) => {
+      finish(() => reject(err));
+    });
+  }));
+}
+function executeGeminiStreaming(prompt, options) {
+  const {
+    model = "gemini-3.6-flash",
+    timeout = 12e4,
+    cwd = process.cwd(),
+    yolo = true,
+    onChunk
+  } = options;
+  return new Promise((resolve2, reject) => {
+    const args = ["-p", prompt, "--output-format", "stream-json", "-m", model];
+    if (yolo) args.push("--yolo");
+    args.push("-e", "none");
+    const start = Date.now();
+    const proc = spawn("gemini", args, {
+      cwd,
+      env: buildCliProcessEnv({
+        ...options.env,
+        NODE_OPTIONS: "--no-deprecation"
+      })
+    });
+    const stdout = createUtf8Collector();
+    const stderr = createUtf8Collector();
+    let lineBuffer = "";
+    let timer;
+    let settled = false;
+    const finish = (cb) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      detachAbort();
+      cb();
+    };
+    const detachAbort = attachCliAbortSignal(
+      proc,
+      options.signal,
+      (error) => finish(() => reject(error))
+    );
+    const flushLineBuffer = () => {
+      const trimmed = lineBuffer.trim();
+      if (!trimmed) return;
+      try {
+        const event = JSON.parse(trimmed);
+        const text = extractGeminiEventText(event);
+        if (text) onChunk(text);
+      } catch {
+      }
+      lineBuffer = "";
+    };
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        terminateCliProcessGroup(proc, "SIGTERM");
+        finish(() => reject(new Error(`Gemini CLI timed out after ${timeout}ms`)));
+      }, timeout);
+    }
+    proc.stdout.on("data", (data) => {
+      const chunk = stdout.write(data);
+      lineBuffer += chunk;
+      let newlineIndex = lineBuffer.indexOf("\n");
+      while (newlineIndex !== -1) {
+        const line = lineBuffer.slice(0, newlineIndex).trim();
+        lineBuffer = lineBuffer.slice(newlineIndex + 1);
+        if (line) {
+          try {
+            const event = JSON.parse(line);
+            const text = extractGeminiEventText(event);
+            if (text) onChunk(text);
+          } catch {
+          }
+        }
+        newlineIndex = lineBuffer.indexOf("\n");
+      }
+    });
+    proc.stderr.on("data", (data) => {
+      stderr.write(data);
+    });
+    proc.on("close", (code) => {
+      lineBuffer += stdout.finish();
+      const raw = stdout.text;
+      const stderrText = stderr.end();
+      flushLineBuffer();
+      if (code !== 0 && code !== null) {
+        finish(
+          () => reject(new Error(`Gemini CLI exited with code ${code}
+stderr: ${stderrText}`))
+        );
+        return;
+      }
+      finish(
+        () => resolve2({
+          text: parseGeminiStreamJson(raw),
+          raw,
+          elapsed: Date.now() - start
+        })
+      );
+    });
+    proc.on("error", (err) => {
+      finish(() => reject(err));
+    });
+  });
+}
+
+export {
+  CliProviderQuotaError,
+  detectCliProviderQuotaLimit,
+  isBufferedCliStreamingProvider,
+  CLI_PROBE_BINARIES,
+  buildCliProcessEnv,
+  materializeCliImageInputs,
+  executeCli,
+  startCliSession,
+  getCliSession,
+  closeCliSession,
+  executeCliSessionTurn,
+  executeCliSessionTurnStreaming,
+  executeCliStreaming
+};