@justin06lee/yagami 0.6.1 → 0.8.2

package/dist/{chunk-ZYHC7PXX.js → chunk-EKN223KD.js}

@@ -183,10 +183,10 @@ function resolveClaudeExecutable(explicit) {
 }
 
 // src/version.ts
-var VERSION = "0.5.0";
+var VERSION = "0.8.2";
 
 // src/core/providers/acp.ts
-import { spawn, spawnSync } from "child_process";
+import { spawn, spawnSync as spawnSync2 } from "child_process";
 import * as fs2 from "fs";
 import * as os2 from "os";
 import * as path2 from "path";
@@ -198,12 +198,165 @@ import {
   PROTOCOL_VERSION
 } from "@agentclientprotocol/sdk";
 
+// src/core/interaction.ts
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function optionsOf(schema) {
+  const oneOf = Array.isArray(schema["oneOf"]) ? schema["oneOf"] : void 0;
+  if (oneOf) {
+    const options = oneOf.flatMap((item) => {
+      const value = record(item);
+      if (!value || typeof value["const"] !== "string") return [];
+      return [{
+        value: value["const"],
+        label: typeof value["title"] === "string" ? value["title"] : value["const"],
+        ...typeof value["description"] === "string" ? { description: value["description"] } : {}
+      }];
+    });
+    if (options.length > 0) return options;
+  }
+  const values = Array.isArray(schema["enum"]) ? schema["enum"].filter((value) => typeof value === "string") : [];
+  return values.length > 0 ? values.map((value) => ({ value, label: value })) : void 0;
+}
+function inputFields(schema) {
+  const root = record(schema);
+  const properties = record(root?.["properties"]);
+  if (!properties) return [];
+  const required = new Set(
+    Array.isArray(root?.["required"]) ? root["required"].filter((value) => typeof value === "string") : []
+  );
+  return Object.entries(properties).flatMap(([id, value]) => {
+    const property = record(value);
+    if (!property || typeof property["type"] !== "string") return [];
+    let type;
+    let options = optionsOf(property);
+    if (property["type"] === "array") {
+      type = "multiselect";
+      options = optionsOf(record(property["items"]) ?? {});
+    } else if (property["type"] === "string" && options) {
+      type = "select";
+    } else if (["string", "number", "integer", "boolean"].includes(property["type"])) {
+      type = property["type"];
+    } else {
+      return [];
+    }
+    const defaultValue = property["default"];
+    return [{
+      id,
+      label: typeof property["title"] === "string" ? property["title"] : id,
+      type,
+      required: required.has(id),
+      ...typeof property["description"] === "string" ? { description: property["description"] } : {},
+      ...options ? { options } : {},
+      ...typeof property["format"] === "string" ? { format: property["format"] } : {},
+      ...typeof property["minimum"] === "number" ? { minimum: property["minimum"] } : {},
+      ...typeof property["maximum"] === "number" ? { maximum: property["maximum"] } : {},
+      ...typeof property["minLength"] === "number" ? { minLength: property["minLength"] } : {},
+      ...typeof property["maxLength"] === "number" ? { maxLength: property["maxLength"] } : {},
+      ...typeof defaultValue === "string" || typeof defaultValue === "number" || typeof defaultValue === "boolean" || Array.isArray(defaultValue) && defaultValue.every((item) => typeof item === "string") ? { default: defaultValue } : {}
+    }];
+  });
+}
+function elicitationRequest(provider, sessionId, raw) {
+  const mode = raw["mode"];
+  if (mode === "url") {
+    return {
+      provider,
+      ...sessionId ? { sessionId } : {},
+      kind: "url",
+      message: typeof raw["message"] === "string" ? raw["message"] : "Open the requested URL",
+      ...typeof raw["serverName"] === "string" ? { source: raw["serverName"] } : {},
+      ...typeof raw["url"] === "string" ? { url: raw["url"] } : {},
+      raw
+    };
+  }
+  return {
+    provider,
+    ...sessionId ? { sessionId } : {},
+    kind: "form",
+    message: typeof raw["message"] === "string" ? raw["message"] : "Input requested",
+    ...typeof raw["serverName"] === "string" ? { source: raw["serverName"] } : {},
+    fields: inputFields(raw["requestedSchema"]),
+    raw
+  };
+}
+function declineInput() {
+  return { action: "decline" };
+}
+function elicitationResponse(response) {
+  return response.action === "accept" ? { action: "accept", content: response.values ?? null } : { action: response.action };
+}
+
+// src/core/providers/process.ts
+import { execFileSync, spawnSync } from "child_process";
+var GRACE_MS = 3e3;
+var ending = /* @__PURE__ */ new WeakSet();
+function descendants(root) {
+  let listing;
+  try {
+    listing = execFileSync("ps", ["-A", "-o", "pid=,ppid="], { encoding: "utf8", timeout: 2e3 });
+  } catch {
+    return [];
+  }
+  const children = /* @__PURE__ */ new Map();
+  for (const line of listing.split("\n")) {
+    const [pid, ppid] = line.trim().split(/\s+/).map(Number);
+    if (!pid || ppid === void 0 || Number.isNaN(ppid)) continue;
+    const list = children.get(ppid);
+    if (list) list.push(pid);
+    else children.set(ppid, [pid]);
+  }
+  const found = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    for (const child of children.get(stack.pop()) ?? []) {
+      found.push(child);
+      stack.push(child);
+    }
+  }
+  return found;
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function signal(pid, sig) {
+  try {
+    process.kill(pid, sig);
+  } catch {
+  }
+}
+function killTree(child, graceMs = GRACE_MS) {
+  if (!child || child.pid === void 0 || ending.has(child)) return;
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  ending.add(child);
+  const pid = child.pid;
+  if (process.platform === "win32") {
+    spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore" });
+    return;
+  }
+  const tree = [pid, ...descendants(pid)];
+  for (const member of tree) signal(member, "SIGTERM");
+  const timer = setTimeout(() => {
+    for (const member of tree) if (isAlive(member)) signal(member, "SIGKILL");
+  }, graceMs);
+  timer.unref?.();
+}
+
 // src/core/providers/queue.ts
 var AsyncQueue = class {
   buffer = [];
   waiting = null;
   ended = false;
   error = void 0;
+  /** Called once if the consumer stops iterating before the queue ends —
+   *  the producer's cue to stop whatever is feeding it. */
+  onReturn;
   push(value) {
     if (this.ended) return;
     if (this.waiting) {
@@ -251,7 +404,10 @@ var AsyncQueue = class {
         });
       },
       return: () => {
+        const stop = this.ended ? void 0 : this.onReturn;
+        this.onReturn = void 0;
         this.ended = true;
+        stop?.();
         return Promise.resolve({ value: void 0, done: true });
       }
     };
