@intentic/sandbox-contract 1.244.0 → 1.246.1

package/src/index.ts

@@ -1,5 +1,6 @@
 import type { ContractRoute } from "./routes.js";
 import { contractRoutes, requestPathFor, routeForProcedure, routeNameForRequest, routeShapes } from "./routes.js";
+import { accountsContract } from "./contracts/accounts.contract.js";
 import { activityContract } from "./contracts/activity.contract.js";
 import { agentContract } from "./contracts/agent.contract.js";
 import { agentsContract } from "./contracts/agents.contract.js";
@@ -8,14 +9,11 @@ import { automationsContract } from "./contracts/automations.contract.js";
 import { capabilitiesContract } from "./contracts/capabilities.contract.js";
 import { choresContract } from "./contracts/chores.contract.js";
 import { ciContract } from "./contracts/ci.contract.js";
-import { claudeContract } from "./contracts/claude.contract.js";
-import { cursorContract } from "./contracts/cursor.contract.js";
 import { endpointsContract } from "./contracts/endpoints.contract.js";
 import { exitContract } from "./contracts/exit.contract.js";
 import { extensionsContract } from "./contracts/extensions.contract.js";
 import { personasContract } from "./contracts/personas.contract.js";
 import { gitContract } from "./contracts/git.contract.js";
-import { grokContract } from "./contracts/grok.contract.js";
 import { historyContract } from "./contracts/history.contract.js";
 import { intenticContract } from "./contracts/intentic.contract.js";
 import { inventoryContract } from "./contracts/inventory.contract.js";
@@ -26,7 +24,6 @@ import { panelsContract } from "./contracts/panels.contract.js";
 import { portsContract } from "./contracts/ports.contract.js";
 import { publicContract } from "./contracts/public.contract.js";
 import { prepushContract } from "./contracts/prepush.contract.js";
-import { keysContract } from "./contracts/keys.contract.js";
 import { providersContract } from "./contracts/providers.contract.js";
 import { pushContract } from "./contracts/push.contract.js";
 import { safetyContract } from "./contracts/safety.contract.js";
@@ -42,6 +39,7 @@ import { vpnContract } from "./contracts/vpn.contract.js";
 import { workflowsContract } from "./contracts/workflows.contract.js";
 import { workspaceContract } from "./contracts/workspace.contract.js";
 
+export { accountsContract } from "./contracts/accounts.contract.js";
 export { activityContract } from "./contracts/activity.contract.js";
 export { agentContract } from "./contracts/agent.contract.js";
 export { agentsContract } from "./contracts/agents.contract.js";
@@ -50,17 +48,14 @@ export { automationsContract } from "./contracts/automations.contract.js";
 export { capabilitiesContract } from "./contracts/capabilities.contract.js";
 export { choresContract } from "./contracts/chores.contract.js";
 export { ciContract } from "./contracts/ci.contract.js";
-export { claudeContract } from "./contracts/claude.contract.js";
-export { cursorContract } from "./contracts/cursor.contract.js";
 export { endpointsContract, type TrialHealth, TrialStatusSchema, type TrialStatusResponse } from "./contracts/endpoints.contract.js";
 export { exitContract } from "./contracts/exit.contract.js";
 export { extensionsContract } from "./contracts/extensions.contract.js";
 export { personasContract } from "./contracts/personas.contract.js";
 export { gitContract } from "./contracts/git.contract.js";
-export { grokContract } from "./contracts/grok.contract.js";
 export { historyContract } from "./contracts/history.contract.js";
 /* Deliberately NOT part of `sandboxContract` below: that map is the daemon's own HTTP surface, and this one is
- * spoken the other way round, over a connected computer's WebSocket, with the MACHINE implementing it. */
+ * spoken the other way round, over a connected device's WebSocket, with the MACHINE implementing it. */
 export { hostContract } from "./contracts/host.contract.js";
 // The same inversion again, one layer in: spoken over the socket a BROWSER EXTENSION opened, with the
 // extension implementing it (contracts/webext.contract.ts).
