talon-agent 3.33.3 → 3.34.0

package/src/frontend/native/routes/host.ts

@@ -0,0 +1,151 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type {
+  BackendOption,
+  BridgeEvent,
+  BridgeStatus,
+  ClientChat,
+  ClientMessage,
+  DeviceInfo,
+  DeviceLocation,
+  LogEntry,
+  LogLevel,
+  ModelOption,
+  PluginItem,
+  SearchResult,
+  SkillItem,
+  ToggleResult,
+} from "../protocol.js";
+import type { ConfigSnapshot } from "../settings.js";
+
+/** Optional attachment references carried alongside a sent message. */
+type SendOptions = {
+  /** Relative bridge path to render inline (e.g. `/media?id=…`). */
+  imagePath?: string;
+  /** Absolute on-disk path handed to the model so it can read the file. */
+  attachmentPath?: string;
+};
+
+/** Everything the transport needs the frontend to implement. */
+export type BridgeServerHandlers = {
+  status(): BridgeStatus;
+  listChats(): ClientChat[];
+  createChat(title?: string): ClientChat;
+  renameChat(id: string, title: string): ClientChat | null;
+  deleteChat(id: string): boolean;
+  /** A page of history: newest window, or the window before `before`. */
+  history(
+    id: string,
+    opts?: { before?: number; limit?: number },
+  ): ClientMessage[];
+  /** Full-text search across chats (or one chat when `chatId` is given). */
+  search(query: string, chatId?: string): SearchResult[];
+  /** Fire-and-forget: streams its results back through `broadcast`. */
+  send(id: string, text: string, opts?: SendOptions): void;
+  /** Persist an uploaded image and return its render path + on-disk path. */
+  upload(
+    filename: string,
+    contentType: string,
+    bytes: Buffer,
+  ): Promise<{ imagePath: string; path: string }>;
+  listModels(
+    id?: string,
+  ):
+    | { active: string; models: ModelOption[] }
+    | Promise<{ active: string; models: ModelOption[] }>;
+  setModel(id: string, model: string): void;
+  /** Backends selectable for a chat + the chat's active backend id. */
+  listBackends(id: string): { active: string; backends: BackendOption[] };
+  /** Switch a chat to another backend; returns ok + an optional error. */
+  setBackend(
+    id: string,
+    backend: string,
+  ): Promise<{ ok: boolean; error?: string }>;
+  setEffort(id: string, effort: string): void;
+  effortLevels(id: string): Promise<{ active: string; levels: string[] }>;
+  resetChat(id: string): boolean;
+  /** Best-effort interrupt of a chat's in-flight turn. `true` if one was
+   *  running and got signalled. */
+  interruptTurn(id: string): Promise<boolean>;
+  setPulse(id: string, on: boolean): void;
+  /** Set/replace/clear the chat's queued follow-up (empty text clears). */
+  queueMessage(id: string, text: string): void;
+  /** Read the daemon's own (allowlisted) settings + health. */
+  getConfig(): ConfigSnapshot;
+  /** Change daemon settings; returns the fresh snapshot. */
+  setConfig(update: Record<string, unknown>): ConfigSnapshot;
+  /** Installed plugins (built-ins + configured entries) with state. */
+  listPlugins(): PluginItem[];
+  /** Enable/disable a plugin; persists + hot-reloads. */
+  setPluginEnabled(name: string, enabled: boolean): Promise<ToggleResult>;
+  /** Installed skills with state. */
+  listSkills(): SkillItem[];
+  /** Enable/disable a skill; rebuilds the prompt index. */
+  setSkillEnabled(name: string, enabled: boolean): ToggleResult;
+  /** Fire a daemon-level control action (e.g. "restart", "dream"). */
+  control(action: string): Promise<{ ok: boolean; message: string }>;
+  /** Newest daemon log entries (for the client's log viewer). */
+  logs(opts: {
+    lines: number;
+    minLevel?: LogLevel;
+    component?: string;
+  }): LogEntry[];
+  /** Events reconstructing any in-progress turns, for a just-connected client. */
+  liveTurnEvents(): BridgeEvent[];
+  /** Resolve a media id to an absolute file path (or null if unknown). */
+  mediaPath(id: string): string | null;
+  /** Register/update one mesh device. */
+  registerDevice(body: Record<string, unknown>): Promise<DeviceInfo>;
+  /** Store the last-known location for one mesh device. */
+  storeLocation(body: Record<string, unknown>): Promise<DeviceLocation>;
+  /** List mesh devices and their last-known locations. */
+  listDevices():
+    | { devices: DeviceInfo[]; locations: DeviceLocation[] }
+    | Promise<{ devices: DeviceInfo[]; locations: DeviceLocation[] }>;
+  /** A device answered a device_command; true when a call was waiting. */
+  completeCommand(body: Record<string, unknown>): boolean;
+  /** A device streams a pull-transfer's file body up (raw request body).
+   *  `fromDeviceId` is the caller's claimed identity, when it sent one. */
+  acceptFileUpload(
+    token: string,
+    body: IncomingMessage,
+    fromDeviceId?: string,
+  ): Promise<{ ok: true; bytes: number } | { ok: false; error: string }>;
+  /** Resolve a push-transfer token to the file to stream down, or null. */
+  openFileDownload(
+    token: string,
+    fromDeviceId?: string,
+  ): Promise<{ path: string; size: number } | null>;
+  /** Resolve a companion-pairing grant to its page/payload, or null. */
+  openCompanionPair(
+    token: string,
+    format: "html" | "json",
+  ): { contentType: string; body: string } | null;
+  /** Resolve a node-provisioning token to its installer script, or null. */
+  openNodeInstall(token: string): { script: string; filename: string } | null;
+  /** Resolve a node-provisioning token to the binary to stream, or null. */
+  openNodeBinary(token: string): { path: string; size: number } | null;
+};
+
+/**
+ * What a route handler may do with the server that owns it. Built once
+ * by BridgeServer as bound closures, so the route modules never see the
+ * class — only this surface.
+ */
+export type RouteHost = {
+  handlers: BridgeServerHandlers;
+  opts: { host: string; token?: string; startedAt: string };
+  port: () => number;
+  scheme: () => "http" | "https";
+  fingerprint: () => string | null;
+  json: (res: ServerResponse, code: number, body: unknown) => void;
+  readJson: (req: IncomingMessage) => Promise<Record<string, unknown>>;
+  readRaw: (req: IncomingMessage, max: number) => Promise<Buffer>;
+  corsHeaders: () => Record<string, string>;
+  streamFile: (
+    res: ServerResponse,
+    file: { path: string; size: number },
+  ) => void;
+  serveMedia: (res: ServerResponse, id: string) => Promise<void>;
+  openStream: (res: ServerResponse, deviceId?: string) => void;
+  unknownProvision: (res: ServerResponse) => void;
+};

