@justin06lee/yagami 0.4.1

package/dist/chunk-ASS6MJ7C.js

@@ -0,0 +1,1821 @@
+// src/core/types.ts
+var ApiError = class extends Error {
+  constructor(status, type, message) {
+    super(message);
+    this.status = status;
+    this.type = type;
+    this.name = "ApiError";
+  }
+  status;
+  type;
+  toBody() {
+    return { type: "error", error: { type: this.type, message: this.message } };
+  }
+};
+
+// src/core/errors.ts
+var YagamiError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "YagamiError";
+  }
+  code;
+};
+var ProviderNotInstalledError = class extends YagamiError {
+  constructor(provider, installHint, detail) {
+    super(
+      `${provider}: CLI not found${detail ? ` (${detail})` : ""}. ${installHint}`,
+      "provider_not_installed"
+    );
+    this.provider = provider;
+    this.installHint = installHint;
+    this.name = "ProviderNotInstalledError";
+  }
+  provider;
+  installHint;
+};
+var AuthRequiredError = class extends YagamiError {
+  constructor(provider, loginCommand, detail) {
+    super(
+      `${provider}: not logged in${detail ? ` (${detail})` : ""}. Run: ${loginCommand}`,
+      "auth_required"
+    );
+    this.provider = provider;
+    this.loginCommand = loginCommand;
+    this.name = "AuthRequiredError";
+  }
+  provider;
+  loginCommand;
+};
+var ProviderError = class extends YagamiError {
+  constructor(provider, message) {
+    super(`${provider}: ${message}`, "provider_error");
+    this.provider = provider;
+    this.name = "ProviderError";
+  }
+  provider;
+};
+var AUTH_PATTERNS = [
+  /not logged in/i,
+  /login required/i,
+  /please (run|use) [`'"]?\/?login/i,
+  /invalid api key/i,
+  /authentication[_ ]error/i,
+  /auth(entication)? required/i,
+  /not authenticated/i,
+  /unauthorized/i,
+  /credentials? (are|is) (missing|invalid|expired)/i,
+  /token (has )?expired/i,
+  /no credentials/i
+];
+function looksLikeAuthFailure(text) {
+  return AUTH_PATTERNS.some((re) => re.test(text));
+}
+function classifyProviderFailure(provider, loginCommand, err) {
+  if (err instanceof YagamiError) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  if (looksLikeAuthFailure(message)) {
+    return new AuthRequiredError(provider, loginCommand, message.split("\n")[0]?.slice(0, 200));
+  }
+  return new ProviderError(provider, message);
+}
+function toApiError(err) {
+  if (err instanceof ApiError) return err;
+  if (err instanceof AuthRequiredError || err instanceof ProviderNotInstalledError) {
+    return new ApiError(503, "api_error", err.message);
+  }
+  if (err instanceof YagamiError) return new ApiError(500, "api_error", err.message);
+  const message = err instanceof Error ? err.message : String(err);
+  return new ApiError(500, "api_error", `engine error: ${message}`);
+}
+
+// src/core/provider.ts
+function parseModelRef(model, providerIds) {
+  if (!model) return {};
+  const ids = new Set(providerIds);
+  if (ids.has(model)) return { providerId: model };
+  const colon = model.indexOf(":");
+  if (colon > 0) {
+    const prefix = model.slice(0, colon);
+    if (ids.has(prefix)) {
+      const rest = model.slice(colon + 1);
+      return rest ? { providerId: prefix, model: rest } : { providerId: prefix };
+    }
+  }
+  return { model };
+}
+function qualifiedModel(providerId, model) {
+  return `${providerId}:${model}`;
+}
+
+// src/core/executable.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+function expandHome(p) {
+  if (p === "~") return os.homedir();
+  if (p.startsWith("~/")) return path.join(os.homedir(), p.slice(2));
+  return p;
+}
+function isFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function commonBinDirs() {
+  const home = os.homedir();
+  return [
+    path.join(home, ".local", "bin"),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    path.join(home, ".npm-global", "bin"),
+    path.join(home, "bin"),
+    path.join(home, ".bun", "bin"),
+    path.join(home, ".cargo", "bin")
+  ];
+}
+function findExecutable(name, options = {}) {
+  if (options.explicit) {
+    const p = expandHome(options.explicit);
+    return isFile(p) ? p : void 0;
+  }
+  if (name.includes("/")) {
+    const p = expandHome(name);
+    return isFile(p) ? p : void 0;
+  }
+  for (const dir of (process.env["PATH"] ?? "").split(path.delimiter)) {
+    if (!dir) continue;
+    const candidate = path.join(dir, name);
+    if (isFile(candidate)) return candidate;
+  }
+  for (const dir of commonBinDirs()) {
+    const candidate = path.join(dir, name);
+    if (isFile(candidate)) return candidate;
+  }
+  for (const candidate of options.extraPaths ?? []) {
+    if (isFile(expandHome(candidate))) return expandHome(candidate);
+  }
+  return void 0;
+}
+function resolveExecutable(providerId, name, installHint, options = {}) {
+  const found = findExecutable(name, options);
+  if (found) return found;
+  const detail = options.explicit ? `configured path ${options.explicit} does not exist` : `\`${name}\` not on PATH`;
+  throw new ProviderNotInstalledError(providerId, installHint, detail);
+}
+function resolveClaudeExecutable(explicit) {
+  const configured = explicit ?? process.env["YAGAMI_CLAUDE_PATH"];
+  return resolveExecutable(
+    "claude",
+    "claude",
+    "Install Claude Code and sign in (run `claude`, then /login), or point yagami at it with YAGAMI_CLAUDE_PATH or providers.claude.path.",
+    {
+      ...configured ? { explicit: configured } : {},
+      extraPaths: [path.join(os.homedir(), ".claude", "local", "claude")]
+    }
+  );
+}
+
+// src/version.ts
+var VERSION = "0.4.1";
+
+// src/core/providers/acp.ts
+import { spawn, spawnSync } from "child_process";
+import * as fs2 from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
+import * as readline from "readline";
+import { PassThrough, Readable, Writable } from "stream";
+import {
+  ClientSideConnection,
+  ndJsonStream,
+  PROTOCOL_VERSION
+} from "@agentclientprotocol/sdk";
+
+// src/core/providers/queue.ts
+var AsyncQueue = class {
+  buffer = [];
+  waiting = null;
+  ended = false;
+  error = void 0;
+  push(value) {
+    if (this.ended) return;
+    if (this.waiting) {
+      const w = this.waiting;
+      this.waiting = null;
+      w.resolve({ value, done: false });
+    } else {
+      this.buffer.push(value);
+    }
+  }
+  end() {
+    if (this.ended) return;
+    this.ended = true;
+    if (this.waiting) {
+      const w = this.waiting;
+      this.waiting = null;
+      w.resolve({ value: void 0, done: true });
+    }
+  }
+  fail(err) {
+    if (this.ended) return;
+    this.error = err;
+    this.ended = true;
+    if (this.waiting) {
+      const w = this.waiting;
+      this.waiting = null;
+      w.reject(err);
+    }
+  }
+  get closed() {
+    return this.ended;
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this.buffer.length > 0) return Promise.resolve({ value: this.buffer.shift(), done: false });
+        if (this.error !== void 0) {
+          const e = this.error;
+          this.error = void 0;
+          return Promise.reject(e);
+        }
+        if (this.ended) return Promise.resolve({ value: void 0, done: true });
+        return new Promise((resolve, reject) => {
+          this.waiting = { resolve, reject };
+        });
+      },
+      return: () => {
+        this.ended = true;
+        return Promise.resolve({ value: void 0, done: true });
+      }
+    };
+  }
+};
+
+// src/core/providers/acp.ts
+function rejectOption(p) {
+  const pick = p.options.find((o) => o.kind === "reject_once") ?? p.options.find((o) => o.kind === "reject_always") ?? p.options[0];
+  if (!pick) return { outcome: { outcome: "cancelled" } };
+  return { outcome: { outcome: "selected", optionId: pick.optionId } };
+}
+var AcpProvider = class {
+  id;
+  label;
+  executable;
+  loginCommand;
+  capabilities = {
+    resume: true,
+    fork: false,
+    images: true,
+    documents: false,
+    systemPrompt: false,
+    thinking: false,
+    effort: false,
+    streaming: "tokens"
+  };
+  args;
+  env;
+  workDir;
+  appName;
+  modelConfigId;
+  connectImpl;
+  constructor(options) {
+    this.id = options.id;
+    this.label = options.label;
+    this.loginCommand = options.loginCommand ?? `${options.command} (sign in per its docs)`;
+    this.executable = options.connect ? options.path ?? options.command : resolveExecutable(options.id, options.command, options.installHint ?? `Install \`${options.command}\` and sign in.`, {
+      ...options.path ? { explicit: options.path } : {}
+    });
+    this.args = options.args ?? [];
+    this.env = { ...process.env, ...options.env };
+    this.workDir = options.workDir ?? path2.join(os2.tmpdir(), "yagami-workspace");
+    this.appName = options.appName ?? "yagami";
+    this.modelConfigId = options.modelConfigId ?? "model";
+    this.connectImpl = options.connect ?? ((cwd) => this.spawnConnection(cwd));
+    fs2.mkdirSync(this.workDir, { recursive: true });
+  }
+  spawnConnection(cwd) {
+    return new Promise((resolve, reject) => {
+      let child;
+      try {
+        child = spawn(this.executable, this.args, { cwd, env: this.env, stdio: ["pipe", "pipe", "pipe"] });
+      } catch (err) {
+        reject(classifyProviderFailure(this.id, this.loginCommand, err));
+        return;
+      }
+      let stderr = "";
+      const noteNoise = (d) => {
+        stderr += d;
+        if (stderr.length > 16e3) stderr = stderr.slice(-8e3);
+      };
+      child.stderr?.on("data", (d) => noteNoise(d.toString()));
+      let handlers = {};
+      const stream = ndJsonStream(
+        Writable.toWeb(child.stdin),
+        Readable.toWeb(jsonLinesOnly(child.stdout, noteNoise))
+      );
+      const agent = new ClientSideConnection(
+        () => ({
+          requestPermission: (p) => handlers.onPermission ? handlers.onPermission(p) : rejectOption(p),
+          sessionUpdate: (n) => {
+            handlers.onUpdate?.(n);
+          }
+        }),
+        stream
+      );
+      let settled = false;
+      child.on("error", (err) => {
+        if (settled) return;
+        settled = true;
+        reject(classifyProviderFailure(this.id, this.loginCommand, err));
+      });
+      child.on("exit", (code) => {
+        if (settled) return;
+        settled = true;
+        reject(classifyProviderFailure(this.id, this.loginCommand, new Error(`${this.executable} exited with code ${code}${stderr ? `: ${stderr.trim().slice(-400)}` : ""}`)));
+      });
+      agent.initialize({
+        protocolVersion: PROTOCOL_VERSION,
+        clientInfo: { name: this.appName, version: VERSION },
+        clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false }
+      }).then((init) => {
+        if (settled) return;
+        settled = true;
+        resolve({
+          agent,
+          init,
+          setHandlers: (h) => {
+            handlers = h;
+          },
+          close: () => {
+            child.kill("SIGTERM");
+          }
+        });
+      }).catch((err) => {
+        if (settled) return;
+        settled = true;
+        child.kill("SIGTERM");
+        reject(this.classify(err, stderr));
+      });
+    });
+  }
+  classify(err, context = "") {
+    const message = err instanceof Error ? err.message : String(err);
+    const code = err?.code;
+    if (code === -32e3 || looksLikeAuthFailure(message) || looksLikeAuthFailure(context)) {
+      return new AuthRequiredError(this.id, this.loginCommand, message.slice(0, 200));
+    }
+    return classifyProviderFailure(this.id, this.loginCommand, err);
+  }
+  async *run(req) {
+    const conn = await this.connectImpl(this.workDir);
+    const queue = new AsyncQueue();
+    let sessionId;
+    let costUsd;
+    const onAbort = () => {
+      if (sessionId) void conn.agent.cancel({ sessionId }).catch(() => {
+      });
+    };
+    try {
+      let configOptions;
+      let modes;
+      if (req.resume) {
+        if (!supportsResume(conn.init)) {
+          throw new ProviderError(this.id, "this agent cannot resume sessions; replaying the transcript instead");
+        }
+        const resumed = await conn.agent.resumeSession({ sessionId: req.resume, cwd: this.workDir }).catch((err) => {
+          throw this.classify(err);
+        });
+        sessionId = req.resume;
+        configOptions = resumed.configOptions;
+        modes = resumed.modes;
+      } else {
+        const created = await conn.agent.newSession({ cwd: this.workDir, mcpServers: [] }).catch((err) => {
+          throw this.classify(err);
+        });
+        sessionId = created.sessionId;
+        configOptions = created.configOptions;
+        modes = created.modes;
+      }
+      yield { type: "session", sessionId };
+      const plan = modes?.availableModes?.find((m) => /^(plan|read[-_]?only|ask)$/i.test(m.id));
+      if (plan && modes?.currentModeId !== plan.id) {
+        await conn.agent.setSessionMode({ sessionId, modeId: plan.id }).catch(() => {
+        });
+      }
+      if (req.model) await this.selectModel(conn, sessionId, configOptions, req.model);
+      const sid = sessionId;
+      conn.setHandlers({
+        onPermission: async (p) => rejectOption(p),
+        onUpdate: (n) => {
+          if (n.sessionId !== sid) return;
+          const u = n.update;
+          if (u.sessionUpdate === "agent_message_chunk" && u.content.type === "text") {
+            queue.push({ type: "text", text: u.content.text });
+          } else if (u.sessionUpdate === "agent_thought_chunk" && u.content.type === "text") {
+            queue.push({ type: "thinking", text: u.content.text });
+          } else if (u.sessionUpdate === "usage_update") {
+            const cost = u.cost;
+            if (cost && typeof cost.amount === "number" && (cost.currency ?? "USD") === "USD") costUsd = cost.amount;
+          }
+        }
+      });
+      req.signal?.addEventListener("abort", onAbort, { once: true });
+      conn.agent.prompt({ sessionId, prompt: toAcpBlocks(req.prompt, req.media ?? [], this.id) }).then((res) => {
+        queue.push({
+          type: "done",
+          usage: mapAcpUsage(res.usage ?? void 0),
+          ...costUsd !== void 0 ? { costUsd } : {},
+          stopReason: mapStopReason(res.stopReason)
+        });
+        queue.end();
+      }).catch((err) => queue.fail(this.classify(err)));
+      for await (const ev of queue) yield ev;
+    } finally {
+      req.signal?.removeEventListener("abort", onAbort);
+      conn.close();
+    }
+  }
+  async selectModel(conn, sessionId, configOptions, model) {
+    const option = configOptions?.find((o) => o.id === this.modelConfigId) ?? configOptions?.find((o) => o.category === "model");
+    if (!option || option.type !== "select") {
+      throw new ProviderError(this.id, `cannot select model "${model}": the agent exposes no model option (omit the model to use its default)`);
+    }
+    if (option.currentValue === model) return;
+    await conn.agent.setSessionConfigOption({ sessionId, configId: option.id, value: model }).catch((err) => {
+      throw this.classify(err);
+    });
+  }
+  async listModels() {
+    const conn = await this.connectImpl(this.workDir);
+    try {
+      const created = await conn.agent.newSession({ cwd: this.workDir, mcpServers: [] }).catch((err) => {
+        throw this.classify(err);
+      });
+      const option = created.configOptions?.find((o) => o.id === this.modelConfigId) ?? created.configOptions?.find((o) => o.category === "model");
+      if (!option || option.type !== "select") return [];
+      return flattenSelectOptions(option).map((o) => ({
+        id: o.value,
+        display_name: o.name,
+        ...o.description ? { description: o.description } : {}
+      }));
+    } finally {
+      conn.close();
+    }
+  }
+  /**
+   * The agent's self-reported name/version from the ACP handshake. When the
+   * handshake fails (wrong binary, version too old for ACP), falls back to
+   * `--version` and says so, because that is exactly what `doctor` needs.
+   */
+  async version() {
+    let handshakeError;
+    try {
+      const conn = await this.connectImpl(this.workDir);
+      try {
+        const info = conn.init.agentInfo;
+        if (info?.version) return `${info.name ?? this.id} ${info.version}`;
+        return `${this.id} (ACP ok)`;
+      } finally {
+        conn.close();
+      }
+    } catch (err) {
+      handshakeError = (err instanceof Error ? err.message : String(err)).split("\n")[0]?.slice(0, 120);
+    }
+    let plain;
+    try {
+      const out = spawnSync(this.executable, ["--version"], { encoding: "utf8", timeout: 1e4 });
+      plain = out.stdout?.trim().split("\n")[0] || void 0;
+    } catch {
+      plain = void 0;
+    }
+    return `${plain ?? "unknown version"} \u26A0 no ACP handshake (${handshakeError ?? "unknown error"}) \u2014 too old, or a different program with the same name?`;
+  }
+};
+function supportsResume(init) {
+  const caps = init.agentCapabilities;
+  return caps?.sessionCapabilities?.resume !== void 0;
+}
+function flattenSelectOptions(option) {
+  const raw = option.options;
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const entry of raw) {
+    if (typeof entry["value"] === "string") {
+      out.push({ value: entry["value"], name: String(entry["name"] ?? entry["value"]), description: entry["description"] });
+    } else if (Array.isArray(entry["options"])) {
+      for (const leaf of entry["options"]) {
+        if (typeof leaf["value"] === "string") {
+          out.push({ value: leaf["value"], name: String(leaf["name"] ?? leaf["value"]), description: leaf["description"] });
+        }
+      }
+    }
+  }
+  return out;
+}
+function toAcpBlocks(text, media, providerId) {
+  const blocks = [];
+  for (const block of media) {
+    if (block.type !== "image") continue;
+    const source = block["source"];
+    if (source?.type !== "base64" || typeof source.data !== "string") {
+      throw new ProviderError(providerId, "only base64 image sources are supported (URL images are not fetched)");
+    }
+    blocks.push({ type: "image", data: source.data, mimeType: source.media_type ?? "image/png" });
+  }
+  if (text.length > 0 || blocks.length === 0) blocks.push({ type: "text", text });
+  return blocks;
+}
+function mapAcpUsage(u) {
+  const num = (k) => typeof u?.[k] === "number" ? u[k] : 0;
+  return {
+    input_tokens: num("inputTokens"),
+    output_tokens: num("outputTokens"),
+    cache_read_input_tokens: num("cachedReadTokens") || num("cacheReadTokens"),
+    cache_creation_input_tokens: num("cachedWriteTokens") || num("cacheWriteTokens")
+  };
+}
+function mapStopReason(reason) {
+  switch (reason) {
+    case "max_tokens":
+      return "max_tokens";
+    case "refusal":
+      return "refusal";
+    default:
+      return "end_turn";
+  }
+}
+function jsonLinesOnly(input, onNoise) {
+  const out = new PassThrough();
+  const rl = readline.createInterface({ input, crlfDelay: Infinity });
+  rl.on("line", (line) => {
+    if (line.trimStart().startsWith("{")) out.write(`${line}
+`);
+    else if (line.trim()) onNoise(`${line}
+`);
+  });
+  rl.on("close", () => out.end());
+  return out;
+}
+
+// src/core/providers/claude.ts
+import { createRequire } from "module";
+import { spawnSync as spawnSync2 } from "child_process";
+import * as fs3 from "fs";
+import * as os3 from "os";
+import * as path3 from "path";
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
+var DENY_ALL_TOOLS = async (toolName) => ({
+  behavior: "deny",
+  message: `yagami is a completions-only endpoint; tool "${toolName}" is disabled.`,
+  interrupt: true
+});
+var ClaudeProvider = class {
+  id = "claude";
+  label = "Claude Code";
+  executable;
+  loginCommand = "claude (then /login)";
+  capabilities = {
+    resume: true,
+    fork: true,
+    images: true,
+    documents: true,
+    systemPrompt: true,
+    thinking: true,
+    effort: true,
+    streaming: "tokens"
+  };
+  configDir;
+  workDir;
+  appName;
+  constructor(options = {}) {
+    this.executable = resolveClaudeExecutable(options.path);
+    this.configDir = options.configDir;
+    this.appName = options.appName ?? "yagami";
+    this.workDir = options.workDir ?? path3.join(os3.tmpdir(), "yagami-workspace");
+    fs3.mkdirSync(this.workDir, { recursive: true });
+  }
+  /** Hardened options shared by every completion turn and probe. */
+  baseOptions() {
+    return {
+      pathToClaudeCodeExecutable: this.executable,
+      cwd: this.workDir,
+      // Pure completions: no built-in tools, no settings/CLAUDE.md/skills
+      // leaking in, exactly one assistant turn per request.
+      tools: [],
+      settingSources: [],
+      maxTurns: 1,
+      canUseTool: DENY_ALL_TOOLS,
+      env: {
+        ...process.env,
+        ...this.configDir ? { CLAUDE_CONFIG_DIR: this.configDir } : {},
+        CLAUDE_AGENT_SDK_CLIENT_APP: `${this.appName}/${VERSION}`
+      }
+    };
+  }
+  async *run(req) {
+    const abortController = new AbortController();
+    const onAbort = () => abortController.abort();
+    req.signal?.addEventListener("abort", onAbort, { once: true });
+    const options = { ...this.baseOptions(), abortController, includePartialMessages: true };
+    if (req.model) options.model = req.model;
+    if (req.system !== void 0) options.systemPrompt = req.system;
+    if (req.resume) {
+      options.resume = req.resume;
+      options.forkSession = true;
+    }
+    const thinking = mapThinking(req.thinking);
+    if (thinking) options.thinking = thinking;
+    if (req.effort) options.effort = req.effort;
+    const prompt = req.media && req.media.length > 0 ? mediaPrompt(req.prompt, req.media) : req.prompt;
+    let result;
+    let model;
+    let stopReason;
+    let sawText = false;
+    try {
+      for await (const msg of query({ prompt, options })) {
+        if (msg.type === "system" && msg.subtype === "init") {
+          yield { type: "session", sessionId: msg.session_id };
+        } else if (msg.type === "stream_event" && msg.parent_tool_use_id === null) {
+          const event = msg.event;
+          if (event.type !== "content_block_delta") continue;
+          const delta = event["delta"];
+          if (delta?.type === "text_delta" && typeof delta.text === "string") {
+            sawText = true;
+            yield { type: "text", text: delta.text };
+          } else if (delta?.type === "thinking_delta" && typeof delta.thinking === "string") {
+            yield { type: "thinking", text: delta.thinking };
+          }
+        } else if (msg.type === "assistant" && msg.parent_tool_use_id === null) {
+          const raw = msg.message;
+          if (typeof raw.model === "string") model = raw.model;
+          if (typeof raw.stop_reason === "string") stopReason = raw.stop_reason;
+        } else if (msg.type === "result") {
+          result = msg;
+        }
+      }
+    } catch (err) {
+      throw classifyProviderFailure(this.id, this.loginCommand, err);
+    } finally {
+      req.signal?.removeEventListener("abort", onAbort);
+    }
+    if (req.signal?.aborted) return;
+    if (!result) throw new ProviderError(this.id, "engine terminated without producing a result");
+    if (result.subtype !== "success") {
+      const detail = "errors" in result && result.errors.length > 0 ? result.errors.join("; ") : result.subtype;
+      throw classifyProviderFailure(this.id, this.loginCommand, new Error(`engine error: ${detail}`));
+    }
+    if (!sawText && result.result) yield { type: "text", text: result.result };
+    yield {
+      type: "done",
+      usage: mapUsage(result.usage),
+      ...result.total_cost_usd !== void 0 ? { costUsd: result.total_cost_usd } : {},
+      ...model ? { model } : {},
+      ...stopReason ? { stopReason } : {}
+    };
+  }
+  /** Ask the CLI which models it supports via a short-lived control session. */
+  async listModels() {
+    const abortController = new AbortController();
+    let release;
+    const gate = new Promise((resolve) => release = resolve);
+    const idle = (async function* () {
+      await gate;
+    })();
+    const q = query({ prompt: idle, options: { ...this.baseOptions(), abortController } });
+    let timer;
+    try {
+      const models = await Promise.race([
+        q.supportedModels(),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error("timed out probing supported models")), 15e3);
+          timer.unref?.();
+        })
+      ]);
+      return models.map((m) => ({
+        id: m.value,
+        display_name: m.displayName,
+        ...m.description ? { description: m.description } : {},
+        ...m.resolvedModel ? { resolved_model: m.resolvedModel } : {}
+      }));
+    } catch (err) {
+      throw classifyProviderFailure(this.id, this.loginCommand, err);
+    } finally {
+      if (timer) clearTimeout(timer);
+      release();
+      abortController.abort();
+    }
+  }
+  async version() {
+    try {
+      const out = spawnSync2(this.executable, ["--version"], { encoding: "utf8", timeout: 1e4 });
+      return out.stdout?.trim().split("\n")[0] || void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Compare the bundled Agent SDK build against the installed CLI. Their
+   * last version components track the same build number when in sync.
+   */
+  async versionSkew() {
+    const binary = await this.version();
+    const sdk = sdkVersion();
+    if (!binary || !sdk) return void 0;
+    const binaryVersion = binary.match(/\d+\.\d+\.\d+/)?.[0];
+    if (!binaryVersion) return void 0;
+    const sdkBuild = sdk.split(".").pop();
+    const binBuild = binaryVersion.split(".").pop();
+    const inSync = sdkBuild === binBuild;
+    return {
+      sdkVersion: sdk,
+      binaryVersion,
+      inSync,
+      note: inSync ? "Agent SDK and claude binary are the same build" : `Agent SDK ${sdk} was built alongside claude x.y.${sdkBuild}; you run ${binaryVersion}. Usually fine \u2014 update whichever is older if something misbehaves.`
+    };
+  }
+};
+function sdkVersion() {
+  try {
+    const req = createRequire(import.meta.url);
+    const entry = req.resolve("@anthropic-ai/claude-agent-sdk");
+    let dir = path3.dirname(entry);
+    for (let i = 0; i < 4; i += 1) {
+      const pkg = path3.join(dir, "package.json");
+      if (fs3.existsSync(pkg)) {
+        const parsed = JSON.parse(fs3.readFileSync(pkg, "utf8"));
+        if (parsed.name === "@anthropic-ai/claude-agent-sdk") return parsed.version;
+      }
+      dir = path3.dirname(dir);
+    }
+  } catch {
+  }
+  return void 0;
+}
+function mapThinking(t) {
+  if (t == null) return void 0;
+  if (t.type === "enabled") {
+    return typeof t.budget_tokens === "number" ? { type: "enabled", budgetTokens: t.budget_tokens } : { type: "enabled" };
+  }
+  if (t.type === "disabled") return { type: "disabled" };
+  return { type: "adaptive" };
+}
+function mapUsage(usage) {
+  const num = (key) => typeof usage[key] === "number" ? usage[key] : void 0;
+  return {
+    input_tokens: num("input_tokens") ?? 0,
+    output_tokens: num("output_tokens") ?? 0,
+    cache_creation_input_tokens: num("cache_creation_input_tokens") ?? 0,
+    cache_read_input_tokens: num("cache_read_input_tokens") ?? 0
+  };
+}
+function mediaPrompt(text, media) {
+  const content = [...media, ...text.length > 0 ? [{ type: "text", text }] : []];
+  const message = {
+    type: "user",
+    message: { role: "user", content },
+    parent_tool_use_id: null
+  };
+  return (async function* () {
+    yield message;
+  })();
+}
+
+// src/core/providers/codex.ts
+import { spawn as spawn3, spawnSync as spawnSync3 } from "child_process";
+import * as fs4 from "fs";
+import * as os4 from "os";
+import * as path4 from "path";
+import * as readline3 from "readline";
+
+// src/core/providers/jsonl.ts
+import { spawn as spawn2 } from "child_process";
+import * as readline2 from "readline";
+var ProcessExitError = class extends Error {
+  constructor(exitCode, stderr) {
+    super(`process exited with code ${exitCode}${stderr ? `: ${stderr.trim().split("\n").slice(-3).join(" | ")}` : ""}`);
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+    this.name = "ProcessExitError";
+  }
+  exitCode;
+  stderr;
+};
+function spawnJsonl(options) {
+  const queue = new AsyncQueue();
+  const child = spawn2(options.command, options.args, {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: [options.stdin !== void 0 ? "pipe" : "ignore", "pipe", "pipe"]
+  });
+  let stderr = "";
+  child.stderr?.on("data", (chunk) => {
+    stderr += chunk.toString();
+    if (stderr.length > 16e3) stderr = stderr.slice(-8e3);
+  });
+  const rl = readline2.createInterface({ input: child.stdout, crlfDelay: Infinity });
+  rl.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) return;
+    try {
+      queue.push(JSON.parse(trimmed));
+    } catch {
+    }
+  });
+  const onAbort = () => {
+    child.kill("SIGTERM");
+    queue.end();
+  };
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  child.on("error", (err) => queue.fail(err));
+  child.on("close", (code) => {
+    options.signal?.removeEventListener("abort", onAbort);
+    if (options.signal?.aborted) return queue.end();
+    if (code !== 0) queue.fail(new ProcessExitError(code, stderr));
+    else queue.end();
+  });
+  if (options.stdin !== void 0) {
+    child.stdin?.end(options.stdin);
+  }
+  return queue;
+}
+
+// src/core/providers/codex.ts
+var INSTALL_HINT = "Install Codex CLI (npm i -g @openai/codex or brew install codex) and run `codex login`.";
+var CodexProvider = class {
+  id = "codex";
+  label = "Codex CLI";
+  executable;
+  loginCommand = "codex login";
+  capabilities = {
+    resume: true,
+    fork: false,
+    images: true,
+    documents: false,
+    systemPrompt: false,
+    thinking: false,
+    effort: true,
+    streaming: "chunks"
+  };
+  workDir;
+  sandbox;
+  env;
+  constructor(options = {}) {
+    this.executable = resolveExecutable("codex", "codex", INSTALL_HINT, {
+      ...options.path ?? process.env["YAGAMI_CODEX_PATH"] ? { explicit: options.path ?? process.env["YAGAMI_CODEX_PATH"] } : {}
+    });
+    this.workDir = options.workDir ?? path4.join(os4.tmpdir(), "yagami-workspace");
+    this.sandbox = options.sandbox ?? "read-only";
+    this.env = { ...process.env, ...options.env };
+    fs4.mkdirSync(this.workDir, { recursive: true });
+  }
+  /** Build the `codex exec` argument list for a turn (exported for tests). */
+  buildArgs(req, imagePaths) {
+    const args = ["exec", "--json", "--skip-git-repo-check", "-C", this.workDir, "-s", this.sandbox, "--color", "never"];
+    if (req.model) args.push("-m", req.model);
+    if (req.effort) args.push("-c", `model_reasoning_effort="${req.effort}"`);
+    for (const p of imagePaths) args.push("-i", p);
+    if (req.resume) args.push("resume", req.resume);
+    args.push(req.prompt);
+    return args;
+  }
+  async *run(req) {
+    const { paths: imagePaths, cleanup } = writeTempImages(req.media ?? []);
+    const emitted = /* @__PURE__ */ new Map();
+    let done = false;
+    try {
+      for await (const raw of spawnJsonl({
+        command: this.executable,
+        args: this.buildArgs(req, imagePaths),
+        cwd: this.workDir,
+        env: this.env,
+        ...req.signal ? { signal: req.signal } : {}
+      })) {
+        const ev = raw;
+        switch (ev.type) {
+          case "thread.started":
+            if (ev.thread_id) yield { type: "session", sessionId: ev.thread_id };
+            break;
+          case "item.started":
+          case "item.updated":
+          case "item.completed": {
+            const item = ev.item;
+            if (!item || typeof item.text !== "string") break;
+            if (item.type !== "agent_message" && item.type !== "reasoning") break;
+            const seen = emitted.get(item.id) ?? 0;
+            const fresh = item.text.slice(seen);
+            emitted.set(item.id, item.text.length);
+            if (fresh) yield { type: item.type === "agent_message" ? "text" : "thinking", text: fresh };
+            break;
+          }
+          case "turn.completed":
+            done = true;
+            yield { type: "done", usage: mapCodexUsage(ev.usage ?? {}), stopReason: "end_turn" };
+            break;
+          case "turn.failed":
+            throw new Error(ev.error?.message ?? "turn failed");
+          case "error":
+            throw new Error(ev.message ?? "codex error");
+          default:
+            break;
+        }
+      }
+    } catch (err) {
+      throw classifyProviderFailure(this.id, this.loginCommand, err);
+    } finally {
+      cleanup();
+    }
+    if (req.signal?.aborted) return;
+    if (!done) throw new ProviderError(this.id, "codex exited without completing the turn");
+  }
+  /** Ask the app-server protocol for the model catalog (no tokens spent). */
+  listModels() {
+    return new Promise((resolve, reject) => {
+      const child = spawn3(this.executable, ["app-server"], { env: this.env, stdio: ["pipe", "pipe", "pipe"] });
+      let stderr = "";
+      let settled = false;
+      const finish = (fn) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        child.kill("SIGTERM");
+        fn();
+      };
+      const timer = setTimeout(() => finish(() => reject(new ProviderError(this.id, "timed out listing models via app-server"))), 15e3);
+      timer.unref?.();
+      child.stderr.on("data", (d) => stderr += d.toString());
+      child.on("error", (err) => finish(() => reject(classifyProviderFailure(this.id, this.loginCommand, err))));
+      child.on(
+        "close",
+        () => finish(() => reject(classifyProviderFailure(this.id, this.loginCommand, new Error(stderr.trim() || "app-server exited"))))
+      );
+      const rl = readline3.createInterface({ input: child.stdout });
+      rl.on("line", (line) => {
+        let msg;
+        try {
+          msg = JSON.parse(line);
+        } catch {
+          return;
+        }
+        if (msg.id === 1) {
+          child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method: "initialized", params: {} })}
+`);
+          child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id: 2, method: "model/list", params: {} })}
+`);
+        } else if (msg.id === 2) {
+          if (msg.error) {
+            finish(() => reject(classifyProviderFailure(this.id, this.loginCommand, new Error(msg.error?.message ?? "model/list failed"))));
+            return;
+          }
+          const models = (msg.result?.data ?? []).filter((m) => m["hidden"] !== true).map((m) => ({
+            id: String(m["id"] ?? m["model"]),
+            display_name: String(m["displayName"] ?? m["id"] ?? m["model"]),
+            ...typeof m["description"] === "string" ? { description: m["description"] } : {}
+          }));
+          finish(() => resolve(models));
+        }
+      });
+      child.stdin.write(
+        `${JSON.stringify({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "initialize",
+          params: { clientInfo: { name: "yagami", title: "yagami", version: VERSION } }
+        })}
+`
+      );
+    });
+  }
+  async version() {
+    try {
+      const out = spawnSync3(this.executable, ["--version"], { encoding: "utf8", timeout: 1e4 });
+      return out.stdout?.trim().split("\n")[0] || void 0;
+    } catch {
+      return void 0;
+    }
+  }
+};
+function mapCodexUsage(u) {
+  return {
+    input_tokens: u["input_tokens"] ?? 0,
+    output_tokens: u["output_tokens"] ?? 0,
+    cache_read_input_tokens: u["cached_input_tokens"] ?? 0,
+    cache_creation_input_tokens: u["cache_write_input_tokens"] ?? 0
+  };
+}
+var EXT_BY_MIME = {
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/gif": ".gif",
+  "image/webp": ".webp"
+};
+function writeTempImages(media) {
+  const images = media.filter((b) => b.type === "image");
+  if (images.length === 0) return { paths: [], cleanup: () => {
+  } };
+  const dir = fs4.mkdtempSync(path4.join(os4.tmpdir(), "yagami-img-"));
+  const paths = [];
+  images.forEach((block, i) => {
+    const source = block["source"];
+    if (source?.type !== "base64" || typeof source.data !== "string") {
+      fs4.rmSync(dir, { recursive: true, force: true });
+      throw new ProviderError("codex", "only base64 image sources are supported (URL images are not fetched)");
+    }
+    const file = path4.join(dir, `image-${i}${EXT_BY_MIME[source.media_type ?? ""] ?? ".png"}`);
+    fs4.writeFileSync(file, Buffer.from(source.data, "base64"));
+    paths.push(file);
+  });
+  return { paths, cleanup: () => fs4.rmSync(dir, { recursive: true, force: true }) };
+}
+
+// src/core/providers/registry.ts
+var PROVIDER_PRESETS = [
+  { id: "claude", label: "Claude Code", kind: "claude", command: "claude", args: [], loginCommand: "claude (then /login)", installHint: "npm i -g @anthropic-ai/claude-code" },
+  { id: "codex", label: "Codex CLI", kind: "codex", command: "codex", args: [], loginCommand: "codex login", installHint: "npm i -g @openai/codex" },
+  { id: "opencode", label: "OpenCode", kind: "acp", command: "opencode", args: ["acp"], loginCommand: "opencode auth login", installHint: "curl -fsSL https://opencode.ai/install | bash" },
+  { id: "gemini", label: "Gemini CLI", kind: "acp", command: "gemini", args: ["--acp"], loginCommand: "gemini (then /auth)", installHint: "npm i -g @google/gemini-cli" },
+  { id: "copilot", label: "GitHub Copilot CLI", kind: "acp", command: "copilot", args: ["--acp"], loginCommand: "copilot (then /login)", installHint: "npm i -g @github/copilot" },
+  { id: "qwen", label: "Qwen Code", kind: "acp", command: "qwen", args: ["--acp"], loginCommand: "qwen (then /auth)", installHint: "npm i -g @qwen-code/qwen-code" },
+  { id: "cursor", label: "Cursor Agent", kind: "acp", command: "cursor-agent", args: ["acp"], loginCommand: "cursor-agent login", installHint: "curl https://cursor.com/install -fsS | bash" },
+  { id: "goose", label: "Goose", kind: "acp", command: "goose", args: ["acp"], loginCommand: "goose configure", installHint: "brew install block-goose-cli" },
+  { id: "kimi", label: "Kimi CLI", kind: "acp", command: "kimi", args: ["acp"], loginCommand: "kimi login", installHint: "see github.com/MoonshotAI/kimi-cli" },
+  { id: "kilo", label: "Kilo", kind: "acp", command: "kilo", args: ["acp"], loginCommand: "kilo login", installHint: "npm i -g @kilocode/cli" },
+  { id: "cline", label: "Cline", kind: "acp", command: "cline", args: ["--acp"], loginCommand: "cline auth", installHint: "npm i -g cline" },
+  { id: "auggie", label: "Auggie", kind: "acp", command: "auggie", args: ["--acp"], loginCommand: "auggie login", installHint: "npm i -g @augmentcode/auggie" },
+  { id: "amp", label: "Amp", kind: "acp", command: "amp-acp", args: [], loginCommand: "amp login", installHint: "see ampcode.com" },
+  { id: "grok", label: "Grok Build", kind: "acp", command: "grok", args: ["agent", "stdio"], loginCommand: "grok login", installHint: "npm i -g @xai-official/grok" },
+  { id: "droid", label: "Factory Droid", kind: "acp", command: "droid", args: ["exec", "--output-format", "acp-daemon"], loginCommand: "droid login", installHint: "curl -fsSL https://app.factory.ai/cli | sh" },
+  { id: "codex-acp", label: "Codex (ACP adapter)", kind: "acp", command: "codex-acp", args: [], loginCommand: "codex login", installHint: "npm i -g @agentclientprotocol/codex-acp" },
+  { id: "claude-acp", label: "Claude (ACP adapter)", kind: "acp", command: "claude-agent-acp", args: [], loginCommand: "claude (then /login)", installHint: "npm i -g @agentclientprotocol/claude-agent-acp" }
+];
+function presetFor(id) {
+  return PROVIDER_PRESETS.find((p) => p.id === id);
+}
+function createProvider(id, entry = {}, common = {}) {
+  const preset = presetFor(id);
+  const kind = preset?.kind ?? "acp";
+  if (kind === "claude") {
+    return new ClaudeProvider({
+      ...entry.path ? { path: entry.path } : {},
+      ...entry.configDir ? { configDir: entry.configDir } : {},
+      ...common
+    });
+  }
+  if (kind === "codex") {
+    return new CodexProvider({
+      ...entry.path ? { path: entry.path } : {},
+      ...entry.sandbox ? { sandbox: entry.sandbox } : {},
+      ...entry.env ? { env: entry.env } : {},
+      ...common.workDir ? { workDir: common.workDir } : {}
+    });
+  }
+  const command = entry.command ?? preset?.command;
+  if (!command) {
+    throw new ProviderNotInstalledError(id, `Add providers.${id}.command (an ACP agent launch command) to config.json.`, "unknown provider with no command");
+  }
+  return new AcpProvider({
+    id,
+    label: entry.label ?? preset?.label ?? id,
+    command,
+    args: entry.args ?? preset?.args ?? [],
+    ...entry.path ? { path: entry.path } : {},
+    ...entry.env ? { env: entry.env } : {},
+    ...entry.modelConfigId ? { modelConfigId: entry.modelConfigId } : {},
+    loginCommand: entry.loginCommand ?? preset?.loginCommand ?? `${command} (sign in per its docs)`,
+    installHint: preset?.installHint ?? `Install \`${command}\`.`,
+    ...common
+  });
+}
+function loadProviders(config = {}, common = {}) {
+  const ids = /* @__PURE__ */ new Set([...PROVIDER_PRESETS.map((p) => p.id), ...Object.keys(config)]);
+  const providers = /* @__PURE__ */ new Map();
+  const unavailable = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const entry = config[id] ?? {};
+    if (entry.enabled === false) {
+      unavailable.set(id, "disabled in config");
+      continue;
+    }
+    try {
+      providers.set(id, createProvider(id, entry, common));
+    } catch (err) {
+      unavailable.set(id, err instanceof Error ? err.message : String(err));
+    }
+  }
+  return { providers, unavailable };
+}
+function detectProviders(config = {}) {
+  const ids = /* @__PURE__ */ new Set([...PROVIDER_PRESETS.map((p) => p.id), ...Object.keys(config)]);
+  return [...ids].map((id) => {
+    const preset = presetFor(id);
+    const entry = config[id] ?? {};
+    const command = entry.command ?? preset?.command ?? id;
+    const path7 = findExecutable(command, entry.path ? { explicit: entry.path } : {});
+    return {
+      id,
+      label: entry.label ?? preset?.label ?? id,
+      kind: preset?.kind ?? "acp",
+      installed: path7 !== void 0 && entry.enabled !== false,
+      ...path7 ? { path: path7 } : {},
+      loginCommand: entry.loginCommand ?? preset?.loginCommand ?? `${command} (sign in per its docs)`,
+      installHint: preset?.installHint ?? `Install \`${command}\`.`
+    };
+  });
+}
+
+// src/core/sessionCache.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+var SessionCache = class {
+  map = /* @__PURE__ */ new Map();
+  maxEntries;
+  persistPath;
+  persistTimer = null;
+  constructor(options = {}) {
+    this.maxEntries = options.maxEntries ?? 1e3;
+    this.persistPath = options.persistPath;
+    this.load();
+  }
+  get size() {
+    return this.map.size;
+  }
+  get(key) {
+    const value = this.map.get(key);
+    if (value !== void 0) {
+      this.map.delete(key);
+      this.map.set(key, value);
+    }
+    return value;
+  }
+  /** Drop a mapping, e.g. when its session turns out to be gone. */
+  delete(key) {
+    if (this.map.delete(key)) this.schedulePersist();
+  }
+  set(key, sessionId) {
+    if (this.map.has(key)) this.map.delete(key);
+    this.map.set(key, sessionId);
+    while (this.map.size > this.maxEntries) {
+      const oldest = this.map.keys().next().value;
+      if (oldest === void 0) break;
+      this.map.delete(oldest);
+    }
+    this.schedulePersist();
+  }
+  load() {
+    if (!this.persistPath) return;
+    try {
+      const raw = JSON.parse(fs5.readFileSync(this.persistPath, "utf8"));
+      for (const [key, value] of raw.entries ?? []) {
+        if (typeof key === "string" && typeof value === "string") this.map.set(key, value);
+      }
+    } catch {
+    }
+  }
+  schedulePersist() {
+    if (!this.persistPath) return;
+    if (this.persistTimer) clearTimeout(this.persistTimer);
+    this.persistTimer = setTimeout(() => this.persistNow(), 200);
+    this.persistTimer.unref?.();
+  }
+  persistNow() {
+    if (!this.persistPath) return;
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+      this.persistTimer = null;
+    }
+    try {
+      fs5.mkdirSync(path5.dirname(this.persistPath), { recursive: true });
+      fs5.writeFileSync(
+        this.persistPath,
+        JSON.stringify({ version: 1, entries: [...this.map] }),
+        { mode: 384 }
+      );
+    } catch {
+    }
+  }
+};
+
+// src/core/engine.ts
+import { randomUUID } from "crypto";
+import * as fs6 from "fs";
+import * as os5 from "os";
+import * as path6 from "path";
+
+// src/core/sse.ts
+var SseSynthesizer = class {
+  constructor(id, model) {
+    this.id = id;
+    this.model = model;
+  }
+  id;
+  model;
+  index = -1;
+  open = null;
+  startedBlocks = 0;
+  start() {
+    return [
+      {
+        event: "message_start",
+        data: {
+          type: "message_start",
+          message: {
+            id: this.id,
+            type: "message",
+            role: "assistant",
+            model: this.model,
+            content: [],
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: 0, output_tokens: 0 }
+          }
+        }
+      }
+    ];
+  }
+  thinking(text) {
+    if (text.length === 0) return [];
+    const out = this.ensure("thinking");
+    out.push({
+      event: "content_block_delta",
+      data: { type: "content_block_delta", index: this.index, delta: { type: "thinking_delta", thinking: text } }
+    });
+    return out;
+  }
+  text(text) {
+    if (text.length === 0) return [];
+    const out = this.ensure("text");
+    out.push({
+      event: "content_block_delta",
+      data: { type: "content_block_delta", index: this.index, delta: { type: "text_delta", text } }
+    });
+    return out;
+  }
+  finish(usage, stopReason = "end_turn") {
+    const out = [];
+    if (this.startedBlocks === 0) out.push(...this.ensure("text"));
+    out.push(...this.closeOpen());
+    out.push({
+      event: "message_delta",
+      data: {
+        type: "message_delta",
+        delta: { stop_reason: stopReason, stop_sequence: null },
+        usage: { input_tokens: usage.input_tokens, output_tokens: usage.output_tokens }
+      }
+    });
+    out.push({ event: "message_stop", data: { type: "message_stop" } });
+    return out;
+  }
+  ensure(kind) {
+    if (this.open === kind) return [];
+    const out = this.closeOpen();
+    this.index += 1;
+    this.startedBlocks += 1;
+    this.open = kind;
+    out.push({
+      event: "content_block_start",
+      data: {
+        type: "content_block_start",
+        index: this.index,
+        content_block: kind === "text" ? { type: "text", text: "" } : { type: "thinking", thinking: "" }
+      }
+    });
+    return out;
+  }
+  closeOpen() {
+    if (this.open === null) return [];
+    this.open = null;
+    return [{ event: "content_block_stop", data: { type: "content_block_stop", index: this.index } }];
+  }
+};
+
+// src/core/transcript.ts
+import { createHash } from "crypto";
+var IGNORABLE_PARAMS = [
+  "max_tokens",
+  "temperature",
+  "top_p",
+  "top_k",
+  "stop_sequences",
+  "metadata",
+  "service_tier"
+];
+function extractSystemText(system) {
+  if (system == null) return void 0;
+  if (typeof system === "string") return system.length > 0 ? system : void 0;
+  if (!Array.isArray(system)) {
+    throw new ApiError(400, "invalid_request_error", "`system` must be a string or an array of text blocks");
+  }
+  const parts = [];
+  for (const block of system) {
+    if (block?.type !== "text" || typeof block.text !== "string") {
+      throw new ApiError(400, "invalid_request_error", "yagami only supports text blocks in `system`");
+    }
+    parts.push(block.text);
+  }
+  const joined = parts.join("\n\n");
+  return joined.length > 0 ? joined : void 0;
+}
+var USER_MEDIA_TYPES = /* @__PURE__ */ new Set(["image", "document"]);
+function contentToParts(content, role) {
+  if (typeof content === "string") return { text: content, media: [] };
+  if (!Array.isArray(content)) {
+    throw new ApiError(400, "invalid_request_error", `message content for role "${role}" must be a string or an array of blocks`);
+  }
+  const parts = [];
+  const media = [];
+  for (const block of content) {
+    if (block?.type === "text" && typeof block["text"] === "string") {
+      parts.push(block["text"]);
+    } else if (role === "assistant" && (block?.type === "thinking" || block?.type === "redacted_thinking")) {
+      continue;
+    } else if (role === "user" && USER_MEDIA_TYPES.has(String(block?.type))) {
+      if (block["source"] == null || typeof block["source"] !== "object") {
+        throw new ApiError(
+          400,
+          "invalid_request_error",
+          `"${block.type}" blocks must carry a \`source\` object`
+        );
+      }
+      media.push(block);
+    } else {
+      throw new ApiError(
+        400,
+        "invalid_request_error",
+        role === "user" ? `unsupported content block type "${String(block?.type)}" (user messages may contain text, image, and document blocks; tool_use/tool_result are not supported)` : `assistant messages may only contain "text" blocks (got "${String(block?.type)}")`
+      );
+    }
+  }
+  return { text: parts.join("\n"), media };
+}
+function normalizeRequest(req) {
+  if (req == null || typeof req !== "object") {
+    throw new ApiError(400, "invalid_request_error", "request body must be a JSON object");
+  }
+  if (req.tools != null || req.tool_choice != null) {
+    throw new ApiError(
+      400,
+      "invalid_request_error",
+      "yagami does not support `tools`/`tool_choice`: the backing engine runs as a pure completions endpoint and never executes or emits tool calls."
+    );
+  }
+  if (!Array.isArray(req.messages) || req.messages.length === 0) {
+    throw new ApiError(400, "invalid_request_error", "`messages` must be a non-empty array");
+  }
+  let messages = req.messages.map((m, i) => {
+    if (m?.role !== "user" && m?.role !== "assistant") {
+      throw new ApiError(400, "invalid_request_error", `messages[${i}].role must be "user" or "assistant"`);
+    }
+    const { text, media } = contentToParts(m.content, m.role);
+    return media.length > 0 ? { role: m.role, text, media } : { role: m.role, text };
+  });
+  let prefill;
+  if (messages[messages.length - 1].role === "assistant") {
+    prefill = messages[messages.length - 1].text;
+    messages = messages.slice(0, -1);
+    if (prefill.length === 0) {
+      throw new ApiError(400, "invalid_request_error", "assistant prefill must contain non-empty text");
+    }
+    if (messages.length === 0 || messages[messages.length - 1].role !== "user") {
+      throw new ApiError(
+        400,
+        "invalid_request_error",
+        "assistant prefill must directly follow a user message"
+      );
+    }
+  }
+  const last = messages[messages.length - 1];
+  if (last.role !== "user") {
+    throw new ApiError(400, "invalid_request_error", 'the final message must have role "user"');
+  }
+  const ignored = IGNORABLE_PARAMS.filter((p) => req[p] != null);
+  return {
+    system: extractSystemText(req.system),
+    messages,
+    lastUserText: last.text,
+    ...prefill !== void 0 ? { prefill } : {},
+    ignored: [...ignored]
+  };
+}
+function prefillDirective(prefill) {
+  return [
+    "<assistant-prefill>",
+    prefill,
+    "</assistant-prefill>",
+    "",
+    "Your reply has already been started with the exact text inside <assistant-prefill>.",
+    "Continue seamlessly from where it stops. Output ONLY the continuation \u2014 do not",
+    "repeat any part of the prefill and do not acknowledge these instructions."
+  ].join("\n");
+}
+var PrefillStripper = class {
+  constructor(prefill) {
+    this.prefill = prefill;
+  }
+  prefill;
+  buffer = "";
+  settled = false;
+  /** True while text is being held back pending the repeat/no-repeat call. */
+  get pending() {
+    return !this.settled && this.buffer.length > 0;
+  }
+  /** Feed a chunk of reply text; returns the text safe to emit now. */
+  push(chunk) {
+    if (this.settled) return chunk;
+    this.buffer += chunk;
+    if (this.buffer.length <= this.prefill.length) {
+      if (this.prefill.startsWith(this.buffer)) return "";
+      this.settled = true;
+      const out2 = this.buffer;
+      this.buffer = "";
+      return out2;
+    }
+    this.settled = true;
+    const out = this.buffer.startsWith(this.prefill) ? this.buffer.slice(this.prefill.length) : this.buffer;
+    this.buffer = "";
+    return out;
+  }
+  /** Emit whatever is still held once the reply has ended. */
+  flush() {
+    if (this.settled) return "";
+    this.settled = true;
+    const out = this.buffer === this.prefill ? "" : this.buffer;
+    this.buffer = "";
+    return out;
+  }
+};
+function prefixKey(system, messages, provider = "claude") {
+  const payload = JSON.stringify([
+    provider,
+    system ?? "",
+    messages.map(
+      (m) => m.media && m.media.length > 0 ? [m.role, m.text, createHash("sha256").update(JSON.stringify(m.media)).digest("hex")] : [m.role, m.text]
+    )
+  ]);
+  return createHash("sha256").update(payload).digest("hex");
+}
+function flattenConversation(messages) {
+  const history = messages.slice(0, -1);
+  const last = messages[messages.length - 1];
+  const lines = history.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.text}`);
+  return [
+    "<conversation-history>",
+    "This is the conversation so far between the user (User) and you (Assistant):",
+    ...lines,
+    "</conversation-history>",
+    "",
+    "Continue that conversation naturally. Respond to the user's latest message:",
+    "",
+    last.text
+  ].join("\n");
+}
+
+// src/core/engine.ts
+var EFFORT_LEVELS = /* @__PURE__ */ new Set(["low", "medium", "high", "xhigh", "max"]);
+var THINKING_TYPES = /* @__PURE__ */ new Set(["enabled", "disabled", "adaptive"]);
+var YagamiEngine = class {
+  providers;
+  unavailable;
+  defaultProviderId;
+  defaultModel;
+  cache;
+  modelsPromises = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    const workDir = options.workDir ?? path6.join(os5.tmpdir(), "yagami-workspace");
+    fs6.mkdirSync(workDir, { recursive: true });
+    this.defaultModel = options.defaultModel;
+    this.cache = options.sessionCache ?? new SessionCache();
+    if (options.providers) {
+      this.providers = new Map(options.providers.map((p) => [p.id, p]));
+      this.unavailable = /* @__PURE__ */ new Map();
+    } else {
+      const config = { ...options.providerConfig };
+      if (options.claudePath || options.claudeConfigDir) {
+        config["claude"] = {
+          ...config["claude"],
+          ...options.claudePath ? { path: options.claudePath } : {},
+          ...options.claudeConfigDir ? { configDir: options.claudeConfigDir } : {}
+        };
+      }
+      const loaded = loadProviders(config, { workDir, ...options.appName ? { appName: options.appName } : {} });
+      this.providers = loaded.providers;
+      this.unavailable = loaded.unavailable;
+    }
+    const wanted = options.defaultProvider ?? (this.providers.has("claude") ? "claude" : [...this.providers.keys()][0]);
+    if (!wanted || !this.providers.has(wanted)) {
+      const reason = wanted ? this.unavailable.get(wanted) : "no supported coding-agent CLI was found on this machine";
+      throw new ProviderNotInstalledError(wanted ?? "(none)", reason ?? "not installed");
+    }
+    this.defaultProviderId = wanted;
+  }
+  get defaultProvider() {
+    return this.providers.get(this.defaultProviderId);
+  }
+  /** Executable of the default provider. */
+  get executable() {
+    return this.defaultProvider.executable;
+  }
+  /** @deprecated Use `executable`. */
+  get claudePath() {
+    return this.executable;
+  }
+  get providerIds() {
+    return [...this.providers.keys()];
+  }
+  /** Route a request's model id to a provider and its native model. */
+  resolve(model) {
+    const ref = parseModelRef(model ?? this.defaultModel, this.providers.keys());
+    if (ref.providerId && !this.providers.has(ref.providerId)) {
+      throw new ApiError(503, "api_error", `provider "${ref.providerId}" is not available: ${this.unavailable.get(ref.providerId) ?? "not installed"}`);
+    }
+    const provider = this.providers.get(ref.providerId ?? this.defaultProviderId);
+    return ref.model ? { provider, model: ref.model } : { provider };
+  }
+  /**
+   * Models across every available provider. The default provider's ids are
+   * listed bare as well as qualified; others only as `provider:model`.
+   * Providers whose probe fails are skipped (their error is not cached).
+   */
+  async listModels() {
+    const out = [];
+    const entries = await Promise.all(
+      [...this.providers.entries()].map(async ([id, provider]) => {
+        try {
+          return [id, await this.providerModels(id, provider)];
+        } catch {
+          return [id, []];
+        }
+      })
+    );
+    for (const [id, models] of entries) {
+      for (const m of models) {
+        if (id === this.defaultProviderId) out.push({ ...m, provider: id });
+        out.push({ ...m, id: qualifiedModel(id, m.id), provider: id });
+      }
+    }
+    return out;
+  }
+  providerModels(id, provider) {
+    let promise = this.modelsPromises.get(id);
+    if (!promise) {
+      promise = provider.listModels().catch((err) => {
+        this.modelsPromises.delete(id);
+        throw err;
+      });
+      this.modelsPromises.set(id, promise);
+    }
+    return promise;
+  }
+  prepare(req, opts = {}) {
+    const norm = normalizeRequest(req);
+    const { provider, model } = this.resolve(req.model);
+    const caps = provider.capabilities;
+    const ignored = [...norm.ignored];
+    if (req.thinking != null) {
+      if (!THINKING_TYPES.has(String(req.thinking.type))) {
+        throw new ApiError(400, "invalid_request_error", `invalid \`thinking.type\`: ${String(req.thinking.type)}`);
+      }
+      if (!caps.thinking) ignored.push("thinking");
+    }
+    if (req.effort != null) {
+      if (typeof req.effort !== "string" || !EFFORT_LEVELS.has(req.effort)) {
+        throw new ApiError(400, "invalid_request_error", `invalid \`effort\`: ${String(req.effort)}`);
+      }
+      if (!caps.effort) ignored.push("effort");
+    }
+    const last = norm.messages[norm.messages.length - 1];
+    const lastMedia = last.media ?? [];
+    if (lastMedia.some((b) => b.type === "image") && !caps.images) {
+      throw new ApiError(400, "invalid_request_error", `provider "${provider.id}" does not accept image blocks`);
+    }
+    if (lastMedia.some((b) => b.type === "document") && !caps.documents) {
+      throw new ApiError(400, "invalid_request_error", `provider "${provider.id}" does not accept document blocks`);
+    }
+    let promptText = norm.lastUserText;
+    let resume;
+    let resumeKey;
+    if (norm.messages.length > 1) {
+      const history = norm.messages.slice(0, -1);
+      if (caps.resume && !opts.skipResume) {
+        resumeKey = prefixKey(norm.system, history, provider.id);
+        resume = this.cache.get(resumeKey);
+        if (resume && !caps.fork) this.cache.delete(resumeKey);
+      }
+      if (!resume) {
+        if (history.some((m) => m.media && m.media.length > 0)) {
+          throw new ApiError(
+            400,
+            "invalid_request_error",
+            "conversation history contains image/document blocks and no cached session matches this prefix; yagami can only replay text history. Continue such conversations against the server that produced them."
+          );
+        }
+        promptText = flattenConversation(norm.messages);
+      }
+    }
+    if (norm.prefill) promptText = `${promptText}
+
+${prefillDirective(norm.prefill)}`;
+    if (norm.system !== void 0 && !caps.systemPrompt) {
+      promptText = `<system>
+${norm.system}
+</system>
+
+${promptText}`;
+    }
+    const turn = {
+      prompt: promptText,
+      ...lastMedia.length > 0 ? { media: lastMedia } : {},
+      ...norm.system !== void 0 && caps.systemPrompt ? { system: norm.system } : {},
+      ...model ? { model } : {},
+      ...resume ? { resume } : {},
+      ...req.thinking != null && caps.thinking ? { thinking: req.thinking } : {},
+      ...typeof req.effort === "string" && caps.effort ? { effort: req.effort } : {}
+    };
+    const requestedModel = model ? provider.id === this.defaultProviderId ? model : qualifiedModel(provider.id, model) : provider.id;
+    return { provider, turn, norm, requestedModel, ignored, ...resume && resumeKey ? { resumeKey } : {} };
+  }
+  /**
+   * A failed resumed attempt usually means the cached session no longer
+   * exists. Drop the stale mapping and re-prepare from scratch — the
+   * transcript-replay path. Undefined when falling back is impossible.
+   */
+  prepareResumeFallback(req, failed) {
+    if (!failed.resumeKey) return void 0;
+    this.cache.delete(failed.resumeKey);
+    try {
+      return this.prepare(req, { skipResume: true });
+    } catch {
+      return void 0;
+    }
+  }
+  storeSession(prepared, continuation, sessionId) {
+    const { norm, provider } = prepared;
+    const fullText = (norm.prefill ?? "") + continuation;
+    if (!sessionId || !fullText || !provider.capabilities.resume) return;
+    const played = [...norm.messages, { role: "assistant", text: fullText }];
+    this.cache.set(prefixKey(norm.system, played, provider.id), sessionId);
+  }
+  async complete(req) {
+    const prepared = this.prepare(req);
+    try {
+      return await this.attemptComplete(prepared);
+    } catch (err) {
+      const fallback = this.prepareResumeFallback(req, prepared);
+      if (!fallback) throw toApiError(err);
+      try {
+        return await this.attemptComplete(fallback);
+      } catch (err2) {
+        throw toApiError(err2);
+      }
+    }
+  }
+  async attemptComplete(prepared) {
+    const { provider, turn, norm, requestedModel, ignored } = prepared;
+    const stripper = norm.prefill ? new PrefillStripper(norm.prefill) : void 0;
+    let sessionId;
+    let text = "";
+    let thinking = "";
+    let done;
+    for await (const ev of provider.run(turn)) {
+      if (ev.type === "session") sessionId = ev.sessionId;
+      else if (ev.type === "text") text += stripper ? stripper.push(ev.text) : ev.text;
+      else if (ev.type === "thinking") thinking += ev.text;
+      else done = ev;
+    }
+    if (stripper) text += stripper.flush();
+    if (!done) throw new ProviderError(provider.id, "turn ended without a result");
+    this.storeSession(prepared, text, sessionId);
+    const content = [
+      ...thinking ? [{ type: "thinking", thinking, signature: "" }] : [],
+      { type: "text", text }
+    ];
+    const response = {
+      id: `msg_${randomUUID().replace(/-/g, "")}`,
+      type: "message",
+      role: "assistant",
+      model: done.model ?? requestedModel,
+      content,
+      stop_reason: done.stopReason ?? "end_turn",
+      stop_sequence: null,
+      usage: done.usage
+    };
+    return {
+      response,
+      ...done.costUsd !== void 0 ? { costUsd: done.costUsd } : {},
+      ...sessionId ? { sessionId } : {},
+      provider: provider.id,
+      ignored
+    };
+  }
+  /**
+   * Validates synchronously (throws ApiError), then returns a lazy generator
+   * of Anthropic-style SSE events.
+   */
+  stream(req, streamOptions = {}) {
+    const prepared = this.prepare(req);
+    return {
+      ignored: prepared.ignored,
+      provider: prepared.provider.id,
+      events: this.runStream(req, prepared, streamOptions)
+    };
+  }
+  async *runStream(req, prepared, streamOptions) {
+    const { signal } = streamOptions;
+    let emitted = false;
+    try {
+      for await (const ev of this.attemptStream(prepared, streamOptions)) {
+        emitted = true;
+        yield ev;
+      }
+      return;
+    } catch (err) {
+      if (signal?.aborted) return;
+      const fallback = emitted ? void 0 : this.prepareResumeFallback(req, prepared);
+      if (!fallback) {
+        yield { event: "error", data: toApiError(err).toBody() };
+        return;
+      }
+      try {
+        yield* this.attemptStream(fallback, streamOptions);
+      } catch (err2) {
+        if (!signal?.aborted) yield { event: "error", data: toApiError(err2).toBody() };
+      }
+    }
+  }
+  async *attemptStream(prepared, streamOptions) {
+    const { provider, turn, norm, requestedModel } = prepared;
+    const { signal } = streamOptions;
+    const stripper = norm.prefill ? new PrefillStripper(norm.prefill) : void 0;
+    const sse = new SseSynthesizer(`msg_${randomUUID().replace(/-/g, "")}`, requestedModel);
+    let sessionId;
+    let text = "";
+    let done;
+    let started = false;
+    const start = () => {
+      if (started) return [];
+      started = true;
+      return sse.start();
+    };
+    for await (const ev of provider.run({ ...turn, ...signal ? { signal } : {} })) {
+      if (ev.type === "session") {
+        sessionId = ev.sessionId;
+      } else if (ev.type === "text") {
+        const out = stripper ? stripper.push(ev.text) : ev.text;
+        text += out;
+        yield* start();
+        yield* sse.text(out);
+      } else if (ev.type === "thinking") {
+        yield* start();
+        yield* sse.thinking(ev.text);
+      } else {
+        done = ev;
+      }
+    }
+    if (signal?.aborted) return;
+    if (!done) throw new ProviderError(provider.id, "turn ended without a result");
+    yield* start();
+    if (stripper) {
+      const held = stripper.flush();
+      text += held;
+      yield* sse.text(held);
+    }
+    yield* sse.finish(done.usage, done.stopReason ?? "end_turn");
+    this.storeSession(prepared, text, sessionId);
+    streamOptions.onResult?.({
+      ...done.costUsd !== void 0 ? { costUsd: done.costUsd } : {},
+      ...sessionId ? { sessionId } : {}
+    });
+  }
+};
+
+export {
+  ApiError,
+  YagamiError,
+  ProviderNotInstalledError,
+  AuthRequiredError,
+  ProviderError,
+  classifyProviderFailure,
+  toApiError,
+  parseModelRef,
+  qualifiedModel,
+  findExecutable,
+  resolveExecutable,
+  resolveClaudeExecutable,
+  AsyncQueue,
+  VERSION,
+  AcpProvider,
+  ClaudeProvider,
+  CodexProvider,
+  PROVIDER_PRESETS,
+  presetFor,
+  createProvider,
+  loadProviders,
+  detectProviders,
+  SessionCache,
+  YagamiEngine
+};
+//# sourceMappingURL=chunk-ASS6MJ7C.js.map