zidane-ui 9.0.4 → 9.1.3

package/src/adapters/browser-workspace-host.ts

@@ -1,92 +0,0 @@
-/**
- * A `WorkspaceHost` for the web app served by zidane-server. The side
- * panel's layout is a UI preference with no server state: it is kept in the
- * browser (`createStorageLayouts` over `localStorage` by default), one record
- * per scope key, and another tab's write shows through the `storage` event.
- *
- * With `client`, the server's extension panels (`panels`): `panels.list`,
- * `panels.load`, `panels.action` and `panels.watch` / `unwatch` (watched
- * again after a reconnect), `panel:changed` to the watchers, and the catalog
- * re-read on `catalog:changed` (extensions, plugins) and every handshake.
- */
-import type { HostSignal } from 'zidane/ipc';
-import type { ServerClient } from 'zidane/ipc/browser';
-
-import type { WorkspaceHost, WorkspacePanels } from '../workspace/headless/host';
-import { createStorageLayouts, type LayoutStorage, type LayoutStoreOptions } from '../workspace/headless/layouts';
-
-/** Options for {@link createBrowserWorkspaceHost}. */
-export interface BrowserWorkspaceHostOptions extends LayoutStoreOptions {
-  /** Where layouts persist. Default: `localStorage` when there is one, else in memory. */
-  storage?: LayoutStorage;
-  /** The storage key. Default: `zidane-ui:workspace:v1`. */
-  key?: string;
-  /** Hears another tab's writes. Default: the `storage` event on `window`. */
-  listenExternal?: (onExternalWrite: (key: string | null) => void) => () => void;
-  /** The server whose extension panels it offers. Absent, or a server without `panels.list`: none. */
-  client?: ServerClient;
-}
-
-function memoryStorage(): LayoutStorage {
-  const map = new Map<string, string>();
-  return { getItem: (k) => map.get(k) ?? null, setItem: (k, v) => void map.set(k, v) };
-}
-
-function defaultStorage(): LayoutStorage {
-  try {
-    if (typeof localStorage !== 'undefined') return localStorage;
-  } catch {
-    // Storage blocked (privacy mode, sandboxed frame): keep layouts in memory.
-  }
-  return memoryStorage();
-}
-
-/** The server's extension panels. */
-function serverPanels(client: ServerClient): WorkspacePanels {
-  return {
-    list: (cwd) => client.call('panels.list', { cwd }),
-    load: (cwd, panelId, ctx) => client.call('panels.load', { cwd, panelId, ctx }),
-    action: async (cwd, panelId, actionId, payload, ctx) => {
-      const result = await client.call('panels.action', { cwd, panelId, actionId, payload, ctx });
-      return result.ok ? result : { ok: false, error: { code: 'failed', message: result.error } };
-    },
-    watch: (cwd, panelId) => {
-      const watch = () => void client.call('panels.watch', { cwd, panelId }).catch(() => undefined);
-      // A reconnect is a new connection: the server forgot the watch.
-      const offOpen = client.onOpen(watch);
-      watch();
-      return () => {
-        offOpen();
-        void client.call('panels.unwatch', { cwd, panelId }).catch(() => undefined);
-      };
-    },
-    subscribe: (onChange) =>
-      client.onSignal((signal: HostSignal) => {
-        if (signal.kind === 'panel:changed') onChange({ cwd: signal.cwd, panelId: signal.panelId });
-      }),
-    subscribeCatalog: (onChange) => {
-      const offSignal = client.onSignal((signal: HostSignal) => {
-        if (signal.kind === 'catalog:changed' && (signal.catalog === 'extensions' || signal.catalog === 'plugins'))
-          onChange();
-      });
-      const offOpen = client.onOpen(() => onChange());
-      return () => {
-        offSignal();
-        offOpen();
-      };
-    },
-  };
-}
-
-/**
- * Creates the web app's {@link WorkspaceHost}: layouts in browser storage, and the server's extension panels.
- *
- * @param options - The storage, its key, what an unknown scope reads, how other tabs' writes arrive and the server.
- */
-export function createBrowserWorkspaceHost(options: BrowserWorkspaceHostOptions = {}): WorkspaceHost {
-  const { storage = defaultStorage(), client, ...rest } = options;
-  return {
-    layouts: createStorageLayouts({ storage, ...rest }),
-    ...(client?.can('panels.list') ? { panels: serverPanels(client) } : {}),
-  };
-}