@@ -259,6 +415,8 @@ var AsyncQueue = class {
 };
 
 // src/core/providers/acp.ts
+var HANDSHAKE_TIMEOUT_MS = 3e4;
+var PROBE_TIMEOUT_MS = 2e4;
 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" } };
@@ -277,14 +435,18 @@ var AcpProvider = class {
     systemPrompt: false,
     thinking: false,
     effort: false,
-    streaming: "tokens"
+    streaming: "tokens",
+    serverTools: false
   };
+  sessionCapabilities = { fork: false };
   args;
   env;
   workDir;
   appName;
   modelConfigId;
   connectImpl;
+  handshakeTimeoutMs;
+  probeTimeoutMs;
   constructor(options) {
     this.id = options.id;
     this.label = options.label;
@@ -298,6 +460,8 @@ var AcpProvider = class {
     this.appName = options.appName ?? "yagami";
     this.modelConfigId = options.modelConfigId ?? "model";
     this.connectImpl = options.connect ?? ((cwd) => this.spawnConnection(cwd));
+    this.handshakeTimeoutMs = options.handshakeTimeoutMs ?? HANDSHAKE_TIMEOUT_MS;
+    this.probeTimeoutMs = options.probeTimeoutMs ?? PROBE_TIMEOUT_MS;
     fs2.mkdirSync(this.workDir, { recursive: true });
   }
   spawnConnection(cwd) {
@@ -323,6 +487,9 @@ var AcpProvider = class {
       const agent = new ClientSideConnection(
         () => ({
           requestPermission: (p) => handlers.onPermission ? handlers.onPermission(p) : rejectOption(p),
+          unstable_createElicitation: (p) => handlers.onInput ? handlers.onInput(p) : Promise.resolve({ action: "decline" }),
+          unstable_completeElicitation: () => {
+          },
           sessionUpdate: (n) => {
             handlers.onUpdate?.(n);
           }
@@ -330,37 +497,52 @@ var AcpProvider = class {
         stream
       );
       let settled = false;
+      const handshake = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        killTree(child);
+        reject(new ProviderError(this.id, `${this.label} did not finish the ACP handshake within ${Math.round(this.handshakeTimeoutMs / 1e3)}s`));
+      }, this.handshakeTimeoutMs);
+      handshake.unref?.();
       child.on("error", (err) => {
         if (settled) return;
         settled = true;
+        clearTimeout(handshake);
         reject(classifyProviderFailure(this.id, this.loginCommand, err));
       });
       child.on("exit", (code) => {
         if (settled) return;
         settled = true;
+        clearTimeout(handshake);
         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 }
+        clientCapabilities: {
+          fs: { readTextFile: false, writeTextFile: false },
+          terminal: false,
+          session: { configOptions: { boolean: {} } },
+          plan: {},
+          elicitation: { form: {}, url: {} }
+        }
       }).then((init) => {
         if (settled) return;
         settled = true;
+        clearTimeout(handshake);
         resolve({
           agent,
           init,
           setHandlers: (h) => {
             handlers = h;
           },
-          close: () => {
-            child.kill("SIGTERM");
-          }
+          close: () => killTree(child)
         });
       }).catch((err) => {
         if (settled) return;
         settled = true;
-        child.kill("SIGTERM");
+        clearTimeout(handshake);
+        killTree(child);
         reject(this.classify(err, stderr));
       });
     });
@@ -381,7 +563,13 @@ var AcpProvider = class {
     const onAbort = () => {
       if (sessionId) void conn.agent.cancel({ sessionId }).catch(() => {
       });
+      else conn.close();
     };
+    if (req.signal?.aborted) {
+      conn.close();
+      return;
+    }
+    req.signal?.addEventListener("abort", onAbort, { once: true });
     try {
       let configOptions;
       let modes;
@@ -410,6 +598,7 @@ var AcpProvider = class {
         });
       }
       if (req.model) await this.selectModel(conn, sessionId, configOptions, req.model);
+      if (req.effort) await this.selectEffort(conn, sessionId, configOptions, req.effort);
       const sid = sessionId;
       conn.setHandlers({
         onPermission: async (p) => rejectOption(p),
@@ -426,7 +615,6 @@ var AcpProvider = class {
           }
         }
       });
-      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",
@@ -455,6 +643,7 @@ var AcpProvider = class {
       connect: (cwd) => this.connectImpl(cwd),
       classify: (err, ctx) => this.classify(err, ctx),
       selectModel: (conn, sessionId, configOptions, model) => this.selectModel(conn, sessionId, configOptions, model),
+      selectEffort: (conn, sessionId, configOptions, effort) => this.selectEffort(conn, sessionId, configOptions, effort),
       options
     });
   }
@@ -468,22 +657,64 @@ var AcpProvider = class {
       throw this.classify(err);
     });
   }
