cli-funnel 0.1.0

package/dist/chunk-2FZ64BNF.js

@@ -0,0 +1,1653 @@
+import {
+  ACCESS_LEVELS,
+  FunnelError
+} from "./chunk-YP5V5YEE.js";
+
+// src/catalog/manifest.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+var bundledDir = [new URL("../../data/models/", import.meta.url), new URL("../data/models/", import.meta.url)].find(
+  (u) => existsSync(fileURLToPath(u))
+) ?? new URL("../../data/models/", import.meta.url);
+var PROVIDER_IDS = ["claude", "codex", "agent", "antigravity"];
+var bundled;
+var remote;
+async function loadBundledManifest() {
+  if (bundled) return bundled;
+  const providers = {};
+  for (const id of PROVIDER_IDS) {
+    providers[id] = JSON.parse(await readFile(fileURLToPath(new URL(`${id}.json`, bundledDir)), "utf8"));
+  }
+  bundled = { schemaVersion: 1, updated: "bundled", providers };
+  return bundled;
+}
+async function loadManifest(url) {
+  if (!url) return loadBundledManifest();
+  if (remote && remote.url === url && Date.now() - remote.at < 36e5) return remote.data;
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(4e3) });
+    if (res.ok) {
+      const data = await res.json();
+      if (data.schemaVersion === 1) {
+        remote = { url, at: Date.now(), data };
+        return data;
+      }
+    }
+  } catch {
+  }
+  return loadBundledManifest();
+}
+function fromManifest(manifest, provider, cliVersion, compare) {
+  return (manifest.providers[provider] ?? []).filter((m) => !m.minCliVersion || !cliVersion || !compare || compare(cliVersion, m.minCliVersion) >= 0).map(({ minCliVersion: _min, ...m }) => ({ ...m, provider, source: "manifest" }));
+}
+function mergeModels(live, fromFile) {
+  const seen = new Set(live.map((m) => m.id));
+  return [...live, ...fromFile.filter((m) => !seen.has(m.id))];
+}
+
+// src/selection.ts
+import { existsSync as existsSync2, statSync } from "fs";
+import { isAbsolute } from "path";
+function validateSelection(selection, provider, models2) {
+  const bad = (msg) => {
+    throw new FunnelError(msg, "invalid-selection");
+  };
+  if (selection.provider !== provider.id) bad(`Selection is for ${selection.provider}, not ${provider.id}.`);
+  if (!ACCESS_LEVELS.includes(selection.access)) bad(`Unknown access level "${selection.access}".`);
+  const hasMachineAccess = provider.capabilities.access.length > 0;
+  if (hasMachineAccess && !provider.capabilities.access.includes(selection.access)) {
+    bad(`${provider.displayName} cannot enforce access "${selection.access}". Supported: ${provider.capabilities.access.join(", ")}.`);
+  }
+  if (hasMachineAccess && (!isAbsolute(selection.cwd) || !existsSync2(selection.cwd) || !statSync(selection.cwd).isDirectory())) {
+    bad(`cwd must be an existing absolute directory: ${selection.cwd}`);
+  }
+  const { capabilities: cap } = provider;
+  if (selection.effort && !cap.effort) bad(`${provider.displayName} has no effort setting.`);
+  if (selection.fast && !cap.fast) bad(`${provider.displayName} has no fast mode.`);
+  if (selection.contextWindow && !cap.contextWindow) bad(`${provider.displayName} has no context window setting.`);
+  if (!selection.model) bad("model is required.");
+  const model = models2?.find((m) => m.id === selection.model);
+  if (models2 && !model) bad(`Unknown model "${selection.model}" for ${provider.displayName}. Call funnel.models() for the list.`);
+  if (model) {
+    if (selection.effort && !model.efforts.some((e) => e.id === selection.effort)) {
+      bad(`${model.id} does not support effort "${selection.effort}".`);
+    }
+    if (selection.fast && !model.fast) bad(`${model.id} has no fast tier.`);
+    if (selection.contextWindow && !model.contextWindows.includes(selection.contextWindow)) {
+      bad(`${model.id} does not offer a ${selection.contextWindow} token context window.`);
+    }
+  }
+}
+
+// src/providers/api.ts
+import { randomUUID } from "crypto";
+
+// src/util/sse.ts
+async function* readSSE(res) {
+  const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
+  let buffer = "";
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) return;
+    buffer += value;
+    let i;
+    while ((i = buffer.search(/\r?\n\r?\n/)) >= 0) {
+      const block = buffer.slice(0, i);
+      buffer = buffer.slice(i).replace(/^\r?\n\r?\n/, "");
+      let event;
+      const data = [];
+      for (const line of block.split(/\r?\n/)) {
+        if (line.startsWith("event:")) event = line.slice(6).trim();
+        else if (line.startsWith("data:")) data.push(line.slice(5).trim());
+      }
+      if (data.length) yield { event, data: data.join("\n") };
+    }
+  }
+}
+
+// src/providers/api.ts
+var NO_EFFORT = { efforts: [], contextWindows: [], fast: false, source: "cli" };
+var anthropic = {
+  id: "anthropic-api",
+  displayName: "Anthropic API",
+  envVar: "ANTHROPIC_API_KEY",
+  keyHint: "console.anthropic.com",
+  async listModels(key) {
+    const res = await fetch("https://api.anthropic.com/v1/models?limit=1000", {
+      headers: { "x-api-key": key, "anthropic-version": "2023-06-01" }
+    });
+    if (!res.ok) throw new FunnelError(`Anthropic API returned ${res.status}.`, "cli-failed");
+    const body = await res.json();
+    return body.data.map((m) => ({ id: m.id, name: m.display_name ?? m.id, provider: "anthropic-api", ...NO_EFFORT }));
+  },
+  async *stream(key, input, messages) {
+    const res = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      signal: input.signal,
+      headers: { "x-api-key": key, "anthropic-version": "2023-06-01", "content-type": "application/json" },
+      body: JSON.stringify({ model: input.selection.model, max_tokens: 8192, stream: true, messages })
+    });
+    if (!res.ok) return yield { type: "error", message: `Anthropic API ${res.status}: ${await res.text()}`, code: "cli-failed" };
+    let inTok = 0;
+    let outTok = 0;
+    let cached = 0;
+    let stop = "stop";
+    for await (const { data } of readSSE(res)) {
+      const e = JSON.parse(data);
+      if (e.type === "message_start") {
+        inTok = e.message.usage?.input_tokens ?? 0;
+        cached = e.message.usage?.cache_read_input_tokens ?? 0;
+      } else if (e.type === "content_block_delta" && e.delta?.type === "text_delta") yield { type: "text.delta", text: e.delta.text };
+      else if (e.type === "message_delta") {
+        outTok = e.usage?.output_tokens ?? outTok;
+        stop = e.delta?.stop_reason ?? stop;
+      } else if (e.type === "error") return yield { type: "error", message: e.error?.message ?? "API error" };
+    }
+    yield { type: "usage", usage: { inputTokens: inTok, outputTokens: outTok, cachedInputTokens: cached, totalTokens: inTok + outTok } };
+    yield { type: "done", text: "", finishReason: stop === "refusal" ? "denied" : "stop" };
+  }
+};
+var openai = {
+  id: "openai-api",
+  displayName: "OpenAI API",
+  envVar: "OPENAI_API_KEY",
+  keyHint: "platform.openai.com",
+  async listModels(key) {
+    const res = await fetch("https://api.openai.com/v1/models", { headers: { authorization: `Bearer ${key}` } });
+    if (!res.ok) throw new FunnelError(`OpenAI API returned ${res.status}.`, "cli-failed");
+    const body = await res.json();
+    return body.data.filter((m) => /^(gpt-|o\d|chatgpt)/.test(m.id) && !/(audio|realtime|tts|transcribe|image|search|embedding|moderation|instruct)/.test(m.id)).map((m) => ({ id: m.id, name: m.id, provider: "openai-api", ...NO_EFFORT })).sort((a, b) => a.id.localeCompare(b.id));
+  },
+  async *stream(key, input, messages) {
+    const res = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      signal: input.signal,
+      headers: { authorization: `Bearer ${key}`, "content-type": "application/json" },
+      body: JSON.stringify({ model: input.selection.model, messages, stream: true, stream_options: { include_usage: true } })
+    });
+    if (!res.ok) return yield { type: "error", message: `OpenAI API ${res.status}: ${await res.text()}`, code: "cli-failed" };
+    let usage;
+    let stop = "stop";
+    for await (const { data } of readSSE(res)) {
+      if (data === "[DONE]") break;
+      const e = JSON.parse(data);
+      const choice = e.choices?.[0];
+      if (choice?.delta?.content) yield { type: "text.delta", text: choice.delta.content };
+      if (choice?.finish_reason) stop = choice.finish_reason;
+      if (e.usage) usage = e.usage;
+    }
+    if (usage) yield { type: "usage", usage: { inputTokens: usage.prompt_tokens, outputTokens: usage.completion_tokens, totalTokens: usage.total_tokens } };
+    yield { type: "done", text: "", finishReason: stop === "content_filter" ? "denied" : "stop" };
+  }
+};
+var histories = /* @__PURE__ */ new Map();
+function makeApiProvider(spec, getKey) {
+  const key = () => {
+    const k = getKey() ?? process.env[spec.envVar];
+    if (!k) throw new FunnelError(`Set ${spec.envVar} (get a key at ${spec.keyHint}) or pass it to createFunnel({ apiKeys }).`, "not-logged-in");
+    return k;
+  };
+  return {
+    id: spec.id,
+    displayName: spec.displayName,
+    binary: "fetch",
+    capabilities: { access: [], effort: false, contextWindow: false, fast: false, resume: true, approvals: false },
+    detect: async () => ({ installed: true, testedRange: { min: "0" }, withinTestedRange: true }),
+    authStatus: async () => ({ loggedIn: !!(getKey() ?? process.env[spec.envVar]), method: "API key" }),
+    login() {
+      return {
+        async *[Symbol.asyncIterator]() {
+          yield { type: "error", message: `${spec.displayName} uses an API key. Set ${spec.envVar}.` };
+        },
+        sendCode() {
+        },
+        cancel() {
+        }
+      };
+    },
+    logout: async () => {
+      throw new FunnelError(`Remove ${spec.envVar} from your environment to sign out.`, "unsupported");
+    },
+    update: async () => ({ changed: false, output: "API providers have nothing to update." }),
+    models: async () => spec.listModels(key()),
+    async *run(input) {
+      const sessionId = input.sessionId ?? randomUUID();
+      const messages = [...histories.get(sessionId) ?? [], { role: "user", content: input.prompt }];
+      yield { type: "session", sessionId, model: input.selection.model };
+      let text = "";
+      for await (const e of spec.stream(key(), input, messages)) {
+        if (e.type === "text.delta") text += e.text;
+        yield e;
+      }
+      histories.set(sessionId, [...messages, { role: "assistant", content: text }]);
+    }
+  };
+}
+var createApiProviders = (keys = {}) => ({
+  "anthropic-api": makeApiProvider(anthropic, () => keys.anthropic),
+  "openai-api": makeApiProvider(openai, () => keys.openai)
+});
+
+// src/util/channel.ts
+var Channel = class {
+  queue = [];
+  waiting = [];
+  closed = false;
+  failure;
+  push(value) {
+    if (this.closed) return;
+    const waiter = this.waiting.shift();
+    if (waiter) waiter({ value, done: false });
+    else this.queue.push(value);
+  }
+  end() {
+    this.closed = true;
+    for (const w of this.waiting.splice(0)) w({ value: void 0, done: true });
+  }
+  fail(error) {
+    this.failure = error;
+    this.end();
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: async () => {
+        if (this.queue.length) return { value: this.queue.shift(), done: false };
+        if (this.closed) {
+          if (this.failure) throw this.failure;
+          return { value: void 0, done: true };
+        }
+        return new Promise((resolve) => this.waiting.push(resolve));
+      }
+    };
+  }
+};
+
+// src/providers/base.ts
+import { spawn as spawn2 } from "child_process";
+
+// src/util/process.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync3, accessSync, constants } from "fs";
+import { homedir } from "os";
+import { delimiter, join } from "path";
+var EXTRA_DIRS = [
+  join(homedir(), ".local", "bin"),
+  join(homedir(), ".bun", "bin"),
+  join(homedir(), ".cursor", "bin"),
+  join(homedir(), ".npm-global", "bin"),
+  "/opt/homebrew/bin",
+  "/usr/local/bin"
+];
+function resolveBinary(name, envVar) {
+  const override = envVar ? process.env[envVar] : void 0;
+  if (override && existsSync3(override)) return override;
+  const dirs = [...(process.env.PATH ?? "").split(delimiter), ...EXTRA_DIRS];
+  const exts = process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+  for (const dir of dirs) {
+    for (const ext of exts) {
+      const candidate = join(dir, name + ext);
+      try {
+        accessSync(candidate, constants.X_OK);
+        return candidate;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function exec(file, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(file, args, {
+      cwd: opts.cwd,
+      env: { ...process.env, ...opts.env },
+      stdio: ["pipe", "pipe", "pipe"],
+      signal: opts.signal
+    });
+    let stdout = "";
+    let stderr = "";
+    const timer = opts.timeoutMs ? setTimeout(() => child.kill("SIGTERM"), opts.timeoutMs) : void 0;
+    child.stdout.on("data", (d) => stdout += d);
+    child.stderr.on("data", (d) => stderr += d);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ stdout, stderr, code });
+    });
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(opts.input ?? "");
+  });
+}
+function spawnStream(file, args, opts = {}) {
+  const child = spawn(file, args, {
+    cwd: opts.cwd,
+    env: { ...process.env, ...opts.env },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const channel = new Channel();
+  let buffer = "";
+  let stderr = "";
+  const flush = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    try {
+      channel.push(JSON.parse(trimmed));
+    } catch {
+      channel.push({ __raw: trimmed });
+    }
+  };
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk;
+    let i;
+    while ((i = buffer.indexOf("\n")) >= 0) {
+      flush(buffer.slice(0, i));
+      buffer = buffer.slice(i + 1);
+    }
+  });
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (d) => stderr += d);
+  child.stdin.on("error", () => {
+  });
+  const exited = new Promise((resolve) => {
+    child.on("error", (e) => {
+      channel.fail(e);
+      resolve(null);
+    });
+    child.on("close", (code) => {
+      flush(buffer);
+      buffer = "";
+      channel.end();
+      resolve(code);
+    });
+  });
+  const onAbort = () => child.kill("SIGTERM");
+  if (opts.signal) {
+    if (opts.signal.aborted) onAbort();
+    else opts.signal.addEventListener("abort", onAbort, { once: true });
+  }
+  if (opts.input !== void 0) child.stdin.write(opts.input);
+  if (opts.closeStdin ?? opts.input !== void 0) child.stdin.end();
+  return {
+    child,
+    lines: channel,
+    stderr: () => stderr,
+    exited,
+    write: (line) => child.stdin.write(line.endsWith("\n") ? line : line + "\n"),
+    closeStdin: () => child.stdin.end()
+  };
+}
+function firstUrl(text) {
+  return text.match(/https?:\/\/[^\s"'<>)\]]+/)?.[0];
+}
+function parseVersion(text) {
+  return text.match(/\d+\.\d+\.\d+(?:[-.][\w.]+)?/)?.[0] ?? text.match(/\d{4}\.\d{2}\.\d{2}[-\w]*/)?.[0];
+}
+function compareVersions(a, b) {
+  const pa = a.split(/[.-]/).map((n) => parseInt(n, 10) || 0);
+  const pb = b.split(/[.-]/).map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d) return d;
+  }
+  return 0;
+}
+
+// src/providers/base.ts
+function binaryEnvVar(binary) {
+  return `CLI_FUNNEL_${binary.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_BIN`;
+}
+function findBinary(binary) {
+  return resolveBinary(binary, binaryEnvVar(binary));
+}
+async function detectInstallation(binary, testedRange, versionArgs = ["--version"]) {
+  const path = findBinary(binary);
+  if (!path) return { installed: false, testedRange };
+  const res = await exec(path, versionArgs, { timeoutMs: 1e4 }).catch(() => void 0);
+  const version = res ? parseVersion(res.stdout + res.stderr) : void 0;
+  const withinTestedRange = version === void 0 ? void 0 : compareVersions(version, testedRange.min) >= 0 && (!testedRange.maxExclusive || compareVersions(version, testedRange.maxExclusive) < 0);
+  return { installed: true, path, version, testedRange, withinTestedRange };
+}
+function spawnLogin(binary, args, readStatus, opts = {}) {
+  const channel = new Channel();
+  const path = findBinary(binary);
+  let child;
+  if (!path) {
+    channel.push({ type: "error", message: `${binary} is not installed.` });
+    channel.end();
+  } else {
+    child = spawn2(path, args, { env: { ...process.env, ...opts.env }, signal: opts.signal, stdio: ["pipe", "pipe", "pipe"] });
+    child.stdin?.on("error", () => {
+    });
+    const seen = /* @__PURE__ */ new Set();
+    const scan = (text) => {
+      channel.push({ type: "log", text });
+      const url = firstUrl(text);
+      if (url && !seen.has(url)) {
+        seen.add(url);
+        channel.push({ type: "open-url", url });
+      }
+      if (/paste|enter (the )?code|verification code/i.test(text)) {
+        channel.push({ type: "code-prompt", message: text.trim() });
+      }
+    };
+    child.stdout?.on("data", (d) => scan(String(d)));
+    child.stderr?.on("data", (d) => scan(String(d)));
+    child.on("close", async (code) => {
+      const status = await readStatus().catch(() => ({ loggedIn: false }));
+      if (status.loggedIn) channel.push({ type: "done", status });
+      else channel.push({ type: "error", message: `Login did not complete (exit ${code}).` });
+      channel.end();
+    });
+  }
+  return {
+    [Symbol.asyncIterator]: () => channel[Symbol.asyncIterator](),
+    sendCode: (code) => child?.stdin?.write(code + "\n"),
+    cancel: () => child?.kill("SIGTERM")
+  };
+}
+async function runUpdate(binary, updateArgs, versionArgs = ["--version"]) {
+  const path = findBinary(binary);
+  if (!path) return { changed: false, output: `${binary} is not installed.` };
+  const read = async () => {
+    const r = await exec(path, versionArgs, { timeoutMs: 1e4 }).catch(() => void 0);
+    return r ? parseVersion(r.stdout + r.stderr) : void 0;
+  };
+  const from = await read();
+  const res = await exec(path, updateArgs, { timeoutMs: 6e5 });
+  const to = await read();
+  return { from, to, changed: !!from && !!to && from !== to, output: (res.stdout + res.stderr).trim() };
+}
+async function runLogout(binary, args) {
+  const path = findBinary(binary);
+  if (path) await exec(path, args, { timeoutMs: 3e4 });
+}
+async function collect(events, input) {
+  const result = {
+    text: "",
+    provider: input.selection.provider,
+    model: input.selection.model,
+    finishReason: "stop",
+    toolCalls: [],
+    deniedActions: []
+  };
+  const tools = /* @__PURE__ */ new Map();
+  for await (const e of events) {
+    switch (e.type) {
+      case "session":
+        result.sessionId = e.sessionId;
+        if (e.model) result.model = e.model;
+        break;
+      case "text.delta":
+        result.text += e.text;
+        break;
+      case "tool.start": {
+        const call = { id: e.id, name: e.name, input: e.input };
+        tools.set(e.id, call);
+        result.toolCalls.push(call);
+        break;
+      }
+      case "tool.end": {
+        const call = tools.get(e.id);
+        if (call && e.error) call.error = e.error;
+        if (e.error?.startsWith("denied:")) result.deniedActions.push(call?.name ?? e.error.slice(7).trim());
+        break;
+      }
+      case "usage":
+        result.usage = e.usage;
+        break;
+      case "done":
+        if (e.text) result.text = e.text;
+        result.finishReason = e.finishReason;
+        break;
+      case "error":
+        result.finishReason = "error";
+        throw Object.assign(new Error(e.message), { code: e.code });
+    }
+  }
+  return result;
+}
+
+// src/providers/claude/parser.ts
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var num = (v) => typeof v === "number" ? v : 0;
+function toolOutput(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return void 0;
+  const text = content.flatMap((c) => isObj(c) && typeof c.text === "string" ? [c.text] : []);
+  return text.length ? text.join("\n") : void 0;
+}
+function parseClaudeMessage(raw) {
+  if (!isObj(raw)) return [];
+  const type = raw.type;
+  if (type === "system" && raw.subtype === "init" && typeof raw.session_id === "string") {
+    return [{ type: "session", sessionId: raw.session_id, model: typeof raw.model === "string" ? raw.model : void 0 }];
+  }
+  if (raw.parent_tool_use_id) return [];
+  if (type === "stream_event" && isObj(raw.event) && raw.event.type === "content_block_delta" && isObj(raw.event.delta)) {
+    const d = raw.event.delta;
+    if (d.type === "text_delta" && typeof d.text === "string") return [{ type: "text.delta", text: d.text }];
+    if (d.type === "thinking_delta" && typeof d.thinking === "string") return [{ type: "reasoning.delta", text: d.thinking }];
+    return [];
+  }
+  if (type === "assistant" && isObj(raw.message) && Array.isArray(raw.message.content)) {
+    return raw.message.content.flatMap(
+      (b) => isObj(b) && b.type === "tool_use" && typeof b.id === "string" ? [{ type: "tool.start", id: b.id, name: String(b.name), input: b.input }] : []
+    );
+  }
+  if (type === "user" && isObj(raw.message) && Array.isArray(raw.message.content)) {
+    return raw.message.content.flatMap((b) => {
+      if (!isObj(b) || b.type !== "tool_result" || typeof b.tool_use_id !== "string") return [];
+      const out = toolOutput(b.content);
+      return [
+        b.is_error === true ? { type: "tool.end", id: b.tool_use_id, error: out ?? "Tool failed." } : { type: "tool.end", id: b.tool_use_id, output: out }
+      ];
+    });
+  }
+  if (type === "result") return parseResult(raw);
+  return [];
+}
+function parseResult(r) {
+  const text = typeof r.result === "string" ? r.result : "";
+  if (r.is_error === true || typeof r.subtype === "string" && r.subtype.startsWith("error")) {
+    const status = r.api_error_status;
+    return [{ type: "error", message: text || `Claude Code failed (${String(r.subtype)}).`, code: status ? String(status) : void 0 }];
+  }
+  const events = [];
+  if (isObj(r.usage)) {
+    const u = r.usage;
+    const cached = num(u.cache_read_input_tokens);
+    const input = num(u.input_tokens) + cached + num(u.cache_creation_input_tokens);
+    const usage = {
+      inputTokens: input,
+      outputTokens: num(u.output_tokens),
+      cachedInputTokens: cached,
+      totalTokens: input + num(u.output_tokens)
+    };
+    events.push({ type: "usage", usage });
+  }
+  const denied = Array.isArray(r.permission_denials) && r.permission_denials.length > 0;
+  const finishReason = denied ? "denied" : "stop";
+  events.push({ type: "done", text, finishReason });
+  return events;
+}
+
+// src/providers/claude/index.ts
+var BIN = "claude";
+var TESTED_RANGE = { min: "2.1.0" };
+var PERMISSION_MODE = {
+  supervised: "manual",
+  "accept-edits": "acceptEdits",
+  auto: "auto",
+  full: "bypassPermissions"
+};
+var capabilities = {
+  access: ["supervised", "accept-edits", "auto", "full"],
+  effort: true,
+  contextWindow: false,
+  fast: false,
+  resume: true,
+  approvals: true
+};
+function buildArgs(input) {
+  const { selection } = input;
+  const args = [
+    "-p",
+    "--input-format",
+    "stream-json",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--include-partial-messages",
+    "--model",
+    selection.model,
+    "--permission-mode",
+    PERMISSION_MODE[selection.access]
+  ];
+  if (selection.effort) args.push("--effort", selection.effort);
+  if (selection.access !== "full" && input.onApproval) args.push("--permission-prompt-tool", "stdio");
+  if (input.sessionId) args.push("--resume", input.sessionId);
+  return args;
+}
+async function* run(input) {
+  const bin = findBinary(BIN);
+  if (!bin) throw new FunnelError("Claude Code is not installed.", "not-installed");
+  if (input.selection.access === "supervised" && !input.onApproval) {
+    throw new FunnelError('Access "supervised" needs an onApproval handler.', "invalid-selection");
+  }
+  const proc = spawnStream(bin, buildArgs(input), { cwd: input.selection.cwd, env: input.env, signal: input.signal, closeStdin: false });
+  proc.write(JSON.stringify({ type: "user", message: { role: "user", content: input.prompt } }));
+  let finished = false;
+  try {
+    for await (const raw of proc.lines) {
+      const msg = raw;
+      if (msg.type === "control_request") {
+        const req = msg.request ?? {};
+        if (req.subtype !== "can_use_tool") {
+          proc.write(JSON.stringify({ type: "control_response", response: { subtype: "error", request_id: msg.request_id, error: "unsupported request" } }));
+          continue;
+        }
+        const request = { id: String(req.tool_use_id ?? msg.request_id), tool: String(req.tool_name), input: req.input, description: req.description };
+        yield { type: "approval.request", request };
+        const decision = await input.onApproval(request);
+        const response = decision === "allow" ? { behavior: "allow", updatedInput: req.input } : { behavior: "deny", message: "Denied by the user." };
+        proc.write(JSON.stringify({ type: "control_response", response: { subtype: "success", request_id: msg.request_id, response } }));
+        continue;
+      }
+      for (const e of parseClaudeMessage(raw)) {
+        if (e.type === "done" || e.type === "error") finished = true;
+        yield e;
+      }
+      if (msg.type === "result") proc.closeStdin();
+    }
+  } finally {
+    if (!finished) proc.child.kill("SIGTERM");
+  }
+  if (finished) return;
+  await proc.exited;
+  if (input.signal?.aborted) yield { type: "done", text: "", finishReason: "cancelled" };
+  else yield { type: "error", message: proc.stderr().trim() || "Claude Code exited without a result.", code: "cli-failed" };
+}
+async function authStatus() {
+  const bin = findBinary(BIN);
+  if (!bin) return { loggedIn: false, detail: "Claude Code is not installed." };
+  const res = await exec(bin, ["auth", "status"], { timeoutMs: 15e3 });
+  try {
+    const j = JSON.parse(res.stdout);
+    return { loggedIn: j.loggedIn === true, method: j.authMethod, account: j.email, plan: j.subscriptionType };
+  } catch {
+    return { loggedIn: false, detail: (res.stderr || res.stdout).trim() || void 0 };
+  }
+}
+var claudeProvider = {
+  id: "claude",
+  displayName: "Claude Code",
+  binary: BIN,
+  capabilities,
+  detect: () => detectInstallation(BIN, TESTED_RANGE),
+  authStatus,
+  login: (options) => spawnLogin(BIN, ["auth", "login"], authStatus, { signal: options?.signal }),
+  logout: () => runLogout(BIN, ["auth", "logout"]),
+  update: () => runUpdate(BIN, ["update"]),
+  async models() {
+    const [manifest, install] = await Promise.all([loadManifest(), claudeProvider.detect()]);
+    return mergeModels([], fromManifest(manifest, "claude", install.version, compareVersions));
+  },
+  run
+};
+
+// src/providers/codex/access.ts
+function planAccess(access) {
+  switch (access) {
+    case "supervised":
+      return { approvalPolicy: "untrusted", sandbox: "workspace-write", approvalsReviewer: "user", autoAllowFileChanges: false };
+    case "accept-edits":
+      return { approvalPolicy: "untrusted", sandbox: "workspace-write", approvalsReviewer: "user", autoAllowFileChanges: true };
+    case "auto":
+      return { approvalPolicy: "on-request", sandbox: "workspace-write", approvalsReviewer: "auto_review", autoAllowFileChanges: false };
+    case "full":
+      return { approvalPolicy: "never", sandbox: "danger-full-access", approvalsReviewer: "user", autoAllowFileChanges: true };
+  }
+}
+
+// src/providers/codex/approvals.ts
+function toApprovalRequest(req, items) {
+  const p = req.params;
+  switch (req.method) {
+    case "item/commandExecution/requestApproval":
+      return {
+        id: String(p.approvalId ?? p.itemId),
+        tool: "command",
+        input: { command: p.command, cwd: p.cwd, reason: p.reason },
+        description: p.reason ?? p.command ?? void 0
+      };
+    case "item/fileChange/requestApproval":
+      return {
+        id: String(p.itemId),
+        tool: "file_change",
+        input: { changes: items.get(p.itemId), reason: p.reason, grantRoot: p.grantRoot },
+        description: p.reason ?? void 0
+      };
+    case "mcpServer/elicitation/request":
+      return { id: String(req.id), tool: "mcp", input: p, description: p.message ?? void 0 };
+    default:
+      return void 0;
+  }
+}
+function toReply(req, decision) {
+  const allow = decision === "allow";
+  switch (req.method) {
+    case "item/commandExecution/requestApproval":
+    case "item/fileChange/requestApproval":
+      return { result: { decision: allow ? "accept" : "decline" } };
+    case "mcpServer/elicitation/request":
+      return { result: { action: allow ? "accept" : "decline", content: null, _meta: null } };
+    default:
+      return { error: { code: -32601, message: `Unsupported request ${req.method}` } };
+  }
+}
+
+// src/providers/codex/auth.ts
+function parseLoginStatus(text) {
+  const line = text.trim().split("\n")[0] ?? "";
+  if (/not logged in/i.test(line)) return { loggedIn: false, detail: line };
+  if (/logged in using chatgpt/i.test(line)) return { loggedIn: true, method: "ChatGPT", detail: line };
+  if (/logged in using an api key/i.test(line)) return { loggedIn: true, method: "API key", detail: "Logged in using an API key" };
+  const other = line.match(/logged in using (.+)/i);
+  if (other) return { loggedIn: true, method: other[1]?.trim(), detail: line };
+  return { loggedIn: false, detail: line || void 0 };
+}
+
+// src/providers/codex/events.ts
+var Translator = class {
+  constructor(threadId) {
+    this.threadId = threadId;
+  }
+  threadId;
+  /** File changes by item id, kept so approval requests can show them. */
+  items = /* @__PURE__ */ new Map();
+  messages = [];
+  usage = { inputTokens: 0, outputTokens: 0, cachedInputTokens: 0, reasoningTokens: 0, totalTokens: 0 };
+  handle(method, p = {}) {
+    if (p.threadId && p.threadId !== this.threadId) return { events: [] };
+    switch (method) {
+      case "item/agentMessage/delta":
+        return { events: [{ type: "text.delta", text: p.delta }] };
+      case "item/reasoning/summaryTextDelta":
+      case "item/reasoning/textDelta":
+        return { events: [{ type: "reasoning.delta", text: p.delta }] };
+      case "item/started":
+        return { events: this.itemStarted(p.item) };
+      case "item/completed":
+        return { events: this.itemCompleted(p.item) };
+      case "thread/tokenUsage/updated": {
+        const l = p.tokenUsage?.last;
+        if (!l) return { events: [] };
+        const u = this.usage;
+        u.inputTokens += l.inputTokens;
+        u.outputTokens += l.outputTokens;
+        u.cachedInputTokens = (u.cachedInputTokens ?? 0) + l.cachedInputTokens;
+        u.reasoningTokens = (u.reasoningTokens ?? 0) + l.reasoningOutputTokens;
+        u.totalTokens += l.totalTokens;
+        return { events: [{ type: "usage", usage: { ...u } }] };
+      }
+      case "error":
+        if (p.willRetry) return { events: [] };
+        return { events: [{ type: "error", message: p.error?.message ?? "Codex reported an error." }], finished: true };
+      case "turn/completed":
+        return this.turnCompleted(p.turn);
+      default:
+        return { events: [] };
+    }
+  }
+  itemStarted(item) {
+    switch (item?.type) {
+      case "commandExecution":
+        return [{ type: "tool.start", id: item.id, name: "command", input: { command: item.command, cwd: item.cwd } }];
+      case "fileChange":
+        this.items.set(item.id, item.changes);
+        return [{ type: "tool.start", id: item.id, name: "file_change", input: { changes: item.changes } }];
+      case "mcpToolCall":
+        return [{ type: "tool.start", id: item.id, name: `mcp:${item.server}/${item.tool}`, input: item.arguments }];
+      case "dynamicToolCall":
+        return [{ type: "tool.start", id: item.id, name: item.tool, input: item.arguments }];
+      default:
+        return [];
+    }
+  }
+  itemCompleted(item) {
+    switch (item?.type) {
+      case "agentMessage":
+        if (item.text) this.messages.push(item.text);
+        return [];
+      case "commandExecution": {
+        const bad = item.status === "failed" || item.status === "declined" || (item.exitCode ?? 0) !== 0;
+        const code = item.exitCode != null ? ` (exit ${item.exitCode})` : "";
+        return [{ type: "tool.end", id: item.id, output: item.aggregatedOutput ?? void 0, error: bad ? `Command ${item.status}${code}` : void 0 }];
+      }
+      case "fileChange": {
+        const bad = item.status === "failed" || item.status === "declined";
+        return [{ type: "tool.end", id: item.id, error: bad ? `File change ${item.status}` : void 0 }];
+      }
+      case "mcpToolCall": {
+        const error = item.error?.message ?? (item.status === "failed" ? "MCP tool call failed" : void 0);
+        const out = item.result ? JSON.stringify(item.result.structuredContent ?? item.result.content) : void 0;
+        return [{ type: "tool.end", id: item.id, output: out, error }];
+      }
+      case "dynamicToolCall":
+        return [{ type: "tool.end", id: item.id, error: item.success === false ? "Tool call failed" : void 0 }];
+      default:
+        return [];
+    }
+  }
+  turnCompleted(turn) {
+    if (turn?.status === "failed") {
+      return { events: [{ type: "error", message: turn.error?.message ?? "Turn failed." }], finished: true };
+    }
+    const finishReason = turn?.status === "interrupted" ? "cancelled" : "stop";
+    return { events: [{ type: "done", text: this.messages.join("\n\n"), finishReason }], finished: true };
+  }
+};
+
+// src/providers/codex/models.ts
+var LABELS = { xhigh: "Extra high" };
+var label = (id) => LABELS[id] ?? id.charAt(0).toUpperCase() + id.slice(1);
+function parseCatalog(json) {
+  const data = JSON.parse(json);
+  return (data.models ?? []).filter((m) => m.visibility === "list").map((m) => ({
+    id: m.slug,
+    name: m.display_name,
+    provider: "codex",
+    efforts: (m.supported_reasoning_levels ?? []).map((l) => ({ id: l.effort, label: label(l.effort) })),
+    defaultEffort: m.default_reasoning_level,
+    contextWindows: [],
+    fast: !!m.additional_speed_tiers?.includes("fast") || !!m.service_tiers?.some((t) => t.id === "priority"),
+    source: "cli"
+  }));
+}
+
+// src/providers/codex/rpc.ts
+var RpcClient = class {
+  constructor(proc, handlers) {
+    this.proc = proc;
+    void (async () => {
+      try {
+        for await (const raw of proc.lines) {
+          const m = raw;
+          if (m.method && m.id !== void 0) handlers.request(m.id, m.method, m.params);
+          else if (m.method) handlers.notification(m.method, m.params);
+          else if (typeof m.id === "number") {
+            const p = this.pending.get(m.id);
+            this.pending.delete(m.id);
+            if (m.error) p?.reject(new Error(m.error.message));
+            else p?.resolve(m.result);
+          }
+        }
+      } catch {
+      }
+      for (const p of this.pending.values()) p.reject(new Error("Codex app-server closed."));
+      this.pending.clear();
+      handlers.closed();
+    })();
+  }
+  proc;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  request(method, params) {
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.proc.write(JSON.stringify({ method, id, params }));
+    });
+  }
+  notify(method) {
+    this.proc.write(JSON.stringify({ method }));
+  }
+  respond(id, reply) {
+    this.proc.write(JSON.stringify({ id, ...reply }));
+  }
+};
+
+// src/providers/codex/index.ts
+var BINARY = "codex";
+var TESTED_RANGE2 = { min: "0.150.0" };
+async function authStatus2() {
+  const path = findBinary(BINARY);
+  if (!path) return { loggedIn: false, detail: "codex is not installed." };
+  const res = await exec(path, ["login", "status"], { timeoutMs: 15e3 });
+  return parseLoginStatus(res.stdout + res.stderr);
+}
+async function models() {
+  const path = findBinary(BINARY);
+  if (path) {
+    try {
+      const res = await exec(path, ["debug", "models"], { timeoutMs: 2e4 });
+      const live = res.code === 0 ? parseCatalog(res.stdout) : [];
+      if (live.length) return live;
+    } catch {
+    }
+  }
+  return fromManifest(await loadBundledManifest(), "codex");
+}
+async function* run2(input) {
+  const path = findBinary(BINARY);
+  if (!path) {
+    yield { type: "error", message: "codex is not installed.", code: "not-installed" };
+    return;
+  }
+  const sel = input.selection;
+  const plan = planAccess(sel.access);
+  const out = new Channel();
+  const proc = spawnStream(path, ["app-server"], { cwd: sel.cwd, env: input.env });
+  let translator;
+  let threadId;
+  let turnId;
+  let finished = false;
+  const finish = (events) => {
+    if (finished) return;
+    finished = true;
+    for (const e of events) out.push(e);
+    out.end();
+    proc.child.kill("SIGTERM");
+  };
+  const decide = async (req) => {
+    if (req.method === "item/fileChange/requestApproval" && plan.autoAllowFileChanges) return "allow";
+    if (sel.access === "full") return "allow";
+    const request = toApprovalRequest(req, translator?.items ?? /* @__PURE__ */ new Map());
+    if (!request) return "deny";
+    out.push({ type: "approval.request", request });
+    if (!input.onApproval) return "deny";
+    try {
+      return await input.onApproval(request);
+    } catch {
+      return "deny";
+    }
+  };
+  const rpc = new RpcClient(proc, {
+    notification(method, params) {
+      if (!translator || finished) return;
+      if (method === "turn/started" && params?.threadId === threadId) turnId = params.turn?.id;
+      const t = translator.handle(method, params);
+      if (t.finished) finish(t.events);
+      else for (const e of t.events) out.push(e);
+    },
+    request(id, method, params) {
+      const req = { id, method, params: params ?? {} };
+      if (!toApprovalRequest(req, translator?.items ?? /* @__PURE__ */ new Map())) {
+        rpc.respond(id, toReply(req, "deny"));
+        return;
+      }
+      void decide(req).then((d) => rpc.respond(id, toReply(req, d)));
+    },
+    closed() {
+      const err = proc.stderr().trim().split("\n").slice(-3).join(" ");
+      finish([{ type: "error", message: `Codex app-server exited early.${err ? ` ${err}` : ""}` }]);
+    }
+  });
+  const onAbort = () => {
+    if (finished) return;
+    if (threadId && turnId) {
+      rpc.request("turn/interrupt", { threadId, turnId }).catch(() => {
+      });
+      setTimeout(() => finish([{ type: "done", text: "", finishReason: "cancelled" }]), 5e3).unref();
+    } else {
+      finish([{ type: "done", text: "", finishReason: "cancelled" }]);
+    }
+  };
+  if (input.signal?.aborted) onAbort();
+  else input.signal?.addEventListener("abort", onAbort, { once: true });
+  void (async () => {
+    try {
+      await rpc.request("initialize", {
+        clientInfo: { name: "cli-funnel", title: null, version: "0.1.0" },
+        capabilities: { experimentalApi: false, requestAttestation: false }
+      });
+      rpc.notify("initialized");
+      const settings = {
+        model: sel.model,
+        cwd: sel.cwd,
+        approvalPolicy: plan.approvalPolicy,
+        approvalsReviewer: plan.approvalsReviewer,
+        sandbox: plan.sandbox,
+        ...sel.fast ? { serviceTier: "priority" } : {}
+      };
+      const started = input.sessionId ? await rpc.request("thread/resume", { threadId: input.sessionId, ...settings }) : await rpc.request("thread/start", settings);
+      threadId = started.thread.id;
+      translator = new Translator(threadId);
+      out.push({ type: "session", sessionId: threadId, model: started.model });
+      const res = await rpc.request("turn/start", {
+        threadId,
+        input: [{ type: "text", text: input.prompt, text_elements: [] }],
+        ...sel.effort ? { effort: sel.effort } : {}
+      });
+      turnId ??= res?.turn?.id;
+    } catch (e) {
+      finish([{ type: "error", message: e instanceof Error ? e.message : String(e), code: "cli-failed" }]);
+    }
+  })();
+  try {
+    yield* out;
+  } finally {
+    input.signal?.removeEventListener("abort", onAbort);
+    proc.child.kill("SIGTERM");
+  }
+}
+var codexProvider = {
+  id: "codex",
+  displayName: "Codex",
+  binary: BINARY,
+  capabilities: {
+    access: ["supervised", "accept-edits", "auto", "full"],
+    effort: true,
+    contextWindow: false,
+    fast: true,
+    resume: true,
+    approvals: true
+  },
+  detect: () => detectInstallation(BINARY, TESTED_RANGE2),
+  authStatus: authStatus2,
+  login: (options) => spawnLogin(BINARY, ["login", "--device-auth"], authStatus2, { signal: options?.signal }),
+  logout: () => runLogout(BINARY, ["logout"]),
+  update: () => runUpdate(BINARY, ["update"]),
+  models,
+  run: run2
+};
+
+// src/providers/agent/parser.ts
+var EFFORT_ORDER = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+var EFFORT_LABEL = {
+  none: "None",
+  minimal: "Minimal",
+  low: "Low",
+  medium: "Medium",
+  high: "High",
+  xhigh: "Extra High",
+  max: "Max"
+};
+var EFFORT_WORDS = /\b(?:Minimal|None|Low|Medium|High|Extra High|Max)\b/g;
+function parseModelList(text) {
+  const out = [];
+  for (const raw of text.replace(/[​-‍]/g, "").split("\n")) {
+    const m = raw.match(/^([a-z0-9][\w.-]*) - (.+)$/i);
+    if (m?.[1] && m[2] && m[1] !== "auto") out.push({ id: m[1], name: m[2].trim() });
+  }
+  return out;
+}
+function splitId(id) {
+  let tokens = id.split("-");
+  let fast = false;
+  let thinking = false;
+  let effort;
+  if (tokens.length > 1 && tokens[tokens.length - 1] === "fast") {
+    fast = true;
+    tokens = tokens.slice(0, -1);
+  }
+  const dropThinking = () => {
+    if (tokens[tokens.length - 1] === "thinking") {
+      thinking = true;
+      tokens = tokens.slice(0, -1);
+    }
+  };
+  dropThinking();
+  const tail = tokens.slice(-2).join("-");
+  if (tail === "extra-high") {
+    effort = "xhigh";
+    tokens = tokens.slice(0, -2);
+  } else if (EFFORT_ORDER.includes(tokens[tokens.length - 1] ?? "")) {
+    effort = tokens[tokens.length - 1];
+    tokens = tokens.slice(0, -1);
+  }
+  dropThinking();
+  const stem = tokens.join("-");
+  return { base: thinking ? `${stem}-thinking` : stem, thinking, effort, fast, bare: effort === void 0 };
+}
+function groupModels(listed) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const { id, name } of listed) {
+    const p = splitId(id);
+    const g = groups.get(p.base) ?? { name: "", efforts: /* @__PURE__ */ new Set(), fast: false, bare: false };
+    const clean = name.replace(EFFORT_WORDS, "").replace(/\bFast\b/g, "").replace(/\s+/g, " ").trim();
+    if (!g.name || clean.length < g.name.length) g.name = clean;
+    if (p.effort) g.efforts.add(p.effort);
+    if (p.fast) g.fast = true;
+    if (p.bare) g.bare = true;
+    groups.set(p.base, g);
+  }
+  const models2 = [];
+  for (const [id, g] of groups) {
+    if (g.bare && g.efforts.size && id.startsWith("gpt-")) g.efforts.add("medium");
+    const efforts = EFFORT_ORDER.filter((e) => g.efforts.has(e)).map((e) => ({ id: e, label: EFFORT_LABEL[e] ?? e }));
+    const defaultEffort = ["medium", "high"].find((e) => g.efforts.has(e)) ?? efforts[0]?.id;
+    models2.push({
+      id,
+      name: g.name,
+      provider: "agent",
+      efforts,
+      ...defaultEffort ? { defaultEffort } : {},
+      contextWindows: [],
+      fast: g.fast,
+      source: "cli"
+    });
+  }
+  return models2;
+}
+function toCliModel(selection, known2 = /* @__PURE__ */ new Set()) {
+  const thinking = selection.model.endsWith("-thinking");
+  const stem = thinking ? selection.model.slice(0, -"-thinking".length) : selection.model;
+  const efforts = selection.effort ? [selection.effort] : ["", "medium", "high", "low", "xhigh", "max", "minimal", "none"];
+  const candidates = [];
+  for (const e of efforts) {
+    const tokens = e === "xhigh" ? ["xhigh", "extra-high"] : [e];
+    for (const t of tokens) {
+      const parts = thinking ? [t ? `${stem}-thinking-${t}` : `${stem}-thinking`, ...t ? [`${stem}-${t}-thinking`] : []] : [t ? `${stem}-${t}` : stem];
+      for (const p of parts) candidates.push(selection.fast ? `${p}-fast` : p);
+    }
+    if (e === "medium" && stem.startsWith("gpt-")) candidates.push(selection.fast ? `${selection.model}-fast` : selection.model);
+  }
+  if (!known2.size) return candidates[0];
+  const hit = candidates.find((c) => known2.has(c));
+  if (!hit) {
+    throw new FunnelError(
+      `Cursor Agent has no variant of ${selection.model} with effort ${selection.effort ?? "default"}${selection.fast ? " and fast tier" : ""}.`,
+      "invalid-selection"
+    );
+  }
+  return hit;
+}
+function parseStatus(json, aboutJson) {
+  let s;
+  try {
+    s = JSON.parse(json);
+  } catch {
+    return { loggedIn: /logged in/i.test(json) && !/not logged in/i.test(json), account: json.match(/Logged in as (\S+)/i)?.[1] };
+  }
+  const status = { loggedIn: s.isAuthenticated === true, method: "Cursor", account: s.userInfo?.email };
+  if (aboutJson) {
+    try {
+      const plan = JSON.parse(aboutJson).subscriptionTier;
+      if (typeof plan === "string") status.plan = plan;
+    } catch {
+    }
+  }
+  return status;
+}
+function toolName(key) {
+  return key.replace(/ToolCall$/, "");
+}
+function toolInput(name, args) {
+  if (!args) return void 0;
+  if (name === "shell") return { command: args.command, workingDirectory: args.workingDirectory || void 0 };
+  return args;
+}
+function failure(result) {
+  if (!result || "success" in result) return void 0;
+  const e = result.error ?? result.failure ?? result.rejected ?? result.permissionDenied;
+  const msg = e && (e.errorMessage ?? e.message ?? e.reason);
+  return typeof msg === "string" ? msg : JSON.stringify(result).slice(0, 300);
+}
+function output(result) {
+  const s = result?.success;
+  if (!s) return void 0;
+  for (const k of ["stdout", "content", "message"]) if (typeof s[k] === "string") return s[k];
+  return void 0;
+}
+function toUsage(u) {
+  if (!u) return void 0;
+  const cached = u.cacheReadTokens ?? 0;
+  const inputTokens = (u.inputTokens ?? 0) + cached + (u.cacheWriteTokens ?? 0);
+  const outputTokens = u.outputTokens ?? 0;
+  return { inputTokens, outputTokens, cachedInputTokens: cached, totalTokens: inputTokens + outputTokens };
+}
+var StreamMapper = class {
+  sawPartial = false;
+  text = "";
+  denied = false;
+  started = /* @__PURE__ */ new Map();
+  map(line) {
+    const m = line;
+    if (!m || typeof m !== "object" || "__raw" in m) return [];
+    switch (m.type) {
+      case "system":
+        return m.subtype === "init" && m.session_id ? [{ type: "session", sessionId: m.session_id }] : [];
+      case "thinking":
+        return m.subtype === "delta" && m.text ? [{ type: "reasoning.delta", text: m.text }] : [];
+      case "assistant": {
+        const partial = m.timestamp_ms !== void 0;
+        if (partial) this.sawPartial = true;
+        else if (this.sawPartial) return [];
+        const text = (m.message?.content ?? []).map((c) => c.type === "text" ? c.text : "").join("");
+        if (!text) return [];
+        this.text += text;
+        return [{ type: "text.delta", text }];
+      }
+      case "tool_call": {
+        const key = Object.keys(m.tool_call ?? {})[0];
+        if (!key) return [];
+        const call = m.tool_call[key];
+        const name = toolName(key);
+        const id = String(m.call_id ?? call.toolCallId ?? name);
+        if (m.subtype === "started") {
+          this.started.set(id, name);
+          return [{ type: "tool.start", id, name, input: toolInput(name, call.args) }];
+        }
+        if (m.subtype === "completed") {
+          const error = failure(call.result);
+          if (error && call.result && ("rejected" in call.result || "permissionDenied" in call.result)) this.denied = true;
+          return [{ type: "tool.end", id, ...error ? { error } : { output: output(call.result) } }];
+        }
+        return [];
+      }
+      case "result": {
+        const events = [];
+        if (m.is_error || m.subtype !== "success") {
+          return [{ type: "error", message: String(m.result ?? m.subtype ?? "Cursor Agent failed") }];
+        }
+        const usage = toUsage(m.usage);
+        if (usage) events.push({ type: "usage", usage });
+        events.push({ type: "done", text: typeof m.result === "string" ? m.result : this.text, finishReason: this.denied ? "denied" : "stop" });
+        return events;
+      }
+      default:
+        return [];
+    }
+  }
+};
+
+// src/providers/agent/index.ts
+var BINARY2 = "agent";
+var TESTED_RANGE3 = { min: "2026.09.01" };
+var known;
+async function listModels() {
+  const path = findBinary(BINARY2);
+  if (!path) return [];
+  const res = await exec(path, ["--list-models"], { timeoutMs: 3e4 }).catch(() => void 0);
+  return res ? parseModelList(res.stdout) : [];
+}
+async function knownIds() {
+  if (!known?.size) known = new Set((await listModels()).map((m) => m.id));
+  return known;
+}
+function accessFlags(access) {
+  if (access === "full") return ["--force"];
+  if (access === "auto") return ["--auto-review"];
+  throw new FunnelError(`Cursor Agent cannot enforce access "${access}". Supported: auto, full.`, "invalid-selection");
+}
+function buildArgs2(input, model) {
+  const { selection } = input;
+  return [
+    "-p",
+    "--output-format",
+    "stream-json",
+    "--stream-partial-output",
+    "--model",
+    model,
+    "--workspace",
+    selection.cwd,
+    "--trust",
+    ...accessFlags(selection.access),
+    ...input.sessionId ? ["--resume", input.sessionId] : [],
+    "--",
+    input.prompt
+  ];
+}
+async function authStatus3() {
+  const path = findBinary(BINARY2);
+  if (!path) return { loggedIn: false, detail: "agent is not installed." };
+  const status = await exec(path, ["status", "--format", "json"], { timeoutMs: 15e3 }).catch(() => void 0);
+  if (!status) return { loggedIn: false };
+  const parsed = parseStatus(status.stdout || status.stderr);
+  if (!parsed.loggedIn) return { loggedIn: false };
+  const about = await exec(path, ["about", "--format", "json"], { timeoutMs: 15e3 }).catch(() => void 0);
+  return parseStatus(status.stdout, about?.stdout);
+}
+async function* run3(input) {
+  const path = findBinary(BINARY2);
+  if (!path) throw new FunnelError("agent is not installed.", "not-installed");
+  const model = toCliModel(input.selection, await knownIds());
+  const args = buildArgs2(input, model);
+  const proc = spawnStream(path, args, { cwd: input.selection.cwd, env: input.env, signal: input.signal, closeStdin: true });
+  const mapper = new StreamMapper();
+  let finished = false;
+  for await (const line of proc.lines) {
+    for (const event of mapper.map(line)) {
+      if (event.type === "done" || event.type === "error") finished = true;
+      yield event;
+    }
+  }
+  const code = await proc.exited;
+  if (input.signal?.aborted) {
+    yield { type: "done", text: "", finishReason: "cancelled" };
+  } else if (!finished) {
+    const detail = proc.stderr().trim().slice(-500);
+    yield {
+      type: "error",
+      message: detail || `agent exited with code ${code} before finishing.`,
+      code: /authentication required|not logged in/i.test(detail) ? "not-logged-in" : "cli-failed"
+    };
+  }
+}
+var agentProvider = {
+  id: "agent",
+  displayName: "Cursor Agent",
+  binary: BINARY2,
+  capabilities: { access: ["auto", "full"], effort: true, contextWindow: false, fast: true, resume: true, approvals: false },
+  detect: () => detectInstallation(BINARY2, TESTED_RANGE3),
+  authStatus: authStatus3,
+  login: (options) => spawnLogin(BINARY2, ["login"], authStatus3, {
+    signal: options?.signal,
+    env: process.env.CLI_FUNNEL_OPEN_BROWSER === "1" ? {} : { NO_OPEN_BROWSER: "1" }
+  }),
+  logout: () => runLogout(BINARY2, ["logout"]),
+  update: () => runUpdate(BINARY2, ["update"]),
+  async models() {
+    const listed = await listModels();
+    if (listed.length) {
+      known = new Set(listed.map((m) => m.id));
+      return groupModels(listed);
+    }
+    return fromManifest(await loadBundledManifest(), "agent", void 0, compareVersions);
+  },
+  run: run3
+};
+
+// src/providers/antigravity/index.ts
+import { existsSync as existsSync4 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+
+// src/providers/antigravity/parser.ts
+var EFFORTS = ["low", "medium", "high", "max"];
+var EFFORT_RE = /^(.+)-(low|medium|high|max)$/;
+function parseModels(text) {
+  const rows = [];
+  for (const line of text.split("\n")) {
+    const [rawId = "", rawName = ""] = line.split("	");
+    const id = rawId.trim();
+    if (!id || id.includes(" ") || !rawName.trim()) continue;
+    const m = EFFORT_RE.exec(id);
+    rows.push({ id, name: rawName.trim(), base: m?.[1] ?? id, effort: m?.[2] });
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const r of rows) groups.set(r.base, [...groups.get(r.base) ?? [], r]);
+  const out = [];
+  for (const [base, members] of groups) {
+    const first = members[0];
+    if (!first) continue;
+    const base0 = { provider: "antigravity", contextWindows: [], fast: false, source: "cli" };
+    if (members.length < 2 || members.some((x) => !x.effort)) {
+      for (const r of members) out.push({ ...base0, id: r.id, name: r.name, efforts: [] });
+      continue;
+    }
+    const efforts = members.map((x) => x.effort).sort((a, b) => EFFORTS.indexOf(a) - EFFORTS.indexOf(b));
+    out.push({
+      ...base0,
+      id: base,
+      name: first.name.replace(/\s*\([^)]*\)\s*$/, ""),
+      efforts: efforts.map((id) => ({ id, label: id.charAt(0).toUpperCase() + id.slice(1) })),
+      defaultEffort: efforts.includes("high") ? "high" : efforts[0]
+    });
+  }
+  return out;
+}
+function toUsage2(u) {
+  if (!u) return void 0;
+  const input = u.input_tokens ?? 0;
+  const output2 = u.output_tokens ?? 0;
+  return {
+    inputTokens: input,
+    outputTokens: output2,
+    cachedInputTokens: u.cache_read_tokens || void 0,
+    reasoningTokens: u.thinking_tokens || void 0,
+    totalTokens: u.total_tokens ?? input + output2
+  };
+}
+function createMapper() {
+  const started = /* @__PURE__ */ new Set();
+  let deniedSeen = 0;
+  let finished = false;
+  return {
+    get finished() {
+      return finished;
+    },
+    map(line) {
+      const o = line;
+      if (!o || typeof o !== "object") return [];
+      if (o.event === "init") {
+        const id = o.conversation_id;
+        return id ? [{ type: "session", sessionId: id, model: o.init?.model }] : [];
+      }
+      if (o.event === "step_update") {
+        const s = o.step_update;
+        if (s.step_type === "agent_response") {
+          return s.text_delta ? [{ type: "text.delta", text: s.text_delta }] : [];
+        }
+        if (s.step_type !== "tool") return [];
+        const id = `${s.conversation_id}:${s.step_index}`;
+        const name = s.tool_name ?? s.tool_info?.name ?? "tool";
+        const events = [];
+        if (!started.has(id)) {
+          started.add(id);
+          events.push({ type: "tool.start", id, name, input: s.tool_info?.parameters });
+        }
+        if (s.state === "DONE") events.push({ type: "tool.end", id });
+        if (s.state === "ERROR") {
+          const msg = String(s.tool_info?.error?.message ?? "tool failed").split("\n")[0] ?? "tool failed";
+          const denied = /denied permission|permission check failed/i.test(msg);
+          if (denied) deniedSeen++;
+          events.push({ type: "tool.end", id, error: denied ? `denied: ${msg}` : msg });
+        }
+        return events;
+      }
+      if (o.event === "result") {
+        finished = true;
+        const r = o.result;
+        if (r.status === "ERROR" || r.error) {
+          return [{ type: "error", message: String(r.error ?? "Antigravity run failed."), code: "cli-failed" }];
+        }
+        const events = [];
+        const denied = r.denied_actions ?? [];
+        denied.slice(deniedSeen).forEach((d, i) => {
+          const id = `denied:${i}`;
+          const name = d.display_name ?? d.action;
+          events.push({ type: "tool.start", id, name });
+          events.push({ type: "tool.end", id, error: `denied: ${d.action} needs permission that headless mode cannot ask for` });
+        });
+        const usage = toUsage2(r.usage);
+        if (usage) events.push({ type: "usage", usage });
+        const text = r.response ?? "";
+        events.push({ type: "done", text, finishReason: denied.length && !text.trim() ? "denied" : "stop" });
+        return events;
+      }
+      return [];
+    }
+  };
+}
+
+// src/providers/antigravity/index.ts
+var TOKEN_FILE = join2(homedir2(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
+var TESTED = { min: "1.2.0" };
+function toCliModel2(selection, models2 = []) {
+  const info = models2.find((m) => m.id === selection.model);
+  const effort = selection.effort ?? (info?.efforts.length ? info.defaultEffort : void 0);
+  return { model: selection.model, effort };
+}
+function buildArgs3(input, models2 = []) {
+  const { selection } = input;
+  const { model, effort } = toCliModel2(selection, models2);
+  const args = ["--print=" + input.prompt, "--output-format", "stream-json", "--model", model];
+  if (effort) args.push("--effort", effort);
+  if (selection.access === "accept-edits") args.push("--mode", "accept-edits");
+  if (selection.access === "full") args.push("--dangerously-skip-permissions");
+  if (input.sessionId) args.push("--conversation", input.sessionId);
+  return args;
+}
+async function loadManifestModels() {
+  return fromManifest(await loadBundledManifest(), "antigravity");
+}
+async function authStatus4() {
+  const path = findBinary("agy");
+  if (!path) return { loggedIn: false, detail: "agy is not installed." };
+  const apiKey = !!process.env.GEMINI_API_KEY;
+  if (!apiKey && !existsSync4(TOKEN_FILE)) return { loggedIn: false, detail: "Run agy in a terminal and sign in." };
+  const res = await exec(path, ["models"], { timeoutMs: 2e4 }).catch(() => void 0);
+  const ok = !!res && res.code === 0 && parseModels(res.stdout).length > 0;
+  return ok ? { loggedIn: true, method: apiKey ? "Gemini API key" : "Google account" } : { loggedIn: false, detail: "agy could not list models. Sign in again." };
+}
+function login(options = {}) {
+  const channel = new Channel();
+  let cancelled = false;
+  const cancel = () => {
+    cancelled = true;
+    channel.end();
+  };
+  options.signal?.addEventListener("abort", cancel, { once: true });
+  channel.push({ type: "needs-terminal", command: ["agy"] });
+  void (async () => {
+    const deadline = Date.now() + 10 * 6e4;
+    while (!cancelled && Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 2e3));
+      if (cancelled) return;
+      const status = await authStatus4();
+      if (status.loggedIn) {
+        channel.push({ type: "done", status });
+        return channel.end();
+      }
+    }
+    if (!cancelled) channel.push({ type: "error", message: "Timed out waiting for sign-in." });
+    channel.end();
+  })();
+  return { [Symbol.asyncIterator]: () => channel[Symbol.asyncIterator](), sendCode: () => {
+  }, cancel };
+}
+async function* run4(input) {
+  const path = findBinary("agy");
+  if (!path) throw new FunnelError("agy is not installed.", "not-installed");
+  const models2 = await loadManifestModels();
+  const stream = spawnStream(path, buildArgs3(input, models2), {
+    cwd: input.selection.cwd,
+    env: input.env,
+    signal: input.signal,
+    input: ""
+  });
+  const mapper = createMapper();
+  for await (const line of stream.lines) {
+    for (const e of mapper.map(line)) yield e;
+  }
+  const code = await stream.exited;
+  if (mapper.finished) return;
+  if (input.signal?.aborted) return void (yield { type: "done", text: "", finishReason: "cancelled" });
+  const detail = stream.stderr().trim().split("\n").slice(-3).join(" ");
+  yield { type: "error", message: `agy exited (${code}) without a result. ${detail}`.trim(), code: "cli-failed" };
+}
+var antigravityProvider = {
+  id: "antigravity",
+  displayName: "Antigravity",
+  binary: "agy",
+  capabilities: { access: ["accept-edits", "full"], effort: true, contextWindow: false, fast: false, resume: true, approvals: false },
+  detect: () => detectInstallation("agy", TESTED),
+  authStatus: authStatus4,
+  login,
+  async logout() {
+    throw new FunnelError(
+      "agy has no sign-out command. Run agy, open its account menu to sign out, or delete the token file in ~/.gemini/antigravity-cli/.",
+      "unsupported"
+    );
+  },
+  update: () => runUpdate("agy", ["update"]),
+  async models() {
+    const fallback = await loadManifestModels();
+    const path = findBinary("agy");
+    if (!path) return fallback;
+    const res = await exec(path, ["models"], { timeoutMs: 2e4 }).catch(() => void 0);
+    const live = res && res.code === 0 ? parseModels(res.stdout) : [];
+    return live.length ? mergeModels(live, fallback) : fallback;
+  },
+  run: run4
+};
+
+// src/providers/index.ts
+var PROVIDERS = {
+  claude: claudeProvider,
+  codex: codexProvider,
+  agent: agentProvider,
+  antigravity: antigravityProvider,
+  ...createApiProviders()
+};
+
+// src/funnel.ts
+function createFunnel(options = {}) {
+  const registry = { ...PROVIDERS, ...options.apiKeys ? createApiProviders(options.apiKeys) : {}, ...options.providers };
+  const provider = (id) => {
+    const p = registry[id];
+    if (!p) throw new FunnelError(`Unknown provider "${id}".`, "invalid-selection");
+    return p;
+  };
+  async function prepare(input) {
+    const p = provider(input.selection.provider);
+    const install = await p.detect();
+    if (!install.installed) throw new FunnelError(`${p.displayName} CLI is not installed.`, "not-installed");
+    const models2 = options.allowUnlistedModels ? void 0 : await p.models();
+    validateSelection(input.selection, p, models2);
+    if (input.selection.access === "supervised" && !input.onApproval) {
+      throw new FunnelError('access "supervised" needs an onApproval callback.', "invalid-selection");
+    }
+    return p;
+  }
+  function stream(input) {
+    const events = (async function* () {
+      const p = await prepare(input);
+      yield* p.run(input);
+    })();
+    const buffered = [];
+    let resolveDone;
+    const done = new Promise((r) => resolveDone = r);
+    let failure2;
+    const iterable = {
+      async *[Symbol.asyncIterator]() {
+        try {
+          for await (const e of events) {
+            buffered.push(e);
+            yield e;
+          }
+        } catch (err) {
+          failure2 = err;
+          throw err;
+        } finally {
+          resolveDone();
+        }
+      }
+    };
+    const result = (async () => {
+      await done;
+      if (failure2) throw failure2;
+      return collect(
+        (async function* () {
+          yield* buffered;
+        })(),
+        input
+      );
+    })();
+    result.catch(() => {
+    });
+    return Object.assign(iterable, { result });
+  }
+  return {
+    providers: registry,
+    /** Installed and logged-in state for every provider, for a provider picker. */
+    async overview() {
+      return Promise.all(
+        Object.values(registry).map(async (p) => {
+          const installation = await (async () => p.detect())().catch(() => ({ installed: false, testedRange: { min: "0" } }));
+          const auth = installation.installed ? await (async () => p.authStatus())().catch(() => void 0) : void 0;
+          return { id: p.id, displayName: p.displayName, capabilities: p.capabilities, installation, auth };
+        })
+      );
+    },
+    models: async (id) => provider(id).models(),
+    authStatus: async (id) => provider(id).authStatus(),
+    login: (id, opts) => provider(id).login(opts),
+    logout: async (id) => provider(id).logout(),
+    update: async (id) => provider(id).update(),
+    manifest: () => loadManifest(options.manifestUrl),
+    stream,
+    /** Runs one turn and resolves with the final text, usage and tool calls. */
+    async run(input) {
+      const s = stream(input);
+      for await (const _ of s) {
+      }
+      return s.result;
+    }
+  };
+}
+
+export {
+  loadManifest,
+  validateSelection,
+  createApiProviders,
+  PROVIDERS,
+  createFunnel
+};