package/src/adapters/closable-client.ts

@@ -1,34 +0,0 @@
-import type { ServerClient } from 'zidane/ipc/browser';
-
-/**
- * A view of a shared client whose listeners one `close()` removes, for a host
- * that listens for its whole life: the host listens through `client`, and its
- * own `close()` calls this one. The shared client stays open. A listener added
- * after `close()` is never attached.
- */
-export function closableClient(shared: ServerClient): { client: ServerClient; close(): void } {
-  const offs = new Set<() => void>();
-  let closed = false;
-  const track =
-    <L>(on: (listener: L) => () => void) =>
-    (listener: L): (() => void) => {
-      if (closed) return () => undefined;
-      const off = on(listener);
-      const once = () => {
-        if (offs.delete(once)) off();
-      };
-      offs.add(once);
-      return once;
-    };
-  const client: ServerClient = Object.create(shared);
-  client.onSignal = track(shared.onSignal);
-  client.onOpen = track(shared.onOpen);
-  client.onState = track(shared.onState);
-  return {
-    client,
-    close() {
-      closed = true;
-      for (const off of [...offs]) off();
-    },
-  };
-}

package/src/adapters/index.ts

@@ -1,32 +0,0 @@
-/**
- * `zidane-ui/adapters`: browser-safe `ChatHost` factories over a real agent:
- * `createRunHost` (your run function), `createWorkerHost` / `exposeRunHost`
- * (a Web Worker), `createSseHost` (`zidane-ui/server`'s SSE handler),
- * `createServerHost` (zidane-server over WebSocket), and their wire protocols;
- * `createStreamPacer` paces a run's live events into its transcript.
- */
-export * from './run-host';
-export * from './worker-host';
-export * from './worker-protocol';
-export * from './sse-host';
-export * from './sse-parser';
-export * from './sse-protocol';
-export * from './server-client';
-export * from './server-host';
-export * from './server-approvals-host';
-export * from './server-session-host';
-export * from './server-composer-host';
-export * from './server-palette-host';
-export * from './server-terminal-host';
-export * from './server-git-host';
-export * from './server-files-host';
-export * from './server-machines-host';
-export * from './server-onboarding-host';
-export * from './server-settings-host';
-export * from './server-sidebar-host';
-export * from './browser-appearance-host';
-export * from './browser-keybindings-host';
-export * from './browser-workspace-host';
-export * from './live';
-export * from './live-events';
-export * from './stream-pacer';

package/src/adapters/live-events.ts

@@ -1,6 +0,0 @@
-/**
- * zidane's live event rule, re-exported for the adapters' public entry. It
- * lives with the session stream store (`chat/headless/streams/`), which
- * folds every transcript with it.
- */
-export { applyLiveEvent, closeThinkingSegment, finishLive } from '../chat/headless/streams/live-events';

package/src/adapters/live.ts