-  async listModels() {
+  async selectEffort(conn, sessionId, configOptions, effort) {
+    const option = configOptions?.find(
+      (candidate) => candidate.category === "thought_level" || /^(?:thought[_-]?level|reasoning[_-]?effort|effort)$/i.test(candidate.id)
+    );
+    if (!option || option.type !== "select" || option.currentValue === effort) return;
+    if (!flattenSelectOptions(option).some((candidate) => candidate.value === effort)) return;
+    await conn.agent.setSessionConfigOption({ sessionId, configId: option.id, value: effort }).catch((err) => {
+      throw this.classify(err);
+    });
+  }
+  /**
+   * Run a short question against a fresh agent and close it, whatever
+   * happens. The deadline covers the whole exchange: an agent that answers
+   * the handshake and then sits on newSession forever (Gemini, signed out
+   * or mid-update) used to hold the probe open — and its process alive —
+   * for as long as the host ran.
+   */
+  async probe(ask) {
     const conn = await this.connectImpl(this.workDir);
+    let timer;
     try {
+      return await Promise.race([
+        ask(conn),
+        new Promise((_, reject) => {
+          timer = setTimeout(
+            () => reject(new ProviderError(this.id, `${this.label} did not answer within ${Math.round(this.probeTimeoutMs / 1e3)}s`)),
+            this.probeTimeoutMs
+          );
+          timer.unref?.();
+        })
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+      conn.close();
+    }
+  }
+  async listModels() {
+    return this.probe(async (conn) => {
       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 [];
+      const effortOption = created.configOptions?.find(
+        (candidate) => candidate.type === "select" && (candidate.category === "thought_level" || /^(?:thought[_-]?level|reasoning[_-]?effort|effort)$/i.test(candidate.id))
+      );
+      const efforts = effortOption?.type === "select" ? flattenSelectOptions(effortOption).map((entry) => ({
+        id: entry.value,
+        ...entry.description ? { description: entry.description } : {}
+      })) : [];
       return flattenSelectOptions(option).map((o) => ({
         id: o.value,
         display_name: o.name,
-        ...o.description ? { description: o.description } : {}
+        ...o.description ? { description: o.description } : {},
+        ...efforts.length > 0 ? { reasoning_efforts: efforts } : {},
+        ...effortOption?.type === "select" ? { default_reasoning_effort: effortOption.currentValue } : {}
       }));
-    } finally {
-      conn.close();
-    }
+    });
   }
   /**
    * The agent's self-reported name/version from the ACP handshake. When the
@@ -506,7 +737,7 @@ var AcpProvider = class {
     }
     let plain;
     try {
-      const out = spawnSync(this.executable, ["--version"], { encoding: "utf8", timeout: 1e4 });
+      const out = spawnSync2(this.executable, ["--version"], { encoding: "utf8", timeout: 1e4 });
       plain = out.stdout?.trim().split("\n")[0] || void 0;
     } catch {
       plain = void 0;
@@ -559,8 +790,10 @@ var AcpAgentSession = class {
     if (mode) await conn.agent.setSessionMode({ sessionId, modeId: mode }).catch(() => {
     });
     if (options.model) await this.cfg.selectModel(conn, sessionId, configOptions, options.model);
+    if (options.effort) await this.cfg.selectEffort(conn, sessionId, configOptions, options.effort);
     conn.setHandlers({
       onPermission: (p) => this.onPermission(p),
+      onInput: (p) => this.onInput(p),
       onUpdate: (n) => this.onUpdate(n)
     });
   }
@@ -593,6 +826,23 @@ var AcpAgentSession = class {
     }
     return rejectOption(p);
   }
+  async onInput(p) {
+    const request = elicitationRequest(
+      this.provider,
+      this.sessionId,
+      p
+    );
+    const handler = this.cfg.options.input;
+    let response = declineInput();
+    if (handler) {
+      try {
+        response = await handler.respond(request);
+      } catch {
+        response = { action: "cancel" };
+      }
+    }
+    return elicitationResponse(response);
+  }
   onUpdate(n) {
     if (n.sessionId !== this.sessionId) return;
     const u = n.update;
@@ -603,6 +853,21 @@ var AcpAgentSession = class {
       case "agent_thought_chunk":
         if (u.content.type === "text") this.queue?.push({ type: "thinking", text: u.content.text });
         break;
+      case "plan":
+        this.queue?.push({ type: "plan", plan: acpPlan(u) });
+        break;
+      case "plan_update":
+        this.queue?.push({ type: "plan", plan: acpPlan(u.plan ?? {}) });
+        break;
+      case "plan_removed":
+        this.queue?.push({
+          type: "plan",
+          plan: {
+            ...typeof u.planId === "string" ? { id: u.planId } : {},
+            removed: true
+          }
+        });
+        break;
       case "tool_call": {
         const t = u;
         const meta = { name: t.kind ?? "tool", ...t.title ? { title: t.title } : {}, ...t.kind ? { kind: t.kind } : {} };
@@ -683,6 +948,24 @@ var AcpAgentSession = class {
     this.conn = void 0;
   }
 };
+function acpPlan(raw) {
+  const entries = Array.isArray(raw["entries"]) ? raw["entries"].flatMap((value) => {
+    const entry = value;
+    if (typeof entry["content"] !== "string") return [];
+    const item = {
+      content: entry["content"],
+      status: entry["status"] === "completed" ? "completed" : entry["status"] === "in_progress" ? "in_progress" : "pending",
+      ...["high", "medium", "low"].includes(String(entry["priority"])) ? { priority: entry["priority"] } : {}
+    };
+    return [item];
+  }) : void 0;
+  return {
+    ...typeof raw["planId"] === "string" ? { id: raw["planId"] } : {},
+    ...entries ? { entries } : {},
+    ...typeof raw["content"] === "string" ? { markdown: raw["content"] } : {},
+    ...typeof raw["uri"] === "string" ? { uri: raw["uri"] } : {}
+  };
+}
 function supportsResume(init) {
   const caps = init.agentCapabilities;
   return caps?.sessionCapabilities?.resume !== void 0;
@@ -751,7 +1034,7 @@ function jsonLinesOnly(input, onNoise) {
 
 // src/core/providers/claude.ts
 import { createRequire } from "module";
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 import * as fs3 from "fs";
 import * as os3 from "os";
 import * as path3 from "path";
@@ -763,6 +1046,15 @@ var DENY_ALL_TOOLS = async (toolName) => ({
   message: `yagami is a completions-only endpoint; tool "${toolName}" is disabled.`,
   interrupt: true
 });
+var allowOnly = (enabled) => {
+  const allowed = new Set(enabled);
+  return async (toolName, input) => allowed.has(toolName) ? { behavior: "allow", updatedInput: input } : {
+    behavior: "deny",
+    message: `yagami is a completions-only endpoint; tool "${toolName}" is disabled.`,
+    interrupt: true
+  };
+};
+var SERVER_TOOL_MAX_TURNS = 24;
 var ClaudeProvider = class {
   id = "claude";
   label = "Claude Code";
@@ -776,7 +1068,8 @@ var ClaudeProvider = class {
     systemPrompt: true,
     thinking: true,
     effort: true,
-    streaming: "tokens"
+    streaming: "tokens",
+    serverTools: true
   };
   configDir;
   workDir;
@@ -811,6 +1104,11 @@ var ClaudeProvider = class {
     const onAbort = () => abortController.abort();
     req.signal?.addEventListener("abort", onAbort, { once: true });
     const options = { ...this.baseOptions(), abortController, includePartialMessages: true };
+    if (req.serverTools && req.serverTools.length > 0) {
+      options.tools = [...req.serverTools];
+      options.canUseTool = allowOnly(req.serverTools);
+      options.maxTurns = SERVER_TOOL_MAX_TURNS;
+    }
     if (req.model) options.model = req.model;
     if (req.system !== void 0) options.systemPrompt = req.system;
     if (req.resume) {
@@ -889,7 +1187,11 @@ var ClaudeProvider = class {
         id: m.value,
         display_name: m.displayName,
         ...m.description ? { description: m.description } : {},
-        ...m.resolvedModel ? { resolved_model: m.resolvedModel } : {}
+        ...m.resolvedModel ? { resolved_model: m.resolvedModel } : {},
+        ...m.supportedEffortLevels?.length ? { reasoning_efforts: m.supportedEffortLevels.map((id) => ({ id })) } : {},
+        ...m.supportsAdaptiveThinking ? { supports_adaptive_thinking: true } : {},
+        ...m.supportsFastMode ? { supports_fast_mode: true } : {},
+        ...m.supportsAutoMode ? { supports_auto_mode: true } : {}
       }));
     } catch (err) {
       throw classifyProviderFailure(this.id, this.loginCommand, err);
@@ -901,7 +1203,7 @@ var ClaudeProvider = class {
   }
   async version() {
     try {
-      const out = spawnSync2(this.executable, ["--version"], { encoding: "utf8", timeout: 1e4 });
+      const out = spawnSync3(this.executable, ["--version"], { encoding: "utf8", timeout: 1e4 });
       return out.stdout?.trim().split("\n")[0] || void 0;
     } catch {
       return void 0;
@@ -975,7 +1277,7 @@ function mediaPrompt(text, media) {
 }
 
 // src/core/providers/codex.ts
-import { spawn as spawn4, spawnSync as spawnSync3 } from "child_process";
+import { spawn as spawn4, spawnSync as spawnSync4 } from "child_process";
 import * as fs4 from "fs";
 import * as os4 from "os";
 import * as path4 from "path";
@@ -999,12 +1301,17 @@ var CodexAgentSession = class {
   lastUsage;
   opening;
   closed = false;
+  sending = false;
+  turnAbort;
+  reasoningEmitted = /* @__PURE__ */ new Map();
+  incoming = /* @__PURE__ */ new Map();
   /** Item text already emitted as deltas, so item/completed only fills gaps. */
   emitted = /* @__PURE__ */ new Map();
   get id() {
     return this.threadId;
   }
   fail(err) {
+    this.turnAbort?.abort();
     for (const [, p] of this.pending) p.reject(err);
     this.pending.clear();
     this.queue?.fail(err);
@@ -1029,6 +1336,7 @@ var CodexAgentSession = class {
     return promise;
   }
   respond(id, result) {
+    if (this.incoming.get(id)?.signal.aborted) return;
     this.child?.stdin?.write(`${JSON.stringify({ jsonrpc: "2.0", id, result })}
 `);
   }
@@ -1082,13 +1390,20 @@ var CodexAgentSession = class {
       ...native.config ? { config: native.config } : {},
       ...options.systemPrompt ? { developerInstructions: options.systemPrompt } : {}
     };
+    if (options.resume && (options.fork || options.forkAt)) {
+      const forked = await this.request("thread/fork", {
+        threadId: options.resume,
+        ...options.forkAt ? { lastTurnId: options.forkAt } : {},
+        ...overrides
+      });
+      this.threadId = forked["thread"]?.id;
+      if (!this.threadId) throw new ProviderError("codex", "thread/fork returned no thread id");
+      return;
+    }
     if (options.resume) {
-      try {
-        const resumed = await this.request("thread/resume", { threadId: options.resume, ...overrides });
-        this.threadId = resumed["thread"]?.id ?? options.resume;
-        return;
-      } catch {
-      }
+      const resumed = await this.request("thread/resume", { threadId: options.resume, ...overrides });
+      this.threadId = resumed["thread"]?.id ?? options.resume;
+      return;
     }
     const started = await this.request("thread/start", overrides);
     this.threadId = started["thread"]?.id;
@@ -1106,7 +1421,17 @@ var CodexAgentSession = class {
     }
     if (!msg.method) return;
     if (msg.id !== void 0) {
-      void this.handleServerRequest(msg.method, msg.id, msg.params ?? {});
+      const id = msg.id;
+      const controller = new AbortController();
+      const parent = this.turnAbort?.signal;
+      const cancel = () => controller.abort();
+      if (parent?.aborted) controller.abort();
+      else parent?.addEventListener("abort", cancel, { once: true });
+      this.incoming.set(id, controller);
+      void this.handleServerRequest(msg.method, id, msg.params ?? {}, controller.signal).finally(() => {
+        parent?.removeEventListener("abort", cancel);
+        this.incoming.delete(id);
+      });
       return;
     }
     this.handleNotification(msg.method, msg.params ?? {});
@@ -1116,7 +1441,13 @@ var CodexAgentSession = class {
   }
   handleNotification(method, params) {
     if (params["threadId"] !== void 0 && params["threadId"] !== this.threadId) return;
+    if (this.currentTurnId && typeof params["turnId"] === "string" && params["turnId"] !== this.currentTurnId) return;
     switch (method) {
+      case "serverRequest/resolved": {
+        const requestId = params["requestId"];
+        if (typeof requestId === "string" || typeof requestId === "number") this.incoming.get(requestId)?.abort();
+        break;
+      }
       case "item/agentMessage/delta": {
         const itemId = params["itemId"];
         const delta = params["delta"];
@@ -1124,6 +1455,14 @@ var CodexAgentSession = class {
         this.push({ type: "text", text: delta });
         break;
       }
+      case "item/reasoning/summaryTextDelta": {
+        const delta = params["delta"];
+        if (typeof delta !== "string") break;
+        const key = `${String(params["itemId"])}:${String(params["summaryIndex"] ?? 0)}`;
+        this.reasoningEmitted.set(key, (this.reasoningEmitted.get(key) ?? 0) + delta.length);
+        this.push({ type: "thinking", text: delta });
+        break;
+      }
       case "item/started":
       case "item/completed": {
         this.handleItem(params["item"], method === "item/completed");
@@ -1142,11 +1481,32 @@ var CodexAgentSession = class {
         }
         break;
       }
+      case "turn/plan/updated": {
+        const steps = Array.isArray(params["plan"]) ? params["plan"] : [];
+        this.push({
+          type: "plan",
+          plan: {
+            ...typeof params["explanation"] === "string" ? { explanation: params["explanation"] } : {},
+            entries: steps.flatMap((value) => {
+              const step = value;
+              if (typeof step["step"] !== "string") return [];
+              return [{
+                content: step["step"],
+                status: codexPlanStatus(step["status"])
+              }];
+            })
+          }
+        });
+        break;
+      }
       case "turn/completed": {
         const turn = params["turn"];
+        const turnId = params["turn"]?.id;
+        if (this.currentTurnId && turnId && turnId !== this.currentTurnId) break;
         const queue = this.queue;
         this.queue = null;
         this.currentTurnId = void 0;
+        this.turnAbort?.abort();
         if (!queue) break;
         if (turn.status === "failed") {
           queue.fail(this.classify(new Error(turn.error?.message ?? "turn failed")));
@@ -1183,8 +1543,13 @@ var CodexAgentSession = class {
       }
       case "reasoning": {
         if (!completed) break;
-        const summary = item["summary"]?.join("\n") ?? "";
-        if (summary) this.push({ type: "thinking", text: summary });
+        const summaries = item["summary"] ?? [];
+        summaries.forEach((summary, index) => {
+          const key = `${id}:${index}`;
+          const seen = this.reasoningEmitted.get(key) ?? 0;
+          if (summary.length > seen) this.push({ type: "thinking", text: summary.slice(seen) });
+          this.reasoningEmitted.delete(key);
+        });
         break;
       }
       case "commandExecution": {
@@ -1237,8 +1602,59 @@ var CodexAgentSession = class {
         });
         break;
       }
-      case "userMessage":
+      case "dynamicToolCall": {
+        const failed = item["status"] === "failed" || item["success"] === false;
+        const namespace = typeof item["namespace"] === "string" ? `${item["namespace"]}.` : "";
+        this.push({
+          type: "tool_call",
+          id,
+          name: `${namespace}${String(item["tool"] ?? "tool")}`,
+          status: completed ? failed ? "failed" : "completed" : "started",
+          kind: "other",
+          input: item["arguments"],
+          ...completed ? { output: item["contentItems"] } : {}
+        });
+        break;
+      }
+      case "collabAgentToolCall": {
+        const status = item["status"];
+        const failed = status === "failed" || status === "interrupted";
+        const tool = collabToolName(item["tool"]);
+        this.push({
+          type: "tool_call",
+          id,
+          name: tool,
+          status: completed ? failed ? "failed" : "completed" : "started",
+          title: typeof item["prompt"] === "string" && item["prompt"] ? item["prompt"] : tool,
+          kind: "other",
+          input: {
+            prompt: item["prompt"],
+            model: item["model"],
+            effort: item["reasoningEffort"],
+            receiverThreadIds: item["receiverThreadIds"]
+          },
+          ...completed ? { output: item["agentsStates"] } : {}
+        });
+        break;
+      }
+      case "imageView": {
+        this.push({
+          type: "tool_call",
+          id,
+          name: "read_file",
+          status: completed ? "completed" : "started",
+          title: String(item["path"] ?? "image"),
+          kind: "read",
+          input: { path: item["path"] }
+        });
+        break;
+      }
       case "plan":
+        if (completed && typeof item["text"] === "string") {
+          this.push({ type: "plan", plan: { id, markdown: item["text"] } });
+        }
+        break;
+      case "userMessage":
         break;
       default:
         this.push({ type: "raw", provider: "codex", payload: item });
@@ -1246,16 +1662,17 @@ var CodexAgentSession = class {
     }
   }
   // ── approvals: forwarded to the host, answered like the TUI would ──
-  async decide(request) {
+  async decide(request, signal2) {
+    if (signal2?.aborted) return "deny";
     try {
-      const decision = await this.config.options.permissions.decide(request);
+      const decision = await this.config.options.permissions.decide(request, signal2);
       this.push({ type: "permission", request, decision });
       return decision;
     } catch {
       return "deny";
     }
   }
-  async handleServerRequest(method, id, params) {
+  async handleServerRequest(method, id, params, signal2) {
     switch (method) {
       case "item/commandExecution/requestApproval": {
         const decision = await this.decide({
@@ -1266,7 +1683,7 @@ var CodexAgentSession = class {
           title: String(params["command"] ?? "command"),
           input: { command: params["command"], cwd: params["cwd"], reason: params["reason"] },
           raw: params
-        });
+        }, signal2);
         this.respond(id, {
           decision: decision === "allow" ? "accept" : decision === "allow_always" ? "acceptForSession" : "decline"
         });
@@ -1281,7 +1698,7 @@ var CodexAgentSession = class {
           title: String(params["reason"] ?? "apply file changes"),
           input: { reason: params["reason"], grantRoot: params["grantRoot"] },
           raw: params
-        });
+        }, signal2);
         this.respond(id, {
           decision: decision === "allow" ? "accept" : decision === "allow_always" ? "acceptForSession" : "decline"
         });
@@ -1297,7 +1714,7 @@ var CodexAgentSession = class {
           title: String(params["reason"] ?? "extra permissions"),
           input: requested,
           raw: params
-        });
+        }, signal2);
         const granted = decision === "allow" || decision === "allow_always";
         this.respond(id, {
           permissions: granted ? { network: requested?.["network"] ?? void 0, fileSystem: requested?.["fileSystem"] ?? void 0 } : {},
@@ -1316,18 +1733,32 @@ var CodexAgentSession = class {
           title: String(params["command"] ?? params["reason"] ?? "approval"),
           input: params,
           raw: params
-        });
+        }, signal2);
         this.respond(id, {
           decision: decision === "allow" ? "approved" : decision === "allow_always" ? "approved_for_session" : { denied: { rejection: "denied by the user" } }
         });
         break;
       }
       case "item/tool/requestUserInput": {
-        this.respond(id, { answers: {} });
+        const response = await this.input(codexQuestionRequest(this.threadId, params), signal2);
+        const values = response.action === "accept" ? response.values ?? {} : {};
+        this.respond(id, {
+          answers: Object.fromEntries(
+            Object.entries(values).map(([key, value]) => [
+              key,
+              { answers: (Array.isArray(value) ? value : [value]).map(String) }
+            ])
+          )
+        });
         break;
       }
       case "mcpServer/elicitation/request": {
-        this.respond(id, { action: "decline", content: null, _meta: null });
+        const response = await this.input(elicitationRequest("codex", this.threadId, params), signal2);
+        this.respond(id, { ...elicitationResponse(response), _meta: null });
+        break;
+      }
+      case "currentTime/read": {
+        this.respond(id, { currentTimeAt: Math.floor(Date.now() / 1e3) });
         break;
       }
       default: {
@@ -1339,51 +1770,133 @@ var CodexAgentSession = class {
       }
     }
   }
+  async input(request, signal2) {
+    const handler = this.config.options.input;
+    if (!handler) return declineInput();
+    try {
+      if (signal2?.aborted) return { action: "cancel" };
+      return await handler.respond(request, signal2);
+    } catch {
+      return { action: "cancel" };
+    }
+  }
   // ── the ProviderSession surface ────────────────────────────────────
   async *send(input) {
     if (this.closed) throw new ProviderError("codex", "session is closed");
-    if (this.queue) throw new ProviderError("codex", "a turn is already running");
-    await this.ensureOpen();
-    const blocks = typeof input === "string" ? [{ type: "text", text: input }] : input;
-    const { paths, cleanup } = writeTempImages(blocks);
-    const items = [];
-    for (const block of blocks) {
-      if (block.type === "text" && typeof block.text === "string") {
-        items.push({ type: "text", text: block.text, text_elements: [] });
-      }
-    }
-    for (const p of paths) items.push({ type: "localImage", path: p });
-    if (items.length === 0) items.push({ type: "text", text: "", text_elements: [] });
+    if (this.sending) throw new ProviderError("codex", "a turn is already running");
+    this.sending = true;
+    const controller = new AbortController();
+    this.turnAbort = controller;
+    let cleanup = () => {
+    };
     const queue = new AsyncQueue();
-    this.queue = queue;
-    this.lastUsage = void 0;
     try {
+      await this.ensureOpen();
+      if (controller.signal.aborted) {
+        yield { type: "done", stopReason: "interrupted" };
+        return;
+      }
+      const blocks = typeof input === "string" ? [{ type: "text", text: input }] : input;
+      const images = writeTempImages(blocks);
+      cleanup = images.cleanup;
+      const items = [];
+      for (const block of blocks) {
+        if (block.type === "text" && typeof block.text === "string") {
+          items.push({ type: "text", text: block.text, text_elements: [] });
+        }
+      }
+      for (const p of images.paths) items.push({ type: "localImage", path: p });
+      if (items.length === 0) items.push({ type: "text", text: "", text_elements: [] });
+      this.queue = queue;
+      this.lastUsage = void 0;
+      this.emitted.clear();
+      this.reasoningEmitted.clear();
       const result = await this.request("turn/start", {
         threadId: this.threadId,
         input: items,
         ...this.config.options.effort ? { effort: this.config.options.effort } : {}
       });
-      this.currentTurnId = result["turn"]?.id;
+      const turnId = result["turn"]?.id;
+      if (this.queue === queue) this.currentTurnId = turnId;
+      if (controller.signal.aborted && this.currentTurnId) await this.interrupt();
       yield { type: "session", sessionId: this.threadId };
+      if (turnId) yield { type: "turn", id: turnId };
       for await (const event of queue) yield event;
     } finally {
       cleanup();
+      controller.abort();
+      if (this.queue === queue) await this.interrupt();
       if (this.queue === queue) this.queue = null;
+      this.currentTurnId = void 0;
+      this.turnAbort = void 0;
+      this.sending = false;
     }
   }
   async interrupt() {
-    if (!this.threadId || !this.currentTurnId) return;
-    await this.request("turn/interrupt", { threadId: this.threadId, turnId: this.currentTurnId }).catch(() => {
-    });
+    const request = this.threadId && this.currentTurnId ? this.request("turn/interrupt", { threadId: this.threadId, turnId: this.currentTurnId }).catch(() => {
+    }) : Promise.resolve();
+    this.turnAbort?.abort();
+    await request;
   }
   async close() {
     if (this.closed) return;
     this.closed = true;
     this.fail(new ProviderError("codex", "session closed"));
-    this.child?.kill("SIGTERM");
+    killTree(this.child);
     this.child = void 0;
   }
 };
