ai-ax 0.4.3 → 0.6.0

package/README.md

@@ -2,146 +2,158 @@
 
 AI Agent Experience (AI/AX) library for Hono + Cloudflare.
 
-ai-ax lets you build the human experience (UI/UX) and the AI agent experience (AI/AX) of a web app as one surface. Every operation is declared exactly once, and that single declaration becomes a click handler for humans and an MCP tool for LLMs at the same time, backed by one realtime state that both sides read and write.
+ai-ax builds the human experience (UI/UX) and the AI agent experience (AI/AX) of a web app as one surface. An operation is declared exactly once, and that one declaration is a click handler for the person watching the screen and an MCP tool for the LLM at the same time, backed by one realtime state that both of them read and write.
 
-Three ideas carry the whole library: **one action**, **one tree**, **one resolver**.
+Three ideas carry the library — **one action**, **one tree**, **one road** — and each of them is a mechanism you can point at, not a slogan: one action is a single tool registry that serves the UI, the MCP server and the cross-side transport; one tree is a single yjs map that is rendered as the screen, dumped as the agent's observation and encoded as the persistence snapshot; one road is a single `ai` object that every runtime adapter receives.
 
 ## Why
 
-The web has been built on the assumption that a human is the one operating it. When an LLM path is bolted onto such an app afterwards, everything doubles: two operation surfaces, two auth stacks, two sets of bugs. The two copies inevitably drift apart, and the drift is usually discovered weeks later in a log.
+The AI agent has become one more user of the web site. The web, however, was built on the assumption that a human is the one operating it, so when an agent path is bolted onto an app as a second route beside the browser, everything doubles: two operation surfaces, two auth stacks, two sets of bugs, roughly twice the code to manage. The two copies inevitably drift apart, and the drift is usually discovered weeks later in a log.
 
-ai-ax removes the second copy instead of maintaining it. The AI agent is treated as one more user of the app: it reads the same state and calls the same operations as the person watching the screen. When a developer debugs a button by clicking it in the UI, that debugged code is literally what the agent runs through MCP. There is no second implementation left to drift.
+ai-ax removes the second copy instead of maintaining it. The person and the agent read the same state and call the same operations, so the declaration of an operation _is_ its MCP tool, and the implementation lives in exactly one place. Every operation is synchronized in realtime through partyserver, whether it arrived from a browser click or from an MCP request, so the agent's moves appear on the human's screen as they happen.
 