package/src/frontend/native/routes/index.ts

@@ -0,0 +1,22 @@
+/**
+ * One handler per BRIDGE_ROUTE_AUTH key, assembled from the route groups.
+ * The return type makes the object exhaustive: a route declared in the
+ * table without a handler here, or vice versa, does not compile.
+ */
+import type { RouteHost } from "./host.js";
+import type { BridgeRoutes } from "./table.js";
+import { preAuthRoutes } from "./pre-auth.js";
+import { chatRoutes } from "./chats.js";
+import { modelRoutes } from "./models.js";
+import { daemonRoutes } from "./daemon.js";
+import { meshRoutes } from "./mesh.js";
+
+export function buildRoutes(host: RouteHost): BridgeRoutes {
+  return {
+    ...preAuthRoutes(host),
+    ...chatRoutes(host),
+    ...modelRoutes(host),
+    ...daemonRoutes(host),
+    ...meshRoutes(host),
+  };
+}

package/src/frontend/native/routes/mesh.ts

@@ -0,0 +1,72 @@
+import type { RouteHost } from "./host.js";
+import type { BridgeRoutes } from "./table.js";
+import type { ServerResponse } from "node:http";
+import { deviceIdParam } from "./params.js";
+
+// Streamed device file transfers (see core/mesh/transfers.ts). The
+// one-time `transfer` token authorizes exactly one direction+path; the
+// caller names itself so the token's device binding can be checked.
+function transferToken(
+  host: RouteHost,
+  url: URL,
+  res: ServerResponse,
+): string | null {
+  const token = url.searchParams.get("transfer") ?? "";
+  if (!token) {
+    host.json(res, 400, { ok: false, error: "transfer required" });
+    return null;
+  }
+  return token;
+}
+
+export function meshRoutes(
+  host: RouteHost,
+): Pick<
+  BridgeRoutes,
+  | "POST /devices/register"
+  | "POST /location"
+  | "GET /devices"
+  | "POST /devices/command-result"
+  | "POST /devices/file"
+  | "GET /devices/file"
+> {
+  const { json, readJson, handlers: h } = host;
+  return {
+    // ── Mesh ───────────────────────────────────────────────────────────
+
+    "POST /devices/register": async ({ req, res }) => {
+      const body = await readJson(req);
+      const device = await h.registerDevice(body);
+      json(res, 200, { ok: true, deviceId: device.id });
+    },
+    "POST /location": async ({ req, res }) => {
+      const body = await readJson(req);
+      await h.storeLocation(body);
+      json(res, 200, { ok: true });
+    },
+    "GET /devices": async ({ res }) => json(res, 200, await h.listDevices()),
+    "POST /devices/command-result": async ({ req, res }) => {
+      const body = await readJson(req);
+      // ok:false for a late/unknown correlation id — not an HTTP error,
+      // the device's POST was well-formed; nothing was waiting anymore.
+      json(res, 200, { ok: h.completeCommand(body) });
+    },
+    "POST /devices/file": async ({ req, res, url }) => {
+      const token = transferToken(host, url, res);
+      if (token === null) return;
+      const result = await h.acceptFileUpload(token, req, deviceIdParam(url));
+      json(res, result.ok ? 200 : 409, result);
+    },
+    "GET /devices/file": async ({ res, url }) => {
+      const token = transferToken(host, url, res);
+      if (token === null) return;
+      const file = await h.openFileDownload(token, deviceIdParam(url));
+      if (!file)
+        return json(res, 404, {
+          ok: false,
+          error: "Unknown or already-used transfer token",
+        });
+      host.streamFile(res, file);
+    },
+  };
+}

