@workerdeck/react 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tobias Strebitzer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,111 @@
+# @workerdeck/react
+
+Headless React layer for WorkerDeck: the `useClaudeSession` hook plus a pure transcript
+reducer. No styling opinion — bring your own rendering, or use
+[`@workerdeck/ui`](https://www.npmjs.com/package/@workerdeck/ui), the styled layer on top.
+
+Part of [WorkerDeck](https://github.com/workerdeck/workerdeck). It sits between
+[`@workerdeck/client`](https://www.npmjs.com/package/@workerdeck/client) (REST + WebSocket
+attach) and your components: the hook attaches to a session, folds the event stream through the
+reducer, and hands back live state plus the control surface (send, approve/deny, interrupt,
+permission mode, model).
+
+## Install
+
+```bash
+npm install @workerdeck/react @workerdeck/client
+```
+
+`react` is a peer dependency (`^18 || ^19`).
+
+## Usage
+
+```tsx
+import { WorkerDeckClient } from '@workerdeck/client'
+import { useClaudeSession } from '@workerdeck/react'
+
+const client = new WorkerDeckClient({ baseUrl: 'http://127.0.0.1:8787/v1' })
+
+function Panel({ sessionId }: { sessionId: string }) {
+  const { state, connected, send, approve, deny, interrupt } = useClaudeSession(client, sessionId)
+
+  return (
+    <div>
+      <header>{state.status} {state.model} {connected ? '' : '(reconnecting)'}</header>
+      {state.items.map((item) =>
+        item.kind === 'assistant_text' ? <p key={item.id}>{item.text}</p> : null,
+      )}
+      {state.pendingApprovals.map((req) => (
+        <div key={req.id}>
+          {req.toolName}
+          <button onClick={() => approve(req.id)}>Allow</button>
+          <button onClick={() => deny(req.id)}>Deny</button>
+        </div>
+      ))}
+      <input onKeyDown={(e) => e.key === 'Enter' && send(e.currentTarget.value)} />
+    </div>
+  )
+}
+```
+
+The hook attaches on mount, detaches on unmount, and survives reconnects — the underlying handle
+replays from the last seen seq, and the reducer ignores anything it has already applied.
+
+### The transcript reducer, standalone
+
+The state machine is framework-free and exported directly — usable in tests, workers, or any
+non-React consumer of the event stream:
+
+```ts
+import { applyEvent, initialTranscriptState, seedFromSessionInfo } from '@workerdeck/react'
+
+let state = initialTranscriptState
+state = seedFromSessionInfo(state, sessionInfo) // optional: seed from the attach snapshot
+for (const event of events) state = applyEvent(state, event)
+```
+
+`seedFromSessionInfo` fills fields (status, model, permission mode) a promptless session's event
+stream doesn't carry yet; events stay authoritative once they arrive.
+
+## What the state contains
+
+`TranscriptState` is everything a session panel needs to render:
+
+- `items` — the ordered transcript: `user`, `assistant_text` (with a `streaming` flag),
+  `thinking`, `tool_call` (input + eventual result), `turn_result`, and `notice` items.
+  Streaming deltas accumulate in-place and are superseded by the full assistant message.
+- `pendingApprovals` — permission requests awaiting an approve/deny decision.
+- `status` / `statusDetail`, `model`, `cwd`, `sdkSessionId`, `permissionMode`.
+- `models` and `commands` — what the session can switch to / accepts (from `capabilities`).
+- `contextUsage`, `rateLimits` (keyed by window; absent for API-key sessions — render nothing,
+  not 0%), `totalCostUsd` (session-cumulative), and `lastSeq` for replay dedupe.
+
+The reducer is pure and immutable: same events in, same state out — which is also how it is
+unit-tested. Keep rendering logic out of it.
+
+## Running tool calls in the tab
+
+A provider-engine session can ask the *browser* to execute a sandboxed tool call, so documents the
+user holds locally never reach the server. `useToolCallHost` answers those requests from a mounted
+component, running the code in a QuickJS guest
+([`@workerdeck/sandbox`](https://www.npmjs.com/package/@workerdeck/sandbox), loaded on
+demand):
+
+```tsx
+const { handle } = useClaudeSession(client, sessionId)
+const { executions } = useToolCallHost(handle, {
+  tools: ['eval_script'], // allowlist — anything else the server asks for is refused
+  timeoutMs: 15_000,
+  fetchText: (url) => myGatedFetch(url), // omit and the guest has no network at all
+})
+```
+
+The host must ride **the hook's own `handle`** — the server bridges each call to the first attached
+client, so a second, separately-created handle would sit idle while the real one gets the requests.
+`createToolCallHost` is the same logic without React. Results returned from a tab are untrusted
+input by construction: fine for the user's own data, never a source of server-authoritative state.
+
+## License
+
+MIT © Tobias Strebitzer — see
+[LICENSE](https://github.com/workerdeck/workerdeck/blob/master/LICENSE).

package/build/index.d.mts

@@ -0,0 +1,197 @@
+import { SessionHandle, WorkerDeckClient } from "@workerdeck/client";
+import { ContextUsage, ModelOption, PermissionMode, PermissionRequest, ProfileEngine, RateLimitInfo, SessionEvent, SessionInfo, SessionStatus, SlashCommandInfo, ToolExecutionBackend } from "@workerdeck/protocol";
+import { RunScriptResult, SandboxEngine, SandboxVfs } from "@workerdeck/sandbox";
+
+//#region src/transcript.d.ts
+/**
+ * Pure transcript state machine over the wire-protocol event stream. Framework-free
+ * so it can be unit-tested and reused outside React.
+ */
+type TranscriptItem = {
+  kind: 'user';
+  id: string;
+  text: string;
+} | {
+  kind: 'assistant_text';
+  id: string;
+  text: string;
+  streaming: boolean;
+  parentToolUseId: string | null;
+} | {
+  kind: 'thinking';
+  id: string;
+  text: string;
+  parentToolUseId: string | null;
+} | {
+  kind: 'tool_call';
+  id: string;
+  name: string;
+  input: unknown;
+  parentToolUseId: string | null;
+  /**
+   * - `running` — the model called it; execution has not been reported
+   * - `pending` — dispatched to an executor (bridged to this client, queued)
+   * - `deferred` — parked beyond this turn; may outlive the session's liveness
+   * - `settled` / `failed` — terminal
+   *
+   * Derive UI from this, not from `result` being present: a pending or
+   * deferred call has no result yet and is not the same as a running one.
+   */
+  status: 'running' | 'pending' | 'deferred' | 'settled' | 'failed';
+  result?: {
+    text: string;
+    isError: boolean;
+  }; /** Correlation id when this call is executed outside the model loop. */
+  executionId?: string; /** Which backend is executing it, when known. */
+  backend?: ToolExecutionBackend; /** Logs captured by the executor (guest console output). */
+  logs?: string[];
+} | {
+  kind: 'turn_result';
+  id: string;
+  subtype: string;
+  isError: boolean;
+  durationMs: number;
+  totalCostUsd: number;
+  errors?: string[];
+} | {
+  kind: 'notice';
+  id: string;
+  level: 'info' | 'error';
+  text: string;
+}
+/** The agent handed over a session file (`file_delivered`). Render a download
+ * card; the file is served by GET /sessions/:id/files/<path> while the
+ * session lives. */
+| {
+  kind: 'file_delivered';
+  id: string;
+  path: string;
+  bytes: number;
+  description?: string;
+};
+type TranscriptState = {
+  status: SessionStatus;
+  statusDetail?: string;
+  model?: string;
+  cwd?: string;
+  sdkSessionId?: string;
+  /** Engine running the session, from the attach snapshot. Gates CLI-only
+   * affordances; absent (an older server) reads as 'claude'. */
+  engine?: ProfileEngine; /** Models the session can switch to (from the `capabilities` event). */
+  models?: ModelOption[]; /** Slash commands the CLI accepts (from the `capabilities` event). */
+  commands?: SlashCommandInfo[]; /** Seeded from `system_init`, updated on `permission_mode_changed`. */
+  permissionMode?: PermissionMode; /** Latest context-window snapshot; absent until the first turn completes. */
+  contextUsage?: ContextUsage;
+  /** Latest rate-limit snapshot per window ('five_hour', 'seven_day', ...).
+   * Absent for API-key sessions — render nothing, not 0%. */
+  rateLimits?: Record<string, RateLimitInfo>;
+  items: TranscriptItem[];
+  pendingApprovals: PermissionRequest[];
+  totalCostUsd: number;
+  lastSeq: number;
+};
+declare const initialTranscriptState: TranscriptState;
+/**
+ * Seed transcript state from the attach snapshot (the `attached` frame's SessionInfo).
+ * A promptless session emits no `system_init` until its first message, so fields like
+ * `permissionMode` and `model` would otherwise stay empty — fill only what events
+ * haven't set yet; the event stream stays authoritative.
+ */
+declare function seedFromSessionInfo(state: TranscriptState, info: SessionInfo): TranscriptState;
+declare function applyEvent(state: TranscriptState, event: SessionEvent): TranscriptState;
+//#endregion
+//#region src/use-session.d.ts
+type UseClaudeSessionOptions = {
+  /** Called when the server rejects a command with a protocol_error frame — e.g. a
+   * permission-mode switch the CLI refuses. Without a handler these are dropped
+   * silently and the UI looks like "nothing happened". */
+  onProtocolError?: (message: string) => void;
+};
+type UseClaudeSessionResult = {
+  state: TranscriptState;
+  connected: boolean;
+  /** The live attach handle, for wiring companions that must ride the SAME
+   * socket — e.g. useToolCallHost: the bridge asks the first attached client,
+   * so a host on a second handle would never see the requests. Undefined until
+   * attached and after unmount. */
+  handle: SessionHandle | undefined;
+  send: (text: string) => void;
+  approve: (requestId: string, updatedInput?: Record<string, unknown>) => void;
+  deny: (requestId: string, message?: string) => void;
+  interrupt: () => void;
+  setPermissionMode: (mode: PermissionMode) => void;
+  setModel: (model?: string) => void;
+  closeSession: () => void;
+};
+/** Attach to a session and maintain live transcript state. Detaches on unmount. */
+declare function useClaudeSession(client: WorkerDeckClient, sessionId: string | undefined, options?: UseClaudeSessionOptions): UseClaudeSessionResult;
+//#endregion
+//#region src/tool-host.d.ts
+/** What the host was asked to do and how it went (for UI/telemetry). */
+type ToolHostExecution = {
+  executionId: string;
+  toolName: string;
+  status: 'running' | 'settled' | 'failed' | 'canceled';
+  reason?: string;
+  startedAt: number;
+  endedAt?: number;
+};
+type ToolHostRunner = (request: {
+  script: string;
+  vfs: SandboxVfs;
+  timeoutMs: number;
+  memoryLimitBytes: number;
+  signal: AbortSignal;
+}) => Promise<RunScriptResult>;
+type ToolCallHostOptions = {
+  /** Tools this client will execute. Anything else is refused, so a server can
+   * never talk this tab into running something it didn't opt into.
+   * Default: `['eval_script']`. */
+  tools?: string[]; /** Guest wall-clock limit, unless the request asks for less. Default 5000. */
+  timeoutMs?: number; /** Guest allocator cap, unless the request asks for less. Default 64 MiB. */
+  memoryLimitBytes?: number;
+  /**
+   * Load the WASM guest engine. Called at most once, on the first bridged call
+   * — nothing is downloaded or parsed until a session actually bridges one.
+   * Defaults to `@workerdeck/sandbox` with the single-file browser build.
+   */
+  loadEngine?: () => Promise<SandboxEngine>;
+  /**
+   * Run the script. Defaults to executing on this thread, which is fine for the
+   * short, time-boxed evaluations this is built for. Supply your own (a Web
+   * Worker running the same engine) to keep long evaluations off the UI thread
+   * — the guest deadline preempts the interpreter, but only between bytecode
+   * ops on whichever thread it runs on.
+   */
+  execute?: ToolHostRunner; /** Host-gated fetch for the guest. Omitted = the guest has no network at all. */
+  fetchText?: (url: string) => Promise<string>; /** Observe executions (rendering, logging). */
+  onExecution?: (execution: ToolHostExecution) => void;
+};
+/**
+ * Answers server-bridged tool calls by executing them in this browser tab.
+ * Framework-free — {@link useToolCallHost} is a thin React wrapper.
+ *
+ * The point is data locality: documents fetched or held client-side can be
+ * evaluated here and never touch the server. The engine loads lazily, so a page
+ * that never bridges a call never pays for the WASM guest.
+ */
+declare function createToolCallHost(handle: SessionHandle, options?: ToolCallHostOptions): {
+  dispose: () => void;
+};
+//#endregion
+//#region src/use-tool-host.d.ts
+type UseToolCallHostOptions = ToolCallHostOptions & {
+  /** Turn the host off without unmounting. Default true. */enabled?: boolean; /** How many recent executions to keep for rendering. Default 50. */
+  historyLimit?: number;
+};
+/**
+ * React wrapper around {@link createToolCallHost}: subscribes while mounted and
+ * exposes recent executions for rendering. All the logic lives in the
+ * framework-free host — this only manages the subscription's lifetime.
+ */
+declare function useToolCallHost(handle: SessionHandle | undefined, options?: UseToolCallHostOptions): {
+  executions: ToolHostExecution[];
+};
+//#endregion
+export { type ToolCallHostOptions, type ToolHostExecution, type ToolHostRunner, type TranscriptItem, type TranscriptState, type UseClaudeSessionResult, type UseToolCallHostOptions, applyEvent, createToolCallHost, initialTranscriptState, seedFromSessionInfo, useClaudeSession, useToolCallHost };
+//# sourceMappingURL=index.d.mts.map

package/build/index.mjs

@@ -0,0 +1,520 @@
+import { useEffect, useMemo, useReducer, useRef, useState } from "react";
+//#region src/transcript.ts
+const initialTranscriptState = {
+	status: "starting",
+	items: [],
+	pendingApprovals: [],
+	totalCostUsd: 0,
+	lastSeq: 0
+};
+const STREAMING_ID = "streaming";
+const STREAMING_THINKING_ID = "streaming-thinking";
+function blockText(content) {
+	if (content === void 0) return "";
+	if (typeof content === "string") return content;
+	return content.map((part) => typeof part.text === "string" ? part.text : "").filter(Boolean).join("\n");
+}
+function contentToBlocks(content) {
+	return typeof content === "string" ? [{
+		type: "text",
+		text: content
+	}] : content;
+}
+/** Render an execution's by-value output for the transcript. */
+function outputText(output) {
+	if (output.type === "text") return output.value;
+	try {
+		return JSON.stringify(output.value);
+	} catch {
+		return String(output.value);
+	}
+}
+/** CLI-side command output arrives as user text wrapped in local-command tags. */
+const LOCAL_COMMAND_OUTPUT = /^<local-command-(stdout|stderr)>([\s\S]*?)<\/local-command-\1>$/;
+function upsert(items, item) {
+	const index = items.findIndex((existing) => existing.id === item.id && existing.kind === item.kind);
+	if (index === -1) return [...items, item];
+	const next = [...items];
+	next[index] = item;
+	return next;
+}
+/**
+* Seed transcript state from the attach snapshot (the `attached` frame's SessionInfo).
+* A promptless session emits no `system_init` until its first message, so fields like
+* `permissionMode` and `model` would otherwise stay empty — fill only what events
+* haven't set yet; the event stream stays authoritative.
+*/
+function seedFromSessionInfo(state, info) {
+	return {
+		...state,
+		status: state.lastSeq === 0 ? info.status : state.status,
+		model: state.model ?? info.model,
+		permissionMode: state.permissionMode ?? info.permissionMode,
+		cwd: state.cwd ?? info.cwd,
+		sdkSessionId: state.sdkSessionId ?? info.sdkSessionId,
+		engine: info.engine ?? state.engine
+	};
+}
+function applyEvent(state, event) {
+	if (event.seq <= state.lastSeq) return state;
+	const base = {
+		...state,
+		lastSeq: event.seq
+	};
+	switch (event.type) {
+		case "system_init": return {
+			...base,
+			model: event.model,
+			cwd: event.cwd,
+			sdkSessionId: event.sdkSessionId,
+			permissionMode: event.permissionMode
+		};
+		case "status_changed": return {
+			...base,
+			status: event.status,
+			statusDetail: event.detail
+		};
+		case "capabilities": return {
+			...base,
+			models: event.models,
+			commands: event.commands
+		};
+		case "model_changed": return event.model === void 0 ? base : {
+			...base,
+			model: event.model
+		};
+		case "permission_mode_changed": return {
+			...base,
+			permissionMode: event.mode
+		};
+		case "context_usage": return {
+			...base,
+			contextUsage: event.usage
+		};
+		case "rate_limit": {
+			const key = event.info.rateLimitType;
+			if (!key) return base;
+			return {
+				...base,
+				rateLimits: {
+					...base.rateLimits,
+					[key]: event.info
+				}
+			};
+		}
+		case "user_message": {
+			let items = base.items;
+			for (const block of contentToBlocks(event.message.content)) if (block.type === "tool_result") {
+				const toolResult = block;
+				const isError = toolResult.is_error === true;
+				items = items.map((item) => item.kind === "tool_call" && item.id === toolResult.tool_use_id ? {
+					...item,
+					status: isError ? "failed" : "settled",
+					result: {
+						text: blockText(toolResult.content),
+						isError
+					}
+				} : item);
+			} else if (block.type === "text" && !event.synthetic) {
+				const text = block.text;
+				const localOutput = LOCAL_COMMAND_OUTPUT.exec(text.trim());
+				if (localOutput) items = upsert(items, {
+					kind: "notice",
+					id: event.uuid ?? `user-${event.seq}`,
+					level: localOutput[1] === "stderr" ? "error" : "info",
+					text: localOutput[2].trim()
+				});
+				else items = upsert(items, {
+					kind: "user",
+					id: event.uuid ?? `user-${event.seq}`,
+					text
+				});
+			}
+			return {
+				...base,
+				items
+			};
+		}
+		case "assistant_message": {
+			let streamedThinking = base.items.find((item) => item.kind === "thinking" && item.id === STREAMING_THINKING_ID)?.text ?? "";
+			let items = base.items.filter((item) => !(item.kind === "assistant_text" && item.id === STREAMING_ID) && !(item.kind === "thinking" && item.id === STREAMING_THINKING_ID));
+			contentToBlocks(event.message.content).forEach((block, index) => {
+				const id = `${event.uuid}-${index}`;
+				if (block.type === "text") items = upsert(items, {
+					kind: "assistant_text",
+					id,
+					text: block.text,
+					streaming: false,
+					parentToolUseId: event.parentToolUseId
+				});
+				else if (block.type === "thinking") {
+					const text = block.thinking || streamedThinking;
+					streamedThinking = "";
+					if (text.trim() === "") return;
+					items = upsert(items, {
+						kind: "thinking",
+						id,
+						text,
+						parentToolUseId: event.parentToolUseId
+					});
+				} else if (block.type === "tool_use") {
+					const toolUse = block;
+					items = upsert(items, {
+						kind: "tool_call",
+						id: toolUse.id,
+						name: toolUse.name,
+						input: toolUse.input,
+						parentToolUseId: event.parentToolUseId,
+						status: "running"
+					});
+				}
+			});
+			return {
+				...base,
+				items
+			};
+		}
+		case "stream_delta": {
+			const delta = event.event;
+			if (delta.type !== "content_block_delta") return base;
+			if (delta.delta?.type === "text_delta") {
+				const item = {
+					kind: "assistant_text",
+					id: STREAMING_ID,
+					text: (base.items.find((item) => item.kind === "assistant_text" && item.id === STREAMING_ID)?.text ?? "") + (delta.delta.text ?? ""),
+					streaming: true,
+					parentToolUseId: event.parentToolUseId
+				};
+				return {
+					...base,
+					items: upsert(base.items, item)
+				};
+			}
+			if (delta.delta?.type === "thinking_delta") {
+				const item = {
+					kind: "thinking",
+					id: STREAMING_THINKING_ID,
+					text: (base.items.find((item) => item.kind === "thinking" && item.id === STREAMING_THINKING_ID)?.text ?? "") + (delta.delta.thinking ?? ""),
+					parentToolUseId: event.parentToolUseId
+				};
+				return {
+					...base,
+					items: upsert(base.items, item)
+				};
+			}
+			return base;
+		}
+		case "turn_result": return {
+			...base,
+			totalCostUsd: event.totalCostUsd,
+			items: [...base.items, {
+				kind: "turn_result",
+				id: `turn-${event.seq}`,
+				subtype: event.subtype,
+				isError: event.isError,
+				durationMs: event.durationMs,
+				totalCostUsd: event.totalCostUsd,
+				errors: event.errors
+			}]
+		};
+		case "permission_requested": return {
+			...base,
+			pendingApprovals: [...base.pendingApprovals, event.request]
+		};
+		case "permission_resolved": return {
+			...base,
+			pendingApprovals: base.pendingApprovals.filter((r) => r.id !== event.requestId)
+		};
+		case "execution_dispatched": return {
+			...base,
+			items: base.items.map((item) => item.kind === "tool_call" && item.id === event.executionId ? {
+				...item,
+				status: event.deferred ? "deferred" : "pending",
+				executionId: event.executionId,
+				backend: event.backend
+			} : item)
+		};
+		case "execution_result": return {
+			...base,
+			items: base.items.map((item) => item.kind === "tool_call" && item.id === event.executionId ? {
+				...item,
+				status: "settled",
+				executionId: event.executionId,
+				result: {
+					text: outputText(event.output),
+					isError: false
+				},
+				logs: event.logs ?? item.logs
+			} : item)
+		};
+		case "execution_failed": return {
+			...base,
+			items: base.items.map((item) => item.kind === "tool_call" && item.id === event.executionId ? {
+				...item,
+				status: "failed",
+				executionId: event.executionId,
+				result: {
+					text: `${event.reason}: ${event.error}`,
+					isError: true
+				},
+				logs: event.logs ?? item.logs
+			} : item)
+		};
+		case "file_delivered": return {
+			...base,
+			items: [...base.items, {
+				kind: "file_delivered",
+				id: `file-${event.seq}`,
+				path: event.path,
+				bytes: event.bytes,
+				description: event.description
+			}]
+		};
+		case "session_error": return {
+			...base,
+			items: [...base.items, {
+				kind: "notice",
+				id: `err-${event.seq}`,
+				level: "error",
+				text: event.message
+			}]
+		};
+		case "session_closed": return {
+			...base,
+			items: [...base.items, {
+				kind: "notice",
+				id: `closed-${event.seq}`,
+				level: "info",
+				text: `Session closed (${event.reason})`
+			}]
+		};
+		default: return base;
+	}
+}
+//#endregion
+//#region src/use-session.ts
+/** Session events drive the reducer; the attach snapshot seeds fields (permission
+* mode, model) that a promptless session's event stream doesn't carry yet. */
+function reduce(state, action) {
+	return action.type === "attached" ? seedFromSessionInfo(state, action.session) : applyEvent(state, action);
+}
+/** Attach to a session and maintain live transcript state. Detaches on unmount. */
+function useClaudeSession(client, sessionId, options) {
+	const [state, dispatch] = useReducer(reduce, initialTranscriptState);
+	const [connected, setConnected] = useState(false);
+	const [handleState, setHandleState] = useState();
+	const handleRef = useRef(null);
+	const onProtocolErrorRef = useRef(options?.onProtocolError);
+	onProtocolErrorRef.current = options?.onProtocolError;
+	useEffect(() => {
+		if (!sessionId) return;
+		const handle = client.attach(sessionId);
+		handleRef.current = handle;
+		setHandleState(handle);
+		const offEvent = handle.on("event", (event) => dispatch(event));
+		const offAttached = handle.on("attached", (frame) => dispatch(frame));
+		const offConn = handle.on("connectionChange", setConnected);
+		const offProtocolError = handle.on("protocolError", (message) => {
+			onProtocolErrorRef.current?.(message);
+		});
+		return () => {
+			offEvent();
+			offAttached();
+			offConn();
+			offProtocolError();
+			handle.detach();
+			handleRef.current = null;
+			setHandleState(void 0);
+		};
+	}, [client, sessionId]);
+	return useMemo(() => ({
+		state,
+		connected,
+		handle: handleState,
+		send: (text) => handleRef.current?.send(text),
+		approve: (requestId, updatedInput) => handleRef.current?.approve(requestId, updatedInput),
+		deny: (requestId, message) => handleRef.current?.deny(requestId, message),
+		interrupt: () => handleRef.current?.interrupt(),
+		setPermissionMode: (mode) => handleRef.current?.setPermissionMode(mode),
+		setModel: (model) => handleRef.current?.setModel(model),
+		closeSession: () => handleRef.current?.closeSession()
+	}), [
+		state,
+		connected,
+		handleState
+	]);
+}
+//#endregion
+//#region src/tool-host.ts
+/**
+* Answers server-bridged tool calls by executing them in this browser tab.
+* Framework-free — {@link useToolCallHost} is a thin React wrapper.
+*
+* The point is data locality: documents fetched or held client-side can be
+* evaluated here and never touch the server. The engine loads lazily, so a page
+* that never bridges a call never pays for the WASM guest.
+*/
+function createToolCallHost(handle, options = {}) {
+	const inFlight = /* @__PURE__ */ new Map();
+	let enginePromise;
+	let disposed = false;
+	const track = (execution) => options.onExecution?.(execution);
+	const refuse = (frame, reason, error, startedAt) => {
+		handle.sendToolCallError(frame.executionId, reason, error);
+		track({
+			executionId: frame.executionId,
+			toolName: frame.toolName,
+			status: "failed",
+			reason,
+			startedAt,
+			endedAt: Date.now()
+		});
+	};
+	const run = async (frame) => {
+		const startedAt = Date.now();
+		if (!(options.tools ?? ["eval_script"]).includes(frame.toolName)) {
+			refuse(frame, "unsupported_tool", `this client does not execute '${frame.toolName}'`, startedAt);
+			return;
+		}
+		const script = frame.input?.script;
+		if (typeof script !== "string") {
+			refuse(frame, "invalid_input", "expected a string `script` input", startedAt);
+			return;
+		}
+		const controller = new AbortController();
+		inFlight.set(frame.executionId, controller);
+		track({
+			executionId: frame.executionId,
+			toolName: frame.toolName,
+			status: "running",
+			startedAt
+		});
+		try {
+			const sandbox = await import("@workerdeck/sandbox");
+			const vfs = sandbox.createVfs(frame.vfsSeed);
+			const timeoutMs = Math.min(frame.limits?.timeoutMs ?? Number.POSITIVE_INFINITY, options.timeoutMs ?? 5e3);
+			const memoryLimitBytes = Math.min(frame.limits?.memoryLimitBytes ?? Number.POSITIVE_INFINITY, options.memoryLimitBytes ?? 64 * 1024 * 1024);
+			const result = options.execute ? await options.execute({
+				script,
+				vfs,
+				timeoutMs,
+				memoryLimitBytes,
+				signal: controller.signal
+			}) : await (async () => {
+				enginePromise ??= (options.loadEngine ?? defaultLoadEngine)();
+				return sandbox.runScript(await enginePromise, {
+					script,
+					vfs,
+					timeoutMs,
+					memoryLimitBytes,
+					signal: controller.signal,
+					fetchText: options.fetchText
+				});
+			})();
+			if (disposed || !inFlight.has(frame.executionId)) return;
+			const logs = result.logs.map((l) => `[${l.level}] ${l.text}`);
+			if (result.ok) {
+				handle.sendToolCallResult(frame.executionId, {
+					type: "json",
+					value: result.value
+				}, logs);
+				track({
+					executionId: frame.executionId,
+					toolName: frame.toolName,
+					status: "settled",
+					startedAt,
+					endedAt: Date.now()
+				});
+			} else {
+				handle.sendToolCallError(frame.executionId, result.reason, result.error, logs);
+				track({
+					executionId: frame.executionId,
+					toolName: frame.toolName,
+					status: "failed",
+					reason: result.reason,
+					startedAt,
+					endedAt: Date.now()
+				});
+			}
+		} catch (error) {
+			if (disposed || !inFlight.has(frame.executionId)) return;
+			refuse(frame, "host_error", error instanceof Error ? error.message : String(error), startedAt);
+		} finally {
+			inFlight.delete(frame.executionId);
+		}
+	};
+	const offRequest = handle.on("toolCallRequest", (frame) => void run(frame));
+	const offCancel = handle.on("toolCallCanceled", ({ executionId, reason }) => {
+		const controller = inFlight.get(executionId);
+		if (!controller) return;
+		controller.abort();
+		inFlight.delete(executionId);
+		track({
+			executionId,
+			toolName: "",
+			status: "canceled",
+			reason,
+			startedAt: Date.now(),
+			endedAt: Date.now()
+		});
+	});
+	return { dispose: () => {
+		disposed = true;
+		offRequest();
+		offCancel();
+		for (const controller of inFlight.values()) controller.abort();
+		inFlight.clear();
+	} };
+}
+/** The single-file browser build keeps this to one lazy chunk — no separate
+* .wasm fetch, and nothing at all until the first bridged call. */
+async function defaultLoadEngine() {
+	const [sandbox, variant] = await Promise.all([import("@workerdeck/sandbox"), import("@jitl/quickjs-singlefile-browser-release-asyncify")]);
+	return sandbox.loadEngine(variant);
+}
+//#endregion
+//#region src/use-tool-host.ts
+/**
+* React wrapper around {@link createToolCallHost}: subscribes while mounted and
+* exposes recent executions for rendering. All the logic lives in the
+* framework-free host — this only manages the subscription's lifetime.
+*/
+function useToolCallHost(handle, options = {}) {
+	const [executions, setExecutions] = useState([]);
+	const optionsRef = useRef(options);
+	optionsRef.current = options;
+	useEffect(() => {
+		if (!handle || options.enabled === false) return;
+		const host = createToolCallHost(handle, {
+			get tools() {
+				return optionsRef.current.tools;
+			},
+			get timeoutMs() {
+				return optionsRef.current.timeoutMs;
+			},
+			get memoryLimitBytes() {
+				return optionsRef.current.memoryLimitBytes;
+			},
+			get loadEngine() {
+				return optionsRef.current.loadEngine;
+			},
+			get execute() {
+				return optionsRef.current.execute;
+			},
+			get fetchText() {
+				return optionsRef.current.fetchText;
+			},
+			onExecution: (execution) => {
+				optionsRef.current.onExecution?.(execution);
+				const limit = optionsRef.current.historyLimit ?? 50;
+				setExecutions((prev) => [...prev.filter((e) => e.executionId !== execution.executionId), execution].slice(-limit));
+			}
+		});
+		return () => host.dispose();
+	}, [handle, options.enabled]);
+	return { executions };
+}
+//#endregion
+export { applyEvent, createToolCallHost, initialTranscriptState, seedFromSessionInfo, useClaudeSession, useToolCallHost };
+
+//# sourceMappingURL=index.mjs.map

package/build/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/transcript.ts","../src/use-session.ts","../src/tool-host.ts","../src/use-tool-host.ts"],"sourcesContent":["import type {\n  ContentBlock,\n  ContextUsage,\n  ModelOption,\n  PermissionMode,\n  PermissionRequest,\n  ProfileEngine,\n  RateLimitInfo,\n  SessionEvent,\n  SessionInfo,\n  SessionStatus,\n  SlashCommandInfo,\n  ToolExecutionBackend,\n  ToolExecutionOutput,\n  ToolResultBlock,\n} from '@workerdeck/protocol'\n\n/**\n * Pure transcript state machine over the wire-protocol event stream. Framework-free\n * so it can be unit-tested and reused outside React.\n */\n\nexport type TranscriptItem =\n  | { kind: 'user'; id: string; text: string }\n  | {\n      kind: 'assistant_text'\n      id: string\n      text: string\n      streaming: boolean\n      parentToolUseId: string | null\n    }\n  | { kind: 'thinking'; id: string; text: string; parentToolUseId: string | null }\n  | {\n      kind: 'tool_call'\n      id: string\n      name: string\n      input: unknown\n      parentToolUseId: string | null\n      /**\n       * - `running` — the model called it; execution has not been reported\n       * - `pending` — dispatched to an executor (bridged to this client, queued)\n       * - `deferred` — parked beyond this turn; may outlive the session's liveness\n       * - `settled` / `failed` — terminal\n       *\n       * Derive UI from this, not from `result` being present: a pending or\n       * deferred call has no result yet and is not the same as a running one.\n       */\n      status: 'running' | 'pending' | 'deferred' | 'settled' | 'failed'\n      result?: { text: string; isError: boolean }\n      /** Correlation id when this call is executed outside the model loop. */\n      executionId?: string\n      /** Which backend is executing it, when known. */\n      backend?: ToolExecutionBackend\n      /** Logs captured by the executor (guest console output). */\n      logs?: string[]\n    }\n  | {\n      kind: 'turn_result'\n      id: string\n      subtype: string\n      isError: boolean\n      durationMs: number\n      totalCostUsd: number\n      errors?: string[]\n    }\n  | { kind: 'notice'; id: string; level: 'info' | 'error'; text: string }\n  /** The agent handed over a session file (`file_delivered`). Render a download\n   * card; the file is served by GET /sessions/:id/files/<path> while the\n   * session lives. */\n  | { kind: 'file_delivered'; id: string; path: string; bytes: number; description?: string }\n\nexport type TranscriptState = {\n  status: SessionStatus\n  statusDetail?: string\n  model?: string\n  cwd?: string\n  sdkSessionId?: string\n  /** Engine running the session, from the attach snapshot. Gates CLI-only\n   * affordances; absent (an older server) reads as 'claude'. */\n  engine?: ProfileEngine\n  /** Models the session can switch to (from the `capabilities` event). */\n  models?: ModelOption[]\n  /** Slash commands the CLI accepts (from the `capabilities` event). */\n  commands?: SlashCommandInfo[]\n  /** Seeded from `system_init`, updated on `permission_mode_changed`. */\n  permissionMode?: PermissionMode\n  /** Latest context-window snapshot; absent until the first turn completes. */\n  contextUsage?: ContextUsage\n  /** Latest rate-limit snapshot per window ('five_hour', 'seven_day', ...).\n   * Absent for API-key sessions — render nothing, not 0%. */\n  rateLimits?: Record<string, RateLimitInfo>\n  items: TranscriptItem[]\n  pendingApprovals: PermissionRequest[]\n  totalCostUsd: number\n  lastSeq: number\n}\n\nexport const initialTranscriptState: TranscriptState = {\n  status: 'starting',\n  items: [],\n  pendingApprovals: [],\n  totalCostUsd: 0,\n  lastSeq: 0,\n}\n\nconst STREAMING_ID = 'streaming'\nconst STREAMING_THINKING_ID = 'streaming-thinking'\n\nfunction blockText(content: ToolResultBlock['content']): string {\n  if (content === undefined) return ''\n  if (typeof content === 'string') return content\n  return content\n    .map((part) => (typeof part.text === 'string' ? part.text : ''))\n    .filter(Boolean)\n    .join('\\n')\n}\n\nfunction contentToBlocks(content: string | ContentBlock[]): ContentBlock[] {\n  return typeof content === 'string' ? [{ type: 'text', text: content }] : content\n}\n\n/** Render an execution's by-value output for the transcript. */\nfunction outputText(output: ToolExecutionOutput): string {\n  if (output.type === 'text') return output.value\n  try {\n    return JSON.stringify(output.value)\n  } catch {\n    return String(output.value)\n  }\n}\n\n/** CLI-side command output arrives as user text wrapped in local-command tags. */\nconst LOCAL_COMMAND_OUTPUT = /^<local-command-(stdout|stderr)>([\\s\\S]*?)<\\/local-command-\\1>$/\n\nfunction upsert(items: TranscriptItem[], item: TranscriptItem): TranscriptItem[] {\n  const index = items.findIndex((existing) => existing.id === item.id && existing.kind === item.kind)\n  if (index === -1) return [...items, item]\n  const next = [...items]\n  next[index] = item\n  return next\n}\n\n/**\n * Seed transcript state from the attach snapshot (the `attached` frame's SessionInfo).\n * A promptless session emits no `system_init` until its first message, so fields like\n * `permissionMode` and `model` would otherwise stay empty — fill only what events\n * haven't set yet; the event stream stays authoritative.\n */\nexport function seedFromSessionInfo(state: TranscriptState, info: SessionInfo): TranscriptState {\n  return {\n    ...state,\n    // Before any event has arrived, the snapshot status is fresher than 'starting'.\n    status: state.lastSeq === 0 ? info.status : state.status,\n    model: state.model ?? info.model,\n    permissionMode: state.permissionMode ?? info.permissionMode,\n    cwd: state.cwd ?? info.cwd,\n    sdkSessionId: state.sdkSessionId ?? info.sdkSessionId,\n    // Never changes for a live session, and no event carries it — the snapshot is\n    // the only source, so take it whenever it is present.\n    engine: info.engine ?? state.engine,\n  }\n}\n\nexport function applyEvent(state: TranscriptState, event: SessionEvent): TranscriptState {\n  if (event.seq <= state.lastSeq) return state\n  const base: TranscriptState = { ...state, lastSeq: event.seq }\n\n  switch (event.type) {\n    case 'system_init':\n      return {\n        ...base,\n        model: event.model,\n        cwd: event.cwd,\n        sdkSessionId: event.sdkSessionId,\n        permissionMode: event.permissionMode,\n      }\n\n    case 'status_changed':\n      return { ...base, status: event.status, statusDetail: event.detail }\n\n    case 'capabilities':\n      return { ...base, models: event.models, commands: event.commands }\n\n    case 'model_changed':\n      // undefined = reset to the server default; keep showing the last known model.\n      return event.model === undefined ? base : { ...base, model: event.model }\n\n    case 'permission_mode_changed':\n      return { ...base, permissionMode: event.mode }\n\n    case 'context_usage':\n      return { ...base, contextUsage: event.usage }\n\n    case 'rate_limit': {\n      // Keyed by window so five_hour and seven_day updates don't clobber each other.\n      const key = event.info.rateLimitType\n      if (!key) return base\n      return { ...base, rateLimits: { ...base.rateLimits, [key]: event.info } }\n    }\n\n    case 'user_message': {\n      let items = base.items\n      for (const block of contentToBlocks(event.message.content)) {\n        if (block.type === 'tool_result') {\n          const toolResult = block as ToolResultBlock\n          const isError = toolResult.is_error === true\n          items = items.map((item) =>\n            item.kind === 'tool_call' && item.id === toolResult.tool_use_id\n              ? {\n                  ...item,\n                  status: isError ? 'failed' : 'settled',\n                  result: { text: blockText(toolResult.content), isError },\n                }\n              : item,\n          )\n        } else if (block.type === 'text' && !event.synthetic) {\n          const text = (block as { text: string }).text\n          const localOutput = LOCAL_COMMAND_OUTPUT.exec(text.trim())\n          if (localOutput) {\n            items = upsert(items, {\n              kind: 'notice',\n              id: event.uuid ?? `user-${event.seq}`,\n              level: localOutput[1] === 'stderr' ? 'error' : 'info',\n              text: localOutput[2].trim(),\n            })\n          } else {\n            items = upsert(items, {\n              kind: 'user',\n              id: event.uuid ?? `user-${event.seq}`,\n              text,\n            })\n          }\n        }\n      }\n      return { ...base, items }\n    }\n\n    case 'assistant_message': {\n      // Encrypted thinking arrives as a signature-only block on the final message: `thinking`\n      // is '' and the human-readable summary, when the model surfaces one at all, exists only\n      // in the thinking_delta stream. Carry the streamed text over rather than let the full\n      // message overwrite it with nothing.\n      let streamedThinking =\n        base.items.find(\n          (item): item is Extract<TranscriptItem, { kind: 'thinking' }> =>\n            item.kind === 'thinking' && item.id === STREAMING_THINKING_ID,\n        )?.text ?? ''\n      // The full message supersedes any in-flight streamed text/thinking.\n      let items = base.items.filter(\n        (item) =>\n          !(item.kind === 'assistant_text' && item.id === STREAMING_ID) &&\n          !(item.kind === 'thinking' && item.id === STREAMING_THINKING_ID),\n      )\n      const blocks = contentToBlocks(event.message.content)\n      blocks.forEach((block, index) => {\n        const id = `${event.uuid}-${index}`\n        if (block.type === 'text') {\n          items = upsert(items, {\n            kind: 'assistant_text',\n            id,\n            text: (block as { text: string }).text,\n            streaming: false,\n            parentToolUseId: event.parentToolUseId,\n          })\n        } else if (block.type === 'thinking') {\n          const text = (block as { thinking: string }).thinking || streamedThinking\n          // One streamed thought backfills at most one block, so a multi-block message\n          // doesn't repeat it.\n          streamedThinking = ''\n          // No summary anywhere: drop the block instead of leaving a \"Thought process\" row\n          // that expands to nothing (and, across consecutive messages, stacks up).\n          if (text.trim() === '') return\n          items = upsert(items, {\n            kind: 'thinking',\n            id,\n            text,\n            parentToolUseId: event.parentToolUseId,\n          })\n        } else if (block.type === 'tool_use') {\n          const toolUse = block as { id: string; name: string; input: unknown }\n          items = upsert(items, {\n            kind: 'tool_call',\n            id: toolUse.id,\n            name: toolUse.name,\n            input: toolUse.input,\n            parentToolUseId: event.parentToolUseId,\n            status: 'running',\n          })\n        }\n      })\n      return { ...base, items }\n    }\n\n    case 'stream_delta': {\n      const delta = event.event as {\n        type: string\n        delta?: { type?: string; text?: string; thinking?: string }\n      }\n      if (delta.type !== 'content_block_delta') return base\n      if (delta.delta?.type === 'text_delta') {\n        const existing = base.items.find(\n          (item): item is Extract<TranscriptItem, { kind: 'assistant_text' }> =>\n            item.kind === 'assistant_text' && item.id === STREAMING_ID,\n        )\n        const item: TranscriptItem = {\n          kind: 'assistant_text',\n          id: STREAMING_ID,\n          text: (existing?.text ?? '') + (delta.delta.text ?? ''),\n          streaming: true,\n          parentToolUseId: event.parentToolUseId,\n        }\n        return { ...base, items: upsert(base.items, item) }\n      }\n      if (delta.delta?.type === 'thinking_delta') {\n        const existing = base.items.find(\n          (item): item is Extract<TranscriptItem, { kind: 'thinking' }> =>\n            item.kind === 'thinking' && item.id === STREAMING_THINKING_ID,\n        )\n        const item: TranscriptItem = {\n          kind: 'thinking',\n          id: STREAMING_THINKING_ID,\n          text: (existing?.text ?? '') + (delta.delta.thinking ?? ''),\n          parentToolUseId: event.parentToolUseId,\n        }\n        return { ...base, items: upsert(base.items, item) }\n      }\n      return base\n    }\n\n    case 'turn_result':\n      return {\n        ...base,\n        // total_cost_usd is session-cumulative on each SDK result message.\n        totalCostUsd: event.totalCostUsd,\n        items: [\n          ...base.items,\n          {\n            kind: 'turn_result',\n            id: `turn-${event.seq}`,\n            subtype: event.subtype,\n            isError: event.isError,\n            durationMs: event.durationMs,\n            totalCostUsd: event.totalCostUsd,\n            errors: event.errors,\n          },\n        ],\n      }\n\n    case 'permission_requested':\n      return { ...base, pendingApprovals: [...base.pendingApprovals, event.request] }\n\n    case 'permission_resolved':\n      return {\n        ...base,\n        pendingApprovals: base.pendingApprovals.filter((r) => r.id !== event.requestId),\n      }\n\n    // Execution lifecycle for tool calls that run outside the model loop\n    // (bridged to this client, queued, or deferred). Keyed by executionId, which\n    // equals the tool_use id for calls the model made. Events for an unknown id\n    // are ignored rather than fabricating an item: the tool_use that explains it\n    // may simply not have arrived (or belongs to another session).\n    case 'execution_dispatched':\n      return {\n        ...base,\n        items: base.items.map((item) =>\n          item.kind === 'tool_call' && item.id === event.executionId\n            ? {\n                ...item,\n                status: event.deferred ? 'deferred' : 'pending',\n                executionId: event.executionId,\n                backend: event.backend,\n              }\n            : item,\n        ),\n      }\n\n    case 'execution_result':\n      return {\n        ...base,\n        items: base.items.map((item) =>\n          item.kind === 'tool_call' && item.id === event.executionId\n            ? {\n                ...item,\n                status: 'settled',\n                executionId: event.executionId,\n                result: { text: outputText(event.output), isError: false },\n                logs: event.logs ?? item.logs,\n              }\n            : item,\n        ),\n      }\n\n    case 'execution_failed':\n      return {\n        ...base,\n        items: base.items.map((item) =>\n          item.kind === 'tool_call' && item.id === event.executionId\n            ? {\n                ...item,\n                status: 'failed',\n                executionId: event.executionId,\n                result: { text: `${event.reason}: ${event.error}`, isError: true },\n                logs: event.logs ?? item.logs,\n              }\n            : item,\n        ),\n      }\n\n    case 'file_delivered':\n      return {\n        ...base,\n        items: [\n          ...base.items,\n          {\n            kind: 'file_delivered',\n            id: `file-${event.seq}`,\n            path: event.path,\n            bytes: event.bytes,\n            description: event.description,\n          },\n        ],\n      }\n\n    case 'session_error':\n      return {\n        ...base,\n        items: [\n          ...base.items,\n          { kind: 'notice', id: `err-${event.seq}`, level: 'error', text: event.message },\n        ],\n      }\n\n    case 'session_closed':\n      return {\n        ...base,\n        items: [\n          ...base.items,\n          {\n            kind: 'notice',\n            id: `closed-${event.seq}`,\n            level: 'info',\n            text: `Session closed (${event.reason})`,\n          },\n        ],\n      }\n\n    case 'sdk_event':\n    default:\n      return base\n  }\n}\n","import { useEffect, useMemo, useReducer, useRef, useState } from 'react'\nimport type { WorkerDeckClient, SessionHandle } from '@workerdeck/client'\nimport type { AttachedFrame, PermissionMode, SessionEvent } from '@workerdeck/protocol'\nimport {\n  applyEvent,\n  initialTranscriptState,\n  seedFromSessionInfo,\n  type TranscriptState,\n} from './transcript.ts'\n\n/** Session events drive the reducer; the attach snapshot seeds fields (permission\n * mode, model) that a promptless session's event stream doesn't carry yet. */\nfunction reduce(state: TranscriptState, action: SessionEvent | AttachedFrame): TranscriptState {\n  return action.type === 'attached'\n    ? seedFromSessionInfo(state, action.session)\n    : applyEvent(state, action)\n}\n\nexport type UseClaudeSessionOptions = {\n  /** Called when the server rejects a command with a protocol_error frame — e.g. a\n   * permission-mode switch the CLI refuses. Without a handler these are dropped\n   * silently and the UI looks like \"nothing happened\". */\n  onProtocolError?: (message: string) => void\n}\n\nexport type UseClaudeSessionResult = {\n  state: TranscriptState\n  connected: boolean\n  /** The live attach handle, for wiring companions that must ride the SAME\n   * socket — e.g. useToolCallHost: the bridge asks the first attached client,\n   * so a host on a second handle would never see the requests. Undefined until\n   * attached and after unmount. */\n  handle: SessionHandle | undefined\n  send: (text: string) => void\n  approve: (requestId: string, updatedInput?: Record<string, unknown>) => void\n  deny: (requestId: string, message?: string) => void\n  interrupt: () => void\n  setPermissionMode: (mode: PermissionMode) => void\n  setModel: (model?: string) => void\n  closeSession: () => void\n}\n\n/** Attach to a session and maintain live transcript state. Detaches on unmount. */\nexport function useClaudeSession(\n  client: WorkerDeckClient,\n  sessionId: string | undefined,\n  options?: UseClaudeSessionOptions,\n): UseClaudeSessionResult {\n  const [state, dispatch] = useReducer(reduce, initialTranscriptState)\n  const [connected, setConnected] = useState(false)\n  // Ref for the stable callbacks below; state so consumers of `handle` re-render\n  // when the socket opens or the session switches.\n  const [handleState, setHandleState] = useState<SessionHandle | undefined>()\n  const handleRef = useRef<SessionHandle | null>(null)\n  // Ref'd so a new inline callback doesn't tear down and reopen the socket.\n  const onProtocolErrorRef = useRef(options?.onProtocolError)\n  onProtocolErrorRef.current = options?.onProtocolError\n\n  useEffect(() => {\n    if (!sessionId) return\n    const handle = client.attach(sessionId)\n    handleRef.current = handle\n    setHandleState(handle)\n    const offEvent = handle.on('event', (event: SessionEvent) => dispatch(event))\n    const offAttached = handle.on('attached', (frame: AttachedFrame) => dispatch(frame))\n    const offConn = handle.on('connectionChange', setConnected)\n    const offProtocolError = handle.on('protocolError', (message: string) => {\n      onProtocolErrorRef.current?.(message)\n    })\n    return () => {\n      offEvent()\n      offAttached()\n      offConn()\n      offProtocolError()\n      handle.detach()\n      handleRef.current = null\n      setHandleState(undefined)\n    }\n  }, [client, sessionId])\n\n  return useMemo(\n    () => ({\n      state,\n      connected,\n      handle: handleState,\n      send: (text) => handleRef.current?.send(text),\n      approve: (requestId, updatedInput) => handleRef.current?.approve(requestId, updatedInput),\n      deny: (requestId, message) => handleRef.current?.deny(requestId, message),\n      interrupt: () => handleRef.current?.interrupt(),\n      setPermissionMode: (mode) => handleRef.current?.setPermissionMode(mode),\n      setModel: (model) => handleRef.current?.setModel(model),\n      closeSession: () => handleRef.current?.closeSession(),\n    }),\n    [state, connected, handleState],\n  )\n}\n","import type { SessionHandle } from '@workerdeck/client'\nimport type { RunScriptResult, SandboxEngine, SandboxVfs } from '@workerdeck/sandbox'\nimport type { ToolCallRequestFrame } from '@workerdeck/protocol'\n\n/** What the host was asked to do and how it went (for UI/telemetry). */\nexport type ToolHostExecution = {\n  executionId: string\n  toolName: string\n  status: 'running' | 'settled' | 'failed' | 'canceled'\n  reason?: string\n  startedAt: number\n  endedAt?: number\n}\n\nexport type ToolHostRunner = (request: {\n  script: string\n  vfs: SandboxVfs\n  timeoutMs: number\n  memoryLimitBytes: number\n  signal: AbortSignal\n}) => Promise<RunScriptResult>\n\nexport type ToolCallHostOptions = {\n  /** Tools this client will execute. Anything else is refused, so a server can\n   * never talk this tab into running something it didn't opt into.\n   * Default: `['eval_script']`. */\n  tools?: string[]\n  /** Guest wall-clock limit, unless the request asks for less. Default 5000. */\n  timeoutMs?: number\n  /** Guest allocator cap, unless the request asks for less. Default 64 MiB. */\n  memoryLimitBytes?: number\n  /**\n   * Load the WASM guest engine. Called at most once, on the first bridged call\n   * — nothing is downloaded or parsed until a session actually bridges one.\n   * Defaults to `@workerdeck/sandbox` with the single-file browser build.\n   */\n  loadEngine?: () => Promise<SandboxEngine>\n  /**\n   * Run the script. Defaults to executing on this thread, which is fine for the\n   * short, time-boxed evaluations this is built for. Supply your own (a Web\n   * Worker running the same engine) to keep long evaluations off the UI thread\n   * — the guest deadline preempts the interpreter, but only between bytecode\n   * ops on whichever thread it runs on.\n   */\n  execute?: ToolHostRunner\n  /** Host-gated fetch for the guest. Omitted = the guest has no network at all. */\n  fetchText?: (url: string) => Promise<string>\n  /** Observe executions (rendering, logging). */\n  onExecution?: (execution: ToolHostExecution) => void\n}\n\n/**\n * Answers server-bridged tool calls by executing them in this browser tab.\n * Framework-free — {@link useToolCallHost} is a thin React wrapper.\n *\n * The point is data locality: documents fetched or held client-side can be\n * evaluated here and never touch the server. The engine loads lazily, so a page\n * that never bridges a call never pays for the WASM guest.\n */\nexport function createToolCallHost(\n  handle: SessionHandle,\n  options: ToolCallHostOptions = {},\n): { dispose: () => void } {\n  const inFlight = new Map<string, AbortController>()\n  let enginePromise: Promise<SandboxEngine> | undefined\n  let disposed = false\n\n  const track = (execution: ToolHostExecution) => options.onExecution?.(execution)\n\n  const refuse = (frame: ToolCallRequestFrame, reason: string, error: string, startedAt: number) => {\n    handle.sendToolCallError(frame.executionId, reason, error)\n    track({\n      executionId: frame.executionId,\n      toolName: frame.toolName,\n      status: 'failed',\n      reason,\n      startedAt,\n      endedAt: Date.now(),\n    })\n  }\n\n  const run = async (frame: ToolCallRequestFrame): Promise<void> => {\n    const startedAt = Date.now()\n    const allowed = options.tools ?? ['eval_script']\n    if (!allowed.includes(frame.toolName)) {\n      refuse(frame, 'unsupported_tool', `this client does not execute '${frame.toolName}'`, startedAt)\n      return\n    }\n    const script = (frame.input as { script?: unknown } | undefined)?.script\n    if (typeof script !== 'string') {\n      refuse(frame, 'invalid_input', 'expected a string `script` input', startedAt)\n      return\n    }\n\n    const controller = new AbortController()\n    inFlight.set(frame.executionId, controller)\n    track({ executionId: frame.executionId, toolName: frame.toolName, status: 'running', startedAt })\n\n    try {\n      const sandbox = await import('@workerdeck/sandbox')\n      const vfs = sandbox.createVfs(frame.vfsSeed)\n      // Never exceed what the server asked for: it owns the deadline it will\n      // give up at, and answering after that is wasted work.\n      const timeoutMs = Math.min(\n        frame.limits?.timeoutMs ?? Number.POSITIVE_INFINITY,\n        options.timeoutMs ?? 5000,\n      )\n      const memoryLimitBytes = Math.min(\n        frame.limits?.memoryLimitBytes ?? Number.POSITIVE_INFINITY,\n        options.memoryLimitBytes ?? 64 * 1024 * 1024,\n      )\n\n      const result = options.execute\n        ? await options.execute({ script, vfs, timeoutMs, memoryLimitBytes, signal: controller.signal })\n        : await (async () => {\n            enginePromise ??= (options.loadEngine ?? defaultLoadEngine)()\n            return sandbox.runScript(await enginePromise, {\n              script,\n              vfs,\n              timeoutMs,\n              memoryLimitBytes,\n              signal: controller.signal,\n              fetchText: options.fetchText,\n            })\n          })()\n\n      // Cancelled or torn down while we worked: the server is no longer waiting.\n      if (disposed || !inFlight.has(frame.executionId)) return\n      const logs = result.logs.map((l) => `[${l.level}] ${l.text}`)\n      if (result.ok) {\n        handle.sendToolCallResult(frame.executionId, { type: 'json', value: result.value }, logs)\n        track({\n          executionId: frame.executionId,\n          toolName: frame.toolName,\n          status: 'settled',\n          startedAt,\n          endedAt: Date.now(),\n        })\n      } else {\n        handle.sendToolCallError(frame.executionId, result.reason, result.error, logs)\n        track({\n          executionId: frame.executionId,\n          toolName: frame.toolName,\n          status: 'failed',\n          reason: result.reason,\n          startedAt,\n          endedAt: Date.now(),\n        })\n      }\n    } catch (error) {\n      if (disposed || !inFlight.has(frame.executionId)) return\n      // Engine load failures land here — tell the server so the agent can adapt\n      // instead of waiting out the deadline.\n      refuse(frame, 'host_error', error instanceof Error ? error.message : String(error), startedAt)\n    } finally {\n      inFlight.delete(frame.executionId)\n    }\n  }\n\n  const offRequest = handle.on('toolCallRequest', (frame) => void run(frame))\n  const offCancel = handle.on('toolCallCanceled', ({ executionId, reason }) => {\n    const controller = inFlight.get(executionId)\n    if (!controller) return\n    controller.abort()\n    inFlight.delete(executionId)\n    track({\n      executionId,\n      toolName: '',\n      status: 'canceled',\n      reason,\n      startedAt: Date.now(),\n      endedAt: Date.now(),\n    })\n  })\n\n  return {\n    dispose: () => {\n      disposed = true\n      offRequest()\n      offCancel()\n      for (const controller of inFlight.values()) controller.abort()\n      inFlight.clear()\n    },\n  }\n}\n\n/** The single-file browser build keeps this to one lazy chunk — no separate\n * .wasm fetch, and nothing at all until the first bridged call. */\nasync function defaultLoadEngine(): Promise<SandboxEngine> {\n  const [sandbox, variant] = await Promise.all([\n    import('@workerdeck/sandbox'),\n    import('@jitl/quickjs-singlefile-browser-release-asyncify'),\n  ])\n  return sandbox.loadEngine(variant as never)\n}\n","import { useEffect, useRef, useState } from 'react'\nimport type { SessionHandle } from '@workerdeck/client'\nimport {\n  createToolCallHost,\n  type ToolCallHostOptions,\n  type ToolHostExecution,\n} from './tool-host.ts'\n\nexport type UseToolCallHostOptions = ToolCallHostOptions & {\n  /** Turn the host off without unmounting. Default true. */\n  enabled?: boolean\n  /** How many recent executions to keep for rendering. Default 50. */\n  historyLimit?: number\n}\n\n/**\n * React wrapper around {@link createToolCallHost}: subscribes while mounted and\n * exposes recent executions for rendering. All the logic lives in the\n * framework-free host — this only manages the subscription's lifetime.\n */\nexport function useToolCallHost(\n  handle: SessionHandle | undefined,\n  options: UseToolCallHostOptions = {},\n): { executions: ToolHostExecution[] } {\n  const [executions, setExecutions] = useState<ToolHostExecution[]>([])\n  // Read options at call time so re-renders never tear down the subscription.\n  const optionsRef = useRef(options)\n  optionsRef.current = options\n\n  useEffect(() => {\n    if (!handle || options.enabled === false) return\n    const host = createToolCallHost(handle, {\n      // Delegate every option through the ref, so a caller passing inline\n      // objects/closures (the common case) doesn't resubscribe each render.\n      get tools() {\n        return optionsRef.current.tools\n      },\n      get timeoutMs() {\n        return optionsRef.current.timeoutMs\n      },\n      get memoryLimitBytes() {\n        return optionsRef.current.memoryLimitBytes\n      },\n      get loadEngine() {\n        return optionsRef.current.loadEngine\n      },\n      get execute() {\n        return optionsRef.current.execute\n      },\n      get fetchText() {\n        return optionsRef.current.fetchText\n      },\n      onExecution: (execution) => {\n        optionsRef.current.onExecution?.(execution)\n        const limit = optionsRef.current.historyLimit ?? 50\n        setExecutions((prev) => [\n          ...prev.filter((e) => e.executionId !== execution.executionId),\n          execution,\n        ].slice(-limit))\n      },\n    })\n    return () => host.dispose()\n  }, [handle, options.enabled])\n\n  return { executions }\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@workerdeck/react",
+  "version": "0.6.0",
+  "type": "module",
+  "description": "Headless React layer for WorkerDeck: useClaudeSession hook + pure transcript reducer. No styling opinion — @workerdeck/ui is the styled layer on top.",
+  "license": "MIT",
+  "main": "./build/index.mjs",
+  "types": "./build/index.d.mts",
+  "files": [
+    "build"
+  ],
+  "exports": {
+    ".": {
+      "@workerdeck/source": "./src/index.ts",
+      "types": "./build/index.d.mts",
+      "default": "./build/index.mjs"
+    }
+  },
+  "dependencies": {
+    "@workerdeck/client": "0.6.0",
+    "@workerdeck/sandbox": "0.6.0",
+    "@workerdeck/protocol": "0.6.0"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "@jitl/quickjs-singlefile-browser-release-asyncify": "^0.31.0"
+  },
+  "peerDependenciesMeta": {
+    "@jitl/quickjs-singlefile-browser-release-asyncify": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@jitl/quickjs-ng-wasmfile-release-asyncify": "^0.31.0",
+    "@jitl/quickjs-singlefile-browser-release-asyncify": "^0.31.0",
+    "@types/node": "^22.10.0",
+    "@types/react": "^19.2.0",
+    "@types/ws": "^8.18.1",
+    "react": "^19.2.0",
+    "rimraf": "^6.1.3",
+    "tsdown": "^0.21.10",
+    "vitest": "^3.2.0",
+    "ws": "^8.21.1",
+    "@workerdeck/core": "0.6.0",
+    "@workerdeck/server": "0.6.0"
+  },
+  "author": "Tobias Strebitzer",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/workerdeck/workerdeck.git",
+    "directory": "packages/react"
+  },
+  "homepage": "https://workerdeck.github.io/workerdeck/",
+  "bugs": "https://github.com/workerdeck/workerdeck/issues",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "agent",
+    "react",
+    "hooks",
+    "headless"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "rimraf build",
+    "build": "tsdown",
+    "typecheck": "tsgo -p tsconfig.json && tsgo -p tsconfig.test.json",
+    "test": "vitest run"
+  }
+}