@@ -1,230 +0,0 @@
-/**
- * The client half of zidane's live transcript, shared by every adapter: the
- * stores a `ChatHost` exposes (session list, transcripts, pending
- * interactions), fed by live events folded with `applyLiveEvent`
- * (`live-events.ts`, zidane's merge rule).
- *
- * The transcripts live in the session stream store (`SessionStreamStore`,
- * `chat/headless/streams/`), the one the desktop app runs on: events fold
- * and prompt echoes dedupe there. This module is a facade that keeps the
- * adapters' own rules on top of it, because they differ from the desktop
- * app's signal rules: a hydrate replaces the window wholesale and forgets
- * pending echoes (the store reconciles a page with the live window),
- * notifications go out at once (the store batches transcript events per
- * frame), a run's end neither appends an error row nor drops pending echoes,
- * and long messages split at the reducer's default size.
- */
-import type { InteractionRequest } from 'zidane/chat';
-
-import type {
-  ChatAttachment,
-  ChatEvent,
-  ChatInteraction,
-  ChatSession,
-  ChatSessionStatus,
-  Transcript,
-  TranscriptState,
-} from '../chat/headless/host';
-import { writable, type Readable, type Writable } from '../chat/headless/store';
-import { applyLiveEvent, finishLive } from '../chat/headless/streams/live-events';
-import { SessionStreamStore } from '../chat/headless/streams/store';
-import { transcriptSnapshot } from '../chat/headless/streams/transcript';
-
-export { applyLiveEvent, finishLive };
-
-/** One session's live transcript: its state store and the echo bookkeeping. */
-export interface LiveTranscript {
-  /** The session's transcript state, updated as events arrive. */
-  state: Writable<TranscriptState>;
-  /** Prompts this client echoed itself, waiting for the host's echo to drop (the store's pending-echo list). */
-  echoes: string[];
-}
-
-/** The client half of the live transcript: the stores a {@link ChatHost} exposes, fed by live events. Shared by every adapter. */
-export interface LiveState {
-  /** The session list store. */
-  sessions: Writable<readonly ChatSession[]>;
-  /** Created on first use; `onOpen` runs then (an adapter starts its stream there). */
-  transcript(sessionId: string): LiveTranscript;
-  /** The `Transcript` a host hands the components, with `onFirstSubscribe` / `onLastUnsubscribe` hooks. */
-  readable(sessionId: string, extra?: Pick<Transcript, 'loadEarlier'>): Transcript;
-  /** Replaces a session's events with a loaded history and marks it hydrated. `patch` sets other transcript state fields, such as `running`. */
-  hydrate(sessionId: string, events: readonly ChatEvent[], patch?: Partial<TranscriptState>): void;
-  /** A live event from the agent; `echo` marks the host repeating a prompt (dropped when this client echoed it). */
-  apply(sessionId: string, event: ChatEvent, echo?: boolean): void;
-  /** Show the user's prompt at once (with its attachment previews); the host's echo of it is then dropped. */
-  echoPrompt(sessionId: string, text: string, attachments?: readonly ChatAttachment[]): void;
-  /** A run started or ended; the session's status follows (`status` overrides: `'error'`, `'idle'` after an interrupt). */
-  setRunning(sessionId: string, running: boolean, status?: ChatSessionStatus): void;
-  /** Merges fields into a session in the list. A session the list does not hold is ignored. */
-  patchSession(sessionId: string, patch: Partial<ChatSession>): void;
-  /** The store of a session's pending interactions. */
-  pending(sessionId: string): Writable<readonly ChatInteraction[]>;
-  /** Every session's pending interactions, in arrival order. */
-  allPending: Readable<readonly ChatInteraction[]>;
-  /** Adds a pending request to a session. A request already pending is ignored. */
-  addInteraction(sessionId: string, request: InteractionRequest): void;
-  /** Removes a request from the pending interactions of every session. */
-  resolveInteraction(requestId: string): void;
-  /** The session a pending request belongs to. */
-  interactionSession(requestId: string): string | undefined;
-}
-
-/** Options for {@link createLiveState}. */
-export interface LiveStateOptions {
-  /** The sessions the list starts with. Default: none. */
-  sessions?: readonly ChatSession[];
-  /** Called with the session id when the first subscriber of its transcript arrives. An adapter starts the session's stream here. */
-  onOpen?: (sessionId: string) => void;
-  /** Called with the session id when the last subscriber of its transcript leaves. An adapter stops the session's stream here. */
-  onClose?: (sessionId: string) => void;
-}
-
-/**
- * Creates the stores a {@link ChatHost} exposes: the session list, per-session transcripts, and pending interactions.
- *
- * @param options - The initial sessions and the transcript open and close hooks.
- */
-export function createLiveState(options: LiveStateOptions = {}): LiveState {
-  const sessions = writable<readonly ChatSession[]>(options.sessions ?? []);
-  // Unbatched, and the reducer's default markdown split: see the module comment.
-  const store = new SessionStreamStore({ batch: false, markdown: {} });
-  const transcripts = new Map<string, LiveTranscript>();
-  const pendings = new Map<string, Writable<readonly ChatInteraction[]>>();
-  const allPending = writable<readonly ChatInteraction[]>([]);
-  const readables = new Map<string, Transcript>();
-
-  const transcript = (sessionId: string) => {
-    let t = transcripts.get(sessionId);
-    if (!t) {
-      t = {
-        state: transcriptState(store, sessionId),
-        get echoes() {
-          return store.pendingEchoes(sessionId);
-        },
-        set echoes(next) {
-          const echoes = store.pendingEchoes(sessionId);
-          echoes.splice(0, echoes.length, ...next);
-        },
-      };
-      transcripts.set(sessionId, t);
-    }
-    return t;
-  };
-  const pending = (sessionId: string) => {
-    let p = pendings.get(sessionId);
-    if (!p) {
-      p = writable<readonly ChatInteraction[]>([]);
-      pendings.set(sessionId, p);
-    }
-    return p;
-  };
-  const patchSession = (sessionId: string, patch: Partial<ChatSession>) =>
-    sessions.set((all) =>
-      all.some((s) => s.id === sessionId) ? all.map((s) => (s.id === sessionId ? { ...s, ...patch } : s)) : all,
-    );
-
-  return {
-    sessions,
-    transcript,
-    readable(sessionId, extra) {
-      let r = readables.get(sessionId);
-      if (r) return r;
-      const { state } = transcript(sessionId);
-      let subscribers = 0;
-      const store: Readable<TranscriptState> = {
-        get: state.get,
-        subscribe(onChange) {
-          const off = state.subscribe(onChange);
-          if (subscribers++ === 0) options.onOpen?.(sessionId);
-          let done = false;
-          return () => {
-            if (done) return;
-            done = true;
-            off();
-            if (--subscribers === 0) options.onClose?.(sessionId);
-          };
-        },
-      };
-      r = { ...store, ...(extra?.loadEarlier ? { loadEarlier: extra.loadEarlier } : {}) };
-      readables.set(sessionId, r);
-      return r;
-    },
-    hydrate(sessionId, events, patch) {
-      const t = transcript(sessionId);
-      t.echoes = [];
-      t.state.set((s) => ({ ...s, ...patch, events: [...events], hydrated: true }));
-    },
-    apply(sessionId, event, echo) {
-      transcript(sessionId);
-      // An echo this client is waiting for is consumed; anything else folds with `applyLiveEvent`.
-      store.applySignal({ kind: 'event', sessionId, event, ...(echo ? { echo } : {}) });
-    },
-    echoPrompt(sessionId, text, attachments) {
-      transcript(sessionId);
-      store.appendUserPrompt(sessionId, text, undefined, attachments ?? []);
-    },
-    setRunning(sessionId, running, status) {
-      const t = transcript(sessionId);
-      t.state.set((s) =>
-        s.running === running ? s : { ...s, running, events: running ? s.events : finishLive(s.events) },
-      );
-      patchSession(sessionId, { status: status ?? (running ? 'running' : 'completed'), updatedAt: Date.now() });
-    },
-    patchSession,
-    pending,
-    allPending,
-    addInteraction(sessionId, request) {
-      if (allPending.get().some((i) => i.requestId === request.id)) return;
-      const item = { requestId: request.id, sessionId, request };
-      pending(sessionId).set((all) => [...all, item]);
-      allPending.set((all) => [...all, item]);
-    },
-    resolveInteraction(requestId) {
-      for (const p of pendings.values()) {
-        if (p.get().some((i) => i.requestId === requestId))
-          p.set((all) => all.filter((i) => i.requestId !== requestId));
-      }
-      if (allPending.get().some((i) => i.requestId === requestId))
-        allPending.set((all) => all.filter((i) => i.requestId !== requestId));
-    },
-    interactionSession(requestId) {
-      for (const p of pendings.values()) {
-        const hit = p.get().find((i) => i.requestId === requestId);
-        if (hit) return hit.sessionId;
-      }
-      return undefined;
-    },
-  };
-}
-
-/**
- * A session's transcript state as a writable store over the session stream
- * store: reads are the store's snapshots, a write sets the events, the run
- * flag and the page state (`hydrated`, `hasEarlier`, `loadingEarlier`) in
- * one notification.
- */
-function transcriptState(store: SessionStreamStore, sessionId: string): Writable<TranscriptState> {
-  let last: TranscriptState | undefined;
-  const get = () => (last = transcriptSnapshot(store, sessionId, last));
-  return {
-    get,
-    set(next) {
-      const prev = get();
-      const resolved = typeof next === 'function' ? next(prev) : next;
-      if (Object.is(resolved, prev)) return;
-      store.write(sessionId, {
-        ...(resolved.events !== prev.events ? { events: resolved.events } : {}),
-        running: resolved.running,
-        page: resolved.hydrated
-          ? {
-              firstSeq: store.getPageSnapshot(sessionId).firstSeq,
-              hasMore: resolved.hasEarlier ?? false,
-              loadingEarlier: resolved.loadingEarlier ?? false,
-            }
-          : null,
-      });
-    },
-    subscribe: (onChange) => store.subscribeSession(sessionId, onChange),
-  };
-}