package/src/frontend/native/routes/models.ts

@@ -0,0 +1,54 @@
+import type { RouteHost } from "./host.js";
+import type { BridgeRoutes } from "./table.js";
+import { asString } from "./params.js";
+
+export function modelRoutes(
+  host: RouteHost,
+): Pick<
+  BridgeRoutes,
+  | "GET /models"
+  | "POST /model"
+  | "GET /backends"
+  | "POST /backend"
+  | "GET /effort"
+  | "POST /effort"
+> {
+  const { json, readJson, handlers: h } = host;
+  return {
+    // ── Models / backends / effort ─────────────────────────────────────
+
+    "GET /models": async ({ res, url }) => {
+      const id = url.searchParams.get("chatId") ?? undefined;
+      json(res, 200, await h.listModels(id));
+    },
+    "POST /model": async ({ req, res }) => {
+      const body = await readJson(req);
+      h.setModel(asString(body.chatId) ?? "", asString(body.model) ?? "");
+      json(res, 200, { ok: true });
+    },
+    "GET /backends": ({ res, url }) =>
+      json(res, 200, h.listBackends(url.searchParams.get("chatId") ?? "")),
+    "POST /backend": async ({ req, res }) => {
+      const body = await readJson(req);
+      // Always 200: ok/error is an application result the client renders,
+      // not an HTTP-level failure (the client's decoder drops >=400
+      // bodies).
+      const result = await h.setBackend(
+        asString(body.chatId) ?? "",
+        asString(body.backend) ?? "",
+      );
+      json(res, 200, result);
+    },
+    "GET /effort": async ({ res, url }) =>
+      json(
+        res,
+        200,
+        await h.effortLevels(url.searchParams.get("chatId") ?? ""),
+      ),
+    "POST /effort": async ({ req, res }) => {
+      const body = await readJson(req);
+      h.setEffort(asString(body.chatId) ?? "", asString(body.effort) ?? "");
+      json(res, 200, { ok: true });
+    },
+  };
+}

package/src/frontend/native/routes/params.ts