+function collabToolName(value) {
+  const names = {
+    spawnAgent: "spawn_agent",
+    sendInput: "send_input",
+    resumeAgent: "resume_agent",
+    closeAgent: "close_agent",
+    sendMessage: "send_message",
+    followupTask: "followup_task",
+    interruptAgent: "interrupt_agent",
+    listAgents: "list_agents"
+  };
+  return names[String(value)] ?? String(value ?? "agent");
+}
+function codexPlanStatus(value) {
+  return value === "completed" ? "completed" : value === "inProgress" || value === "in_progress" ? "in_progress" : "pending";
+}
+function codexQuestionRequest(sessionId, raw) {
+  const questions = Array.isArray(raw["questions"]) ? raw["questions"] : [];
+  const fields = questions.flatMap((value) => {
+    const question = value;
+    if (typeof question["id"] !== "string" || typeof question["question"] !== "string") return [];
+    const choices = Array.isArray(question["options"]) ? question["options"].flatMap((option) => {
+      const item = option;
+      if (typeof item["label"] !== "string") return [];
+      return [{
+        value: item["label"],
+        label: item["label"],
+        ...typeof item["description"] === "string" ? { description: item["description"] } : {}
+      }];
+    }) : [];
+    return [{
+      id: question["id"],
+      label: question["question"],
+      ...typeof question["header"] === "string" ? { description: question["header"] } : {},
+      type: choices.length > 0 ? "select" : "string",
+      required: true,
+      secret: question["isSecret"] === true,
+      allowOther: question["isOther"] === true,
+      ...choices.length > 0 ? { options: choices } : {}
+    }];
+  });
+  return {
+    provider: "codex",
+    ...sessionId ? { sessionId } : {},
+    kind: "questions",
+    message: fields.length === 1 ? fields[0].label : "Input requested",
+    fields,
+    blocking: raw["isBlocking"] !== false,
+    raw
+  };
+}
 
 // src/core/providers/jsonl.ts
 import { spawn as spawn3 } from "child_process";