package/src/adapters/run-host.ts

@@ -1,238 +0,0 @@
-/**
- * A `ChatHost` around a run function you supply: the kit keeps the sessions,
- * transcripts and pending interactions in memory, you run the agent.
- *
- * `run` is called once per sent prompt. It streams the reply with `emit`,
- * using zidane's live event rule (see `live.ts`): `{ kind: 'markdown', text:
- * delta, streaming: true }` and `{ kind: 'thinking', text: delta }` grow the
- * open block, any other `StreamEvent` (`tool`, `tool-result`, `error`, …) is
- * a row of its own. It raises a question or a plan with `ask` and gets the
- * answer back (`null`: dismissed or interrupted). It watches `signal` for an
- * interrupt. Wiring a real zidane agent into `run` is the app's job, which
- * keeps this module free of the zidane runtime (it runs in a page or a Web
- * Worker). The user's prompt is echoed by the host; `run` does not emit it.
- */
-import type { InteractionRequest, InteractionResponse } from 'zidane/chat';
-
-import type {
-  ChatAttachment,
-  ChatEvent,
-  ChatHost,
-  ChatModelProvider,
-  ChatSession,
-  SendInput,
-} from '../chat/headless/host';
-import { constant, type Readable } from '../chat/headless/store';
-import { createLiveState } from './live';
-
-/** What {@link createRunHost} hands to the `run` function for one sent prompt. */
-export interface RunContext {
-  /** Id of the session the prompt was sent to. */
-  sessionId: string;
-  /** The prompt text. */
-  prompt: string;
-  /** Files sent with the prompt. Empty when there are none. */
-  attachments: readonly ChatAttachment[];
-  /** The model the user picked, as `provider/model` or a bare id. Absent when none was picked. */
-  model?: string;
-  /** The reasoning effort the user picked. Absent when none was picked. */
-  thinking?: SendInput['thinking'];
-  /** Aborted on interrupt. */
-  signal: AbortSignal;
-  /** Streams an event into the session's transcript. Markdown and thinking events with `streaming` grow the open block; any other event is a new row. */
-  emit(event: ChatEvent): void;
-  /** Ask the user; resolves with the answer, or `null` when dismissed or interrupted. */
-  ask(request: InteractionRequest): Promise<InteractionResponse | null>;
-  /** Receive messages the user steers into this run. Without a listener, `steer` reports false. */
-  onSteer(listener: (message: string) => void): void;
-}
-
-/** Runs the agent for one prompt. Called once per sent prompt with a {@link RunContext}. The run ends when the returned promise settles; a rejection shows as an error row. */
-export type RunFn = (context: RunContext) => void | Promise<void>;
-
-/** Options for {@link createRunHost}. */
-export interface RunHostOptions {
-  /** The function that runs the agent for each sent prompt. */
-  run: RunFn;
-  /** Sessions to start with (default: none; the user creates them). */
-  sessions?: readonly ChatSession[];
-  /** Their existing events, per session id. */
-  transcripts?: Record<string, readonly ChatEvent[]>;
-  /** Providers and models the host offers, fixed or live (a model's details change). Default: none. */
-  models?: readonly ChatModelProvider[] | Readable<readonly ChatModelProvider[]>;
-  /** New session ids (default: `crypto.randomUUID()`). */
-  newId?: () => string;
-}
-
-/** The {@link ChatHost} {@link createRunHost} returns, plus what only an in-memory host can do. */
-export interface RunHost extends ChatHost {
-  /**
-   * Adds a session with a history, as a new session first in the list (a saved or shared one). Its events show as they are; the agent's own memory of them is the app's concern.
-   *
-   * @param session - The session's title.
-   * @param events - Its transcript events, oldest first.
-   */
-  restore(session: { title: string }, events: readonly ChatEvent[]): ChatSession;
-}
-
-interface ActiveRun {
-  controller: AbortController;
-  steer?: (message: string) => void;
-  queued: SendInput[];
-}
-
-/**
- * Creates a {@link ChatHost} around a run function. Sessions, transcripts, and pending interactions live in memory; the app supplies the agent through `run`.
- *
- * @param options - The `run` function and optional initial sessions, transcripts, and models.
- */
-export function createRunHost(options: RunHostOptions): RunHost {
-  const state = createLiveState({ sessions: options.sessions ?? [] });
-  for (const s of options.sessions ?? []) state.hydrate(s.id, options.transcripts?.[s.id] ?? []);
-  const runs = new Map<string, ActiveRun>();
-  const waiters = new Map<string, (response: InteractionResponse | null) => void>();
-  const newId = options.newId ?? (() => crypto.randomUUID());
-
-  const settle = (requestId: string, response: InteractionResponse | null) => {
-    state.resolveInteraction(requestId);
-    const waiter = waiters.get(requestId);
-    waiters.delete(requestId);
-    waiter?.(response);
-  };
-
-  const send = async (input: SendInput): Promise<void> => {
-    const { sessionId } = input;
-    if (runs.has(sessionId)) {
-      // A run is in flight: the prompt waits for it, as a follow-up.
-      runs.get(sessionId)!.queued.push(input);
-      return;
-    }
-    const t = state.transcript(sessionId);
-    if (!t.state.get().hydrated) state.hydrate(sessionId, []);
-    const active: ActiveRun = { controller: new AbortController(), queued: [] };
-    runs.set(sessionId, active);
-    state.echoPrompt(sessionId, input.prompt, input.attachments);
-    state.setRunning(sessionId, true);
-    const live = () => runs.get(sessionId) === active;
-    const asked = new Set<string>();
-    let failed = false;
-    try {
-      await options.run({
-        sessionId,
-        prompt: input.prompt,
-        attachments: input.attachments ?? [],
-        ...(input.model ? { model: input.model } : {}),
-        ...(input.thinking ? { thinking: input.thinking } : {}),
-        signal: active.controller.signal,
-        emit(event) {
-          if (live()) state.apply(sessionId, event);
-        },
-        ask(request) {
-          if (!live()) return Promise.resolve(null);
-          asked.add(request.id);
-          return new Promise((resolve) => {
-            waiters.set(request.id, resolve);
-            state.addInteraction(sessionId, request);
-          });
-        },
-        onSteer(listener) {
-          active.steer = listener;
-        },
-      });
-    } catch (error) {
-      if (live() && !active.controller.signal.aborted) {
-        failed = true;
-        state.apply(sessionId, { kind: 'error', text: error instanceof Error ? error.message : String(error) });
-      }
-    }
-    for (const id of asked) if (waiters.has(id)) settle(id, null);
-    if (!live()) return;
-    runs.delete(sessionId);
-    state.setRunning(sessionId, false, failed ? 'error' : 'completed');
-    const next = active.queued.shift();
-    if (next !== undefined) {
-      // The rest of the queue moves to the run `next` starts (registered synchronously).
-      const started = send(next);
-      runs.get(sessionId)?.queued.push(...active.queued);
-      await started;
-    }
-  };
-
-  const host: RunHost = {
-    restore({ title }, events) {
-      const now = Date.now();
-      const session: ChatSession = { id: newId(), title, status: 'idle', createdAt: now, updatedAt: now };
-      state.sessions.set((all) => [session, ...all]);
-      state.hydrate(session.id, events);
-      return session;
-    },
-    sessions: {
-      list: state.sessions,
-      async create(input) {
-        const now = Date.now();
-        const session: ChatSession = {
-          id: newId(),
-          title: input?.title ?? 'New session',
-          status: 'idle',
-          createdAt: now,
-          updatedAt: now,
-        };
-        state.sessions.set((all) => [session, ...all]);
-        state.hydrate(session.id, []);
-        return session;
-      },
-      async rename(sessionId, title) {
-        state.patchSession(sessionId, { title, updatedAt: Date.now() });
-      },
-      async setArchived(sessionId, archived) {
-        state.patchSession(sessionId, { archived });
-      },
-      async remove(sessionId) {
-        host.interrupt!(sessionId);
-        state.sessions.set((all) => all.filter((s) => s.id !== sessionId));
-      },
-    },
-    transcript: (sessionId) => {
-      const t = state.transcript(sessionId);
-      if (!t.state.get().hydrated) state.hydrate(sessionId, []);
-      return state.readable(sessionId);
-    },
-    send,
-    interrupt(sessionId) {
-      const active = runs.get(sessionId);
-      if (!active) return;
-      runs.delete(sessionId);
-      active.controller.abort();
-      for (const i of state.pending(sessionId).get()) settle(i.requestId, null);
-      state.setRunning(sessionId, false, 'idle');
-    },
-    async steer(sessionId, message) {
-      const active = runs.get(sessionId);
-      if (!active?.steer) return false;
-      state.apply(sessionId, { kind: 'user-prompt', text: message });
-      active.steer(message);
-      return true;
-    },
-    async followUp(sessionId, message) {
-      const active = runs.get(sessionId);
-      if (!active) return false;
-      active.queued.push({ sessionId, prompt: message });
-      return true;
-    },
-    interactions: {
-      pending: state.pending,
-      async answer(requestId, response) {
-        settle(requestId, response);
-      },
-      async cancel(requestId) {
-        settle(requestId, null);
-      },
-    },
-    models: isReadable(options.models) ? options.models : constant(options.models ?? []),
-  };
-  return host;
-}
-
-function isReadable<T>(value: T | Readable<T> | undefined): value is Readable<T> {
-  return typeof value === 'object' && value !== null && typeof (value as Readable<T>).subscribe === 'function';
-}