@@ -0,0 +1,29 @@
+/** Query/body coercions shared by the bridge's route handlers. */
+
+/**
+ * Longest device id a client may claim (`?deviceId=…`). Matches the
+ * registry's own id cap — a longer id can never name a real device, and the
+ * claim is held for the life of a connection, so it stays a bounded key.
+ */
+const MAX_DEVICE_ID_CHARS = 128;
+
+export function asString(v: unknown): string | undefined {
+  return typeof v === "string" ? v : undefined;
+}
+
+/**
+ * The `deviceId` a mesh client claims on `/events` and `/devices/file`.
+ * Undefined when absent or blank — every consumer treats "no claim" as the
+ * legacy case, so an empty string must never look like a claimed id.
+ */
+export function deviceIdParam(url: URL): string | undefined {
+  const raw = (url.searchParams.get("deviceId") ?? "").trim();
+  return raw ? raw.slice(0, MAX_DEVICE_ID_CHARS) : undefined;
+}
+
+/** Parse a positive-integer query param; undefined when absent/invalid. */
+export function asPositiveInt(v: string | null): number | undefined {
+  if (!v) return undefined;
+  const n = Number(v);
+  return Number.isInteger(n) && n > 0 ? n : undefined;
+}

package/src/frontend/native/routes/pre-auth.ts

@@ -0,0 +1,94 @@
+import type { RouteHost } from "./host.js";
+import type { BridgeRoutes } from "./table.js";
+import { BRIDGE_PROTOCOL_VERSION } from "../protocol.js";
+
+export function preAuthRoutes(
+  host: RouteHost,
+): Pick<
+  BridgeRoutes,
+  "GET /health" | "GET /pair" | "GET /node/install" | "GET /node/binary"
+> {
+  const { json, handlers: h } = host;
+  return {
+    // ── Pre-auth ───────────────────────────────────────────────────────
+
+    // Unauthenticated so clients can discover/ping the bridge before they
+    // hold a token. Pre-auth it serves only what pairing needs (identity,
+    // protocol, fingerprint) — operational details like bot name,
+    // backend, and chat count are not for internet scanners to enumerate.
+    "GET /health": ({ res, auth }) => {
+      const base = {
+        app: "talon-bridge",
+        ok: true,
+        protocol: BRIDGE_PROTOCOL_VERSION,
+        port: host.port(),
+        scheme: host.scheme(),
+        // The certificate's own hash — public by definition (any TLS
+        // client sees the certificate), surfaced so pairing UIs can
+        // display it.
+        fingerprint: host.fingerprint(),
+        authRequired: Boolean(host.opts.token),
+      };
+      if (auth !== "ok") return json(res, 200, base);
+      const s = h.status();
+      return json(res, 200, {
+        ...base,
+        host: host.opts.host,
+        startedAt: host.opts.startedAt,
+        botName: s.botName,
+        backend: s.backend,
+        model: s.model,
+        activeChats: s.activeChats,
+        capabilities: ["mesh", "mesh-commands", "mesh-file-stream"],
+      });
+    },
+
+    // Companion pairing: the phone holds no bridge credential yet, and
+    // the single-use grant is what it comes to collect. Serving the page
+    // IS the handover, so the grant is spent whichever leg is hit.
+    "GET /pair": ({ req, res, url }) => {
+      const token = url.searchParams.get("grant") ?? "";
+      const wantsJson =
+        url.searchParams.get("format") === "json" ||
+        (req.headers.accept ?? "").includes("application/json");
+      const served = token
+        ? h.openCompanionPair(token, wantsJson ? "json" : "html")
+        : null;
+      if (!served) {
+        return json(res, 404, {
+          ok: false,
+          error: "Unknown, expired, or already-used pairing link",
+        });
+      }
+      res.writeHead(200, {
+        "Content-Type": served.contentType,
+        // A pairing payload is a credential; nothing may keep a copy.
+        "Cache-Control": "no-store",
+        ...host.corsHeaders(),
+      });
+      res.end(served.body);
+    },
+
+    // Node provisioning: the target host holds no bridge credential yet —
+    // the single-use grant token (minted by make_node_install_link,
+    // expiring, one serve per leg) is the entire authorization, the same
+    // trust model as streamed-transfer tokens.
+    "GET /node/install": ({ res, url }) => {
+      const token = url.searchParams.get("provision") ?? "";
+      const install = token ? h.openNodeInstall(token) : null;
+      if (!install) return host.unknownProvision(res);
+      res.writeHead(200, {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Content-Disposition": `attachment; filename="${install.filename}"`,
+        ...host.corsHeaders(),
+      });
+      res.end(install.script);
+    },
+    "GET /node/binary": ({ res, url }) => {
+      const token = url.searchParams.get("provision") ?? "";
+      const binary = token ? h.openNodeBinary(token) : null;
+      if (!binary) return host.unknownProvision(res);
+      host.streamFile(res, binary);
+    },
+  };
+}