@@ -1420,12 +1933,17 @@ function spawnJsonl(options) {
     }
   });
   const onAbort = () => {
-    child.kill("SIGTERM");
+    killTree(child);
     queue.end();
   };
   options.signal?.addEventListener("abort", onAbort, { once: true });
+  queue.onReturn = () => {
+    options.signal?.removeEventListener("abort", onAbort);
+    killTree(child);
+  };
   child.on("error", (err) => queue.fail(err));
   child.on("close", (code) => {
+    queue.onReturn = void 0;
     options.signal?.removeEventListener("abort", onAbort);
     if (options.signal?.aborted) return queue.end();
     if (code !== 0) queue.fail(new ProcessExitError(code, stderr));
@@ -1452,8 +1970,10 @@ var CodexProvider = class {
     systemPrompt: false,
     thinking: false,
     effort: true,
-    streaming: "chunks"
+    streaming: "chunks",
+    serverTools: false
   };
+  sessionCapabilities = { fork: true };
   workDir;
   sandbox;
   env;
@@ -1549,7 +2069,7 @@ var CodexProvider = class {
         if (settled) return;
         settled = true;
         clearTimeout(timer);
-        child.kill("SIGTERM");
+        killTree(child);
         fn();
       };
       const timer = setTimeout(() => finish(() => reject(new ProviderError(this.id, "timed out listing models via app-server"))), 15e3);
@@ -1578,11 +2098,34 @@ var CodexProvider = class {
             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"] } : {}
-          }));
+          const models = (msg.result?.data ?? []).filter((m) => m["hidden"] !== true).map((m) => {
+            const efforts = Array.isArray(m["supportedReasoningEfforts"]) ? m["supportedReasoningEfforts"].flatMap(
+              (entry) => typeof entry["reasoningEffort"] === "string" ? [{
+                id: entry["reasoningEffort"],
+                ...typeof entry["description"] === "string" ? { description: entry["description"] } : {}
+              }] : []
+            ) : [];
+            const tiers = Array.isArray(m["serviceTiers"]) ? m["serviceTiers"].flatMap(
+              (entry) => typeof entry["id"] === "string" ? [{
+                id: entry["id"],
+                display_name: typeof entry["name"] === "string" ? entry["name"] : entry["id"],
+                ...typeof entry["description"] === "string" ? { description: entry["description"] } : {}
+              }] : []
+            ) : [];
+            return {
+              id: String(m["id"] ?? m["model"]),
+              display_name: String(m["displayName"] ?? m["id"] ?? m["model"]),
+              ...typeof m["description"] === "string" ? { description: m["description"] } : {},
+              ...efforts.length > 0 ? { reasoning_efforts: efforts } : {},
+              ...typeof m["defaultReasoningEffort"] === "string" ? { default_reasoning_effort: m["defaultReasoningEffort"] } : {},
+              ...Array.isArray(m["inputModalities"]) ? { input_modalities: m["inputModalities"].filter((value) => typeof value === "string") } : {},
+              ...m["supportsPersonality"] === true ? { supports_personality: true } : {},
+              ...typeof m["multiAgentVersion"] === "string" ? { multi_agent: m["multiAgentVersion"] } : {},
+              ...tiers.length > 0 ? { service_tiers: tiers } : {},
+              ...typeof m["defaultServiceTier"] === "string" ? { default_service_tier: m["defaultServiceTier"] } : {},
+              ...m["isDefault"] === true ? { is_default: true } : {}
+            };
+          });
           finish(() => resolve(models));
         }
       });
