@justin06lee/yagami 0.4.1 → 0.5.0

package/README.md

@@ -4,54 +4,62 @@
 
 # yagami
 
-**Your signed-in coding-agent CLIs as one self-hosted Anthropic-compatible API.**<br>
-*Claude Code, Codex, OpenCode, Gemini CLI and any ACP agent — point any Anthropic client at your own subscriptions, or embed the engine as a library.*
+**Your signed-in coding-agent CLIs as one self-hosted Anthropic- and OpenAI-compatible API.**<br>
+*Claude Code, Codex, OpenCode, Gemini CLI and any ACP agent — point any Anthropic or OpenAI client at your own subscriptions, or embed the engine as a library with zero config.*
 
 </div>
 
 ---
 
-yagami does the T3-Code trick, generalized: it drives the coding-agent CLIs you already installed and logged into — Claude Code through the Agent SDK (`pathToClaudeCodeExecutable`), Codex through `codex exec`, and OpenCode, Gemini CLI, Copilot, Cursor, Qwen Code, Kimi, Goose and the rest of the [ACP registry](https://agentclientprotocol.com) through the Agent Client Protocol. No API keys from any vendor, no separate auth — each spawned engine uses the same login your terminal sessions do. On top it serves `POST /v1/messages` with Anthropic request/response shapes and SSE streaming, so anything that accepts an Anthropic `baseURL` + `apiKey` can use it as a drop-in, and pick a harness per request with `model: "<provider>:<model>"`.
+yagami does the T3-Code trick, generalized: it drives the coding-agent CLIs you already installed and logged into — Claude Code through the Agent SDK (`pathToClaudeCodeExecutable`), Codex through `codex exec`, and OpenCode, Gemini CLI, Copilot, Cursor, Qwen Code, Kimi, Goose and the rest of the [ACP registry](https://agentclientprotocol.com) through the Agent Client Protocol. No API keys from any vendor, no separate auth — each spawned engine uses the same login your terminal sessions do.
+
+There are two doors in, and they're deliberately different:
+
+| | Who it's for | What you get |
+|---|---|---|
+| **Server** — the `yagami` binary | A machine that should hand out an API key (a home server, a box your other apps talk to) | `yagami start` prints a **URL + API key** that works with any app that accepts an Anthropic *or* OpenAI base URL + key |
+| **Library** — `@justin06lee/yagami` | An app running *on* the machine with the signed-in CLIs | `new Yagami()` — **no URL, no API key, nothing to configure**. It finds the CLIs itself and syncs with the binary's config |
 
 > **Personal use only.** This exists so *you* can point *your own tools* at *your own subscriptions*. Offering subscription-backed access to other people is against every one of these vendors' terms. Keep the endpoint private and don't share keys.
 
-## Install
+## Server mode
 
 ```sh
 make          # bun install + build + install `yagami` onto your PATH (~/.local/bin)
 yagami start  # first run generates + saves an API key and prints it
 ```
 
-`make update` stops any running yagami server, rebuilds, reinstalls, and restarts it.
-
-Or install the published package from npm:
-
-```sh
-bun add -g @justin06lee/yagami   # global `yagami` CLI
-bun add @justin06lee/yagami      # or as a library (see Library mode)
-```
+`make update` stops any running yagami server, rebuilds, reinstalls, and restarts it. Or install from npm: `bun add -g @justin06lee/yagami`.
 
 ```
-yagami v0.4.1
+yagami v0.5.0
   listening   http://127.0.0.1:8787
   provider    claude — /Users/you/.local/bin/claude (2.1.238 (Claude Code))
   also        codex, opencode (use model "<provider>:<model>")
   api key     ygm_…
+
+Connect apps — either dialect, same key (`yagami key` prints ready-to-paste env exports):
+  Anthropic apps   baseURL http://127.0.0.1:8787      (ANTHROPIC_BASE_URL / ANTHROPIC_API_KEY)
+  OpenAI apps      baseURL http://127.0.0.1:8787/v1   (OPENAI_BASE_URL / OPENAI_API_KEY)
 ```
 
-Then from any Anthropic client:
+Apps can't be reached by a key alone — they need somewhere to route — so the pair is always **URL + key**. Most apps take them as a "base URL" field or the standard env vars; `yagami key` prints both ready to paste:
+
+```sh
+export ANTHROPIC_BASE_URL=http://127.0.0.1:8787   ANTHROPIC_API_KEY=ygm_...
+export OPENAI_BASE_URL=http://127.0.0.1:8787/v1   OPENAI_API_KEY=ygm_...
+```
+
+Anthropic-dialect apps speak to `POST /v1/messages`, OpenAI-dialect apps to `POST /v1/chat/completions` — same engine, same key, streaming included:
 
 ```ts
 import Anthropic from "@anthropic-ai/sdk";
+const anthropic = new Anthropic({ baseURL: "http://127.0.0.1:8787", apiKey: process.env.YAGAMI_KEY });
+await anthropic.messages.create({ model: "sonnet", max_tokens: 1024, messages: [{ role: "user", content: "hello" }] });
 
-const client = new Anthropic({
-  baseURL: "http://127.0.0.1:8787",
-  apiKey: process.env.YAGAMI_KEY, // your ygm_ key
-});
-
-await client.messages.create({ model: "sonnet", max_tokens: 1024, messages: [{ role: "user", content: "hello" }] });
-await client.messages.create({ model: "codex:gpt-5.6-sol", max_tokens: 1024, messages: [{ role: "user", content: "hello" }] });
-await client.messages.create({ model: "opencode:anthropic/claude-sonnet-4", max_tokens: 1024, messages: [{ role: "user", content: "hello" }] });
+import OpenAI from "openai";
+const openai = new OpenAI({ baseURL: "http://127.0.0.1:8787/v1", apiKey: process.env.YAGAMI_KEY });
+await openai.chat.completions.create({ model: "codex:gpt-5.6-sol", messages: [{ role: "user", content: "hello" }] });
 ```
 
 Or raw curl:
@@ -60,8 +68,84 @@ Or raw curl:
 curl http://127.0.0.1:8787/v1/messages \
   -H "x-api-key: ygm_..." -H "content-type: application/json" \
   -d '{"model":"codex","max_tokens":64,"messages":[{"role":"user","content":"ping"}]}'
+
+curl http://127.0.0.1:8787/v1/chat/completions \
+  -H "authorization: Bearer ygm_..." -H "content-type: application/json" \
+  -d '{"model":"codex","messages":[{"role":"user","content":"ping"}]}'
+```
+
+One caveat for OpenAI-dialect apps: the `model` field still routes through yagami's providers — set it to a model your CLIs actually serve (`sonnet`, `codex:gpt-5.6-sol`, `opencode:…`), not whatever `gpt-*` id the app defaults to.
+
+## Library mode
+
+For apps that run on the machine with the signed-in CLIs — a desktop app, a script, anything embedding the engine in-process. **No server, no URL, no API key**: `new Yagami()` auto-detects the CLIs and reads `~/.config/yagami/config.json` if the binary has one, so library and server stay in sync automatically.
+
+```ts
+import { Yagami } from "@justin06lee/yagami";
+
+const yagami = new Yagami(); // that's it — hooks straight into the host's CLIs
+
+// Anthropic SDK shape:
+const msg = await yagami.messages.create({ messages: [{ role: "user", content: "hello" }] });
+for await (const ev of yagami.messages.create({ messages: [...], stream: true })) { /* Anthropic stream events */ }
+
+// OpenAI SDK shape, same engine:
+const completion = await yagami.chat.completions.create({ messages: [{ role: "user", content: "hello" }] });
+for await (const chunk of yagami.chat.completions.create({ messages: [...], stream: true })) { /* chat chunks */ }
+
+// Models across every installed harness:
+const { data } = await yagami.models.list();
+```
+
+Options are for overrides only (`new Yagami({ defaultModel: "sonnet" })`, `{ defaultProvider: "codex" }`, `{ syncHostConfig: false }`, …); the zero-argument form is the intended use. For lower-level control the engine underneath is `yagami.engine` (a `YagamiEngine` — `complete()` returns cost/session/provider metadata, `stream()` returns raw SSE events), and you can hand-pick providers instead of auto-detecting:
+
+```ts
+import { YagamiEngine, ClaudeProvider, AcpProvider } from "@justin06lee/yagami";
+
+const engine = new YagamiEngine({
+  providers: [new ClaudeProvider(), new AcpProvider({ id: "gemini", label: "Gemini", command: "gemini", args: ["--acp"] })],
+});
+const { response, costUsd } = await engine.complete({ messages: [{ role: "user", content: "hello" }] });
 ```
 
+Every provider implements one small `Provider` contract (`run(turn)` → normalized `session`/`text`/`thinking`/`done` events, plus `listModels()` and `version()`), so adding a harness that isn't ACP-capable is one file. Failures are typed: `AuthRequiredError` (carries the login command), `ProviderNotInstalledError` (carries the install hint), `ProviderError`.
+
+### Building a UI on Claude Code
+
+`Yagami`/`YagamiEngine` are completions-only by design. To build an actual coding UI — tools, permissions, plan mode, a warm session across turns — use `AgentSession`, which wraps the full Claude Code agent with the lifecycle the interactive terminal gives you for free:
+
+```ts
+import { AgentSession } from "@justin06lee/yagami";
+
+const session = new AgentSession({
+  cwd: "/path/to/project",
+  parity: "terminal",          // load your CLAUDE.md, skills, hooks, .mcp.json — like the CLI
+  appName: "my-app",           // reported to Claude as the client
+  onPermission: async (req) => {
+    // Your approve/deny UI. Policy stays here; yagami owns the state machine.
+    const ok = await showDialog(req.toolName, req.input);
+    return ok ? { behavior: "allow" } : { behavior: "deny", message: "user declined" };
+  },
+});
+
+session.send("fix the failing test");     // process starts here and stays warm
+for await (const msg of session) {        // raw SDKMessages — render however you like
+  render(msg);
+  if (msg.type === "result") break;
+}
+session.send("now add a test for the edge case");   // next turn resumes the same session
+await session.interrupt();                // the CLI's Esc
+await session.setModel("opus");           // the CLI's /model
+await session.setPermissionMode("plan");  // shift+tab
+session.close();
+```
+
+This resolves the parts of embedding Claude Code that every host would otherwise reimplement identically — process lifecycle, session resume, interrupt, settings parity, and the permission state machine. What stays yours are the genuinely app-specific choices: rendering the `SDKMessage` stream, deciding what to auto-approve, and picking the working directory. `parity` is `"terminal"` (load user+project+local settings, matching your CLI), `"project"` (project+local only), or `"isolated"` (load nothing — reproducible, no personal config). The permission `fallback` defaults to `"deny"`, so a session is safe before the UI is wired up; `autoAllow`/`autoDeny` skip the handler for named tools.
+
+For a lower-level handle, `claudeCodeSession(prompt, { options })` returns the raw Agent SDK `Query`.
+
+The server is also embeddable: `import { startYagami } from "@justin06lee/yagami/server"`.
+
 ## Providers
 
 A bare model id goes to the **default provider** (Claude Code unless you change it). `"<provider>:<model>"` routes to another harness; a bare provider id (`"codex"`) means that harness's own default model. `GET /v1/models` and `yagami models` list everything that's actually installed, with ids ready to paste.
@@ -97,6 +181,7 @@ Any other ACP agent works too — add it to config with its launch command:
 | `yagami start` | Start the server (`-p` port, `-H` host, `--provider <id>` default provider, `--claude <path>`, `--cors`). Add `--daemon` to run it in the background (`--log <file>` overrides the default log at `~/.config/yagami/yagami.log`) |
 | `yagami stop` | Stop the running server |
 | `yagami status` | Show whether it's running, plus uptime, request count, and cumulative would-be API cost |
+| `yagami key` | Print the URL + API key, plus ready-to-paste `ANTHROPIC_*`/`OPENAI_*` env exports for client apps |
 | `yagami models` | List models across every installed provider (`--provider <id>` to filter) |
 | `yagami keygen` | Generate another API key and save it to the config |
 | `yagami doctor` | Check every harness CLI; `--live` sends one tiny real completion (`--provider <id>` to pick which) |
@@ -119,80 +204,14 @@ Every request is logged as one line (time, status, model, duration, cost, sessio
 }
 ```
 
-Env overrides: `YAGAMI_HOST`, `YAGAMI_PORT`, `YAGAMI_API_KEY`, `YAGAMI_PROVIDER`, `YAGAMI_DEFAULT_MODEL`, `YAGAMI_CLAUDE_PATH`, `YAGAMI_CODEX_PATH`. The older `claudePath` / `claudeConfigDir` keys still work as shorthands for `providers.claude`.
-
-## Library mode
-
-For apps that want the engine in-process with no HTTP hop (e.g. a desktop app):
-
-```ts
-import { YagamiEngine, claudeCodeSession, ClaudeProvider, CodexProvider, AcpProvider } from "@justin06lee/yagami";
-
-// 1. Anthropic-shaped completions across every installed harness:
-const engine = new YagamiEngine({ defaultModel: "sonnet" });
-const { response } = await engine.complete({ messages: [{ role: "user", content: "hello" }] });
-const codex = await engine.complete({ model: "codex", messages: [{ role: "user", content: "hello" }] });
-
-// streaming (Anthropic SSE event objects):
-const { events } = engine.stream({ model: "opencode", messages: [...], stream: true });
-for await (const ev of events) { /* ev.event, ev.data */ }
-
-// hand-pick providers instead of auto-detecting:
-const custom = new YagamiEngine({
-  providers: [new ClaudeProvider(), new AcpProvider({ id: "gemini", label: "Gemini", command: "gemini", args: ["--acp"] })],
-});
-
-// 2. Full agentic Claude Code sessions — tools, permissions, the works.
-for await (const msg of claudeCodeSession("fix the failing test", {
-  options: { cwd: "/path/to/project", permissionMode: "acceptEdits" },
-})) {
-  // render SDK messages however you like
-}
-```
-
-Every provider implements one small `Provider` contract (`run(turn)` → normalized `session`/`text`/`thinking`/`done` events, plus `listModels()` and `version()`), so adding a harness that isn't ACP-capable is one file. Failures are typed: `AuthRequiredError` (carries the login command), `ProviderNotInstalledError` (carries the install hint), `ProviderError`.
-
-### Building a UI on Claude Code
-
-`YagamiEngine` is completions-only by design. To build an actual coding UI — tools, permissions, plan mode, a warm session across turns — use `AgentSession`, which wraps the full Claude Code agent with the lifecycle the interactive terminal gives you for free:
-
-```ts
-import { AgentSession } from "@justin06lee/yagami";
-
-const session = new AgentSession({
-  cwd: "/path/to/project",
-  parity: "terminal",          // load your CLAUDE.md, skills, hooks, .mcp.json — like the CLI
-  appName: "my-app",           // reported to Claude as the client
-  onPermission: async (req) => {
-    // Your approve/deny UI. Policy stays here; yagami owns the state machine.
-    const ok = await showDialog(req.toolName, req.input);
-    return ok ? { behavior: "allow" } : { behavior: "deny", message: "user declined" };
-  },
-});
-
-session.send("fix the failing test");     // process starts here and stays warm
-for await (const msg of session) {        // raw SDKMessages — render however you like
-  render(msg);
-  if (msg.type === "result") break;
-}
-session.send("now add a test for the edge case");   // next turn resumes the same session
-await session.interrupt();                // the CLI's Esc
-await session.setModel("opus");           // the CLI's /model
-await session.setPermissionMode("plan");  // shift+tab
-session.close();
-```
-
-This resolves the parts of embedding Claude Code that every host would otherwise reimplement identically — process lifecycle, session resume, interrupt, settings parity, and the permission state machine. What stays yours are the genuinely app-specific choices: rendering the `SDKMessage` stream, deciding what to auto-approve, and picking the working directory. `parity` is `"terminal"` (load user+project+local settings, matching your CLI), `"project"` (project+local only), or `"isolated"` (load nothing — reproducible, no personal config). The permission `fallback` defaults to `"deny"`, so a session is safe before the UI is wired up; `autoAllow`/`autoDeny` skip the handler for named tools.
-
-For a lower-level handle, `claudeCodeSession(prompt, { options })` returns the raw Agent SDK `Query`.
-
-The server is also embeddable: `import { startYagami } from "@justin06lee/yagami/server"`.
+Env overrides: `YAGAMI_HOST`, `YAGAMI_PORT`, `YAGAMI_API_KEY`, `YAGAMI_PROVIDER`, `YAGAMI_DEFAULT_MODEL`, `YAGAMI_CLAUDE_PATH`, `YAGAMI_CODEX_PATH`. The older `claudePath` / `claudeConfigDir` keys still work as shorthands for `providers.claude`. Library mode reads the same file (minus the server-only fields — host, port, keys), which is what keeps an embedded `Yagami` and the binary in agreement.
 
 ## How it works
 
-- **Engine**: each `/v1/messages` request becomes one sandboxed turn on the chosen harness. Claude runs with `tools: []`, `settingSources: []` (your CLAUDE.md/skills never leak into API completions), `maxTurns: 1` and a deny-all permission callback; Codex runs in its read-only sandbox with no approvals; ACP agents are moved to a plan/read-only mode when they offer one and every permission request is refused. All of them work in a throwaway directory. The API is text-in/text-out; a leaked key can burn tokens but never edit anything on the host — though note that agents other than Claude keep their own read-only tools, so they can still *look* at that empty directory.
+- **Engine**: each request becomes one sandboxed turn on the chosen harness. Claude runs with `tools: []`, `settingSources: []` (your CLAUDE.md/skills never leak into API completions), `maxTurns: 1` and a deny-all permission callback; Codex runs in its read-only sandbox with no approvals; ACP agents are moved to a plan/read-only mode when they offer one and every permission request is refused. All of them work in a throwaway directory. The API is text-in/text-out; a leaked key can burn tokens but never edit anything on the host — though note that agents other than Claude keep their own read-only tools, so they can still *look* at that empty directory.
+- **Dialects**: `POST /v1/messages` is native. `POST /v1/chat/completions` translates OpenAI shapes at the edge — system/developer messages fold into `system`, `image_url` parts become image blocks, streams are re-emitted as `chat.completion.chunk` events ending in `[DONE]`, and thinking output rides along as `reasoning_content`. Errors on that path come back OpenAI-shaped too. `GET /v1/models` serves one merged shape both SDKs parse.
 - **Multi-turn**: the Messages API is stateless but harness sessions aren't. yagami hashes each conversation prefix (per provider) and remembers which session produced it; a follow-up request resumes that session and sends only the new user message. Unmatched histories fall back to replaying the transcript in a single prompt, and if a cached session turns out to be gone, the stale mapping is dropped and the request transparently retries via replay. The cache persists across restarts at `~/.config/yagami/sessions.json`.
-- **Streaming**: every harness's output is normalized into deltas and re-emitted as a proper Anthropic SSE sequence — `message_start` → thinking/text content blocks → `message_delta` → `message_stop`. Claude and ACP agents stream tokens; Codex streams per message part.
+- **Streaming**: every harness's output is normalized into deltas and re-emitted as a proper Anthropic SSE sequence — `message_start` → thinking/text content blocks → `message_delta` → `message_stop` (or the OpenAI chunk sequence on the chat-completions path). Claude and ACP agents stream tokens; Codex streams per message part.
 - **Models**: `GET /v1/models` asks each installed CLI what it supports (Claude via the SDK, Codex via its app-server protocol, ACP agents via their session config) — probed once per process, then cached. Failed probes are skipped and retried next time; a static fallback list is served only if nothing answers (`x-yagami-models-source` says which).
 - **Auth**: `x-api-key` or `Authorization: Bearer`, compared in constant time. Binds to `127.0.0.1` by default and warns loudly on anything else.
 
@@ -200,11 +219,11 @@ Extra response headers: `x-yagami-provider`, `x-yagami-cost-usd` (what the turn
 
 ## Limitations
 
-- No `tools` / `tool_choice` (rejected with 400 — by design, see above). `tool_use`/`tool_result` content blocks are rejected too.
+- No `tools` / `tool_choice` / function calling (rejected with 400 — by design, see above). `tool_use`/`tool_result` content blocks and OpenAI `tool`/`function` messages are rejected too.
 - User messages may contain `text`, `image`, and `document` blocks (documents: Claude only; images: base64 sources only outside Claude); `system` and assistant messages are text-only. Thinking blocks echoed back in assistant history are dropped, not rejected. A conversation whose *history* contains images/documents can only be continued while the server that produced it still has that session cached.
 - Assistant prefill (a trailing `assistant` message) is emulated: the engine is instructed to continue from the prefill text, and the response carries only the continuation, like the real API. An accidentally repeated prefill is stripped from the reply, including mid-stream.
-- `max_tokens`, `temperature`, `top_p`, `top_k`, `stop_sequences` are accepted but ignored (reported via `x-yagami-ignored`) — none of the CLI engines expose them.
-- `thinking` and a yagami-extension `effort` ("low"…"max") are passed through where the harness supports them (see the provider table) and reported as ignored elsewhere.
+- `max_tokens`, `temperature`, `top_p`, `top_k`, `stop_sequences` (and their OpenAI counterparts, plus `presence_penalty`, `seed`, `response_format`, …) are accepted but ignored (reported via `x-yagami-ignored`) — none of the CLI engines expose them. OpenAI `n` must be 1.
+- `thinking` and a yagami-extension `effort` ("low"…"max") are passed through where the harness supports them (see the provider table) and reported as ignored elsewhere. OpenAI `reasoning_effort` maps onto `effort`.
 - Cost is reported only by harnesses that price their own turns (Claude, OpenCode); Codex reports token usage without cost.
 
 ## Development

package/dist/{chunk-ASS6MJ7C.js → chunk-2UG5CR5X.js}

@@ -180,7 +180,7 @@ function resolveClaudeExecutable(explicit) {
 }
 
 // src/version.ts
-var VERSION = "0.4.1";
+var VERSION = "0.5.0";
 
 // src/core/providers/acp.ts
 import { spawn, spawnSync } from "child_process";
@@ -1115,13 +1115,13 @@ function detectProviders(config = {}) {
     const preset = presetFor(id);
     const entry = config[id] ?? {};
     const command = entry.command ?? preset?.command ?? id;
-    const path7 = findExecutable(command, entry.path ? { explicit: entry.path } : {});
+    const path8 = 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 } : {},
+      installed: path8 !== void 0 && entry.enabled !== false,
+      ...path8 ? { path: path8 } : {},
       loginCommand: entry.loginCommand ?? preset?.loginCommand ?? `${command} (sign in per its docs)`,
       installHint: preset?.installHint ?? `Install \`${command}\`.`
     };
@@ -1792,6 +1792,266 @@ ${promptText}`;
   }
 };
 
+// src/core/hostConfig.ts
+import * as fs7 from "fs";
+import * as os6 from "os";
+import * as path7 from "path";
+function yagamiConfigDir() {
+  return process.env["YAGAMI_CONFIG_DIR"] ?? path7.join(os6.homedir(), ".config", "yagami");
+}
+function loadHostEngineConfig() {
+  let file = {};
+  try {
+    file = JSON.parse(fs7.readFileSync(path7.join(yagamiConfigDir(), "config.json"), "utf8"));
+  } catch {
+  }
+  const env = process.env;
+  const defaultProvider = env["YAGAMI_PROVIDER"] ?? (typeof file["defaultProvider"] === "string" ? file["defaultProvider"] : void 0);
+  const defaultModel = env["YAGAMI_DEFAULT_MODEL"] ?? (typeof file["defaultModel"] === "string" ? file["defaultModel"] : void 0);
+  const claudePath = env["YAGAMI_CLAUDE_PATH"] ?? (typeof file["claudePath"] === "string" ? file["claudePath"] : void 0);
+  const claudeConfigDir = typeof file["claudeConfigDir"] === "string" ? file["claudeConfigDir"] : void 0;
+  const providers = file["providers"];
+  return {
+    ...defaultProvider ? { defaultProvider } : {},
+    ...defaultModel ? { defaultModel } : {},
+    ...providers != null && typeof providers === "object" && !Array.isArray(providers) ? { providerConfig: providers } : {},
+    ...claudePath ? { claudePath } : {},
+    ...claudeConfigDir ? { claudeConfigDir } : {}
+  };
+}
+
+// src/core/openai.ts
+var IGNORED_OPENAI_PARAMS = [
+  "presence_penalty",
+  "frequency_penalty",
+  "logit_bias",
+  "logprobs",
+  "top_logprobs",
+  "seed",
+  "user",
+  "response_format",
+  "prediction",
+  "modalities",
+  "audio",
+  "store",
+  "parallel_tool_calls",
+  "web_search_options"
+];
+var EFFORT_MAP = {
+  minimal: "low",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "xhigh",
+  max: "max"
+};
+function imagePartToBlock(part) {
+  const url = part["image_url"]?.["url"];
+  if (typeof url !== "string" || url.length === 0) {
+    throw new ApiError(400, "invalid_request_error", "`image_url` parts must carry an `image_url.url` string");
+  }
+  const dataUrl = /^data:([^;,]+);base64,(.+)$/s.exec(url);
+  if (dataUrl) {
+    return { type: "image", source: { type: "base64", media_type: dataUrl[1], data: dataUrl[2] } };
+  }
+  if (/^https?:\/\//.test(url)) {
+    return { type: "image", source: { type: "url", url } };
+  }
+  throw new ApiError(400, "invalid_request_error", "`image_url.url` must be a data: URL or an http(s) URL");
+}
+function partsToContent(parts, role) {
+  const blocks = [];
+  for (const part of parts) {
+    if (part?.type === "text" && typeof part["text"] === "string") {
+      blocks.push({ type: "text", text: part["text"] });
+    } else if (part?.type === "image_url" && role === "user") {
+      blocks.push(imagePartToBlock(part));
+    } else {
+      throw new ApiError(
+        400,
+        "invalid_request_error",
+        `unsupported content part type "${String(part?.type)}" for role "${role}" (yagami supports "text", plus "image_url" in user messages)`
+      );
+    }
+  }
+  return blocks.every((b) => b.type === "text") ? blocks.map((b) => b["text"]).join("\n") : blocks;
+}
+function messageText(content, role) {
+  if (content == null) return "";
+  if (typeof content === "string") return content;
+  const flattened = partsToContent(content, role);
+  if (typeof flattened !== "string") {
+    throw new ApiError(400, "invalid_request_error", `"${role}" messages may only contain text parts`);
+  }
+  return flattened;
+}
+function chatToMessagesRequest(body) {
+  if (body == null || typeof body !== "object") {
+    throw new ApiError(400, "invalid_request_error", "request body must be a JSON object");
+  }
+  if (body.tools != null || body.tool_choice != null || body.functions != null || body.function_call != null) {
+    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."
+    );
+  }
+  if (body.n != null && body.n !== 1) {
+    throw new ApiError(400, "invalid_request_error", "`n` must be 1 (yagami produces a single completion)");
+  }
+  if (!Array.isArray(body.messages) || body.messages.length === 0) {
+    throw new ApiError(400, "invalid_request_error", "`messages` must be a non-empty array");
+  }
+  const systemParts = [];
+  const messages = [];
+  for (const [i, m] of body.messages.entries()) {
+    const role = m?.role;
+    if (role === "system" || role === "developer") {
+      systemParts.push(messageText(m.content, role));
+    } else if (role === "user") {
+      messages.push({ role: "user", content: Array.isArray(m.content) ? partsToContent(m.content, "user") : m.content ?? "" });
+    } else if (role === "assistant") {
+      messages.push({ role: "assistant", content: messageText(m.content, "assistant") });
+    } else if (role === "tool" || role === "function") {
+      throw new ApiError(400, "invalid_request_error", "yagami does not support tool/function messages (tool calling is disabled by design)");
+    } else {
+      throw new ApiError(400, "invalid_request_error", `messages[${i}].role must be "system", "developer", "user", or "assistant"`);
+    }
+  }
+  const extraIgnored = IGNORED_OPENAI_PARAMS.filter((p) => body[p] != null).map(String);
+  let effort;
+  if (body.reasoning_effort != null) {
+    effort = EFFORT_MAP[String(body.reasoning_effort)];
+    if (!effort) extraIgnored.push("reasoning_effort");
+  }
+  const maxTokens = body.max_completion_tokens ?? body.max_tokens;
+  const system = systemParts.filter((s) => s.length > 0).join("\n\n");
+  const req = {
+    ...body.model !== void 0 ? { model: body.model } : {},
+    messages,
+    ...system.length > 0 ? { system } : {},
+    ...maxTokens !== void 0 ? { max_tokens: maxTokens } : {},
+    ...body.temperature !== void 0 ? { temperature: body.temperature } : {},
+    ...body.top_p !== void 0 ? { top_p: body.top_p } : {},
+    ...body.stop != null ? { stop_sequences: Array.isArray(body.stop) ? body.stop : [body.stop] } : {},
+    ...body.metadata != null ? { metadata: body.metadata } : {},
+    ...body.service_tier != null ? { service_tier: String(body.service_tier) } : {},
+    ...effort ? { effort } : {},
+    ...body.stream === true ? { stream: true } : {}
+  };
+  return { req, extraIgnored, includeUsage: body.stream_options?.include_usage === true };
+}
+function finishReason(stopReason) {
+  return stopReason === "max_tokens" ? "length" : "stop";
+}
+function toOpenAiUsage(usage) {
+  return {
+    prompt_tokens: usage.input_tokens,
+    completion_tokens: usage.output_tokens,
+    total_tokens: usage.input_tokens + usage.output_tokens
+  };
+}
+function toChatCompletion(resp) {
+  const text = resp.content.filter((b) => b.type === "text").map((b) => String(b["text"] ?? "")).join("");
+  const thinking = resp.content.filter((b) => b.type === "thinking").map((b) => String(b["thinking"] ?? "")).join("");
+  return {
+    id: resp.id.replace(/^msg_/, "chatcmpl_"),
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model: resp.model,
+    choices: [
+      {
+        index: 0,
+        message: { role: "assistant", content: text, ...thinking ? { reasoning_content: thinking } : {}, refusal: null },
+        finish_reason: finishReason(resp.stop_reason),
+        logprobs: null
+      }
+    ],
+    usage: toOpenAiUsage(resp.usage)
+  };
+}
+function openAiErrorBody(err) {
+  return { error: { message: err.message, type: err.type, param: null, code: null } };
+}
+var ChatChunkTranslator = class {
+  constructor(includeUsage) {
+    this.includeUsage = includeUsage;
+  }
+  includeUsage;
+  id = "chatcmpl_stream";
+  model = "";
+  created = Math.floor(Date.now() / 1e3);
+  stopReason = null;
+  usage = { input_tokens: 0, output_tokens: 0 };
+  /** Set when the engine reported an error mid-stream (no [DONE] after). */
+  errored = false;
+  chunk(delta, finish = null) {
+    return {
+      id: this.id,
+      object: "chat.completion.chunk",
+      created: this.created,
+      model: this.model,
+      choices: [{ index: 0, delta, finish_reason: finish }]
+    };
+  }
+  /** Translate one engine SSE event into zero or more OpenAI chunk payloads. */
+  push(ev) {
+    const data = ev.data;
+    switch (ev.event) {
+      case "message_start": {
+        const message = data["message"];
+        if (message?.id) this.id = message.id.replace(/^msg_/, "chatcmpl_");
+        if (message?.model) this.model = message.model;
+        return [this.chunk({ role: "assistant", content: "" })];
+      }
+      case "content_block_delta": {
+        const delta = data["delta"];
+        if (delta?.type === "text_delta" && delta.text) return [this.chunk({ content: delta.text })];
+        if (delta?.type === "thinking_delta" && delta.thinking) return [this.chunk({ reasoning_content: delta.thinking })];
+        return [];
+      }
+      case "message_delta": {
+        const delta = data["delta"];
+        if (delta?.stop_reason) this.stopReason = delta.stop_reason;
+        const usage = data["usage"];
+        if (usage) this.usage = usage;
+        return [];
+      }
+      case "message_stop": {
+        const out = [this.chunk({}, finishReason(this.stopReason))];
+        if (this.includeUsage) {
+          out.push({
+            id: this.id,
+            object: "chat.completion.chunk",
+            created: this.created,
+            model: this.model,
+            choices: [],
+            usage: toOpenAiUsage(this.usage)
+          });
+        }
+        return out;
+      }
+      case "error": {
+        this.errored = true;
+        const error = data["error"];
+        return [{ error: { message: error?.message ?? "stream error", type: error?.type ?? "api_error", param: null, code: null } }];
+      }
+      default:
+        return [];
+    }
+  }
+};
+function modelListBody(models) {
+  const created = Math.floor(Date.now() / 1e3);
+  return {
+    object: "list",
+    data: models.map((m) => ({ type: "model", object: "model", created, owned_by: "yagami", ...m })),
+    has_more: false,
+    ...models[0] ? { first_id: models[0].id } : {},
+    ...models.length > 0 ? { last_id: models[models.length - 1].id } : {}
+  };
+}
+
 export {
   ApiError,
   YagamiError,
@@ -1816,6 +2076,13 @@ export {
   loadProviders,
   detectProviders,
   SessionCache,
-  YagamiEngine
+  YagamiEngine,
+  yagamiConfigDir,
+  loadHostEngineConfig,
+  chatToMessagesRequest,
+  toChatCompletion,
+  openAiErrorBody,
+  ChatChunkTranslator,
+  modelListBody
 };
-//# sourceMappingURL=chunk-ASS6MJ7C.js.map
+//# sourceMappingURL=chunk-2UG5CR5X.js.map