package/src/frontend/native/routes/table.ts

@@ -0,0 +1,92 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+/**
+ * ok: request carries the right token (or none is required).
+ * anonymous: no credential presented — a pre-pairing probe, not an attack.
+ * bad: a credential was presented and it is wrong.
+ */
+export type AuthState = "ok" | "anonymous" | "bad";
+
+/**
+ * "public": served without a bearer token. Every entry is gated some other
+ * way — a single-use grant minted by the daemon, or (for /health) by
+ * answering only what pairing needs until a token is presented.
+ * "bearer": the request must carry the bridge token.
+ */
+export type BridgeRouteAuth = "public" | "bearer";
+
+/**
+ * The bridge's routes and the auth tier of each — declared once, here,
+ * rather than implied by where an `if` sits relative to the auth check.
+ * The security posture of the transport is this table: a route is
+ * pre-auth only by appearing in it as "public", and the route test walks
+ * every entry and proves the tier holds on the wire. Adding a route
+ * without an entry is a type error (`buildRoutes` is exhaustive over
+ * these keys); adding one as "public" is a diff a reviewer sees.
+ */
+export const BRIDGE_ROUTE_AUTH = {
+  // Pre-auth by design. /health serves pairing data (identity, protocol,
+  // fingerprint) to anyone and the operational view only to a token
+  // holder. /pair, /node/install and /node/binary hand over a credential
+  // to a device that holds none yet; the single-use grant in the query is
+  // the entire authorization.
+  "GET /health": "public",
+  "GET /pair": "public",
+  "GET /node/install": "public",
+  "GET /node/binary": "public",
+
+  // Everything a client can do once paired.
+  "GET /events": "bearer",
+  "GET /chats": "bearer",
+  "POST /chats": "bearer",
+  "POST /chats/rename": "bearer",
+  "POST /chats/delete": "bearer",
+  "POST /chats/reset": "bearer",
+  "POST /chats/interrupt": "bearer",
+  "POST /chats/pulse": "bearer",
+  "POST /queue": "bearer",
+  "GET /history": "bearer",
+  "GET /search": "bearer",
+  "POST /send": "bearer",
+  "POST /upload": "bearer",
+  "GET /media": "bearer",
+  "GET /models": "bearer",
+  "POST /model": "bearer",
+  "GET /backends": "bearer",
+  "POST /backend": "bearer",
+  "GET /effort": "bearer",
+  "POST /effort": "bearer",
+  "GET /logs": "bearer",
+  "GET /plugins": "bearer",
+  "POST /plugins/toggle": "bearer",
+  "GET /skills": "bearer",
+  "POST /skills/toggle": "bearer",
+  "GET /config": "bearer",
+  "POST /config": "bearer",
+  "POST /control": "bearer",
+
+  // Mesh. The one-time `transfer` token on /devices/file authorizes one
+  // direction+path, but the route still sits behind the bearer like every
+  // device route — the token is a scope, not a credential.
+  "POST /devices/register": "bearer",
+  "POST /location": "bearer",
+  "GET /devices": "bearer",
+  "POST /devices/command-result": "bearer",
+  "POST /devices/file": "bearer",
+  "GET /devices/file": "bearer",
+} as const satisfies Record<string, BridgeRouteAuth>;
+
+export type BridgeRouteKey = keyof typeof BRIDGE_ROUTE_AUTH;
+
+/** What a route handler receives; `auth` is already evaluated. */
+export type RouteContext = {
+  req: IncomingMessage;
+  res: ServerResponse;
+  url: URL;
+  auth: AuthState;
+};
+
+export type RouteHandler = (ctx: RouteContext) => void | Promise<void>;
+
+/** Every route with its handler — exhaustive over BRIDGE_ROUTE_AUTH by construction. */
+export type BridgeRoutes = Record<BridgeRouteKey, RouteHandler>;

package/src/frontend/native/runtime.ts