@@ -77,7 +72,6 @@ export { panelsContract } from "./contracts/panels.contract.js";
 export { portsContract } from "./contracts/ports.contract.js";
 export { publicContract } from "./contracts/public.contract.js";
 export { prepushContract } from "./contracts/prepush.contract.js";
-export { keysContract } from "./contracts/keys.contract.js";
 export { providersContract } from "./contracts/providers.contract.js";
 export { pushContract } from "./contracts/push.contract.js";
 export { safetyContract } from "./contracts/safety.contract.js";
@@ -159,7 +153,8 @@ export * from "./schemas/capabilities.js";
 export * from "./schemas/ci.js";
 export * from "./schemas/claude-gate.js";
 export * from "./schemas/codebase-health.js";
-export * from "./schemas/computers.js";
+export * from "./schemas/context.js";
+export * from "./schemas/devices.js";
 export * from "./schemas/engines.js";
 export * from "./schemas/environment.js";
 export * from "./schemas/exit.js";
@@ -212,6 +207,7 @@ export * from "./workflow-faults.js";
 // browser's typed oRPC client (ContractRouterClient<typeof sandboxContract>). The wire paths it declares are
 // mounted at the sandbox root, so /health and /workspace/raw (plain Hono routes) sit alongside it.
 export const sandboxContract = {
+    accounts: accountsContract,
     activity: activityContract,
     agent: agentContract,
     agents: agentsContract,
@@ -220,8 +216,6 @@ export const sandboxContract = {
     capabilities: capabilitiesContract,
     chores: choresContract,
     ci: ciContract,
-    claude: claudeContract,
-    cursor: cursorContract,
     endpoints: endpointsContract,
     extensions: extensionsContract,
     personas: personasContract,
@@ -232,7 +226,6 @@ export const sandboxContract = {
     skills: skillsContract,
     intentic: intenticContract,
     git: gitContract,
-    grok: grokContract,
     history: historyContract,
     workspace: workspaceContract,
     inventory: inventoryContract,
@@ -243,7 +236,6 @@ export const sandboxContract = {
     ports: portsContract,
     public: publicContract,
     prepush: prepushContract,
-    keys: keysContract,
     providers: providersContract,
     push: pushContract,
     secrets: secretsContract,

package/src/model-order.ts

@@ -146,7 +146,7 @@ const releaseTierRankOf = (family: string): number => lastRankOf(family, RELEASE
  *
  * That is not a small mis-sort. Thinking is the difference between a commit message that is in the box before
  * the user has finished reading the file list and one that arrives half a minute later, measured at ~2s versus
- * ~27s on the same model and the same diff (agent/one-shot.ts, which disables thinking for the rungs where a
+ * ~27s on the same model and the same diff (claude/claude-one-shot.ts, which disables thinking for the rungs where a
  * request parameter can). For a routed rung there is no such parameter: the id IS the setting, so this ranking
  * is the only place the choice can be made.
  *

package/src/peer-dial.test.ts

@@ -0,0 +1,203 @@
+import { expect, test, vi } from "vitest";
+import { dialPeer, type SocketLike } from "./peer-dial.js";
+
+/* The loop every peer runs, over a socket the test plays. What is at stake is the order of the two phases
+ * (handler attached BEFORE the hello goes out), the retry after a drop, the one close that is never retried,
+ * and that a stop reaches a dial still deciding where to go. */
+
+class FakeSocket implements SocketLike {
+    readyState = 0;
+    readonly sent: string[] = [];
+    closed: { readonly code: number | undefined; readonly reason: string | undefined } | undefined;
+    private readonly listeners = new Map<string, Set<(event: { readonly code?: number }) => void>>();
+
+    addEventListener(type: "open" | "close" | "error", listener: (event: { readonly code?: number }) => void): void {
+        const set = this.listeners.get(type) ?? new Set();
+        set.add(listener);
+        this.listeners.set(type, set);
+    }
+    send(data: string): void {
+        this.sent.push(data);
+    }
+    close(code?: number, reason?: string): void {
+        this.closed = { code, reason };
+        this.readyState = 3;
+    }
+    opens(): void {
+        this.readyState = 1;
+        this.emit("open");
+    }
+    drops(code: number): void {
+        this.readyState = 3;
+        this.emit("close", code);
+    }
+    private emit(type: string, code?: number): void {
+        for (const listener of this.listeners.get(type) ?? []) {
+            listener(code === undefined ? {} : { code });
+        }
+    }
+}
+
+// A ladder that answers with a fixed delay and records what it was told, so the test can read the held time.
+const ladder = (delay = 1_000) => {
+    const held: number[] = [];
+    return {
+        held,
+        next: (heldMs: number) => {
+            held.push(heldMs);
+            return delay;
+        },
+    };
+};
+
+const dialling = () => {
+    const sockets: FakeSocket[] = [];
+    const attached: FakeSocket[] = [];
+    const said: string[] = [];
+    const revoked = vi.fn();
+    const link = dialPeer<FakeSocket>({
+        open: async () => {
+            const socket = new FakeSocket();
+            sockets.push(socket);
+            return { socket, said: `connected #${sockets.length}` };
+        },
+        hello: () => ({ type: "hello", token: "iht_test", version: "1.0.0" }),
+        attach: (socket) => void attached.push(socket),
+        backoff: ladder(),
+        log: (message) => void said.push(message),
+        revoked,
+    });
+    return { link, sockets, attached, said, revoked };
+};
+
+test("the handler is attached before the hello goes out, and the hello is the first frame", async () => {
+    const { link, sockets, attached, said } = dialling();
+    await vi.waitFor(() => expect(sockets).toHaveLength(1));
+    expect(link.state()).toBe("connecting");
+    sockets[0]?.opens();
+    await vi.waitFor(() => expect(sockets[0]?.sent).toHaveLength(1));
+    expect(attached).toEqual([sockets[0]]);
+    expect(JSON.parse(sockets[0]?.sent[0] ?? "{}")).toEqual({ type: "hello", token: "iht_test", version: "1.0.0" });
+    expect(said).toEqual(["connected #1"]);
+    expect(link.state()).toBe("open");
+    link.stop();
+    await link.done;
+    expect(sockets[0]?.closed).toEqual({ code: 1000, reason: "stopping" });
+    expect(link.state()).toBe("closed");
+});
+
+test("a drop redials on the ladder, telling it how long the socket held", async () => {
+    vi.useFakeTimers();
+    try {
+        const { link, sockets, said } = dialling();
+        await vi.waitFor(() => expect(sockets).toHaveLength(1));
+        sockets[0]?.opens();
+        await vi.advanceTimersByTimeAsync(5_000);
+        sockets[0]?.drops(1006);
+        expect(link.state()).toBe("connecting");
+        expect(said.at(-1)).toBe("disconnected (1006); reconnecting in 1s");
+        await vi.advanceTimersByTimeAsync(1_000);
+        await vi.waitFor(() => expect(sockets).toHaveLength(2));
+        link.stop();
+        await link.done;
+    } finally {
+        vi.useRealTimers();
+    }
+});
+
+test("a refused enrollment (1008) is never retried and is reported once", async () => {
+    vi.useFakeTimers();
+    try {
+        const { link, sockets, revoked } = dialling();
+        await vi.waitFor(() => expect(sockets).toHaveLength(1));
+        sockets[0]?.opens();
+        sockets[0]?.drops(1008);
+        await link.done;
+        expect(revoked).toHaveBeenCalledTimes(1);
+        await vi.advanceTimersByTimeAsync(60_000);
+        expect(sockets).toHaveLength(1);
+        expect(link.state()).toBe("closed");
+    } finally {
+        vi.useRealTimers();
+    }
+});
+
+// A stop that lands while the address is still being decided has nothing to close and must open nothing after
+// the fact: a socket dialled by a loop that has already reported itself done would be a connection nobody stops.
+test("a stop during resolution opens nothing, and a socket a slow resolver still hands over is closed", async () => {
+    let answer: (() => void) | undefined;
+    const sockets: FakeSocket[] = [];
+    const link = dialPeer<FakeSocket>({
+        open: async (signal) => {
+            await new Promise<void>((resolve) => {
+                answer = resolve;
+            });
+            if (signal.aborted) {
+                return undefined;
+            }
+            const socket = new FakeSocket();
+            sockets.push(socket);
+            return { socket };
+        },
+        hello: () => ({}),
+        attach: () => undefined,
+        backoff: ladder(),
+        log: () => undefined,
+        revoked: () => undefined,
+    });
+    await vi.waitFor(() => expect(answer).toEqual(expect.any(Function)));
+    link.stop();
+    await link.done;
+    answer?.();
+    await new Promise<void>((resolve) => setTimeout(resolve, 0));
+    expect(sockets).toHaveLength(0);
+
+    // The other order: a resolver that ignores the signal and hands a socket over anyway.
+    const late: FakeSocket[] = [];
+    const careless = dialPeer<FakeSocket>({
+        open: async () => {
+            await new Promise<void>((resolve) => {
+                answer = resolve;
+            });
+            const socket = new FakeSocket();
+            late.push(socket);
+            return { socket };
+        },
+        hello: () => ({}),
+        attach: () => undefined,
+        backoff: ladder(),
+        log: () => undefined,
+        revoked: () => undefined,
+    });
+    await vi.waitFor(() => expect(answer).toEqual(expect.any(Function)));
+    careless.stop();
+    answer?.();
+    await vi.waitFor(() => expect(late[0]?.closed).toEqual({ code: 1000, reason: "stopping" }));
+});
+
+test("a pairing that is gone by the next attempt ends the loop rather than dialling nowhere", async () => {
+    let pairings = 1;
+    const sockets: FakeSocket[] = [];
+    const link = dialPeer<FakeSocket>({
+        open: async () => {
+            if (pairings === 0) {
+                return undefined;
+            }
+            pairings -= 1;
+            const socket = new FakeSocket();
+            sockets.push(socket);
+            return { socket };
+        },
+        hello: () => ({}),
+        attach: () => undefined,
+        backoff: ladder(0),
+        log: () => undefined,
+        revoked: () => undefined,
+    });
+    await vi.waitFor(() => expect(sockets).toHaveLength(1));
+    sockets[0]?.opens();
+    sockets[0]?.drops(1006);
+    await link.done;
+    expect(sockets).toHaveLength(1);
+    expect(link.state()).toBe("closed");
+});

package/src/peer-dial.ts

@@ -0,0 +1,163 @@
+/* THE ONE SOCKET a peer holds to its sandbox, written once for the three things that hold one: the machine
+ * agent (@intentic/machine), the browser extension (@intentic/webext) and a runner (the daemon itself, in
+ * runner mode). Each dials OUT, sends a plain-JSON hello carrying its enrollment token (host-protocol.ts,
+ * webext-protocol.ts, runner-protocol.ts), and from then on everything the sandbox asks arrives on the socket
+ * as oRPC against the door's contract, with the PEER serving.
+ *
+ * OUTBOUND ONLY, and that is the entire networking story: no port is opened, no router configured, no VPN
+ * joined. A laptop on hotel wifi behind a corporate proxy holds this connection because it is an ordinary
+ * outbound wss://, the same thing every chat app on the machine is already doing.
+ *
+ * The socket has exactly two phases. First the hello, plain JSON, because the sandbox has nothing to call until
+ * it knows whose socket this is (the token rides the FRAME, never the URL, which would write a durable key into
+ * every proxy log between the peer and the sandbox). Then the sandbox attaches its client and the socket is pure
+ * oRPC: request/response correlation, argument validation and error shape all belong to the link from that
+ * point on, which is why there is no message plumbing here.
+ *
+ * THE HANDLER IS ATTACHED BEFORE THE HELLO GOES OUT: the sandbox may call the moment it has verified the token,
+ * and a race there would drop the first `setScopes`, the one call whose loss would leave a device enforcing a
+ * stale grant.
+ *
+ * RECONNECTION IS THE NORMAL CASE, not the failure case. Lids close, wifi changes, tunnels idle out, sandboxes
+ * restart on every rebuild. So a dropped socket is routine and comes back on an exponential ladder the caller
+ * supplies (@intentic/base's createBackoff, over PEER_LINK_BACKOFF): a link that held for a minute was working
+ * and its drop redials at the floor; one that opened and died at once keeps climbing. The one thing that is NOT
+ * retried is a refused enrollment (close code 1008): the owner revoked this peer, that never heals on its own,
+ * and hammering a door that has been locked is how an agent turns a revocation into a support ticket.
+ *
+ * Here, in the contract, beside the hello schemas it sends and the URL builders it dials, rather than in a
+ * package of its own: every peer already depends on this one, and the loop is the far end of the same wire. */
+
+// Backoff bounds. The first retry is fast because the overwhelmingly common cause is a sandbox restart, which
+// takes seconds; the ceiling is low enough that a laptop opened after a night asleep is back within a minute.
+export const PEER_LINK_BACKOFF = { floorMs: 1_000, capMs: 30_000, stableMs: 60_000 } as const;
+
+// The sandbox closes with this when the token is not enrolled: a decision, not a fault, and one that never heals.
+const UNAUTHORIZED = 1008;
+
+// A socket's readyState value for "open", per the WebSocket spec, named so a caller's fake need not import a class.
+const OPEN = 1;
+
+// What the two runtimes' sockets have in common, taken structurally: a browser's WebSocket, node's global one,
+// and a test's fake all satisfy it without a cast.
+export interface SocketLike {
+    readonly readyState: number;
+    addEventListener(type: "open" | "close" | "error", listener: (event: { readonly code?: number }) => void): void;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+}
+
+export interface PeerDialSpec<S extends SocketLike> {
+    /* ONE ATTEMPT'S SOCKET, dialled at whatever address the caller resolves for THIS attempt: a sandbox on the
+     * same machine is a loopback hop away on one attempt and behind its tunnel on the next, and asking on every
+     * attempt rather than once at startup is exactly what a reconnect is about. `said` is the line the log gets
+     * once the socket is open. Undefined ⇒ there is nothing to dial any more (the pairing was forgotten), and
+     * the loop ends. `signal` is aborted by `stop`, so a resolution that outlives the stop opens nothing. */
+    readonly open: (signal: AbortSignal) => Promise<{ readonly socket: S; readonly said?: string } | undefined>;
+    // The first frame, carrying the enrollment token and whatever the door's hello schema asks for.
+    readonly hello: () => Promise<Record<string, unknown>> | Record<string, unknown>;
+    // Hand the open socket to the oRPC handler serving the door's contract.
+    readonly attach: (socket: S) => void;
+    // The retry ladder: how long to wait after a drop, given how long the socket had held.
+    readonly backoff: { readonly next: (heldMs: number) => number };
+    readonly log: (message: string) => void;
+    // The sandbox refused the enrollment (1008). The loop has already stopped; this is where the peer says so.
+    readonly revoked: () => void;
+}
+
+export interface PeerLink {
+    // Resolves when the loop is asked to stop or refused for good; never rejects, a connection error is a retry.
+    readonly done: Promise<void>;
+    readonly stop: (reason?: string) => void;
+    // "connecting" covers a dial in flight AND a retry waiting on the ladder: both mean nobody should start another.
+    readonly state: () => "open" | "connecting" | "closed";
+}
+
+export const dialPeer = <S extends SocketLike>(spec: PeerDialSpec<S>): PeerLink => {
+    const stopping = new AbortController();
+    let socket: S | undefined;
+    let waiting = false;
+    let openedAt: number | undefined;
+    let resolveDone: () => void = () => undefined;
+    const done = new Promise<void>((resolve) => {
+        resolveDone = resolve;
+    });
+
+    const open = async (): Promise<void> => {
+        waiting = true;
+        const attempt = await spec.open(stopping.signal);
+        waiting = false;
+        // Stopped while the address was still being decided: there is nothing to open, and `stop` has already
+        // settled `done`. A socket a slow resolver still handed over is closed rather than left dialling.
+        if (stopping.signal.aborted) {
+            attempt?.socket.close(1000, "stopping");
+            return;
+        }
+        if (attempt === undefined) {
+            stopping.abort();
+            resolveDone();
+            return;
+        }
+        const ws = attempt.socket;
+        socket = ws;
+
+        ws.addEventListener("open", () => {
+            openedAt = Date.now();
+            spec.attach(ws);
+            const send = (hello: Record<string, unknown>): void => {
+                ws.send(JSON.stringify(hello));
+                if (attempt.said !== undefined) {
+                    spec.log(attempt.said);
+                }
+            };
+            // Sent in the open handler's own tick where the hello is already in hand: the sandbox's auth
+            // deadline is generous, but a frame that could go now and waits a tick is a frame a test cannot
+            // read, and a hello that needs a read first (a runner's settings claim) simply follows it.
+            const hello = spec.hello();
+            if (hello instanceof Promise) {
+                void hello.then(send);
+            } else {
+                send(hello);
+            }
+        });
+
+        ws.addEventListener("close", (event) => {
+            socket = undefined;
+            if (stopping.signal.aborted) {
+                resolveDone();
+                return;
+            }
+            if (event.code === UNAUTHORIZED) {
+                stopping.abort();
+                resolveDone();
+                spec.revoked();
+                return;
+            }
+            const delay = spec.backoff.next(openedAt === undefined ? 0 : Date.now() - openedAt);
+            openedAt = undefined;
+            spec.log(`disconnected (${event.code ?? "no code"}); reconnecting in ${Math.round(delay / 1000)}s`);
+            waiting = true;
+            setTimeout(() => void open(), delay);
+        });
+
+        // A socket error is always followed by a close event, which owns the retry; this only records the cause,
+        // which the close code alone never carries.
+        ws.addEventListener("error", () => spec.log("connection error"));
+    };
+
+    void open();
+
+    return {
+        done,
+        stop: (reason = "stopping") => {
+            stopping.abort();
+            waiting = false;
+            // Forgotten before the close frame arrives, so `state` reads closed the moment the peer asked.
+            const held = socket;
+            socket = undefined;
+            held?.close(1000, reason);
+            resolveDone();
+        },
+        state: () => (socket?.readyState === OPEN ? "open" : socket !== undefined || waiting ? "connecting" : "closed"),
+    };
+};

package/src/peer-mcp-server.test.ts

@@ -0,0 +1,104 @@
+import { expect, test } from "vitest";
+import { z } from "zod";
+import { createMcpServer, type McpAuditEntry, textResult, tool } from "./peer-mcp-server.js";
+
+/* The dispatch every peer serves its tools through, against two hand-written tools: what the model is shown,
+ * what an arriving call is checked against, and the rule that a failed tool is a result and not a fault. */
+
+class Refused extends Error {}
+
+const build = () => {
+    const audits: McpAuditEntry[] = [];
+    const handle = createMcpServer<{ readonly allowed: boolean }>({
+        serverInfo: () => ({ name: "intentic-test", version: "9.9.9" }),
+        tools: [
+            tool({
+                name: "echo",
+                description: "Say it back.",
+                input: z.object({ text: z.string().min(1) }),
+                run: async ({ text }, ctx) => {
+                    if (!ctx.allowed) {
+                        throw new Refused("the switch is off");
+                    }
+                    return textResult(text);
+                },
+            }),
+            tool({
+                name: "fail",
+                description: "Always errs as a result.",
+                input: z.object({}),
+                run: async () => textResult("nope", true),
+            }),
+        ],
+        noSuchTool: (name) => `This peer has no tool called "${name}".`,
+        refused: (error) => error instanceof Refused,
+        errorMessage: (error) => (error instanceof Error ? error.message : String(error)),
+        audit: (entry) => void audits.push(entry),
+    });
+    return { handle, audits };
+};
+
+const call = (name: string, args: Record<string, unknown>, allowed = true) => build().handle({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name, arguments: args } }, { allowed });
+
+test("initialize names the peer and its build; ping answers empty; an unknown method is a JSON-RPC error", async () => {
+    const { handle } = build();
+    expect(await handle({ jsonrpc: "2.0", id: 1, method: "initialize" }, { allowed: true })).toMatchObject({
+        result: { capabilities: { tools: {} }, serverInfo: { name: "intentic-test", version: "9.9.9" } },
+    });
+    expect(await handle({ jsonrpc: "2.0", id: 2, method: "ping" }, { allowed: true })).toEqual({ jsonrpc: "2.0", id: 2, result: {} });
+    expect(await handle({ jsonrpc: "2.0", id: 3, method: "resources/list" }, { allowed: true })).toMatchObject({ error: { code: -32601 } });
+    expect(await handle({ jsonrpc: "2.0", method: "notifications/initialized" }, { allowed: true })).toBeUndefined();
+    expect(await handle("not an object", { allowed: true })).toMatchObject({ error: { code: -32600 } });
+});
+
+test("tools/list publishes each tool's schema as JSON Schema, without the dialect line", async () => {
+    const { handle } = build();
+    const listed = (await handle({ jsonrpc: "2.0", id: 1, method: "tools/list" }, { allowed: true })) as { result: { tools: { name: string; inputSchema: Record<string, unknown> }[] } };
+    expect(listed.result.tools.map((entry) => entry.name)).toEqual(["echo", "fail"]);
+    expect(listed.result.tools[0]?.inputSchema).toMatchObject({ type: "object", properties: { text: { type: "string" } } });
+    expect(listed.result.tools[0]?.inputSchema).not.toHaveProperty("$schema");
+});
+
+test("a call is checked against the same schema, and a bad argument is a readable result, not a fault", async () => {
+    expect(await call("echo", { text: "hi" })).toEqual({ jsonrpc: "2.0", id: 1, result: { content: [{ type: "text", text: "hi" }], isError: false } });
+    const bad = (await call("echo", { text: "" })) as { result: { content: { text: string }[]; isError: boolean } };
+    expect(bad.result.isError).toBe(true);
+    expect(bad.result.content[0]?.text).toContain("text");
+});
+
+test("a tool this peer does not have answers in the peer's own words", async () => {
+    expect(await call("delete_everything", {})).toEqual({
+        jsonrpc: "2.0",
+        id: 1,
+        result: { content: [{ type: "text", text: `This peer has no tool called "delete_everything".` }], isError: true },
+    });
+});
+
+test("a thrown refusal and a thrown failure are both results, and the audit line says which", async () => {
+    const { handle, audits } = build();
+    const refused = (await handle({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "echo", arguments: { text: "hi" } } }, { allowed: false })) as {
+        result: { content: { text: string }[]; isError: boolean };
+    };
+    expect(refused.result).toEqual({ content: [{ type: "text", text: "the switch is off" }], isError: true });
+    await handle({ jsonrpc: "2.0", id: 2, method: "tools/call", params: { name: "fail", arguments: {} } }, { allowed: true });
+    await handle({ jsonrpc: "2.0", id: 3, method: "tools/call", params: { name: "echo", arguments: { text: "ok" } } }, { allowed: true });
+    expect(audits).toEqual([
+        { tool: "echo", args: { text: "hi" }, ok: false, failure: { refused: true, message: "the switch is off" } },
+        { tool: "fail", args: {}, ok: false },
+        { tool: "echo", args: { text: "ok" }, ok: true },
+    ]);
+});
+
+test("an audit log that cannot be written never fails the answer", async () => {
+    const handle = createMcpServer<undefined>({
+        serverInfo: () => ({ name: "x", version: "1" }),
+        tools: [tool({ name: "hi", description: "Hi.", input: z.object({}), run: async () => textResult("hi") })],
+        noSuchTool: () => "no",
+        refused: () => false,
+        errorMessage: String,
+        audit: () => {
+            throw new Error("disk full");
+        },
+    });
+    expect(await handle({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "hi", arguments: {} } }, undefined)).toMatchObject({ result: { isError: false } });
+});