-![one action, one tree](https://r.tsei.jp/ai-ax/concept.svg)
-
-**One action** — the smallest unit of operation is declared once and reached from both the UI and MCP. **One tree** — all state lives in a single yjs tree, which humans see as the rendered screen and the LLM observes as `get_tree`. **One resolver** — authorization is a single function that decides which room a user may enter; every path, human or AI, goes through it.
+Authentication is the one place where the two users genuinely differ, because an MCP request from the Claude API cannot carry the browser's session. ai-ax closes that gap with a signed token: when the user sends a prompt, the Hono side mints a token and hands it to the Claude API, the token comes back on every MCP request, and the MCP server verifies the signature before executing anything.
 
 ## What
 
-The assumed stack is Hono + Cloudflare Workers. Realtime sync is partyserver (Durable Objects) with yjs, authentication is Auth.js, and the LLM is the Claude API with its MCP connector. ai-ax ships the server-side plumbing between them — authentication, authorization, realtime sync, the MCP server, and the LLM relay — as Hono middleware.
-
-![stack](https://r.tsei.jp/ai-ax/stack.svg)
-
-The worker needs one composite middleware, and the Durable Object is a re-export.
+The assumed stack is Hono on Cloudflare Workers. Realtime sync is partyserver — the successor of partykit, which was deprecated after becoming a Cloudflare product — running yjs docs on Durable Objects deployed straight to Cloudflare. Authentication is Auth.js, and the LLM is the Claude API with its MCP connector. Hono itself is confined to the `ai-ax/hono` entry, so every other entry stays framework free.
 
-```ts
-import { Hono } from 'hono'
-import { createAiax, ownSelf } from 'ai-ax'
-import { PROMPT } from './prompt'
-import './actions'
+The whole library is one loop: the browser and the agent join the same room, and every operation — clicked or tool-called — lands on the same doc and syncs back to both.
 
-const ai = createAiax({ name: 'demo', own: ownSelf(), database: (e) => e.my_d1, system: PROMPT })
-const app = new Hono().use('*', ai.all())
-
-export default app
-export { AiaxServer } from 'ai-ax/server'
-```
-
-`ai.all()` routes `/parties/*` to websocket sync, `/api/mcp` to the MCP server, `POST /api/llm` to the Claude relay, and handles Auth.js sessions; everything else falls through to your own routes. The exported `AiaxServer` class is deployed as a Durable Object under the binding name `v1`.
+![diagram](https://r.tsei.jp/ai-ax/diagram.svg)
 
 ### One action
 
+`x(params, config)` builds the `ai` object. The first argument declares typed state keys with their initial values (write `x<Keys>()` when a key should start undefined), and the second argument is the service config.
+
+<!-- prettier-ignore -->
 ```ts
-import { action } from 'ai-ax/action'
+// actions.ts
+import { x } from 'ai-ax'
 import { z } from 'zod'
 
-export const placeMark = action<{ cell: number }, string>(() => import('./actions/place-mark'), 'both', {
-        name: 'place_mark',
-        description: 'Place the current player mark on an empty cell',
-        input: { cell: z.number().describe('cell index 0-8') },
-})
+export default x(
+        { count: 0 },
+        { name: 'counter', tree: 'count is the current value. Observe before acting', own: ({ sub }) => sub },
+)
+        .describe('A counting app.', (a) =>
+                a
+                        .action('increment', 'Add 1 to the current value', () => ++ai.count)
+                        .action('overwrite', 'Overwrite the current value', { count: z.number() }, ({ count }) => (ai.count = count)),
+        )
+        .client('notify', 'Show an alert in the browser', { text: z.string() }, ({ text }) => alert(text))
+        .server('heavy', 'Run heavy work on the server', { src: z.string() }, () => import('./heavy'))
 ```
 
-This one declaration yields two things: an async function the UI calls from event handlers, and an MCP tool (name, description, zod input schema) exposed to the LLM. The first argument is either a dynamic import or the implementation function itself, so bundles can stay split or stay simple.
+Each definition takes the tool name first, and after that the description, the zod schema and the implementation in any order — each part is recognized by its type, so an inline handler reads hono-like as `(name, schema, fn)` while a dynamic import reads `(name, () => import('./x'), description, schema)` with the schema at the end where the whole list scans best. The implementation is either an inline function or a dynamic import whose default export receives `(input, ai)`, so heavy or browser-incompatible code stays out of the other side's bundle. `.action` runs on whichever side called it, `.client` only in the browser, `.server` only in the Durable Object; when the other side calls it, the request travels over the shared doc and the result travels back, so a tool call from the LLM can open a dialog in the connected browser and return what the user did. `.describe(text, fn)` blocks nest, and their texts concatenate hierarchically into the MCP tool description. `get_tree` is built in — every service exposes the same observation tool, and `config.tree` replaces its description.
 
-`side` states where the implementation is able to run, and ai-ax forwards calls across the boundary when the other side needs it.
+The declared names and schemas flow into the type of `ai`: `ai.overwrite({ count: 3 })` typechecks, `ai.overwrite(true)` and `ai.missing()` do not.
 
-| side     | runs on                          | when called from the other side                            |
-| -------- | -------------------------------- | ---------------------------------------------------------- |
-| `both`   | browser and Durable Object       | executed locally on whichever side called it               |
-| `client` | browser only (needs browser API) | delegated to the connected browser via yjs act-req/act-res |
-| `server` | Durable Object only              | forwarded to the Durable Object                            |
+### One tree
 
-Inside an action, `data()` returns the shared `Y.Map` named `tree`. Whatever is written there syncs to every connected browser in realtime and is exactly what the LLM observes, so the agent's moves appear on the human's screen as they happen.
+All shared state lives in a single yjs map. State declared in the first argument is read and written through plain properties — `ai.count = 3` above syncs to every connected browser and to the agent's next `get_tree` — and any undeclared key travels the same proxy: `ai['files/a.txt'] = entry`, `ai['files/a.txt']` and `delete ai['files/a.txt']` are how repeated rows live under a `name/id` convention. `ai.rows(prefix)` lists the direct children of a prefix sorted by `pos`, `ai.scan(prefix)` lists every descendant, `ai.wipe(prefix)` clears them, `ai.tx(fn, origin?)` groups writes into one transaction, and `ai.history(options?)` is the undo manager over the same map. `ai.data()` exposes the underlying `Y.Map` only for what a property can never express — `observe` subscriptions and whole-tree iteration.
 
-The browser side connects once and everything above starts working.
+The tree is also the persistence unit. `config.load` restores a snapshot when the doc first wakes, `config.save` persists one on the update debounce, on a durable alarm and on every disconnect — which is what survives Durable Object hibernation — and `ai.snapshot()` encodes it. `config.ui` names the volatile keys (a trailing `/` marks a prefix): they still sync and still show up in `get_tree`, but they are excluded from both the snapshot and the undo capture, so a saved file holds the work and not the open menus. `config.history` merges extra `Y.UndoManager` options such as `captureTimeout`. A `lobby` room skips persistence entirely, so an anonymous top page stays playable without touching storage. State that should stay out of the shared tree entirely deliberately steps off the road: the `ai-ax/react` entry ships a small atom store (`atom`, `setAtom`, `useAtomValue`) for browser-local values like an IME buffer or a chat stream.
 
 ```ts
-import { ALIAS, connect } from 'ai-ax/client'
-
-const link = connect({ room: ALIAS })
-link.synced(() => boot())
+x(
+        {},
+        {
+                name: 'notes',
+                lobby: 'notes',
+                own: async ({ env, sub, path }) => (await env.my_bucket.head(`${sub}/${path}`))?.customMetadata?.site ?? '',
+                load: async ({ env, sub, path }) => (await env.my_bucket.get(`${sub}/${path}`))?.arrayBuffer(),
+                save: ({ env, sub, path, room }, buf) => env.my_bucket.put(`${sub}/${path}`, buf, { customMetadata: { site: room } }),
+        },
+)
 ```
 
-Clients always connect to the alias room `my-room`. The server rewrites it to the authorized room, so no client ever picks a real room name.
+### One road
 
-### One resolver
-
-Only two kinds of credentials exist, and both are jwt signed with `AUTH_SECRET`; a plain user id never crosses the network.
-
-| path                       | credential                   | issued by                                  | verified by                             |
-| -------------------------- | ---------------------------- | ------------------------------------------ | --------------------------------------- |
-| Browser → Worker           | session cookie (Auth.js jwt) | `/api/auth` (Google OAuth)                 | `userSub()`                             |
-| Claude → Worker `/api/mcp` | grant jwt `{ sub, path }`    | llm middleware, minted after authorization | `readGrant()`                           |
-| Worker → Durable Object    | room name + `x-user-sub`     | worker overwrites with authorized values   | DO is reachable only via worker binding |
-
-Authorization concentrates into a single function.
+The app touches the library through the one `ai` object, and each runtime has exactly one adapter that receives it.
 
+<!-- prettier-ignore -->
 ```ts
-type Own = (env: any, sub: string, path: string) => Promise<string> | string
+// index.ts (worker + Durable Object)
+import { Hono } from 'hono'
+import { hono } from 'ai-ax/hono'
+import { Server } from 'ai-ax/server'
+import { PROMPT } from './prompt'
+import ai from './actions'
+
+export default new Hono().use('*', hono(ai, { system: PROMPT }))
+export class PartyServer extends Server {
+        ai = ai
+}
 ```
 
-It answers one question — which room does this user get for this path — and an empty string denies. `ownSelf()` returns the user's own id (personal apps: everyone gets exactly one private room). `ownSite(bucket)` reads the file's metadata from R2 (editor apps: owning the file opens its room). A resolver that joins a D1 membership table fits the same type.
+```tsx
+// client.tsx (browser)
+import { useClient } from 'ai-ax/react'
+import ai from './actions'
 
-The grant jwt is minted per turn by the llm middleware and carried by the Claude API to `/api/mcp` on every MCP request. The LLM cannot choose the token's contents, and rewriting it breaks the signature, so at any moment the agent is sealed inside the one room that was just authorized.
+const App = () => {
+        const { count } = useClient(ai)
+        return <button onClick={() => ai.increment()}>{count}</button>
+}
+```
 
-![grant sequence](https://r.tsei.jp/ai-ax/grant.svg)
+`hono(ai, extra?)` routes `/parties/*` to websocket sync, the MCP endpoint, the LLM relay and the Auth.js session, and lets everything else fall through to the app's own routes; `extra` merges server-only config such as the system prompt or an Auth.js `adapter`, so they never enter the browser bundle. `Server` is the Durable Object: the app subclass assigns it the one `ai` (`class PartyServer extends Server { ai = ai }`), and it records the owning user across hibernation, serializes action execution, and drives the `load` / `save` hooks. `useClient(ai)` connects once and re-renders on every tree change (`Client` is the component form, `client(ai)` the non-React form; `route.synced` fires after the first sync, and `route.room: ''` opens the local doc without any connection), and `hydrate(ai, entries)` fills that local doc from a published JSON snapshot without waking a Durable Object at all.
 
-### LLM relay
+Runtime-only values — Cloudflare bindings, the authorized user, the room — travel the same road instead of module globals. `.abstract(name)` declares a function that actions may call before anyone has implemented it, and `.override(name, (input, next, ai) => ...)` supplies or wraps implementations onion-style, where `next(input)` runs whatever was underneath. The Durable Object overrides one well-known abstract before every execution: `ai.peer()` returns the authorized `{ env, room, sub, path }`, and everything else an app needs (an R2 client, a sandbox runner) is an abstract the app declares in its actions and overrides in its `PartyServer`. Overrides intercept tools too, which is how a browser rewrites the variables the Claude API sends before an action runs.
 
-`POST /api/llm` with `{ path, prompt, model?, messages? }` authorizes the caller, mints a grant, calls the Claude API with the MCP server attached, and relays the response as a text stream. `messages` is prior conversation to prepend before the prompt. The library never stores history — what to persist, where, and in which shape is the application's decision, and whatever is passed here is simply replayed.
+`createStream()` from `ai-ax/client` is the browser side of the relay's wire format: `POST` to the relay streams plain text in which a `[tool]` line marks each MCP call and a trailing `[usage]` line closes the turn, and `parse` / `send` / prior-`messages` replay are the pieces an app needs to render and continue conversations without touching the format itself.
 
-The stream is plain text: a `[tool] server name` line marks a tool call and a trailing `[usage] ...` line closes the turn. `createStream()` returns the browser-side counterpart of this wire format.
+### One resolver
 
-```ts
-import { createStream } from 'ai-ax/client'
+Authorization concentrates into the single `own` function: given `{ env, sub, path }` it answers which room this user may enter, and an empty string denies. Only two kinds of credentials exist, both jwt signed with `AUTH_SECRET` — a plain user id never crosses the network.
 
-const stream = createStream()
-const items = await stream.send({ prompt, path, model, messages }, (u) => draw(u.items))
-```
+| path                    | credential                   | issued by                                    | verified by                                 |
+| ----------------------- | ---------------------------- | -------------------------------------------- | ------------------------------------------- |
+| Browser → Worker        | session cookie (Auth.js jwt) | `/api/auth` (Google OAuth by default)        | the Auth.js session                         |
+| Claude → Worker MCP     | grant jwt `{ sub, path }`    | the LLM relay, minted per prompt             | signature check before every tool execution |
+| Worker → Durable Object | room name + user headers     | the worker overwrites with authorized values | the DO is reachable only through the worker |
 
-`parse` splits raw text into items of `{ text, tools }` with usage hidden, `send` posts and streams with parsed updates, and the symmetric pair `pack` / `unpack` converts a finished reply into a storable `{ reply, tools }` form and back — the pieces an app needs to render, persist, and replay conversations without ever touching the wire format itself.
+Browsers always connect to the alias room `my-room`, and the worker rewrites it to the room `own` returned, so no client ever picks a real room name. The grant jwt is minted when the user sends a prompt and is carried by the Claude API back on every MCP request; the LLM cannot choose the token's contents, and rewriting it breaks the signature, so at any moment the agent is sealed inside the one room that was just authorized, for at most `maxAge` seconds.
 
 ## How
 
-| entry          | main exports                             | where it runs             |
-| -------------- | ---------------------------------------- | ------------------------- |
-| `ai-ax`        | `createAiax`, `ownSelf`, `ownSite`       | worker (Hono middleware)  |
-| `ai-ax/client` | `connect`, `createStream`, `ALIAS`       | browser                   |
-| `ai-ax/action` | `action`, `actions`, `data`, `side`      | shared action definitions |
-| `ai-ax/server` | `AiaxServer`                             | Durable Object            |
-| `ai-ax/const`  | protocol constants (paths, header names) | both                      |
-
-`createAiax(config)` accepts the following and returns `{ all, auth, party, mcp, llm }` — `all()` is the composite shown above, and the four factories are also usable individually.
-
-| key       | type                  | default                                   | meaning                                                      |
-| --------- | --------------------- | ----------------------------------------- | ------------------------------------------------------------ |
-| name      | `string`              | required                                  | service id, becomes the MCP server name                      |
-| own       | `Own`                 | required                                  | authorization resolver, `''` denies                          |
-| database  | `(env) => D1Database` | none                                      | D1 for the Auth.js DrizzleAdapter, jwt-only when omitted     |
-| lobby     | `string`              | none                                      | one anonymous demo room, all paths require auth when omitted |
-| alias     | `string`              | `'my-room'`                               | connection name meaning "my room", rewritten by `own`        |
-| system    | `string`              | `''`                                      | system prompt for the LLM                                    |
-| model     | `string`              | `'claude-sonnet-5'`                       | Claude API model id                                          |
-| claude    | `string`              | `'https://api.anthropic.com/v1/messages'` | Claude API URL, replaceable with an AI Gateway               |
-| maxTokens | `number`              | `32000`                                   | max_tokens per response                                      |
-| maxTurns  | `number`              | `10`                                      | upper bound of pause_turn continuations                      |
-| binding   | `string`              | `'v1'`                                    | Durable Object binding name                                  |
-| endpoint  | `string`              | `'/api/mcp'`                              | MCP endpoint path                                            |
-| version   | `string`              | `'1.0.0'`                                 | MCP server version string                                    |
-| salt      | `string`              | `'authjs.mcp-token'`                      | grant jwt salt, separates services                           |
-| maxAge    | `number`              | `43200` (12h)                             | grant jwt lifetime in seconds                                |
-| cookie    | `{ apex, services }`  | none                                      | services sharing a session cookie across subdomains          |
-| providers | `any[]`               | Google                                    | Auth.js providers                                            |
+| entry          | main exports                                             | where it runs           |
+| -------------- | -------------------------------------------------------- | ----------------------- |
+| `ai-ax`        | `x`                                                      | everywhere (isomorphic) |
+| `ai-ax/hono`   | `hono`                                                   | worker                  |
+| `ai-ax/server` | `Server`                                                 | Durable Object          |
+| `ai-ax/client` | `client`, `hydrate`, `createStream`                      | browser                 |
+| `ai-ax/react`  | `useClient`, `Client`, `atom`, `setAtom`, `useAtomValue` | browser (React)         |
+| `ai-ax/const`  | protocol constants (paths, header names)                 | both                    |
+
+The worker expects a Durable Object binding named `v1` pointing at the exported `Server` class, and the environment needs `AUTH_SECRET`, the OAuth client credentials and `ANTHROPIC_API_KEY`. Config keys of `x(params, config)` and `hono(ai, extra)`:
+
+| key       | type                       | default                                   | meaning                                               |
+| --------- | -------------------------- | ----------------------------------------- | ----------------------------------------------------- |
+| name      | `string`                   | `'x'`                                     | service id, becomes the MCP server name               |
+| tree      | `string`                   | generic text                              | description of the built-in `get_tree` tool           |
+| own       | `(at: Peer) => string`     | deny all                                  | authorization resolver, `''` denies                   |
+| adapter   | `(env) => Adapter`         | none                                      | Auth.js adapter factory, jwt-only when omitted        |
+| lobby     | `string`                   | none                                      | one anonymous room without persistence                |
+| load      | `(at: Saved) => buf`       | none                                      | snapshot restore on first doc load                    |
+| save      | `(at: Saved, buf) => void` | none                                      | snapshot persist on debounce / alarm / disconnect     |
+| ui        | `string[]`                 | `[]`                                      | volatile keys (trailing `/` = prefix), no undo / save |
+| history   | `object`                   | none                                      | extra `Y.UndoManager` options (e.g. `captureTimeout`) |
+| alias     | `string`                   | `'my-room'`                               | connection name meaning "my room", rewritten by `own` |
+| system    | `string`                   | `''`                                      | system prompt for the LLM                             |
+| model     | `string`                   | `'claude-sonnet-5'`                       | Claude API model id                                   |
+| claude    | `string`                   | `'https://api.anthropic.com/v1/messages'` | Claude API URL, replaceable with an AI Gateway        |
+| maxTokens | `number`                   | `32000`                                   | max_tokens per response                               |
+| maxTurns  | `number`                   | `10`                                      | upper bound of pause_turn continuations               |
+| binding   | `string`                   | `'v1'`                                    | Durable Object binding name                           |
+| host      | `string`                   | request host                              | public host the Claude API reaches the MCP through    |
+| endpoint  | `string`                   | `'/api/mcp'`                              | MCP endpoint path                                     |
+| relay     | `string`                   | `'/api/llm'`                              | LLM relay path                                        |
+| version   | `string`                   | `'1.0.0'`                                 | MCP server version string                             |
+| salt      | `string`                   | `'authjs.mcp-token'`                      | grant jwt salt, separates services                    |
+| maxAge    | `number`                   | `43200` (12h)                             | grant jwt lifetime in seconds                         |
+| cookie    | `{ apex, services }`       | none                                      | services sharing a session cookie across subdomains   |
+| providers | `any[]`                    | Google                                    | Auth.js providers                                     |
 
 The `x-user-sub` / `x-user-path` header names and the anthropic-version are internal protocol constants and intentionally not configurable, because both ends of each protocol must change together.

package/dist/client.d.ts

@@ -1,49 +1,2 @@
-import { ActMeta, ActionDef, Side } from "./types.js";
-import { Call, action, actions, bind, data, init, side } from "./action.js";
-import { ALIAS, BINDING } from "./const.js";
-import * as Y from "yjs";
-//#region src/browser/stream.d.ts
-interface StreamTool {
-  server: string;
-  name: string;
-}
-interface StreamItem {
-  text: string;
-  tools: StreamTool[];
-  error?: boolean;
-}
-interface StreamSend {
-  prompt: string;
-  path?: string;
-  model?: string;
-  messages?: any[];
-  headers?: Record<string, string>;
-}
-interface StreamUpdate {
-  items: StreamItem[];
-  delta: string;
-  raw: string;
-}
-declare const createStream: (endpoint?: string) => {
-  parse: (raw: string) => StreamItem[];
-  send: (input: StreamSend, update?: (u: StreamUpdate) => void) => Promise<StreamItem[]>;
-};
-//#endregion
-//#region src/client.d.ts
-interface Route {
-  room?: string;
-  path?: string;
-  host?: string;
-  party?: string;
-  doc?: Y.Doc;
-}
-interface Link {
-  doc: Y.Doc;
-  call: Call;
-  synced: (fn: () => void) => void;
-  leave: () => void;
-}
-declare const onLeave: (fn: () => void) => undefined;
-declare const connect: (route?: Route) => Link;
-//#endregion
-export { ALIAS, type ActMeta, type ActionDef, BINDING, Link, Route, type Side, type StreamItem, type StreamSend, type StreamTool, type StreamUpdate, action, actions, bind, connect, createStream, data, init, onLeave, side };
+import { a as StreamSend, c as createStream, i as StreamItem, n as client, o as StreamTool, r as hydrate, s as StreamUpdate, t as Route } from "./client-DG7hCEbP.js";
+export { Route, type StreamItem, type StreamSend, type StreamTool, type StreamUpdate, client, createStream, hydrate };

package/dist/client.js

@@ -1,2 +1,2 @@
-import{ALIAS as e,BINDING as t,LLM_PATH as n}from"./const.js";import{action as r,actions as i,bind as a,data as o,init as s,side as c}from"./action.js";import l from"y-partyserver/provider";import*as u from"yjs";const d=/^\[tool\] (?:(\S+) )?(\S+)$/,f=(e=n)=>{let t=e=>{let t=[{text:``,tools:[]}],n=!1;for(let r of e.split(`
-`)){if(r.startsWith(`[usage]`))continue;let e=d.exec(r),i=t[t.length-1];if(e){i.tools.push({server:e[1]??``,name:e[2]}),n=!0;continue}if(!(n&&r.trim()===``)){if(n){t.push({text:r,tools:[]}),n=!1;continue}i.text=i.text===``?r:`${i.text}\n${r}`}}return t.map(e=>({...e,text:e.text.trim()})).filter(e=>e.text!==``||e.tools.length>0)};return{parse:t,send:async(n,r)=>{let{headers:i={},...a}=n,o=await fetch(e,{method:`POST`,headers:{"content-type":`application/json`,...i},body:JSON.stringify(a)});if(!o.ok){let e=(await o.text()).replace(/\n/g,` `),t=[{text:e,tools:[],error:!0}];return r?.({items:t,delta:e,raw:e}),t}let s=o.body.getReader(),c=new TextDecoder,l=``;for(;;){let{done:e,value:n}=await s.read();if(e)break;let i=c.decode(n,{stream:!0});l+=i,r?.({items:t(l),delta:i,raw:l})}return t(l)}}};let p=null,m=new Set;const h=e=>void m.add(e),g=(e={})=>{p?.leave();let{room:t=``,path:n=``,host:r=location.host,party:i=`v1`,doc:a}=e,o=t?new l(r,t,a,{party:i,params:{path:n}}):null,c=o?.doc??a??new u.Doc;return p={doc:c,call:s(c),synced(e){if(!o||o.synced)return void e();o.once(`synced`,()=>e())},leave(){m.forEach(e=>e()),m=new Set,o?.destroy()}}};export{e as ALIAS,t as BINDING,r as action,i as actions,a as bind,g as connect,f as createStream,o as data,s as init,h as onLeave,c as side};
+import{ALIAS as e,LLM_PATH as t}from"./const.js";import n from"y-partyserver/provider";const r=/^\[tool\] (?:(\S+) )?(\S+)$/,i=(e=t)=>{let n=e=>{let t=[{text:``,tools:[]}],n=!1;for(let i of e.split(`
+`)){if(i.startsWith(`[usage]`))continue;let e=r.exec(i),a=t[t.length-1];if(e){a.tools.push({server:e[1]??``,name:e[2]}),n=!0;continue}if(!(n&&i.trim()===``)){if(n){t.push({text:i,tools:[]}),n=!1;continue}a.text=a.text===``?i:`${a.text}\n${i}`}}return t.map(e=>({...e,text:e.text.trim()})).filter(e=>e.text!==``||e.tools.length>0)};return{parse:n,send:async(t,r)=>{let{headers:i={},...a}=t,o=await fetch(e,{method:`POST`,headers:{"content-type":`application/json`,...i},body:JSON.stringify(a)});if(!o.ok){let e=(await o.text()).replace(/\n/g,` `),t=[{text:e,tools:[],error:!0}];return r?.({items:t,delta:e,raw:e}),t}let s=o.body.getReader(),c=new TextDecoder,l=``;for(;;){let{done:e,value:t}=await s.read();if(e)break;let i=c.decode(t,{stream:!0});l+=i,r?.({items:n(l),delta:i,raw:l})}return n(l)}}},a=new WeakSet,o=(t,r={})=>{if(a.has(t))return t;a.add(t);let{room:i=e,path:o=``,host:s=location.host,party:c=`v1`,synced:l}=r,u=t.open().data().doc,d=i?new n(s,i,u,{party:c,params:{path:o}}):null;return l&&(!d||d.synced?l():d.once(`synced`,()=>l())),t},s=(e,t,n=(e,t)=>t)=>{if(a.has(e))return e;a.add(e);let r=e;return r.open().tx(()=>Object.entries(t).forEach(([e,t])=>r[e]=n(e,t))),e};export{o as client,i as createStream,s as hydrate};

package/dist/hono.d.ts

@@ -0,0 +1,5 @@
+import { Ai, Config } from "./types.js";
+//#region src/hono.d.ts
+declare const hono: (ai: Ai<any>, extra?: Partial<Config>) => import("hono").MiddlewareHandler<any, string, {}, Response>;
+//#endregion
+export { hono };

package/dist/hono.js

@@ -0,0 +1,2 @@
+import{PATH_HEADER as e,SUB_HEADER as t}from"./const.js";import{createMiddleware as n}from"hono/factory";import r from"@auth/core/providers/google";import{decode as i,encode as a}from"@auth/core/jwt";import{getAuthUser as o,initAuthConfig as s}from"@hono/auth-js";import{env as c}from"hono/adapter";import{streamText as l}from"hono/streaming";import{StreamableHTTPTransport as u}from"@hono/mcp";import{McpServer as d}from"@modelcontextprotocol/sdk/server/mcp.js";import{getServerByName as f,routePartykitRequest as p}from"partyserver";const m=`authjs.mcp-token`,h=e=>s(t=>{let n=new URL(t.req.url).host,i=!!e.cookie&&e.cookie.services.some(t=>n===`${t}.${e.cookie.apex}`),a={sessionToken:{options:{domain:`.${e.cookie?.apex}`}}},o=e.providers??[r({clientId:t.env.GOOGLE_CLIENT_ID,clientSecret:t.env.GOOGLE_CLIENT_SECRET})];return{...e.adapter?{adapter:e.adapter(t.env)}:{},providers:o,secret:t.env.AUTH_SECRET,session:{strategy:`jwt`},...i?{cookies:a}:{}}}),g=async e=>(await o(e))?.token?.sub??``,_=(e,t,n,r)=>a({token:{sub:t,path:n},secret:c(e).AUTH_SECRET,salt:r?.salt??m,maxAge:r?.maxAge??43200}),v=async(e,t)=>{let n=(e.req.header(`Authorization`)??``).replace(/^Bearer\s+/i,``);if(!n)return null;let r=await i({token:n,secret:c(e).AUTH_SECRET,salt:t?.salt??m}).catch(()=>null);return{sub:r?.sub??``,path:r?.path??``}},y=e=>e.startsWith(`data:`)?JSON.parse(e.slice(5)):null,b=(e,t,n)=>fetch(e.api,{method:`POST`,headers:{"x-api-key":e.key,"anthropic-version":`2023-06-01`,"anthropic-beta":`mcp-client-2025-11-20`,"content-type":`application/json`},body:JSON.stringify({model:e.model,max_tokens:e.maxTokens,stream:!0,cache_control:{type:`ephemeral`},system:e.system,mcp_servers:[{type:`url`,url:e.url,name:e.name,...t?{authorization_token:t}:{}}],tools:[{type:`mcp_toolset`,mcp_server_name:e.name}],messages:n})}),x=async(e,t)=>{let n=[],r=null,i=0,a=0,o=0,s=``,c=e.body.getReader(),l=new TextDecoder,u=``;for(;;){let{done:e,value:d}=await c.read();if(e)break;u+=l.decode(d,{stream:!0});let f=u.split(`
+`);u=f.pop()??``;for(let e of f){let c=y(e);if(c){if(c.type===`message_start`){let e=c.message?.usage??{};i+=(e.input_tokens??0)+(e.cache_creation_input_tokens??0)+(e.cache_read_input_tokens??0),a+=e.cache_read_input_tokens??0}c.type===`message_delta`&&(o=c.usage?.output_tokens??o,s=c.delta?.stop_reason??s),c.type===`content_block_start`&&(r={...c.content_block},n.push(r),r.type===`mcp_tool_use`&&await t(`\n[tool] ${r.server_name} ${r.name}\n`)),c.type===`content_block_delta`&&c.delta?.type===`text_delta`&&(r.text=(r.text??``)+c.delta.text,await t(c.delta.text)),c.type===`content_block_delta`&&c.delta?.type===`input_json_delta`&&(r.partial=(r.partial??``)+c.delta.partial_json),c.type===`content_block_delta`&&c.delta?.type===`thinking_delta`&&(r.thinking=(r.thinking??``)+c.delta.thinking),c.type===`content_block_delta`&&c.delta?.type===`signature_delta`&&(r.signature=(r.signature??``)+c.delta.signature),c.type===`content_block_stop`&&r?.partial!==void 0&&(r.input=r.partial?JSON.parse(r.partial):{},delete r.partial)}}}return{blocks:n,input:i,cached:a,output:o,stop:s}},S=async(e,t,n,r,i,a=10)=>{let o=r,s=0,c=0,l=0,u=``;for(let r=0;r<a;r++){let r=await x(o,i);if(s+=r.input,c+=r.cached,l+=r.output,u=r.stop||u,u!==`pause_turn`)break;if(n.push({role:`assistant`,content:r.blocks.filter(e=>e.type!==`thinking`||e.thinking||e.signature)}),o=await b(e,await t(),n),!o.ok){await i(`\n[error] ${(await o.text()).replace(/\n/g,` `)}\n`);break}}await i(`\n[usage] input ${s} (cache ${c}) / output ${l} tokens (${u})\n`)},C=e=>n(async t=>{let n=await g(t),{path:r=``,prompt:i,model:a=``,messages:o=[]}=await t.req.json(),s=!!e.lobby&&!r;if(!s&&!n)return t.text(`Unauthorized`,401);if(!s&&!await(e.own??(()=>``))({env:c(t),sub:n,path:r}))return t.text(`Forbidden`,403);let u=e.host??t.req.header(`x-original-host`)??t.req.header(`x-forwarded-host`)??new URL(t.req.url).host,d={key:c(t).ANTHROPIC_API_KEY,api:e.claude??`https://api.anthropic.com/v1/messages`,name:e.name??`aiax`,url:`https://${u}${e.endpoint??`/api/mcp`}`,model:a||e.model||`claude-sonnet-5`,system:e.system??``,maxTokens:e.maxTokens??32e3},f=()=>s?Promise.resolve(``):_(t,n,r,e),p=[...o,{role:`user`,content:i}],m=await b(d,await f(),p);return m.ok?l(t,t=>S(d,f,p,m,e=>t.write(e),e.maxTurns??10)):t.text(await m.text(),500)}),w=async(n,r,i,a,o)=>{let s=await f(n,r),c={[t]:i.sub,[e]:encodeURIComponent(i.path)};return(await s.fetch(`https://internal/act`,{method:`POST`,headers:c,body:JSON.stringify({name:a,input:o})})).json()},T=(e,t)=>n(async n=>{let r=await v(n,t),i=r?.sub??``,a=r?.path??``,o=t.lobby??``;if(r||!o){if(!i)return n.text(`Unauthorized`,401);if(o=await(t.own??(()=>``))({env:c(n),sub:i,path:a}),!o)return n.text(`Forbidden`,403)}let s=new d({name:t.name??`aiax`,version:t.version??`1.0.0`}),l=new u;return e.actions.forEach((e,r)=>s.registerTool(r,{description:e.description,inputSchema:{...e.input}},async e=>{let s=await w(c(n)[t.binding??`v1`],o,{sub:i,path:a},r,e);return{content:[{type:`text`,text:JSON.stringify(s)}]}})),await s.connect(l),l.handleRequest(n)}),E=async(n,r,i,a)=>{let o=new Headers(n.req.raw.headers);o.set(t,i),o.set(e,encodeURIComponent(a));let s=new URL(n.req.url),l=s.pathname.split(`/`);l[3]=encodeURIComponent(r),s.pathname=l.join(`/`);let u=new Request(s,new Request(n.req.raw,{headers:o}));return await p(u,c(n))??n.text(`Not Found`,404)},D=e=>n(async t=>{let n=decodeURIComponent(t.req.path.split(`/`)[3]??``),r=t.req.query(`path`)??``,i=await g(t);if(e.lobby&&n===e.lobby)return E(t,n,i,r);if(!i)return t.text(`Unauthorized`,401);let a=await(e.own??(()=>``))({env:c(t),sub:i,path:r});return!a||n!==a&&n!==(e.alias??`my-room`)?t.text(`Forbidden`,403):E(t,a,i,r)}),O=(e,t={})=>{let r=Object.assign(e.config,t),i={auth:h(r),party:D(r),mcp:T(e,r),llm:C(r)};return n(async(e,t)=>{let n=()=>e.req.path.startsWith(`/parties/`)?i.party(e,t):e.req.path===(r.endpoint??`/api/mcp`)?i.mcp(e,t):e.req.path===(r.relay??`/api/llm`)&&e.req.method===`POST`?i.llm(e,t):t(),a;if(await i.auth(e,async()=>void(a=await n())),a)return a})};export{O as hono};

package/dist/index.d.ts

@@ -1,16 +1,7 @@
-import { Config, Own } from "./types.js";
-//#region src/worker/auth.d.ts
-declare const ownSite: (bucket: (env: any) => any, meta?: string) => Own;
-declare const ownSelf: () => Own;
-//#endregion
+import { ActionDef, Ai, Config, Cookie, Define, Grant, Own, Peer, Saved, Side } from "./types.js";
 //#region src/index.d.ts
-declare const createAiax: (config: Config) => {
-  config: Config;
-  all: () => import("hono").MiddlewareHandler<any, string, {}, Response>;
-  auth: () => import("hono").MiddlewareHandler;
-  party: () => import("hono").MiddlewareHandler<any, string, {}, any>;
-  mcp: () => import("hono").MiddlewareHandler<any, string, {}, Response>;
-  llm: () => import("hono").MiddlewareHandler<any, string, {}, Response>;
-};
+declare const side: Side;
+declare function x<P extends object>(params: P, config?: Config): Ai<P>;
+declare function x<P extends object = {}>(params?: Partial<P>, config?: Config): Ai<P>;
 //#endregion
-export { createAiax, ownSelf, ownSite };
+export { type ActionDef, type Ai, type Config, type Cookie, type Define, type Grant, type Own, type Peer, type Saved, type Side, side, x };

package/dist/index.js

@@ -1,2 +1 @@
-import{PATH_HEADER as e,SUB_HEADER as t}from"./const.js";import{actions as n}from"./action.js";import{createMiddleware as r}from"hono/factory";import i from"@auth/core/providers/google";import{decode as a,encode as o}from"@auth/core/jwt";import{DrizzleAdapter as s}from"@auth/drizzle-adapter";import{getAuthUser as c,initAuthConfig as l}from"@hono/auth-js";import{drizzle as u}from"drizzle-orm/d1";import{env as d}from"hono/adapter";import{streamText as f}from"hono/streaming";import{StreamableHTTPTransport as p}from"@hono/mcp";import{McpServer as m}from"@modelcontextprotocol/sdk/server/mcp.js";import{getServerByName as h,routePartykitRequest as g}from"partyserver";const _=`authjs.mcp-token`,v=e=>l(t=>{let n=new URL(t.req.url).host,r=!!e.cookie&&e.cookie.services.some(t=>n===`${t}.${e.cookie.apex}`),a={sessionToken:{options:{domain:`.${e.cookie?.apex}`}}},o=e.providers??[i({clientId:t.env.GOOGLE_CLIENT_ID,clientSecret:t.env.GOOGLE_CLIENT_SECRET})];return{...e.database?{adapter:s(u(e.database(t.env)))}:{},providers:o,secret:t.env.AUTH_SECRET,session:{strategy:`jwt`},...r?{cookies:a}:{}}}),y=async e=>(await c(e))?.token?.sub??``,b=(e,t,n,r)=>o({token:{sub:t,path:n},secret:d(e).AUTH_SECRET,salt:r?.salt??_,maxAge:r?.maxAge??43200}),x=async(e,t)=>{let n=(e.req.header(`Authorization`)??``).replace(/^Bearer\s+/i,``);if(!n)return null;let r=await a({token:n,secret:d(e).AUTH_SECRET,salt:t?.salt??_}).catch(()=>null);return{sub:r?.sub??``,path:r?.path??``}},S=(e,t=`site`)=>async(n,r,i)=>!r||!i?``:(await e(n).head(`${r}/${i}`))?.customMetadata?.[t]??``,C=()=>(e,t)=>t,w=e=>e.startsWith(`data:`)?JSON.parse(e.slice(5)):null,T=(e,t,n)=>fetch(e.api,{method:`POST`,headers:{"x-api-key":e.key,"anthropic-version":`2023-06-01`,"anthropic-beta":`mcp-client-2025-11-20`,"content-type":`application/json`},body:JSON.stringify({model:e.model,max_tokens:e.maxTokens,stream:!0,cache_control:{type:`ephemeral`},system:e.system,mcp_servers:[{type:`url`,url:e.url,name:e.name,...t?{authorization_token:t}:{}}],tools:[{type:`mcp_toolset`,mcp_server_name:e.name}],messages:n})}),E=async(e,t)=>{let n=[],r=null,i=0,a=0,o=0,s=``,c=e.body.getReader(),l=new TextDecoder,u=``;for(;;){let{done:e,value:d}=await c.read();if(e)break;u+=l.decode(d,{stream:!0});let f=u.split(`
-`);u=f.pop()??``;for(let e of f){let c=w(e);if(c){if(c.type===`message_start`){let e=c.message?.usage??{};i+=(e.input_tokens??0)+(e.cache_creation_input_tokens??0)+(e.cache_read_input_tokens??0),a+=e.cache_read_input_tokens??0}c.type===`message_delta`&&(o=c.usage?.output_tokens??o,s=c.delta?.stop_reason??s),c.type===`content_block_start`&&(r={...c.content_block},n.push(r),r.type===`mcp_tool_use`&&await t(`\n[tool] ${r.server_name} ${r.name}\n`)),c.type===`content_block_delta`&&c.delta?.type===`text_delta`&&(r.text=(r.text??``)+c.delta.text,await t(c.delta.text)),c.type===`content_block_delta`&&c.delta?.type===`input_json_delta`&&(r.partial=(r.partial??``)+c.delta.partial_json),c.type===`content_block_delta`&&c.delta?.type===`thinking_delta`&&(r.thinking=(r.thinking??``)+c.delta.thinking),c.type===`content_block_delta`&&c.delta?.type===`signature_delta`&&(r.signature=(r.signature??``)+c.delta.signature),c.type===`content_block_stop`&&r?.partial!==void 0&&(r.input=r.partial?JSON.parse(r.partial):{},delete r.partial)}}}return{blocks:n,input:i,cached:a,output:o,stop:s}},D=async(e,t,n,r,i,a=10)=>{let o=r,s=0,c=0,l=0,u=``;for(let r=0;r<a;r++){let r=await E(o,i);if(s+=r.input,c+=r.cached,l+=r.output,u=r.stop||u,u!==`pause_turn`)break;if(n.push({role:`assistant`,content:r.blocks.filter(e=>e.type!==`thinking`||e.thinking||e.signature)}),o=await T(e,await t(),n),!o.ok){await i(`\n[error] ${(await o.text()).replace(/\n/g,` `)}\n`);break}}await i(`\n[usage] input ${s} (cache ${c}) / output ${l} tokens (${u})\n`)},O=e=>r(async t=>{let n=await y(t),{path:r=``,prompt:i,model:a=``,messages:o=[]}=await t.req.json(),s=!!e.lobby&&!r;if(!s&&!n)return t.text(`Unauthorized`,401);if(!s&&!await e.own(d(t),n,r))return t.text(`Forbidden`,403);let c=t.req.header(`x-original-host`)??t.req.header(`x-forwarded-host`)??new URL(t.req.url).host,l={key:d(t).ANTHROPIC_API_KEY,api:e.claude??`https://api.anthropic.com/v1/messages`,name:e.name,url:`https://${c}${e.endpoint??`/api/mcp`}`,model:a||e.model||`claude-sonnet-5`,system:e.system??``,maxTokens:e.maxTokens??32e3},u=()=>s?Promise.resolve(``):b(t,n,r,e),p=[...o,{role:`user`,content:i}],m=await T(l,await u(),p);return m.ok?f(t,t=>D(l,u,p,m,e=>t.write(e),e.maxTurns??10)):t.text(await m.text(),500)}),k=async(n,r,i,a,o)=>{let s=await h(n,r),c={[t]:i.sub,[e]:encodeURIComponent(i.path)};return(await s.fetch(`https://internal/act`,{method:`POST`,headers:c,body:JSON.stringify({name:a,input:o})})).json()},A=e=>r(async t=>{let r=await x(t,e),i=r?.sub??``,a=r?.path??``,o=e.lobby??``;if(r||!o){if(!i)return t.text(`Unauthorized`,401);if(o=await e.own(d(t),i,a),!o)return t.text(`Forbidden`,403)}let s=new m({name:e.name,version:e.version??`1.0.0`}),c=new p;return n.forEach((n,r)=>s.registerTool(r,{description:n.description,inputSchema:{...n.input}},async n=>{let s=await k(d(t)[e.binding??`v1`],o,{sub:i,path:a},r,n);return{content:[{type:`text`,text:JSON.stringify(s)}]}})),await s.connect(c),c.handleRequest(t)}),j=async(n,r,i,a)=>{let o=new Headers(n.req.raw.headers);o.set(t,i),o.set(e,encodeURIComponent(a));let s=new URL(n.req.url),c=s.pathname.split(`/`);c[3]=encodeURIComponent(r),s.pathname=c.join(`/`);let l=new Request(s,new Request(n.req.raw,{headers:o}));return await g(l,d(n))??n.text(`Not Found`,404)},M=e=>r(async t=>{let n=decodeURIComponent(t.req.path.split(`/`)[3]??``),r=t.req.query(`path`)??``,i=await y(t);if(e.lobby&&n===e.lobby)return j(t,n,i,r);if(!i)return t.text(`Unauthorized`,401);let a=await e.own(d(t),i,r);return!a||n!==a&&n!==(e.alias??`my-room`)?t.text(`Forbidden`,403):j(t,a,i,r)}),N=e=>{let t={auth:v(e),party:M(e),mcp:A(e),llm:O(e)},n=r(async(n,r)=>{let i=()=>n.req.path.startsWith(`/parties/`)?t.party(n,r):n.req.path===(e.endpoint??`/api/mcp`)?t.mcp(n,r):n.req.path===`/api/llm`&&n.req.method===`POST`?t.llm(n,r):r(),a;if(await t.auth(n,async()=>void(a=await i())),a)return a});return{config:e,all:()=>n,auth:()=>t.auth,party:()=>t.party,mcp:()=>t.mcp,llm:()=>t.llm}};export{N as createAiax,C as ownSelf,S as ownSite};
+import*as e from"yjs";const t=(t,n)=>{let r=t.ui??[],i=e=>r.some(t=>t.endsWith(`/`)?e.startsWith(t):e===t),a=new WeakMap,o=e=>{for(let t of e.changed.values())for(let e of t)if(e===null||!i(e))return!0;return!1};return{rows(e){let t=[];return n().forEach((n,r)=>r.startsWith(e)&&!r.slice(e.length).includes(`/`)&&t.push(n)),t.sort((e,t)=>(e?.pos??0)-(t?.pos??0))},history(r){let i=n();return a.has(i)||a.set(i,new e.UndoManager(i,{_captureTransaction:o,...t.history,...r})),a.get(i)},snapshot(){let t=new e.Doc,r=t.getMap(`tree`);return t.transact(()=>n().forEach((t,n)=>!i(n)&&r.set(n,t instanceof e.AbstractType?t.clone():t))),e.encodeStateAsUpdate(t)}}},n=(t,n)=>{let r=new e.Doc,i=new WeakSet,a=new WeakMap,o=new Map,s=(e,c)=>{e&&(r=e),c&&a.set(r,c);let l=r;if(i.has(l))return;i.add(l);let u=l.getMap(`act-req`),d=l.getMap(`act-res`),f=async e=>{let r=u.get(e),i=n.get(r?.name);if(!i||i.side!==t)return;u.delete(e);let o=a.get(l)??(e=>e());d.set(e,{value:await o(()=>(s(l),i.run(r.input)))})},p=e=>{let t=o.get(e);!t||!d.has(e)||(o.delete(e),t(d.get(e).value),d.delete(e))};u.observe(e=>e.keysChanged.forEach(f)),d.observe(e=>e.keysChanged.forEach(p))};return{open:s,data:(e=`tree`)=>r.getMap(e),call(e,i){let a=n.get(e);return a?a.side===t||a.side===`both`?(s(),Promise.resolve(a.run(i))):new Promise(t=>{let n=crypto.randomUUID();o.set(n,t),r.getMap(`act-req`).set(n,{name:e,input:i})}):Promise.reject(Error(`unknown action: ${e}`))}}},r=e=>!!e&&typeof e.parse==`function`,i=e=>r(e)?{value:e}:e,a=(e,t)=>r(e)&&t&&typeof t==`object`&&`value`in t?t.value:t,o=(e,t,n)=>{let r=[],o=(e,r)=>i=>{let a=t.get(e);return a?a(i,r,n()):r(i)};return{chain:o,missing:e=>()=>Promise.reject(Error(`not implemented: ${e}`)),describe(e,t){return t?(r=[...r,e],t(n()),r=r.slice(0,-1),n()):n()},define:t=>(s,...c)=>{let l=c.find(e=>typeof e==`string`)??``,u=c.find(e=>typeof e==`function`),d=c.find(e=>e&&typeof e==`object`),f=async e=>{let t=a(d,e),r=await u(t,n());return typeof r==`function`?r(t,n()):r&&r.default?r.default(t,n()):r},p=[...r,l].filter(Boolean).join(` `);return e.set(s,{name:s,description:p,side:t,input:i(d),run:o(s,f)}),n()}}},s=typeof window>`u`?`server`:`client`;function c(e={},r={}){let i=new Map,a=new Map,c=new Set,l=n(s,i),u=t(r,l.data),d=o(i,a,()=>m),f=async()=>{let e={};return l.data().forEach((t,n)=>e[n]=t),e},p={config:r,side:s,actions:i,action:d.define(`both`),client:d.define(`client`),server:d.define(`server`),describe:d.describe,abstract:e=>(c.add(e),m),override:(e,t)=>(a.set(e,t),m),data:l.data,open:(e,t)=>(l.open(e,t),m),call:l.call,rows:u.rows,scan:e=>{let t=[];return l.data().forEach((n,r)=>r.startsWith(e)&&t.push(n)),t},wipe:e=>{let t=[];l.data().forEach((n,r)=>r.startsWith(e)&&t.push(r)),t.forEach(e=>l.data().delete(e))},tx:(e,t)=>l.data().doc.transact(e,t),history:u.history,snapshot:u.snapshot};i.set(`get_tree`,{name:`get_tree`,description:r.tree??`Dump every key/value of the shared tree to observe the current state before acting`,side:`both`,run:d.chain(`get_tree`,f)});let m=new Proxy(p,{get(t,n){if(typeof n!=`string`||n in t)return t[n];if(i.has(n))return e=>l.call(n,e);if(c.has(n))return d.chain(n,d.missing(n));if(n!==`then`&&n!==`toJSON`)return l.data().get(n)??e[n]},set(e,t,n){return typeof t!=`string`||t in e?(e[t]=n,!0):(l.data().set(t,n),!0)},deleteProperty(e,t){return typeof t!=`string`||t in e||l.data().delete(t),!0}});return m}export{s as side,c as x};

package/dist/react.d.ts

@@ -0,0 +1,23 @@
+import { t as Route } from "./client-DG7hCEbP.js";
+import { ReactNode } from "react";
+//#region src/react.d.ts
+declare const atom: <T>(initial: T) => {
+  value: T;
+  listeners: Set<(v: T) => void>;
+};
+type Atom<T> = ReturnType<typeof atom<T>>;
+declare const setAtom: <T>(a: Atom<T>, v: T | ((p: T) => T)) => void;
+declare const useAtomValue: <T>(a: Atom<T>) => T;
+declare const useAtom: <T>(a: Atom<T>) => [T, (v: T) => void];
+declare const AtomValue: <T>({ atom, children }: {
+  atom: Atom<T>;
+  children: (v: T) => ReactNode;
+}) => ReactNode;
+declare const useClient: <T extends object>(ai: T, route?: Route) => T;
+declare const Client: <T extends object>({ ai, route, children }: {
+  ai: T;
+  route?: Route;
+  children: (ai: T) => ReactNode;
+}) => ReactNode;
+//#endregion
+export { Atom, AtomValue, Client, atom, setAtom, useAtom, useAtomValue, useClient };

package/dist/react.js

@@ -0,0 +1 @@
+import{useCallback as e,useEffect as t,useState as n}from"react";const r=e=>({value:e,listeners:new Set}),i=(e,t)=>{typeof t==`function`&&(t=t(e.value)),e.value=t,e.listeners.forEach(e=>e(t))},a=e=>{let[r,i]=n(()=>e.value);return t(()=>{let t=e=>i(e);return e.listeners.add(t),r!==e.value&&i(e.value),()=>void e.listeners.delete(t)},[e]),r},o=t=>[a(t),e(e=>i(t,e),[t])],s=({atom:e,children:t})=>t(a(e)),c=(e,r)=>{let[,i]=n(0);return t(()=>{import(`./client.js`).then(({client:t})=>t(e,r));let t=e.data(),n=()=>i(e=>e+1);return t.observe(n),()=>t.unobserve(n)},[e]),e},l=({ai:e,route:t,children:n})=>n(c(e,t));export{s as AtomValue,l as Client,r as atom,i as setAtom,o as useAtom,a as useAtomValue,c as useClient};

package/dist/server.d.ts

@@ -1,14 +1,65 @@
-import { Grant } from "./types.js";
-import { Call } from "./action.js";
-import { BINDING } from "./const.js";
+import { ActionDef, Ai, Config, Define, Grant, Side } from "./types.js";
+import * as Y from "yjs";
 import { YServer } from "y-partyserver";
 //#region src/server.d.ts
-declare class AiaxServer extends YServer {
+declare class Server extends YServer {
+  static options: {
+    hibernate: boolean;
+  };
+  static callbackOptions: {
+    debounceWait: number;
+    debounceMaxWait: number;
+  };
+  env: any;
+  ctx: any;
+  ai: Ai;
+  sub: string;
+  path: string;
+  grant: Grant | null;
+  queue: Promise<any>;
+  hook: (run: () => Promise<any>) => Promise<any>;
+  wire: () => {
+    config: Config;
+    side: Side;
+    actions: Map<string, ActionDef>;
+    action: Define<{}>;
+    client: Define<{}>;
+    server: Define<{}>;
+    describe(text: string): /*elided*/ any;
+    describe<U extends object>(text: string, fn: (ai: /*elided*/ any) => Ai<U>): Ai<U>;
+    abstract<N extends string>(name: N): Ai<Record<N, (input?: any) => any>>;
+    override(name: string, fn: (input: any, next: (input: any) => Promise<any>, ai: any) => any): /*elided*/ any;
+    data<V = any>(name?: string): Y.Map<V>;
+    open(doc?: Y.Doc, wrap?: (run: () => Promise<any>) => Promise<any>): /*elided*/ any;
+    call(name: string, input?: any): Promise<any>;
+    rows<V = any>(prefix: string): V[];
+    scan<V = any>(prefix: string): V[];
+    wipe(prefix: string): void;
+    tx(fn: () => void, origin?: any): void;
+    history(options?: object): Y.UndoManager;
+    snapshot(): Uint8Array;
+  };
   wrap: (run: () => Promise<any>) => Promise<any>;
-  call: Call;
+  call: (name: string, input?: any) => Promise<any>;
+  conf(): Config;
+  isLobby(): boolean;
+  saved(grant: Grant): {
+    env: any;
+    sub: string;
+    path: string;
+    room: string;
+  };
   grantOf(request: Request): Grant;
-  onAct(_grant: Grant, _request: Request): Promise<void>;
+  owner(): Promise<Grant>;
+  remember(sub: string, path: string): Promise<void>;
+  onAct(grant: Grant, _request?: Request): Promise<void>;
+  onStart(): Promise<void>;
+  onConnect(conn: any, ctx: any): Promise<void>;
+  onLoad(): Promise<void>;
+  onSave(): Promise<void>;
+  onAlarm(): Promise<void>;
+  onClose(conn: any, code: number, reason: string, wasClean: boolean): Promise<void>;
   onRequest(request: Request): Promise<Response>;
 }
 //#endregion
-export { AiaxServer, BINDING, type Grant };
+export { Server };

package/dist/server.js

@@ -1 +1 @@
-import{BINDING as e}from"./const.js";import{actions as t,bind as n,init as r}from"./action.js";import{YServer as i}from"y-partyserver";var a=class extends i{wrap=e=>e();call=r(this.document,e=>this.wrap(e));grantOf(e){return{sub:e.headers.get(`x-user-sub`)??``,path:decodeURIComponent(e.headers.get(`x-user-path`)??``)}}async onAct(e,t){}async onRequest(e){if(n(this.document),e.method!==`POST`)return new Response(`Not Found`,{status:404});let{name:r,input:i}=await e.json();return t.get(r)?.side===`client`?Response.json({ok:!0,result:await this.call(r,i)}):(await this.onAct(this.grantOf(e),e),Response.json({ok:!0,result:await this.wrap(()=>this.call(r,i))}))}};export{a as AiaxServer,e as BINDING};
+import"./const.js";import*as e from"yjs";import{YServer as t}from"y-partyserver";var n=class extends t{static options={hibernate:!0};static callbackOptions={debounceWait:6e4,debounceMaxWait:6e4};ai=null;sub=``;path=``;grant=null;queue=Promise.resolve();hook=e=>e();wire=()=>this.ai.open(this.document,e=>this.wrap(e));wrap=e=>{let t=this.grant;this.grant=null;let n=async()=>{let n={env:this.env,room:this.name,...t??await this.owner()};return this.wire(),this.ai.override(`peer`,()=>n),this.hook(e)};return this.queue=this.queue.then(n,n),this.queue};call=(e,t)=>(this.wire(),this.ai.call(e,t));conf(){return this.ai?.config??{}}isLobby(){let e=this.conf().lobby;return!!e&&this.name===e}saved(e){return{env:this.env,sub:e.sub,path:e.path,room:this.name}}grantOf(e){return{sub:e.headers.get(`x-user-sub`)??``,path:decodeURIComponent(e.headers.get(`x-user-path`)??``)}}async owner(){for(let e of this.getConnections()){let t=e.state;if(t?.sub)return t}return this.sub?{sub:this.sub,path:this.path}:await this.ctx.storage.get(`owner`)??{sub:``,path:``}}async remember(e,t){this.sub=e||this.sub,this.path=t||this.path,e&&await this.ctx.storage.put(`owner`,{sub:e,path:t})}async onAct(e,t){this.grant=e,await this.remember(e.sub,e.path)}async onStart(){this.wire(),await super.onStart(),this.conf().save&&this.document.on(`update`,()=>{this.isLobby()||this.ctx.storage.setAlarm(Date.now()+7e4)})}async onConnect(e,t){let{sub:n,path:r}=this.grantOf(t.request);return e.setState({sub:n,path:r}),await this.remember(n,r),super.onConnect(e,t)}async onLoad(){this.wire();let t=this.conf().load;if(!t||this.isLobby())return;let n=await t(this.saved(await this.owner()));n&&n.byteLength&&e.applyUpdate(this.document,new Uint8Array(n),`load`)}async onSave(){let e=this.conf().save;if(!e||this.isLobby())return;let t=await this.owner();t.sub&&(this.wire(),await e(this.saved(t),this.ai.snapshot()))}async onAlarm(){await this.onSave()}async onClose(e,t,n,r){await super.onClose(e,t,n,r),await this.onSave()}async onRequest(e){if(this.wire(),e.method!==`POST`)return new Response(`Not Found`,{status:404});let{name:t,input:n}=await e.json();return this.ai.actions.get(t)?.side===`client`?Response.json({ok:!0,result:await this.call(t,n)}):(await this.onAct(this.grantOf(e),e),Response.json({ok:!0,result:await this.wrap(()=>this.call(t,n))}))}};export{n as Server};

package/dist/types.d.ts

@@ -1,28 +1,36 @@
-import { ZodRawShape } from "zod";
+import * as Y from "yjs";
+import { ZodRawShape, ZodType } from "zod";
 //#region src/types.d.ts
 type Side = 'server' | 'client' | 'both';
-interface ActMeta {
+interface ActionDef {
   name: string;
   description: string;
-  input?: ZodRawShape;
-}
-interface ActionDef extends ActMeta {
   side: Side;
+  input?: ZodRawShape;
   run: (input: any) => Promise<any>;
 }
 interface Grant {
   sub: string;
   path: string;
 }
-type Own = (env: any, sub: string, path: string) => Promise<string> | string;
+interface Peer {
+  env: any;
+  sub: string;
+  path: string;
+}
+interface Saved extends Peer {
+  room: string;
+}
+type Own = (at: Peer) => Promise<string> | string;
 interface Cookie {
   apex: string;
   services: string[];
 }
 interface Config {
-  name: string;
-  own: Own;
-  database?: (env: any) => any;
+  name?: string;
+  tree?: string;
+  own?: Own;
+  adapter?: (env: any) => any;
   lobby?: string;
   alias?: string;
   system?: string;
@@ -31,12 +39,54 @@ interface Config {
   maxTokens?: number;
   maxTurns?: number;
   binding?: string;
+  host?: string;
   endpoint?: string;
+  relay?: string;
   version?: string;
   salt?: string;
   maxAge?: number;
   cookie?: Cookie;
   providers?: any[];
+  ui?: string[];
+  history?: object;
+  load?: (at: Saved) => Promise<any>;
+  save?: (at: Saved, buf: Uint8Array) => Promise<any>;
 }
+type AnyFn = (...args: any[]) => any;
+type Shape = ZodRawShape | ZodType;
+type Value<Z> = Z extends ZodType<infer O> ? O : any;
+type Opt<S> = { [K in keyof S]: undefined extends Value<S[K]> ? K : never; }[keyof S];
+type Input<S> = S extends ZodType<infer O> ? O : { [K in Exclude<keyof S, Opt<S>>]: Value<S[K]>; } & { [K in Opt<S>]?: Value<S[K]>; };
+type Result<F> = F extends AnyFn ? (Awaited<ReturnType<F>> extends {
+  default: infer D;
+} ? (D extends AnyFn ? Awaited<ReturnType<D>> : Awaited<ReturnType<F>>) : Awaited<ReturnType<F>>) : never;
+type Part = string | Shape | AnyFn;
+type FnOf<A> = A extends readonly [infer H, ...infer R] ? (H extends AnyFn ? H : FnOf<R>) : never;
+type SchemaOf<A> = A extends readonly [infer H, ...infer R] ? (H extends AnyFn ? SchemaOf<R> : H extends string ? SchemaOf<R> : H) : unknown;
+type Tool<S, F> = unknown extends S ? (input?: any) => Promise<Result<F>> : (input: Input<S>) => Promise<Result<F>>;
+interface Define<T extends object> {
+  <N extends string, A extends readonly [Part, ...Part[]]>(name: N, ...parts: A): Ai<T & Record<N, Tool<SchemaOf<A>, FnOf<A>>>>;
+}
+type Ai<T extends object = {}> = T & {
+  config: Config;
+  side: Side;
+  actions: Map<string, ActionDef>;
+  action: Define<T>;
+  client: Define<T>;
+  server: Define<T>;
+  describe(text: string): Ai<T>;
+  describe<U extends object>(text: string, fn: (ai: Ai<T>) => Ai<U>): Ai<T & U>;
+  abstract<N extends string>(name: N): Ai<T & Record<N, (input?: any) => any>>;
+  override(name: string, fn: (input: any, next: (input: any) => Promise<any>, ai: any) => any): Ai<T>;
+  data<V = any>(name?: string): Y.Map<V>;
+  open(doc?: Y.Doc, wrap?: (run: () => Promise<any>) => Promise<any>): Ai<T>;
+  call(name: string, input?: any): Promise<any>;
+  rows<V = any>(prefix: string): V[];
+  scan<V = any>(prefix: string): V[];
+  wipe(prefix: string): void;
+  tx(fn: () => void, origin?: any): void;
+  history(options?: object): Y.UndoManager;
+  snapshot(): Uint8Array;
+};
 //#endregion
-export { ActMeta, ActionDef, Config, Cookie, Grant, Own, Side };
+export { ActionDef, Ai, Config, Cookie, Define, Grant, Own, Peer, Saved, Side };

package/package.json

@@ -1,7 +1,7 @@
 {
         "name": "ai-ax",
         "author": "tseijp",
-        "version": "0.4.3",
+        "version": "0.6.0",
         "license": "MIT",
         "description": "AI Agent Experience (AI/AX) library for Hono + Cloudflare. One act surface for both human UI/UX and LLM MCP tools, with authentication, authorization, realtime sync and Claude API relay.",
         "keywords": [
@@ -30,10 +30,6 @@
                         "types": "./dist/index.d.ts",
                         "default": "./dist/index.js"
                 },
-                "./action": {
-                        "types": "./dist/action.d.ts",
-                        "default": "./dist/action.js"
-                },
                 "./client": {
                         "types": "./dist/client.d.ts",
                         "default": "./dist/client.js"
@@ -42,10 +38,22 @@
                         "types": "./dist/const.d.ts",
                         "default": "./dist/const.js"
                 },
+                "./hono": {
+                        "types": "./dist/hono.d.ts",
+                        "default": "./dist/hono.js"
+                },
+                "./react": {
+                        "types": "./dist/react.d.ts",
+                        "default": "./dist/react.js"
+                },
                 "./server": {
                         "types": "./dist/server.d.ts",
                         "default": "./dist/server.js"
                 },
+                "./types": {
+                        "types": "./dist/types.d.ts",
+                        "default": "./dist/types.js"
+                },
                 "./src": {
                         "types": "./src/index.ts",
                         "default": "./src/index.ts"
@@ -61,40 +69,48 @@
                 "README.md"
         ],
         "scripts": {
-                "build": "tsdown --config ../../tsdown.config.ts",
+                "build": "tsdown --config ../../tsdown.config.ts && rm -f dist/*-*.d.ts",
                 "mmd": "for f in concept stack grant; do mmdc -i media/$f.mmd -o media/$f.svg; done"
         },
         "devDependencies": {
                 "@auth/core": "0.34.3",
-                "@auth/drizzle-adapter": "1.11.2",
                 "@hono/auth-js": "1.1.1",
                 "@hono/mcp": "0.3.1",
                 "@modelcontextprotocol/sdk": "1.29.0",
-                "drizzle-orm": "0.45.2",
+                "@types/react": "^19.2.17",
                 "hono": "4.12.30",
                 "partyserver": "0.5.8",
+                "react": "^19.2.7",
                 "y-partyserver": "2.2.0",
                 "yjs": "13.6.31",
                 "zod": "4.4.3"
         },
         "peerDependencies": {
                 "@auth/core": ">=0.34.0",
-                "@auth/drizzle-adapter": ">=1.0.0",
                 "@hono/auth-js": ">=1.0.0",
                 "@hono/mcp": ">=0.3.0",
                 "@modelcontextprotocol/sdk": ">=1.0.0",
-                "drizzle-orm": ">=0.40.0",
                 "hono": ">=4.0.0",
                 "partyserver": ">=0.5.0",
+                "react": ">=18.0.0",
                 "y-partyserver": ">=2.0.0",
                 "yjs": ">=13.0.0",
                 "zod": ">=3.25.0"
         },
         "peerDependenciesMeta": {
-                "@auth/drizzle-adapter": {
+                "@hono/auth-js": {
+                        "optional": true
+                },
+                "@hono/mcp": {
+                        "optional": true
+                },
+                "@modelcontextprotocol/sdk": {
+                        "optional": true
+                },
+                "hono": {
                         "optional": true
                 },
-                "drizzle-orm": {
+                "react": {
                         "optional": true
                 }
         }

package/README.ja.md

@@ -1,147 +0,0 @@
-# ai-ax
-
-AI Agent Experience (AI/AX) library for Hono + Cloudflare.
-
-ai-ax は、web アプリの「人間向けの体験 (UI/UX)」と「AI agent 向けの体験 (AI/AX)」を 1 つの操作面として実装するための library。操作は 1 度だけ宣言され、その宣言が人間には click handler、LLM には MCP tool として同時に機能する。両者は同じ realtime 状態を読み書きする。
-
-library 全体を支える考えは 3 つ。**one action**、**one tree**、**one resolver**。
-
-## Why
-
-web は「操作するのは人間」という前提で UI/UX を積み上げてきた。そこへ後から LLM の操作経路を足すと、操作面が 2 つ、認証認可が 2 系統、バグも 2 倍になる。2 つの実装は必ずずれていき、そのずれは数週間後の log でようやく見つかる。
-
-ai-ax は 2 つ目の実装を管理するのではなく、消す。AI agent をアプリのユーザーの一人として扱い、画面を見る人間と同じ状態を読ませ、同じ操作を呼ばせる。開発者が UI のボタンを click して debug すれば、その debug 済みコードがそのまま MCP 経由で agent が実行するコードになる。ずれていく「もう 1 つの実装」は存在しない。
-
-![one action, one tree](https://r.tsei.jp/ai-ax/concept.svg)
-
-**one action** — 操作の最小単位を 1 度だけ宣言し、UI と MCP の両方から同じ実装に到達させる。**one tree** — 全状態は単一の yjs の木であり、人間には描画された画面として、LLM には `get_tree` の観測結果として同じ木が見える。**one resolver** — 認可は「誰がどの部屋に入れるか」を決める 1 つの関数に集約され、人間も AI もすべての経路がそこを通る。
-
-## What
-
-前提となる構成は Hono + Cloudflare Workers。realtime 同期は partyserver (Durable Objects) + yjs、認証は Auth.js、LLM は Claude API の MCP connector。ai-ax はその接続部 — 認証、認可、realtime 同期、MCP server、LLM 中継 — を Hono middleware として提供する。
-
-![stack](https://r.tsei.jp/ai-ax/stack.svg)
-
-worker 側は合成 middleware を 1 つ置くだけでよく、Durable Object は re-export で済む。
-
-```ts
-import { Hono } from 'hono'
-import { createAiax, ownSelf } from 'ai-ax'
-import { PROMPT } from './prompt'
-import './actions'
-
-const ai = createAiax({ name: 'demo', own: ownSelf(), database: (e) => e.my_d1, system: PROMPT })
-const app = new Hono().use('*', ai.all())
-
-export default app
-export { AiaxServer } from 'ai-ax/server'
-```
-
-`ai.all()` は `/parties/*` を websocket 同期へ、`/api/mcp` を MCP server へ、`POST /api/llm` を Claude 中継へ振り分け、Auth.js の session も処理する。それ以外はすべて自作の route へ素通しする。export した `AiaxServer` は binding 名 `v1` の Durable Object として deploy する。
-
-### one action
-
-```ts
-import { action } from 'ai-ax/action'
-import { z } from 'zod'
-
-export const placeMark = action<{ cell: number }, string>(() => import('./actions/place-mark'), 'both', {
-        name: 'place_mark',
-        description: '空いているマスに現在の手番の印を置く',
-        input: { cell: z.number().describe('マス番号 0-8') },
-})
-```
-
-この 1 つの宣言から 2 つのものが生まれる。UI の event handler から呼べる async 関数と、LLM に公開される MCP tool (name / description / zod input schema)。第 1 引数は dynamic import でも実装関数そのものでもよく、bundle を分けたい service にも 1 file で書きたいアプリにも合う。
-
-`side` は「その実装がどこでなら動けるか」を表し、反対側から呼ばれたときは ai-ax が境界を越えて実行を届ける。
-
-| side     | 動作場所                          | 反対側から呼ばれたとき                             |
-| -------- | --------------------------------- | -------------------------------------------------- |
-| `both`   | browser と Durable Object の両方  | 呼んだ側でそのまま実行                             |
-| `client` | browser のみ (browser API が必要) | yjs 上の act-req / act-res で接続中 browser へ委譲 |
-| `server` | Durable Object のみ               | Durable Object へ転送                              |
-
-action の中では `data()` が共有の `Y.Map` (`tree`) を返す。ここへの書き込みは接続中の全 browser に realtime 同期され、LLM が観測するのも全く同じ木。だから agent の操作は人間の画面にその場で現れる。
-
-browser 側は 1 度接続すればすべてが動き出す。
-
-```ts
-import { ALIAS, connect } from 'ai-ax/client'
-
-const link = connect({ room: ALIAS })
-link.synced(() => boot())
-```
-
-client は常に別名 `my-room` で接続する。server が認可済みの room 名へ書き換えるため、client が実際の room 名を選ぶことはない。
-
-### one resolver
-
-credential は 2 種類だけ。どちらも `AUTH_SECRET` で署名された jwt であり、平文の user id が network を渡ることはない。
-
-| 経路                       | credential                   | 発行                              | 検証                                  |
-| -------------------------- | ---------------------------- | --------------------------------- | ------------------------------------- |
-| Browser → Worker           | session cookie (Auth.js jwt) | `/api/auth` (Google OAuth)        | `userSub()`                           |
-| Claude → Worker `/api/mcp` | grant jwt `{ sub, path }`    | llm middleware が認可後に発行     | `readGrant()`                         |
-| Worker → Durable Object    | room 名 + `x-user-sub`       | worker が認可済みの値で必ず上書き | DO へは worker binding 経由でのみ到達 |
-
-認可は 1 つの関数に集約される。
-
-```ts
-type Own = (env: any, sub: string, path: string) => Promise<string> | string
-```
-
-答えるのは「この user はこの path に対してどの部屋を得るか」だけで、空文字は拒否。`ownSelf()` は user 本人の id を返す (個人アプリ: 全員が自分だけの部屋を持つ)。`ownSite(bucket)` は R2 の file metadata を引く (editor アプリ: file を所有していればその部屋が開く)。D1 の所属 table を join する resolver も同じ型で書ける。
-
-grant jwt は llm middleware が turn ごとに発行し、Claude API がすべての MCP request に載せて `/api/mcp` へ運ぶ。MCP server は毎回署名を検証してから操作を実行する。LLM は token の中身を選べず、書き換えれば署名が壊れる。つまり agent はその瞬間に認可された 1 部屋の中に封じられる。
-
-![grant sequence](https://r.tsei.jp/ai-ax/grant.svg)
-
-### LLM 中継
-
-`POST /api/llm` に `{ path, prompt, model?, messages? }` を送ると、認可 → grant 発行 → MCP server 付きで Claude API 呼び出し → text stream 中継、が 1 本で流れる。`messages` は prompt の前に積む過去の会話。library は履歴を保存しない — 何をどこへどんな形で永続化するかはアプリの決めごとであり、ここに渡されたものをそのまま再生するだけ。
-
-stream は素の text で、`[tool] server name` の行が tool 呼び出しを、末尾の `[usage] ...` の行が turn の終わりを表す。この wire format の browser 側の相棒が `createStream()`。
-
-```ts
-import { createStream } from 'ai-ax/client'
-
-const stream = createStream()
-const items = await stream.send({ prompt, path, model, messages }, (u) => draw(u.items))
-```
-
-`parse` は raw text を `{ text, tools }` の item 列に分解して usage を隠し、`send` は POST しながら parse 済みの update を流す。対になる `pack` / `unpack` は完成した応答を保存可能な `{ reply, tools }` 形式と相互変換する。アプリは wire format そのものに触れずに、会話の描画・永続化・再生ができる。
-
-## How
-
-| entry          | 主な export                         | 動作場所                 |
-| -------------- | ----------------------------------- | ------------------------ |
-| `ai-ax`        | `createAiax`, `ownSelf`, `ownSite`  | worker (Hono middleware) |
-| `ai-ax/client` | `connect`, `createStream`, `ALIAS`  | browser                  |
-| `ai-ax/action` | `action`, `actions`, `data`, `side` | 共有の action 宣言       |
-| `ai-ax/server` | `AiaxServer`                        | Durable Object           |
-| `ai-ax/const`  | protocol 定数 (path と header 名)   | 両方                     |
-
-`createAiax(config)` は以下を受け取り `{ all, auth, party, mcp, llm }` を返す。`all()` が上で示した合成 middleware で、4 つの factory は個別にも使える。
-
-| key       | 型                    | 既定値                                    | 説明                                                        |
-| --------- | --------------------- | ----------------------------------------- | ----------------------------------------------------------- |
-| name      | `string`              | 必須                                      | service id。MCP server 名になる                             |
-| own       | `Own`                 | 必須                                      | 認可 resolver。`''` で拒否                                  |
-| database  | `(env) => D1Database` | なし                                      | Auth.js DrizzleAdapter に渡す D1。省略時は adapter なし jwt |
-| lobby     | `string`              | なし                                      | 匿名で開放する demo 部屋 1 つ。省略時は全経路で認証必須     |
-| alias     | `string`              | `'my-room'`                               | 「自分の部屋」を指す接続名。`own` の結果へ書き換えられる    |
-| system    | `string`              | `''`                                      | LLM の system prompt                                        |
-| model     | `string`              | `'claude-sonnet-5'`                       | Claude API の model id                                      |
-| claude    | `string`              | `'https://api.anthropic.com/v1/messages'` | Claude API の URL。AI Gateway 経由に差し替え可              |
-| maxTokens | `number`              | `32000`                                   | 1 応答の max_tokens                                         |
-| maxTurns  | `number`              | `10`                                      | pause_turn 継続の上限回数                                   |
-| binding   | `string`              | `'v1'`                                    | Durable Object binding 名                                   |
-| endpoint  | `string`              | `'/api/mcp'`                              | MCP endpoint の path                                        |
-| version   | `string`              | `'1.0.0'`                                 | MCP server の version 表記                                  |
-| salt      | `string`              | `'authjs.mcp-token'`                      | grant jwt の salt。service ごとの分離                       |
-| maxAge    | `number`              | `43200` (12h)                             | grant jwt の有効秒数                                        |
-| cookie    | `{ apex, services }`  | なし                                      | subdomain 間で session cookie を共有する service 群         |
-| providers | `any[]`               | Google                                    | Auth.js providers の差し替え                                |
-
-`x-user-sub` / `x-user-path` の header 名と anthropic-version は library 内部の protocol 定数であり、意図的に設定不可。protocol の両端は同時に変わる必要があるため。

package/dist/action.d.ts

@@ -1,13 +0,0 @@
-import { ActMeta, ActionDef, Side } from "./types.js";
-import * as Y from "yjs";
-//#region src/action.d.ts
-type Action<I, R> = (input: I) => R | Promise<R>;
-type Call = (name: string, input: any) => Promise<any>;
-declare const actions: Map<string, ActionDef>;
-declare const side: Side;
-declare const bind: (doc: Y.Doc) => Y.Doc;
-declare const data: <T = any>(name?: string) => Y.Map<T>;
-declare function action<I extends object, R>(load: Action<I, R> | ((input?: I) => any), at: Side, meta: ActMeta): (input: I) => Promise<R>;
-declare const init: (doc: Y.Doc, wrap?: (run: () => Promise<any>) => Promise<any>) => Call;
-//#endregion
-export { Call, action, actions, bind, data, init, side };

package/dist/action.js

@@ -1 +0,0 @@
-const e=new Map,t=typeof window>`u`?`server`:`client`;let n,r;const i=e=>r=e,a=(e=`tree`)=>r.getMap(e);function o(t,r,i){let a=async e=>{let n=await t(e);return typeof n==`function`?n(e):n?.default?n.default(e):n};return e.set(i.name,{...i,side:r,run:a}),e=>n(i.name,e)}const s=(r,a=e=>e())=>{i(r);let o=r.getMap(`act-req`),s=r.getMap(`act-res`),c=new Map,l=async n=>{let c=o.get(n),l=e.get(c?.name);!l||l.side!==t||(o.delete(n),s.set(n,{value:await a(()=>(i(r),l.run(c.input)))}))},u=e=>{let t=c.get(e);!t||!s.has(e)||(c.delete(e),t(s.get(e).value),s.delete(e))};return o.observe(e=>e.keysChanged.forEach(l)),s.observe(e=>e.keysChanged.forEach(u)),n=(n,a)=>{let s=e.get(n);return s.side===t||s.side===`both`?(i(r),s.run(a)):new Promise(e=>{let t=crypto.randomUUID();c.set(t,e),o.set(t,{name:n,input:a})})},n};export{o as action,e as actions,i as bind,a as data,s as init,t as side};