@@ -0,0 +1,109 @@
+/**
+ * Native frontend runtime — the state every bridge module shares.
+ *
+ * `createNativeFrontend` used to hold all of this as closure variables with
+ * every handler nested inside it. It is now one explicit object, constructed
+ * once, that each module (chat-wire, context, emit, turn, …) takes as its
+ * first parameter. The runtime carries state plus two primitives — the
+ * message-id minter and the broadcast sink; the modules own the behaviour.
+ */
+
+import type { TalonConfig } from "../../util/config.js";
+import type { Gateway } from "../../core/engine/gateway.js";
+import { getMeshService, type MeshService } from "../../core/mesh/index.js";
+import { NativeChats } from "./chats.js";
+import type { BridgeEvent, ClientToolCall, ContextInfo } from "./protocol.js";
+
+/** One tool call observed during a running turn, kept for mid-turn replay. */
+export type LiveToolEntry = {
+  call: ClientToolCall;
+  startedAt: number;
+  done?: boolean;
+};
+
+/** A chat's single queued follow-up, with its attachment paths intact. */
+export type QueuedEntry = {
+  text: string;
+  imagePath?: string;
+  attachmentPath?: string;
+};
+
+export type NativeRuntime = {
+  readonly config: TalonConfig;
+  readonly gateway: Gateway;
+  /** ISO timestamp of frontend construction — surfaced on /health + status. */
+  readonly startedAt: string;
+  readonly botName: string;
+  readonly chats: NativeChats;
+  /**
+   * Daemon-wide mesh service (core/mesh). This frontend is its transport:
+   * companions register/report/answer through the bridge routes, and the
+   * SSE transport (wired in init) pushes locate requests and device commands
+   * out. The model's mesh tools are served by the shared gateway actions, so
+   * they work from every frontend.
+   */
+  readonly mesh: MeshService;
+  /**
+   * Ephemeral registry mapping a short media id → absolute file path, so the
+   * bridge can serve images the bot attaches without exposing raw paths in
+   * the URL. Lives for the process; history rows keep only a text
+   * placeholder, so images render live in-session (mirroring how the chat
+   * frontends behave).
+   */
+  readonly media: Map<string, string>;
+  /**
+   * Live context-window fill per chat, refreshed at the end of each turn.
+   * Cached (not computed inline) so the sync `toClientChat` projection stays
+   * sync — it just reads the last computed value.
+   */
+  readonly contextByChat: Map<string, ContextInfo>;
+  /**
+   * In-progress turns, keyed by chat id, so a client that (re)connects
+   * mid-turn can be replayed the turn's tool activity instead of waiting for
+   * the turn to finish. Holds the same live tool map `runTurn` mutates;
+   * cleared at turn end.
+   */
+  readonly liveTurns: Map<string, Map<string, LiveToolEntry>>;
+  /**
+   * The single queued follow-up per chat, held server-side so every
+   * connected client shares (and can edit/cancel) the same queue. Keeps the
+   * attachment paths so a queued image sends intact when the turn ends.
+   */
+  readonly queuedByChat: Map<string, QueuedEntry>;
+  /**
+   * The most recent assistant message id per chat — turn_end attaches the
+   * turn's meta (tools/stats) to this message so history hydration can show
+   * what the model did after a reload.
+   */
+  readonly lastAssistantId: Map<string, string>;
+  /**
+   * Monotonic message-id minter. Seeded from the wall clock so ids stay
+   * unique and ascending across restarts (history rows persist their ids).
+   */
+  nextId(): number;
+  /** Fan an event out to every connected bridge client. */
+  broadcast(event: BridgeEvent): void;
+};
+
+export function createNativeRuntime(
+  config: TalonConfig,
+  gateway: Gateway,
+  broadcast: (event: BridgeEvent) => void,
+): NativeRuntime {
+  let seq = Date.now();
+  return {
+    config,
+    gateway,
+    startedAt: new Date().toISOString(),
+    botName: config.botDisplayName || "Talon",
+    chats: new NativeChats(),
+    mesh: getMeshService(),
+    media: new Map(),
+    contextByChat: new Map(),
+    liveTurns: new Map(),
+    queuedByChat: new Map(),
+    lastAssistantId: new Map(),
+    nextId: () => ++seq,
+    broadcast,
+  };
+}