@justin06lee/yagami 0.4.1 → 0.6.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)
+```
+
+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_...
 ```
 
-Then from any Anthropic client:
+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,111 @@ 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`.
+
+### Building a UI on any other harness
+
+The same idea works for the non-Claude harnesses — verbatim. Codex and every ACP agent implement `SessionProvider.openSession()`: a live, warm session on the harness's own engine (`codex app-server` — what the Codex TUI runs on; a persistent ACP connection for OpenCode, Gemini, and friends), with the harness's own config, sandbox, and approval flow. Nothing is overridden unless you pass `native` overrides; approval requests are forwarded to your handler exactly as the harness's own UI would prompt.
+
+```ts
+import { createProvider, isSessionProvider } from "@justin06lee/yagami";
+
+const codex = createProvider("codex", {}, { appName: "my-app" });
+if (isSessionProvider(codex)) {
+  const session = codex.openSession({
+    cwd: "/path/to/project",
+    permissions: {
+      decide: async (req) => (await showDialog(req.tool, req.input)) ? "allow" : "deny",
+    },                                    // "allow_always" answers like the TUI's "don't ask again"
+  });
+  for await (const ev of session.send("fix the failing test")) {
+    // normalized AgentEvents: text / thinking / tool_call (started→completed,
+    // with inputs and outputs) / permission / done (usage, stop reason)
+  }
+  session.send("now add a test");         // same warm thread, context carries
+  await session.interrupt();
+  await session.close();                  // session.id resumes it later via { resume }
+}
+```
+
+`ProviderSessionOptions` takes `cwd`, `model`, `resume`, `effort`, `systemPrompt` (extra developer instructions where the harness supports them), and a `native` escape hatch (Codex: `{ sandbox, approvalPolicy, config }`; ACP: `{ mode }`). The completion-turn `run()` path stays for API-style callers; sessions are for hosts that want the real interactive agent.
+
+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 +208,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 +231,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 +246,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-M5UHR273.js → chunk-D2PNH6GV.js}

@@ -1,9 +1,16 @@
 import {
+  ApiError,
+  ChatChunkTranslator,
   SessionCache,
   VERSION,
   YagamiEngine,
-  toApiError
-} from "./chunk-ASS6MJ7C.js";
+  chatToMessagesRequest,
+  modelListBody,
+  openAiErrorBody,
+  toApiError,
+  toChatCompletion,
+  yagamiConfigDir
+} from "./chunk-ZYHC7PXX.js";
 
 // src/server.ts
 import { serve } from "@hono/node-server";
@@ -27,10 +34,10 @@ function safeEqual(a, b) {
 function errorBody(type, message) {
   return { type: "error", error: { type, message } };
 }
-function requestLine(status, model, startedAt, extra = {}) {
+function requestLine(path2, status, model, startedAt, extra = {}) {
   const parts = [
     (/* @__PURE__ */ new Date()).toISOString(),
-    `POST /v1/messages ${status}`,
+    `POST ${path2} ${status}`,
     `model=${model}`,
     `${((Date.now() - startedAt) / 1e3).toFixed(1)}s`
   ];
@@ -67,7 +74,8 @@ function createApp(options) {
     const header = c.req.header("x-api-key") ?? c.req.header("authorization")?.replace(/^Bearer\s+/i, "");
     const ok = header != null && apiKeys.some((key) => safeEqual(key, header));
     if (!ok) {
-      return c.json(errorBody("authentication_error", "invalid x-api-key"), 401);
+      const err = new ApiError(401, "authentication_error", "invalid API key (x-api-key or Authorization: Bearer)");
+      return c.req.path.startsWith("/v1/chat") ? c.json(openAiErrorBody(err), 401) : c.json(err.toBody(), 401);
     }
     await next();
   });
@@ -83,12 +91,7 @@ function createApp(options) {
     } catch {
     }
     c.header("x-yagami-models-source", source);
-    return c.json({
-      data: models.map((m) => ({ type: "model", ...m })),
-      has_more: false,
-      first_id: models[0]?.id,
-      last_id: models[models.length - 1]?.id
-    });
+    return c.json(modelListBody(models));
   });
   app.post("/v1/messages", async (c) => {
     let body;
@@ -109,7 +112,7 @@ function createApp(options) {
           onResult: (info) => {
             if (info.costUsd !== void 0) stats.totalCostUsd += info.costUsd;
             log?.(
-              requestLine(200, model, startedAt, {
+              requestLine("/v1/messages", 200, model, startedAt, {
                 stream: true,
                 ...info.costUsd !== void 0 ? { cost: info.costUsd } : {},
                 ...info.sessionId ? { session: info.sessionId } : {}
@@ -129,7 +132,7 @@ function createApp(options) {
       const result = await engine.complete(req);
       if (result.costUsd !== void 0) stats.totalCostUsd += result.costUsd;
       log?.(
-        requestLine(200, model, startedAt, {
+        requestLine("/v1/messages", 200, model, startedAt, {
           ...result.costUsd !== void 0 ? { cost: result.costUsd } : {},
           ...result.sessionId ? { session: result.sessionId } : {}
         })
@@ -141,10 +144,72 @@ function createApp(options) {
       return c.json(result.response);
     } catch (err) {
       const apiErr = toApiError(err);
-      log?.(requestLine(apiErr.status, model, startedAt, { error: apiErr.type }));
+      log?.(requestLine("/v1/messages", apiErr.status, model, startedAt, { error: apiErr.type }));
       return c.json(apiErr.toBody(), apiErr.status);
     }
   });
+  app.post("/v1/chat/completions", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json(openAiErrorBody(new ApiError(400, "invalid_request_error", "request body must be valid JSON")), 400);
+    }
+    const startedAt = Date.now();
+    const chatReq = body;
+    const model = typeof chatReq?.model === "string" ? chatReq.model : "(default)";
+    stats.requests += 1;
+    try {
+      const { req, extraIgnored, includeUsage } = chatToMessagesRequest(chatReq);
+      if (req.stream === true) {
+        const abortController = new AbortController();
+        const { ignored, provider, events } = engine.stream(req, {
+          signal: abortController.signal,
+          onResult: (info) => {
+            if (info.costUsd !== void 0) stats.totalCostUsd += info.costUsd;
+            log?.(
+              requestLine("/v1/chat/completions", 200, model, startedAt, {
+                stream: true,
+                ...info.costUsd !== void 0 ? { cost: info.costUsd } : {},
+                ...info.sessionId ? { session: info.sessionId } : {}
+              })
+            );
+          }
+        });
+        c.header("x-yagami-provider", provider);
+        const allIgnored2 = [...ignored, ...extraIgnored];
+        if (allIgnored2.length > 0) c.header("x-yagami-ignored", allIgnored2.join(","));
+        const translator = new ChatChunkTranslator(includeUsage);
+        return streamSSE(c, async (stream) => {
+          stream.onAbort(() => abortController.abort());
+          for await (const ev of events) {
+            for (const chunk of translator.push(ev)) {
+              await stream.writeSSE({ data: JSON.stringify(chunk) });
+            }
+          }
+          if (!translator.errored) await stream.writeSSE({ data: "[DONE]" });
+        });
+      }
+      const result = await engine.complete(req);
+      if (result.costUsd !== void 0) stats.totalCostUsd += result.costUsd;
+      log?.(
+        requestLine("/v1/chat/completions", 200, model, startedAt, {
+          ...result.costUsd !== void 0 ? { cost: result.costUsd } : {},
+          ...result.sessionId ? { session: result.sessionId } : {}
+        })
+      );
+      c.header("x-yagami-provider", result.provider);
+      const allIgnored = [...result.ignored, ...extraIgnored];
+      if (allIgnored.length > 0) c.header("x-yagami-ignored", allIgnored.join(","));
+      if (result.costUsd !== void 0) c.header("x-yagami-cost-usd", result.costUsd.toFixed(6));
+      if (result.sessionId) c.header("x-yagami-session", result.sessionId);
+      return c.json(toChatCompletion(result.response));
+    } catch (err) {
+      const apiErr = toApiError(err);
+      log?.(requestLine("/v1/chat/completions", apiErr.status, model, startedAt, { error: apiErr.type }));
+      return c.json(openAiErrorBody(apiErr), apiErr.status);
+    }
+  });
   app.notFound(
     (c) => c.json(errorBody("not_found_error", `no route for ${c.req.method} ${c.req.path}`), 404)
   );
@@ -158,16 +223,12 @@ function createApp(options) {
 // src/server/config.ts
 import { randomBytes } from "crypto";
 import * as fs from "fs";
-import * as os from "os";
 import * as path from "path";
 var DEFAULT_CONFIG = {
   host: "127.0.0.1",
   port: 8787,
   apiKeys: []
 };
-function yagamiConfigDir() {
-  return process.env["YAGAMI_CONFIG_DIR"] ?? path.join(os.homedir(), ".config", "yagami");
-}
 function configFilePath() {
   return path.join(yagamiConfigDir(), "config.json");
 }
@@ -298,7 +359,6 @@ function definedProps(obj) {
 
 export {
   createApp,
-  yagamiConfigDir,
   configFilePath,
   sessionCachePath,
   serverStatePath,
@@ -314,4 +374,4 @@ export {
   maskKey,
   startYagami
 };
-//# sourceMappingURL=chunk-M5UHR273.js.map
+//# sourceMappingURL=chunk-D2PNH6GV.js.map

package/dist/chunk-D2PNH6GV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/server.ts","../src/server/app.ts","../src/server/config.ts"],"sourcesContent":["import { serve, type ServerType } from \"@hono/node-server\";\nimport { YagamiEngine } from \"./core/engine.js\";\nimport { SessionCache } from \"./core/sessionCache.js\";\nimport { createApp } from \"./server/app.js\";\nimport {\n  loadConfig,\n  sessionCachePath,\n  type YagamiConfig,\n} from \"./server/config.js\";\nimport { VERSION } from \"./version.js\";\n\nexport interface RunningServer {\n  server: ServerType;\n  engine: YagamiEngine;\n  sessionCache: SessionCache;\n  config: YagamiConfig;\n  url: string;\n  close(): Promise<void>;\n}\n\nexport interface StartOptions extends Partial<YagamiConfig> {\n  /** Sink for one-line request logs (default: console.log). Pass null to disable. */\n  log?: ((line: string) => void) | null;\n}\n\n/**\n * Start a yagami server. Overrides are merged over the loaded config\n * (~/.config/yagami/config.json plus YAGAMI_* env vars).\n */\nexport async function startYagami(overrides: StartOptions = {}): Promise<RunningServer> {\n  const { log, ...configOverrides } = overrides;\n  const config: YagamiConfig = { ...loadConfig(), ...definedProps(configOverrides) };\n  if (config.apiKeys.length === 0) {\n    throw new Error(\n      \"no API keys configured — run `yagami keygen` (or set YAGAMI_API_KEY) so the endpoint isn't unauthenticated\",\n    );\n  }\n\n  const sessionCache = new SessionCache({ persistPath: sessionCachePath() });\n  const engine = new YagamiEngine({\n    ...(config.providers ? { providerConfig: config.providers } : {}),\n    ...(config.defaultProvider ? { defaultProvider: config.defaultProvider } : {}),\n    ...(config.claudePath ? { claudePath: config.claudePath } : {}),\n    ...(config.claudeConfigDir ? { claudeConfigDir: config.claudeConfigDir } : {}),\n    ...(config.defaultModel ? { defaultModel: config.defaultModel } : {}),\n    sessionCache,\n    appName: \"yagami\",\n  });\n\n  const app = createApp({\n    engine,\n    apiKeys: config.apiKeys,\n    cors: config.cors,\n    version: VERSION,\n    ...(log === null ? {} : { log: log ?? ((line: string) => console.log(line)) }),\n  });\n\n  const server = await new Promise<ServerType>((resolve) => {\n    const s = serve({ fetch: app.fetch, hostname: config.host, port: config.port }, () => resolve(s));\n  });\n\n  const address = server.address();\n  const port = typeof address === \"object\" && address ? address.port : config.port;\n\n  return {\n    server,\n    engine,\n    sessionCache,\n    config: { ...config, port },\n    url: `http://${config.host}:${port}`,\n    close: () =>\n      new Promise<void>((resolve, reject) => {\n        server.close((err) => (err ? reject(err) : resolve()));\n      }),\n  };\n}\n\nfunction definedProps<T extends object>(obj: T): Partial<T> {\n  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined)) as Partial<T>;\n}\n\nexport { createApp } from \"./server/app.js\";\nexport type { AppOptions, EngineLike } from \"./server/app.js\";\nexport {\n  loadConfig,\n  loadFileConfig,\n  saveConfig,\n  generateApiKey,\n  configFilePath,\n  sessionCachePath,\n  serverStatePath,\n  logFilePath,\n  readServerState,\n  writeServerState,\n  clearServerState,\n  isProcessAlive,\n  yagamiConfigDir,\n  type YagamiConfig,\n  type ServerState,\n} from \"./server/config.js\";\n","import { createHash, randomUUID, timingSafeEqual } from \"node:crypto\";\nimport { Hono } from \"hono\";\nimport { cors } from \"hono/cors\";\nimport { streamSSE } from \"hono/streaming\";\nimport type { ContentfulStatusCode } from \"hono/utils/http-status\";\nimport { ApiError, type MessagesRequest } from \"../core/types.js\";\nimport { toApiError } from \"../core/errors.js\";\nimport type { CompleteResult, EngineModel, StreamOptions, StreamStart } from \"../core/engine.js\";\nimport {\n  ChatChunkTranslator,\n  chatToMessagesRequest,\n  modelListBody,\n  openAiErrorBody,\n  toChatCompletion,\n  type ChatCompletionsRequest,\n} from \"../core/openai.js\";\n\n/** What the app needs from an engine — lets tests inject a fake. */\nexport interface EngineLike {\n  /** Executable of the default provider. */\n  executable: string;\n  defaultProviderId: string;\n  providerIds: string[];\n  complete(req: MessagesRequest): Promise<CompleteResult>;\n  stream(req: MessagesRequest, opts?: StreamOptions): StreamStart;\n  listModels(): Promise<EngineModel[]>;\n}\n\nexport interface AppOptions {\n  engine: EngineLike;\n  apiKeys: string[];\n  cors?: boolean;\n  version?: string;\n  /** Sink for one-line request logs; omit to disable request logging. */\n  log?: (line: string) => void;\n}\n\n/** Served by GET /v1/models only when probing the CLI fails. */\nconst FALLBACK_MODELS: EngineModel[] = [\n  \"claude-fable-5\",\n  \"claude-opus-5\",\n  \"claude-sonnet-5\",\n  \"claude-haiku-4-5-20251001\",\n].map((id) => ({ id, display_name: id }));\n\nfunction safeEqual(a: string, b: string): boolean {\n  const ha = createHash(\"sha256\").update(a).digest();\n  const hb = createHash(\"sha256\").update(b).digest();\n  return timingSafeEqual(ha, hb);\n}\n\nfunction errorBody(type: ApiError[\"type\"], message: string) {\n  return { type: \"error\" as const, error: { type, message } };\n}\n\nfunction requestLine(\n  path: string,\n  status: number,\n  model: string,\n  startedAt: number,\n  extra: { cost?: number; session?: string; stream?: boolean; error?: string } = {},\n): string {\n  const parts = [\n    new Date().toISOString(),\n    `POST ${path} ${status}`,\n    `model=${model}`,\n    `${((Date.now() - startedAt) / 1000).toFixed(1)}s`,\n  ];\n  if (extra.stream) parts.push(\"stream\");\n  if (extra.cost !== undefined) parts.push(`cost=$${extra.cost.toFixed(6)}`);\n  if (extra.session) parts.push(`session=${extra.session}`);\n  if (extra.error) parts.push(`error=${extra.error}`);\n  return parts.join(\" \");\n}\n\nexport function createApp(options: AppOptions): Hono {\n  const { engine, apiKeys, log } = options;\n  const app = new Hono();\n  const stats = { startedAt: Date.now(), requests: 0, totalCostUsd: 0 };\n\n  if (options.cors) app.use(\"*\", cors());\n\n  app.use(\"*\", async (c, next) => {\n    c.header(\"request-id\", `req_${randomUUID().replace(/-/g, \"\")}`);\n    await next();\n  });\n\n  app.get(\"/healthz\", (c) =>\n    c.json({\n      ok: true,\n      service: \"yagami\",\n      version: options.version,\n      provider: engine.defaultProviderId,\n      providers: engine.providerIds,\n      executable: engine.executable,\n      uptime_s: Math.round((Date.now() - stats.startedAt) / 1000),\n      requests: stats.requests,\n      total_cost_usd: stats.totalCostUsd,\n    }),\n  );\n\n  app.use(\"/v1/*\", async (c, next) => {\n    const header = c.req.header(\"x-api-key\") ?? c.req.header(\"authorization\")?.replace(/^Bearer\\s+/i, \"\");\n    const ok = header != null && apiKeys.some((key) => safeEqual(key, header));\n    if (!ok) {\n      const err = new ApiError(401, \"authentication_error\", \"invalid API key (x-api-key or Authorization: Bearer)\");\n      // The chat-completions path answers in the OpenAI error shape.\n      return c.req.path.startsWith(\"/v1/chat\")\n        ? c.json(openAiErrorBody(err), 401)\n        : c.json(err.toBody(), 401);\n    }\n    await next();\n  });\n\n  // Served in a merged shape: Anthropic fields + OpenAI fields per model, so\n  // both SDKs' models.list() parse it.\n  app.get(\"/v1/models\", async (c) => {\n    let models = FALLBACK_MODELS;\n    let source = \"fallback\";\n    try {\n      const probed = await engine.listModels();\n      if (probed.length > 0) {\n        models = probed;\n        source = \"engine\";\n      }\n    } catch {\n      // engine unavailable or slow — the static list keeps clients working\n    }\n    c.header(\"x-yagami-models-source\", source);\n    return c.json(modelListBody(models));\n  });\n\n  app.post(\"/v1/messages\", async (c) => {\n    let body: unknown;\n    try {\n      body = await c.req.json();\n    } catch {\n      return c.json(errorBody(\"invalid_request_error\", \"request body must be valid JSON\"), 400);\n    }\n    const req = body as MessagesRequest;\n    const startedAt = Date.now();\n    const model = typeof req.model === \"string\" ? req.model : \"(default)\";\n    stats.requests += 1;\n\n    try {\n      if (req.stream === true) {\n        const abortController = new AbortController();\n        const { ignored, provider, events } = engine.stream(req, {\n          signal: abortController.signal,\n          onResult: (info) => {\n            if (info.costUsd !== undefined) stats.totalCostUsd += info.costUsd;\n            log?.(\n              requestLine(\"/v1/messages\", 200, model, startedAt, {\n                stream: true,\n                ...(info.costUsd !== undefined ? { cost: info.costUsd } : {}),\n                ...(info.sessionId ? { session: info.sessionId } : {}),\n              }),\n            );\n          },\n        });\n        c.header(\"x-yagami-provider\", provider);\n        if (ignored.length > 0) c.header(\"x-yagami-ignored\", ignored.join(\",\"));\n        return streamSSE(c, async (stream) => {\n          stream.onAbort(() => abortController.abort());\n          for await (const ev of events) {\n            await stream.writeSSE({ event: ev.event, data: JSON.stringify(ev.data) });\n          }\n        });\n      }\n\n      const result = await engine.complete(req);\n      if (result.costUsd !== undefined) stats.totalCostUsd += result.costUsd;\n      log?.(\n        requestLine(\"/v1/messages\", 200, model, startedAt, {\n          ...(result.costUsd !== undefined ? { cost: result.costUsd } : {}),\n          ...(result.sessionId ? { session: result.sessionId } : {}),\n        }),\n      );\n      c.header(\"x-yagami-provider\", result.provider);\n      if (result.ignored.length > 0) c.header(\"x-yagami-ignored\", result.ignored.join(\",\"));\n      if (result.costUsd !== undefined) c.header(\"x-yagami-cost-usd\", result.costUsd.toFixed(6));\n      if (result.sessionId) c.header(\"x-yagami-session\", result.sessionId);\n      return c.json(result.response);\n    } catch (err) {\n      const apiErr = toApiError(err);\n      log?.(requestLine(\"/v1/messages\", apiErr.status, model, startedAt, { error: apiErr.type }));\n      return c.json(apiErr.toBody(), apiErr.status as ContentfulStatusCode);\n    }\n  });\n\n  // OpenAI dialect: the same engine behind Chat Completions shapes, so apps\n  // that expect an OpenAI base URL + API key work against the same key.\n  app.post(\"/v1/chat/completions\", async (c) => {\n    let body: unknown;\n    try {\n      body = await c.req.json();\n    } catch {\n      return c.json(openAiErrorBody(new ApiError(400, \"invalid_request_error\", \"request body must be valid JSON\")), 400);\n    }\n    const startedAt = Date.now();\n    const chatReq = body as ChatCompletionsRequest;\n    const model = typeof chatReq?.model === \"string\" ? chatReq.model : \"(default)\";\n    stats.requests += 1;\n\n    try {\n      const { req, extraIgnored, includeUsage } = chatToMessagesRequest(chatReq);\n\n      if (req.stream === true) {\n        const abortController = new AbortController();\n        const { ignored, provider, events } = engine.stream(req, {\n          signal: abortController.signal,\n          onResult: (info) => {\n            if (info.costUsd !== undefined) stats.totalCostUsd += info.costUsd;\n            log?.(\n              requestLine(\"/v1/chat/completions\", 200, model, startedAt, {\n                stream: true,\n                ...(info.costUsd !== undefined ? { cost: info.costUsd } : {}),\n                ...(info.sessionId ? { session: info.sessionId } : {}),\n              }),\n            );\n          },\n        });\n        c.header(\"x-yagami-provider\", provider);\n        const allIgnored = [...ignored, ...extraIgnored];\n        if (allIgnored.length > 0) c.header(\"x-yagami-ignored\", allIgnored.join(\",\"));\n        const translator = new ChatChunkTranslator(includeUsage);\n        return streamSSE(c, async (stream) => {\n          stream.onAbort(() => abortController.abort());\n          for await (const ev of events) {\n            for (const chunk of translator.push(ev)) {\n              await stream.writeSSE({ data: JSON.stringify(chunk) });\n            }\n          }\n          if (!translator.errored) await stream.writeSSE({ data: \"[DONE]\" });\n        });\n      }\n\n      const result = await engine.complete(req);\n      if (result.costUsd !== undefined) stats.totalCostUsd += result.costUsd;\n      log?.(\n        requestLine(\"/v1/chat/completions\", 200, model, startedAt, {\n          ...(result.costUsd !== undefined ? { cost: result.costUsd } : {}),\n          ...(result.sessionId ? { session: result.sessionId } : {}),\n        }),\n      );\n      c.header(\"x-yagami-provider\", result.provider);\n      const allIgnored = [...result.ignored, ...extraIgnored];\n      if (allIgnored.length > 0) c.header(\"x-yagami-ignored\", allIgnored.join(\",\"));\n      if (result.costUsd !== undefined) c.header(\"x-yagami-cost-usd\", result.costUsd.toFixed(6));\n      if (result.sessionId) c.header(\"x-yagami-session\", result.sessionId);\n      return c.json(toChatCompletion(result.response));\n    } catch (err) {\n      const apiErr = toApiError(err);\n      log?.(requestLine(\"/v1/chat/completions\", apiErr.status, model, startedAt, { error: apiErr.type }));\n      return c.json(openAiErrorBody(apiErr), apiErr.status as ContentfulStatusCode);\n    }\n  });\n\n  app.notFound((c) =>\n    c.json(errorBody(\"not_found_error\", `no route for ${c.req.method} ${c.req.path}`), 404),\n  );\n\n  app.onError((err, c) => {\n    const apiErr = toApiError(err);\n    return c.json(apiErr.toBody(), apiErr.status as ContentfulStatusCode);\n  });\n\n  return app;\n}\n","import { randomBytes } from \"node:crypto\";\nimport * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport { yagamiConfigDir } from \"../core/hostConfig.js\";\nimport type { ProviderConfigEntry } from \"../core/providers/registry.js\";\n\nexport { yagamiConfigDir } from \"../core/hostConfig.js\";\n\nexport interface YagamiConfig {\n  host: string;\n  port: number;\n  apiKeys: string[];\n  /** @deprecated Use providers.claude.path. */\n  claudePath?: string;\n  /** @deprecated Use providers.claude.configDir. */\n  claudeConfigDir?: string;\n  defaultModel?: string;\n  cors?: boolean;\n  /** Provider used for bare model ids (default: claude). */\n  defaultProvider?: string;\n  /** Per-provider settings, keyed by provider id. */\n  providers?: Record<string, ProviderConfigEntry>;\n}\n\nexport const DEFAULT_CONFIG: YagamiConfig = {\n  host: \"127.0.0.1\",\n  port: 8787,\n  apiKeys: [],\n};\n\nexport function configFilePath(): string {\n  return path.join(yagamiConfigDir(), \"config.json\");\n}\n\nexport function sessionCachePath(): string {\n  return path.join(yagamiConfigDir(), \"sessions.json\");\n}\n\nexport function serverStatePath(): string {\n  return path.join(yagamiConfigDir(), \"server.json\");\n}\n\nexport function logFilePath(): string {\n  return path.join(yagamiConfigDir(), \"yagami.log\");\n}\n\n/** What a running server records about itself for `stop`/`status`. */\nexport interface ServerState {\n  pid: number;\n  host: string;\n  port: number;\n  url: string;\n  startedAt: string;\n  version: string;\n  log?: string;\n}\n\nexport function readServerState(): ServerState | undefined {\n  try {\n    const state = JSON.parse(fs.readFileSync(serverStatePath(), \"utf8\")) as ServerState;\n    return typeof state?.pid === \"number\" ? state : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nexport function writeServerState(state: ServerState): void {\n  fs.mkdirSync(yagamiConfigDir(), { recursive: true, mode: 0o700 });\n  fs.writeFileSync(serverStatePath(), `${JSON.stringify(state, null, 2)}\\n`, { mode: 0o600 });\n}\n\n/** Remove the state file; with `pid`, only if it still belongs to that pid. */\nexport function clearServerState(pid?: number): void {\n  try {\n    if (pid !== undefined && readServerState()?.pid !== pid) return;\n    fs.unlinkSync(serverStatePath());\n  } catch {\n    // already gone\n  }\n}\n\nexport function isProcessAlive(pid: number): boolean {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/** Config as stored on disk, without env overrides (safe to save back). */\nexport function loadFileConfig(): YagamiConfig {\n  let fromFile: Partial<YagamiConfig> = {};\n  try {\n    fromFile = JSON.parse(fs.readFileSync(configFilePath(), \"utf8\")) as Partial<YagamiConfig>;\n  } catch {\n    // no config file yet\n  }\n  return {\n    ...DEFAULT_CONFIG,\n    ...fromFile,\n    apiKeys: Array.isArray(fromFile.apiKeys) ? fromFile.apiKeys.filter((k) => typeof k === \"string\") : [],\n  };\n}\n\n/** File config plus environment overrides. */\nexport function loadConfig(): YagamiConfig {\n  const cfg = loadFileConfig();\n  const env = process.env;\n  if (env[\"YAGAMI_HOST\"]) cfg.host = env[\"YAGAMI_HOST\"];\n  if (env[\"YAGAMI_PORT\"] && Number.isFinite(Number(env[\"YAGAMI_PORT\"]))) {\n    cfg.port = Number(env[\"YAGAMI_PORT\"]);\n  }\n  if (env[\"YAGAMI_API_KEY\"] && !cfg.apiKeys.includes(env[\"YAGAMI_API_KEY\"])) {\n    cfg.apiKeys.push(env[\"YAGAMI_API_KEY\"]);\n  }\n  if (env[\"YAGAMI_CLAUDE_PATH\"]) cfg.claudePath = env[\"YAGAMI_CLAUDE_PATH\"];\n  if (env[\"YAGAMI_DEFAULT_MODEL\"]) cfg.defaultModel = env[\"YAGAMI_DEFAULT_MODEL\"];\n  if (env[\"YAGAMI_PROVIDER\"]) cfg.defaultProvider = env[\"YAGAMI_PROVIDER\"];\n  return cfg;\n}\n\nexport function saveConfig(cfg: YagamiConfig): string {\n  const dir = yagamiConfigDir();\n  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });\n  const file = configFilePath();\n  fs.writeFileSync(file, `${JSON.stringify(cfg, null, 2)}\\n`, { mode: 0o600 });\n  return file;\n}\n\nexport function generateApiKey(): string {\n  return `ygm_${randomBytes(24).toString(\"hex\")}`;\n}\n\nexport function maskKey(key: string): string {\n  return key.length <= 12 ? key : `${key.slice(0, 12)}…`;\n}\n"],"mappings":"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","names":["path","allIgnored"]}