@@ -1599,7 +2142,7 @@ var CodexProvider = class {
   }
   async version() {
     try {
-      const out = spawnSync3(this.executable, ["--version"], { encoding: "utf8", timeout: 1e4 });
+      const out = spawnSync4(this.executable, ["--version"], { encoding: "utf8", timeout: 1e4 });
       return out.stdout?.trim().split("\n")[0] || void 0;
     } catch {
       return void 0;
@@ -1901,6 +2444,61 @@ var SseSynthesizer = class {
 
 // src/core/transcript.ts
 import { createHash } from "crypto";
+
+// src/core/serverTools.ts
+var SERVER_TOOLS = {
+  web_search: "WebSearch",
+  web_fetch: "WebFetch"
+};
+function serverToolFor(type) {
+  if (typeof type !== "string") return void 0;
+  for (const [prefix, tool] of Object.entries(SERVER_TOOLS)) {
+    if (type === prefix || type.startsWith(`${prefix}_`)) return tool;
+  }
+  return void 0;
+}
+function resolveServerTools(tools, toolChoice) {
+  if (tools == null) {
+    if (toolChoice != null) {
+      throw new ApiError(
+        400,
+        "invalid_request_error",
+        "`tool_choice` was given without `tools`."
+      );
+    }
+    return void 0;
+  }
+  if (!Array.isArray(tools)) {
+    throw new ApiError(400, "invalid_request_error", "`tools` must be an array");
+  }
+  if (tools.length === 0) return void 0;
+  const resolved = /* @__PURE__ */ new Set();
+  for (const tool of tools) {
+    const entry = tool;
+    const mapped = serverToolFor(entry?.type);
+    if (!mapped) {
+      const label = typeof entry?.name === "string" ? `"${entry.name}"` : `type "${String(entry?.type)}"`;
+      throw new ApiError(
+        400,
+        "invalid_request_error",
+        `yagami supports Anthropic server tools (${Object.keys(SERVER_TOOLS).join(", ")}) but not custom tools: ${label} would have to be executed by you, and this endpoint never emits tool_use blocks. Drop it, or ask for the result as text/JSON instead.`
+      );
+    }
+    resolved.add(mapped);
+  }
+  const choice = toolChoice?.type;
+  if (choice != null && choice !== "auto" && choice !== "none") {
+    throw new ApiError(
+      400,
+      "invalid_request_error",
+      `\`tool_choice.type\` must be "auto" or "none" with server tools (got "${String(choice)}"): server tools run on the engine's side and cannot be forced.`
+    );
+  }
+  if (choice === "none") return void 0;
+  return [...resolved];
+}
+
+// src/core/transcript.ts
 var IGNORABLE_PARAMS = [
   "max_tokens",
   "temperature",
@@ -1962,13 +2560,7 @@ 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."
-    );
-  }
+  const serverTools = resolveServerTools(req.tools, req.tool_choice);
   if (!Array.isArray(req.messages) || req.messages.length === 0) {
     throw new ApiError(400, "invalid_request_error", "`messages` must be a non-empty array");
   }
@@ -2004,7 +2596,8 @@ function normalizeRequest(req) {
     messages,
     lastUserText: last.text,
     ...prefill !== void 0 ? { prefill } : {},
-    ignored: [...ignored]
+    ignored: [...ignored],
+    ...serverTools ? { serverTools } : {}
   };
 }
 function prefillDirective(prefill) {
@@ -2232,6 +2825,13 @@ ${norm.system}
 
 ${promptText}`;
     }
+    if (norm.serverTools && !caps.serverTools) {
+      throw new ApiError(
+        400,
+        "invalid_request_error",
+        `provider "${provider.id}" cannot run server tools (${norm.serverTools.join(", ")}). Answering without them would silently drop the lookup you asked for, so the request is refused instead. Use the claude provider, or drop \`tools\`.`
+      );
+    }
     const turn = {
       prompt: promptText,
       ...lastMedia.length > 0 ? { media: lastMedia } : {},
@@ -2239,7 +2839,8 @@ ${promptText}`;
       ...model ? { model } : {},
       ...resume ? { resume } : {},
       ...req.thinking != null && caps.thinking ? { thinking: req.thinking } : {},
-      ...typeof req.effort === "string" && caps.effort ? { effort: req.effort } : {}
+      ...typeof req.effort === "string" && caps.effort ? { effort: req.effort } : {},
+      ...norm.serverTools ? { serverTools: norm.serverTools } : {}
     };
     const requestedModel = model ? provider.id === this.defaultProviderId ? model : qualifiedModel(provider.id, model) : provider.id;
     return { provider, turn, norm, requestedModel, ignored, ...resume && resumeKey ? { resumeKey } : {} };
@@ -2330,7 +2931,7 @@ ${promptText}`;
     };
   }
   async *runStream(req, prepared, streamOptions) {
-    const { signal } = streamOptions;
+    const { signal: signal2 } = streamOptions;
     let emitted = false;
     try {
       for await (const ev of this.attemptStream(prepared, streamOptions)) {
@@ -2339,7 +2940,7 @@ ${promptText}`;
       }
       return;
     } catch (err) {
-      if (signal?.aborted) return;
+      if (signal2?.aborted) return;
       const fallback = emitted ? void 0 : this.prepareResumeFallback(req, prepared);
       if (!fallback) {
         yield { event: "error", data: toApiError(err).toBody() };
@@ -2348,13 +2949,13 @@ ${promptText}`;
       try {
         yield* this.attemptStream(fallback, streamOptions);
       } catch (err2) {
-        if (!signal?.aborted) yield { event: "error", data: toApiError(err2).toBody() };
+        if (!signal2?.aborted) yield { event: "error", data: toApiError(err2).toBody() };
       }
     }
   }
   async *attemptStream(prepared, streamOptions) {
     const { provider, turn, norm, requestedModel } = prepared;
-    const { signal } = streamOptions;
+    const { signal: signal2 } = streamOptions;
     const stripper = norm.prefill ? new PrefillStripper(norm.prefill) : void 0;
     const sse = new SseSynthesizer(`msg_${randomUUID().replace(/-/g, "")}`, requestedModel);
     let sessionId;
@@ -2366,7 +2967,7 @@ ${promptText}`;
       started = true;
       return sse.start();
     };
-    for await (const ev of provider.run({ ...turn, ...signal ? { signal } : {} })) {
+    for await (const ev of provider.run({ ...turn, ...signal2 ? { signal: signal2 } : {} })) {
       if (ev.type === "session") {
         sessionId = ev.sessionId;
       } else if (ev.type === "text") {
@@ -2381,7 +2982,7 @@ ${promptText}`;
         done = ev;
       }
     }
-    if (signal?.aborted) return;
+    if (signal2?.aborted) return;
     if (!done) throw new ProviderError(provider.id, "turn ended without a result");
     yield* start();
     if (stripper) {
@@ -2499,7 +3100,7 @@ function chatToMessagesRequest(body) {
     throw new ApiError(
       400,
       "invalid_request_error",
-      "yagami does not support `tools`/function calling: the backing engine runs as a pure completions endpoint and never executes or emits tool calls."
+      "yagami does not support OpenAI function calling: the backing engine never emits tool calls for you to execute. Anthropic **server** tools (web_search, web_fetch) do run \u2014 request them through the Anthropic dialect at /v1/messages."
     );
   }
   if (body.n != null && body.n !== 1) {
@@ -2692,4 +3293,4 @@ export {
   ChatChunkTranslator,
   modelListBody
 };
-//# sourceMappingURL=chunk-ZYHC7PXX.js.map
+//# sourceMappingURL=chunk-EKN223KD.js.map