@justin06lee/yagami 0.6.0 → 0.8.1

package/README.md

@@ -32,7 +32,7 @@ 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 from npm: `bun add -g @justin06lee/yagami`.
 
 ```
-yagami v0.5.0
+yagami v0.7.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>")
@@ -74,6 +74,20 @@ curl http://127.0.0.1:8787/v1/chat/completions \
   -d '{"model":"codex","messages":[{"role":"user","content":"ping"}]}'
 ```
 
+### Web search and fetch
+
+`/v1/messages` accepts Anthropic's **server tools**, so a client can ask the engine to go look something up before it answers:
+
+```sh
+curl http://127.0.0.1:8787/v1/messages \
+  -H "x-api-key: ygm_..." -H "content-type: application/json" \
+  -d '{"model":"sonnet","max_tokens":600,
+       "tools":[{"type":"web_search_20260209","name":"web_search"}],
+       "messages":[{"role":"user","content":"What is the current stable Rust version?"}]}'
+```
+
+Server tools run *inside* the engine — they map onto the CLI's own `WebSearch` and `WebFetch`, and the results are folded into the reply. Nothing changes about the endpoint's contract: it still never emits a `tool_use` block for you to execute. Every dated variant of a type works (`web_search_20250305`, `web_search_20260209`, …), `tool_choice` may be `auto` or `none`, and any other tool in the array is rejected — a custom tool would have to run on your side, and there is no round trip here to run it on. Only the claude provider serves them; asking codex or an ACP agent for them fails loudly rather than quietly answering without the lookup.
+
 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
@@ -112,7 +126,7 @@ Every provider implements one small `Provider` contract (`run(turn)` → normali
 
 ### 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:
+`Yagami`/`YagamiEngine` are completions-only by design (server tools aside, they never hand you a tool call to run). 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";
@@ -137,6 +151,9 @@ session.send("now add a test for the edge case");   // next turn resumes the sam
 await session.interrupt();                // the CLI's Esc
 await session.setModel("opus");           // the CLI's /model
 await session.setPermissionMode("plan");  // shift+tab
+// the CLI's /rewind: restore tracked files to their state at a user
+// message's uuid (needs options: { enableFileCheckpointing: true })
+await session.rewindFiles(userMessageUuid);
 session.close();
 ```
 
@@ -158,10 +175,16 @@ if (isSessionProvider(codex)) {
     permissions: {
       decide: async (req) => (await showDialog(req.tool, req.input)) ? "allow" : "deny",
     },                                    // "allow_always" answers like the TUI's "don't ask again"
+    input: {
+      // Codex request_user_input and MCP/ACP form or URL elicitations all
+      // arrive in this provider-neutral shape. Throwing safely cancels it.
+      respond: async (request) => renderInput(request),
+    },
   });
   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)
+    // normalized AgentEvents: session / turn / text / thinking / tool_call
+    // (started→completed, including Codex multi-agent operations) / permission
+    // / plan / done
   }
   session.send("now add a test");         // same warm thread, context carries
   await session.interrupt();
@@ -169,7 +192,7 @@ if (isSessionProvider(codex)) {
 }
 ```
 
-`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.
+`ProviderSessionOptions` takes `cwd`, `model`, `resume`, `effort`, `systemPrompt` (extra developer instructions where the harness supports them), `permissions`, optional `input`, and a `native` escape hatch (Codex: `{ sandbox, approvalPolicy, config }`; ACP: `{ mode }`). A session provider reports `sessionCapabilities.fork`; when true, `{ resume, fork: true }` branches at the tip and `{ resume, forkAt: turnId }` branches through an exact `turn` event without mutating the source conversation. Input fields preserve labels, options, required/secret flags, primitive constraints, and URLs; omitting the handler declines safely instead of hanging a turn. ACP sessions also map `effort` onto the agent's `thought_level` option when it exposes one. 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"`.
 
@@ -181,7 +204,7 @@ A bare model id goes to the **default provider** (Claude Code unless you change
 |---|---|---|---|---|---|
 | `claude` — Claude Code | Agent SDK → your `claude` binary | yes, forking | yes (+ documents) | native | native |
 | `codex` — Codex CLI | `codex exec --json` (read-only sandbox) | yes | yes | emulated | effort only |
-| `opencode`, `gemini`, `copilot`, `cursor`, `qwen`, `goose`, `kimi`, `kilo`, `cline`, `auggie`, `amp`, `grok`, `droid`, `codex-acp`, `claude-acp` | Agent Client Protocol over stdio | if the agent supports it | if the agent supports it | emulated | — |
+| `opencode`, `gemini`, `copilot`, `cursor`, `qwen`, `goose`, `kimi`, `kilo`, `cline`, `auggie`, `amp`, `grok`, `droid`, `codex-acp`, `claude-acp` | Agent Client Protocol over stdio | if the agent supports it | if the agent supports it | emulated | `thought_level` when exposed |
 
 "Emulated" means the system prompt is folded into the user turn as a `<system>` block; unsupported `thinking`/`effort` are accepted and reported in `x-yagami-ignored` rather than rejected. Without native forking, a resumed session is single-use: a sibling branch of the same conversation falls back to transcript replay instead of corrupting the shared session.
 
@@ -239,7 +262,7 @@ Env overrides: `YAGAMI_HOST`, `YAGAMI_PORT`, `YAGAMI_API_KEY`, `YAGAMI_PROVIDER`
 - **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` (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).
+- **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. Library callers also receive native model metadata when reported: reasoning levels/default, input modalities, fast/auto/adaptive-thinking flags, personality and multi-agent support, service tiers, and the provider's default model. 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.
 
 Extra response headers: `x-yagami-provider`, `x-yagami-cost-usd` (what the turn would have cost at API prices, when the harness reports it), `x-yagami-session`, `x-yagami-ignored` (accepted-but-unsupported params). `/healthz` (unauthenticated) reports the default provider, installed providers, uptime, request count, and the cumulative would-be cost — `yagami status` shows the same.
@@ -261,3 +284,5 @@ bun run smoke                       # live end-to-end through your real Claude C
 bun run live:providers              # live check across every installed harness (tiny token cost each)
 make build                          # build dist/ only
 ```
+
+Codex sessions preserve proposed plan documents and stream reasoning summaries as they arrive, and completed items only fill missing text. A failed resume is reported as an error; it never silently opens an empty conversation. Only one send can run at a time, including during startup. Input and permission handlers receive an abort signal when the server resolves their request, their turn stops, or the session closes; hosts should dismiss the corresponding prompt. Close and reopen a failed session with its last ID to retry.

package/dist/{chunk-D2PNH6GV.js → chunk-4S5QNDQK.js}

@@ -10,7 +10,7 @@ import {
   toApiError,
   toChatCompletion,
   yagamiConfigDir
-} from "./chunk-ZYHC7PXX.js";
+} from "./chunk-U3RFT7QV.js";
 
 // src/server.ts
 import { serve } from "@hono/node-server";
@@ -374,4 +374,4 @@ export {
   maskKey,
   startYagami
 };
-//# sourceMappingURL=chunk-D2PNH6GV.js.map
+//# sourceMappingURL=chunk-4S5QNDQK.js.map