@saadnvd1/agent-os 0.3.779 → 0.3.781

package/lib/chat/worker/protocol.ts

@@ -25,6 +25,10 @@ import type { CompactFirst } from "../stale";
 
 export const PROTOCOL_VERSION = 1;
 
+// In a worker's hello caps: it holds a live guest's turns to the host's taps
+// (./guest-gate). Without it no Drive prompt is sent to it.
+export const GUEST_GATE_CAP = "guest-gate";
+
 // Server -> worker. A send carries the id its user item gets, so a send
 // retried after a dropped connection is never run twice.
 export type WorkerCommand =
@@ -37,6 +41,7 @@ export type WorkerCommand =
       from?: string;
       peer?: PeerMessage;
       origin?: ChatOrigin;
+      host?: true;
       // From the composer: waits its turn behind a running one, in the
       // queue, rather than joining it.
       queue?: boolean;
@@ -79,6 +84,12 @@ export type WorkerCommand =
   // (now, if idle) the agent's conversation ends and the next worker
   // starts a new one with today's brief and permissions.
   | { type: "fresh" }
+  // A live share's Drive is over (downgrade, take-back, kick, end): its
+  // queued prompts go, a turn it steers stops, and nothing more from it is
+  // taken in (lib/chat/worker/guest-gate).
+  | { type: "guest_release"; share: string; wheel: string }
+  // The driving guest's Stop: ends a turn their wheel steers, never another.
+  | { type: "guest_stop"; share: string; wheel: string }
   | { type: "close" };
 
 // Worker -> server: what's live right now on connecting, then events.

package/lib/connect/control-api.ts

@@ -482,13 +482,20 @@ export interface LiveShare {
   expires_at: string | null;
   ends_with_session: boolean;
   max_guests: number;
+  /** Connect confirmed it holds an access code for the share. */
+  access_code: boolean;
 }
 
 /** Mints a live link for one session; the answer carries the link, once. */
 export async function createLiveShare(
   config: ConnectConfig,
   privateKey: string,
-  share: { title: string; expiresIn: LiveExpiry; access?: string }
+  share: {
+    title: string;
+    expiresIn: LiveExpiry;
+    access?: string;
+    accessCode?: string;
+  }
 ): Promise<LiveShare> {
   const res = await signed(config, privateKey)(
     "POST",
@@ -497,6 +504,7 @@ export async function createLiveShare(
       title: share.title,
       expires_in: share.expiresIn,
       ...(share.access ? { access: share.access } : {}),
+      ...(share.accessCode ? { access_code: share.accessCode } : {}),
     }
   );
   const r = (await res.json().catch(() => null)) as Record<
@@ -517,5 +525,26 @@ export async function createLiveShare(
     expires_at: typeof r.expires_at === "string" ? r.expires_at : null,
     ends_with_session: r.ends_with_session === true,
     max_guests: typeof r.max_guests === "number" ? r.max_guests : 0,
+    access_code: r.access_code === true,
   };
 }
+
+/** Sets (a code) or clears (null) a live share's access code; Connect must say it did. */
+export async function setLiveAccessCode(
+  config: ConnectConfig,
+  privateKey: string,
+  id: string,
+  code: string | null
+): Promise<void> {
+  if (!/^[a-z0-9]{12}$/.test(id)) throw new Error("not a share id");
+  const res = await signed(config, privateKey)(
+    "PUT",
+    `/api/v1/machines/${config.machineId}/live-shares/${id}/access-code`,
+    { access_code: code }
+  );
+  const r = (await res.json().catch(() => null)) as {
+    access_code?: unknown;
+  } | null;
+  if (r?.access_code !== (code !== null))
+    throw new Error("the Connect service did not confirm the access code");
+}

package/lib/db/migrations/20261030T1300_chat_guest_steers.ts

@@ -0,0 +1,20 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261030T1300_chat_guest_steers",
+  up: (db) => {
+    // A live guest's steer on a chat (lib/chat/worker/guest-gate): kept
+    // here so a worker that restarts mid-Drive still gates its turns.
+    db.exec(
+      `CREATE TABLE IF NOT EXISTS chat_guest_steers (
+         session_id TEXT PRIMARY KEY,
+         share_id TEXT NOT NULL,
+         wheel TEXT NOT NULL,
+         guest_id TEXT NOT NULL,
+         name TEXT NOT NULL,
+         tool_calls INTEGER NOT NULL DEFAULT 0,
+         started_at INTEGER NOT NULL
+       )`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/20261030T1400_chat_guest_steers_ended.ts

@@ -0,0 +1,14 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261030T1400_chat_guest_steers_ended",
+  up: (db) => {
+    // When the steer's Drive ended: a worker that restarts after it has no
+    // guest turn left to gate.
+    const cols = db.prepare(`PRAGMA table_info(chat_guest_steers)`).all() as {
+      name: string;
+    }[];
+    if (!cols.some((c) => c.name === "ended_at"))
+      db.exec(`ALTER TABLE chat_guest_steers ADD COLUMN ended_at INTEGER`);
+  },
+} satisfies Migration;

package/lib/db/migrations/20261031T1200_live_share_access_code.ts

@@ -0,0 +1,14 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261031T1200_live_share_access_code",
+  up: (db) => {
+    const cols = (
+      db.prepare(`PRAGMA table_info(live_shares)`).all() as { name: string }[]
+    ).map((c) => c.name);
+    // Null is off. The code is kept in plain text so the host can see it again;
+    // Connect holds only a keyed hash of it.
+    if (!cols.includes("access_code"))
+      db.exec(`ALTER TABLE live_shares ADD COLUMN access_code TEXT`);
+  },
+} satisfies Migration;

package/lib/live/clean.ts

@@ -38,6 +38,12 @@ export function cleanName(input: unknown): string | null {
   return s;
 }
 
+/**
+ * Claude Code reads an `@path` in a message as a file to attach, with no
+ * tool call a gate could stop: a guest's `@` can't be one.
+ */
+export const noMentions = (t: string) => t.replace(/@/g, "\uff20");
+
 /** A block of text (a suggestion): newlines and tabs kept, or null. */
 export function cleanBody(input: unknown, max = MAX_SUGGESTION): string | null {
   if (typeof input !== "string" || !wellFormed(input)) return null;

package/lib/live/code-view.ts

@@ -0,0 +1,56 @@
+import type { LiveCodeView, LiveInvite } from "./types";
+import { displayCode } from "./code";
+import type { Runtime } from "./runtime";
+
+const HINT =
+  "Guests type this before they reach your lobby. You still let each one in.";
+
+const RULES = "6 to 32 letters or digits.";
+
+/** The access code block of a share, with the actions it offers right now. */
+export function codeView(rt: Runtime, now = Date.now()): LiveCodeView {
+  const code = rt.share.access_code;
+  const locked = rt.codeLockedUntil && rt.codeLockedUntil > now;
+  return {
+    on: !!code,
+    display: code ? displayCode(code) : null,
+    copyText: code
+      ? `${rt.share.url}\nAccess code: ${displayCode(code)}`
+      : null,
+    label: "Access code",
+    hint: HINT,
+    notice:
+      code && locked
+        ? `Too many wrong codes. New guests can join again at ${new Date(
+            rt.codeLockedUntil!
+          ).toLocaleTimeString([], {
+            hour: "numeric",
+            minute: "2-digit",
+          })}, or change the code now.`
+        : null,
+    prompt: {
+      title: "Use my own code",
+      message: RULES,
+      placeholder: "Your code",
+    },
+    actions: code
+      ? [
+          { kind: "copy", label: "Copy link and code" },
+          { kind: "copy_link", label: "Copy link" },
+          { kind: "new_code", label: "New code" },
+          { kind: "set_code", label: "Use my own…" },
+          { kind: "code_off", label: "Turn off" },
+        ]
+      : [{ kind: "code_on", label: "Turn on" }],
+  };
+}
+
+export function inviteCode(): LiveInvite["code"] {
+  return {
+    default: false,
+    label: "Require an access code",
+    hint: HINT,
+    customLabel: "Use my own code",
+    rules: RULES,
+  };
+}

package/lib/live/code.ts

@@ -0,0 +1,25 @@
+import crypto from "crypto";
+
+/** The code is never logged, so nothing here prints it. */
+
+/** Six digits, zero-padded so 123 is "000123". */
+export function generateCode(): string {
+  return String(crypto.randomInt(0, 1_000_000)).padStart(6, "0");
+}
+
+/** The shape Connect checks: spaces and dashes dropped, upper-cased. */
+export function normalizeCode(code: string): string {
+  return code.replace(/[\s-]/g, "").toUpperCase();
+}
+
+/** Why a host's own code is refused, or null when it's fine. */
+export function codeRefusal(code: string): string | null {
+  return /^[A-Z0-9]{6,32}$/.test(normalizeCode(code))
+    ? null
+    : "The access code must be 6 to 32 letters or digits.";
+}
+
+/** What the host sees and copies: "482-917" for six digits, else as typed in capitals. */
+export function displayCode(code: string): string {
+  return /^\d{6}$/.test(code) ? `${code.slice(0, 3)}-${code.slice(3)}` : code;
+}

package/lib/live/drive.ts

@@ -0,0 +1,398 @@
+/**
+ * Drive: the one guest holding the wheel on a Drive share can start a turn.
+ * Everything is decided here, on this machine, on every prompt: Connect only
+ * relays, and nothing it sends can give the wheel, change the level or
+ * answer an approval. What such a turn may do without the host's tap is the
+ * worker's guest gate (lib/chat/worker/guest-gate).
+ */
+
+import os from "os";
+import path from "path";
+import { randomBytes } from "crypto";
+import type { Session } from "../db";
+import { getSession, registry } from "../chat/registry";
+import { chatRefusal } from "../chat/hold";
+import { listQueue } from "../chat/queued";
+import { hasItem } from "../chat/store";
+import type { ChatServerMessage } from "../chat/events";
+import {
+  GATE_MISSING,
+  deleteQueuedChat,
+  releaseGuestChat,
+  sendGuestPrompt,
+  stopGuestTurn,
+} from "../chat/runner";
+import { getProject } from "../projects";
+import { cleanBody, noMentions } from "./clean";
+import { admittedGuestIds, hasDrivePrompt, logLive, wheelOf } from "./store";
+import {
+  live,
+  type DrivePrompt,
+  type DriveState,
+  type Runtime,
+} from "./runtime";
+import type { DriverState } from "./types";
+
+export const DRIVE_MAX_CHARS = 4000;
+export const DRIVE_EVERY_MS = 15_000;
+export const DRIVE_PER_HOUR = 40;
+// How long a prompt may be missing from the queue, unstarted, before it
+// counts as removed by the host (the worker takes it off just before it
+// starts it).
+const REMOVED_AFTER_MS = 3000;
+
+export type StopReason =
+  "downgraded" | "taken_back" | "kicked" | "left" | "ended";
+
+const STOPPED: Record<StopReason, string> = {
+  downgraded: "You can now only watch",
+  taken_back: "The host took back control",
+  kicked: "You were removed",
+  left: "You left",
+  ended: "The session ended",
+};
+
+export interface DriveFx {
+  send: (
+    shareId: string,
+    action: string,
+    data?: Record<string, unknown>
+  ) => void;
+}
+
+const home = (p: string) => path.resolve(p.replace(/^~(?=$|\/)/, os.homedir()));
+
+/**
+ * Why guests can't drive this session, or null. Only a task's own chat,
+ * in its own worktree, run by Claude on this machine.
+ */
+export function driveRefusal(s: Session): string | null {
+  if (s.view !== "chat" || s.agent_type !== "claude")
+    return "Claude chat sessions only";
+  if (s.role) return "Not for an orchestrator";
+  if (!s.task_prompt) return "Task sessions only";
+  if (!s.worktree_path) return "Task sessions with their own worktree only";
+  const project = s.project_id ? getProject(s.project_id) : undefined;
+  const wt = home(s.worktree_path);
+  if (home(s.working_directory) !== wt)
+    return "Task sessions with their own worktree only";
+  if (project && home(project.working_directory) === wt)
+    return "Not in the project's main checkout";
+  if (s.archived_at || s.peer_mirror) return "Not for this session";
+  if (s.task_status && s.task_status !== "running")
+    return "Only while the task is running";
+  return chatRefusal(s.id) ? "Not while the task is moving" : null;
+}
+
+export function newDrive(shareId: string): DriveState {
+  return { wheel: wheelOf(shareId), prompts: [], accepted: [], epoch: 0 };
+}
+
+const sessionOf = (rt: Runtime): Session | null => {
+  try {
+    return getSession(rt.share.session_id);
+  } catch {
+    return null;
+  }
+};
+
+// Whether this guest may drive this share right now (not the rate caps).
+function eligibility(rt: Runtime, guestId: string): string | null {
+  if (live.runtimes.get(rt.share.id) !== rt || rt.share.ended_at)
+    return "This live link has ended";
+  if (rt.share.level !== "drive") return "Drive is off for this session";
+  const g = rt.guests.get(guestId);
+  if (
+    rt.drive.wheel?.guestId !== guestId ||
+    g?.status !== "admitted" ||
+    !admittedGuestIds(rt.share.id).has(guestId)
+  )
+    return "You're not driving this session";
+  const s = sessionOf(rt);
+  if (!s) return "This session is gone";
+  if (driveRefusal(s)) return "This session can't be driven";
+  const w = registry.live.get(s.id);
+  if (w && !w.canGuestGate) return GATE_MISSING;
+  return null;
+}
+
+function limits(rt: Runtime, now: number): string | null {
+  const d = rt.drive;
+  if (d.prompts.some((p) => p.status !== "running"))
+    return "Your last prompt hasn't started yet";
+  if (d.prompts.length >= 2) return "Your last prompt hasn't finished yet";
+  d.accepted = d.accepted.filter((t) => now - t < 3600_000);
+  if (d.accepted.some((t) => now - t < DRIVE_EVERY_MS))
+    return "Wait a few seconds between prompts";
+  if (d.accepted.length >= DRIVE_PER_HOUR)
+    return `You've reached the limit of ${DRIVE_PER_HOUR} prompts an hour`;
+  return null;
+}
+
+const msgId = (promptId: string) => `guest-${promptId}`;
+
+// The agent reads it as a stranger's request; the chat shows only the text.
+export function framed(name: string, text: string): string {
+  const who = noMentions(name.replace(/["\[\]\n]/g, ""));
+  return `[Live guest "${who}", not the owner of this machine, asks:]\n${noMentions(text)}`;
+}
+
+function status(
+  rt: Runtime,
+  fx: DriveFx,
+  p: { id: string; guestId: string },
+  s: "running" | "done" | "stopped" | "refused",
+  reason?: string
+) {
+  fx.send(rt.share.id, "drive_status", {
+    guest_id: p.guestId,
+    id: p.id,
+    status: s,
+    ...(reason && { reason }),
+  });
+}
+
+/** A drive_prompt from Connect. Returns false when it was dropped as bogus. */
+export function acceptPrompt(
+  rt: Runtime,
+  frame: { id: string; guest: { id: string }; text: string },
+  fx: DriveFx,
+  now = Date.now()
+): boolean {
+  const guestId = frame.guest.id;
+  const p0 = { id: frame.id, guestId };
+  if (
+    rt.drive.prompts.some((p) => p.id === frame.id) ||
+    hasDrivePrompt(rt.share.id, frame.id)
+  )
+    return false;
+  const why = eligibility(rt, guestId) ?? limits(rt, now);
+  if (why) return (status(rt, fx, p0, "refused", why), true);
+  const text = cleanBody(frame.text);
+  if (!text || [...text].length > DRIVE_MAX_CHARS) {
+    status(
+      rt,
+      fx,
+      p0,
+      "refused",
+      `A prompt is 1 to ${DRIVE_MAX_CHARS} characters`
+    );
+    return true;
+  }
+  const name = rt.guests.get(guestId)!.name;
+  const wheel = rt.drive.wheel!.wheel;
+  const epoch = rt.drive.epoch;
+  logLive({
+    share_id: rt.share.id,
+    kind: "drive_prompt",
+    guest_id: guestId,
+    guest_name: name,
+    ref: frame.id,
+    text,
+    sent_text: null,
+  });
+  rt.drive.accepted.push(now);
+  const p: DrivePrompt & { cancelled?: boolean } = { ...p0, status: "sending" };
+  rt.drive.prompts.push(p);
+  const forget = () => {
+    rt.drive.prompts = rt.drive.prompts.filter((x) => x !== p);
+  };
+  void sendGuestPrompt(
+    rt.share.session_id,
+    {
+      id: msgId(frame.id),
+      text: framed(name, text),
+      origin: {
+        kind: "guest-drive",
+        label: name,
+        body: text,
+        share: rt.share.id,
+        guestId,
+        wheel,
+      },
+    },
+    // Again right before the worker gets it: a Drive that ended meanwhile
+    // (or this prompt stopped) sends nothing.
+    () =>
+      p.cancelled
+        ? "You stopped it"
+        : rt.drive.epoch !== epoch || rt.drive.wheel?.wheel !== wheel
+          ? "Drive ended"
+          : eligibility(rt, guestId)
+  )
+    .then((refused) => {
+      if (refused) {
+        if (!rt.drive.prompts.includes(p)) return;
+        forget();
+        status(rt, fx, p, p.cancelled ? "stopped" : "refused", refused);
+      } else if (p.status === "sending") p.status = "queued";
+    })
+    // The error stays on this machine: the guest gets a fixed line.
+    .catch(() => {
+      if (!rt.drive.prompts.includes(p)) return;
+      forget();
+      status(rt, fx, p, "refused", "Not sent");
+    });
+  return true;
+}
+
+/** drive_stop: the wheel holder stops their own prompt, never another's. */
+export function stopPrompt(
+  rt: Runtime,
+  frame: { id: string; guest: { id: string } },
+  fx: DriveFx
+): boolean {
+  const w = rt.drive.wheel;
+  if (!w || w.guestId !== frame.guest.id) return false;
+  const p = rt.drive.prompts.find(
+    (x) => x.id === frame.id && x.guestId === frame.guest.id
+  ) as (DrivePrompt & { cancelled?: boolean }) | undefined;
+  if (!p) return true;
+  if (p.status === "running") {
+    p.stopWhy = "You stopped it";
+    stopGuestTurn(rt.share.session_id, rt.share.id, w.wheel);
+    return true;
+  }
+  p.cancelled = true;
+  if (p.status === "queued") {
+    deleteQueuedChat(rt.share.session_id, msgId(p.id));
+    rt.drive.prompts = rt.drive.prompts.filter((x) => x !== p);
+    status(rt, fx, p, "stopped", "You stopped it");
+  }
+  return true;
+}
+
+/**
+ * Gives the wheel (or takes it back, with null). In order, before anything
+ * can interleave: the new holder is set and logged, so a racing prompt is
+ * refused; then the old holder's Drive is released.
+ */
+export function setWheel(
+  rt: Runtime,
+  guestId: string | null,
+  reason: StopReason,
+  fx: DriveFx
+): void {
+  const old = rt.drive.wheel;
+  if (old?.guestId === guestId && guestId) return;
+  const next = guestId
+    ? { guestId, wheel: randomBytes(9).toString("base64url") }
+    : null;
+  rt.drive.wheel = next;
+  if (old || next)
+    logLive({
+      share_id: rt.share.id,
+      kind: "wheel",
+      guest_id: guestId,
+      guest_name: guestId ? (rt.guests.get(guestId)?.name ?? null) : null,
+      ref: next?.wheel ?? null,
+      text: null,
+      sent_text: null,
+    });
+  releaseDrive(rt, reason, fx, old?.wheel ?? "");
+}
+
+/**
+ * Ends what a Drive left: queued prompts go (here and in the worker), a
+ * turn it steers stops (its pending cards expire as denied), and the guest
+ * is told. Synchronous: nothing from that wheel is taken in after it.
+ */
+export function releaseDrive(
+  rt: Runtime,
+  reason: StopReason,
+  fx: DriveFx,
+  wheel = rt.drive.wheel?.wheel ?? ""
+): void {
+  rt.drive.epoch++;
+  if (wheel && rt.drive.wheel?.wheel === wheel) rt.drive.wheel = null;
+  const prompts = rt.drive.prompts.splice(0);
+  if (!wheel && !prompts.length) return;
+  releaseGuestChat(rt.share.session_id, rt.share.id, wheel);
+  for (const p of prompts)
+    status(
+      rt,
+      fx,
+      p,
+      p.status === "running" ? "stopped" : "refused",
+      STOPPED[reason]
+    );
+  logLive({
+    share_id: rt.share.id,
+    kind: "drive_stopped",
+    guest_id: prompts[0]?.guestId ?? null,
+    guest_name: null,
+    ref: reason,
+    text: null,
+    sent_text: null,
+  });
+}
+
+/** What the driving guest's prompt is doing, for the host's view. */
+export function driverState(rt: Runtime): DriverState {
+  const ps = rt.drive.prompts;
+  if (ps.some((p) => p.status === "running"))
+    return registry.live.get(rt.share.session_id)?.state === "waiting"
+      ? "waiting_on_host"
+      : "working";
+  return ps.length ? "queued" : "idle";
+}
+
+/** A tap on the session's messages: a Drive prompt starting, ending, removed. */
+export function onDriveMessage(
+  sessionId: string,
+  m: ChatServerMessage,
+  fx: DriveFx
+): void {
+  for (const rt of live.runtimes.values()) {
+    if (rt.share.session_id !== sessionId || !rt.drive.prompts.length) continue;
+    const running = rt.drive.prompts.find((p) => p.status === "running");
+    if (m.type === "item" && m.item.kind === "user") {
+      const p = rt.drive.prompts.find((x) => msgId(x.id) === m.item.id);
+      if (p && p.status !== "running") {
+        p.status = "running";
+        status(rt, fx, p, "running");
+      }
+    } else if (
+      m.type === "item" &&
+      m.item.kind === "note" &&
+      m.item.id.startsWith("note-guest-stop-") &&
+      running
+    ) {
+      running.stopWhy = m.item.text.replace(/^Stopped: /, "").slice(0, 100);
+    } else if (
+      running &&
+      ((m.type === "item" && m.item.kind === "turn_end") ||
+        (m.type === "state" && m.state === "idle"))
+    ) {
+      rt.drive.prompts = rt.drive.prompts.filter((p) => p !== running);
+      const interrupted =
+        m.type === "item" && m.item.kind === "turn_end" && m.item.interrupted;
+      if (running.stopWhy || interrupted)
+        status(
+          rt,
+          fx,
+          running,
+          "stopped",
+          running.stopWhy ?? "The host stopped it"
+        );
+      else status(rt, fx, running, "done");
+    } else if (m.type === "queue") {
+      for (const p of rt.drive.prompts)
+        if (p.status === "queued" && !m.queue.some((q) => q.id === msgId(p.id)))
+          setTimeout(
+            () => removedByHost(rt, p, fx),
+            REMOVED_AFTER_MS
+          ).unref?.();
+    }
+  }
+}
+
+// Gone from the queue and never started: the host deleted it.
+function removedByHost(rt: Runtime, p: DrivePrompt, fx: DriveFx) {
+  const id = msgId(p.id);
+  if (!rt.drive.prompts.includes(p) || p.status !== "queued") return;
+  if (listQueue(rt.share.session_id).some((q) => q.id === id)) return;
+  if (hasItem(rt.share.session_id, id)) return;
+  rt.drive.prompts = rt.drive.prompts.filter((x) => x !== p);
+  status(rt, fx, p, "refused", "The host removed it");
+}

package/lib/live/frames.ts

@@ -56,11 +56,13 @@ export function stateOf(state: ChatState): LiveState {
 }
 
 // Messages that were not typed by the reader (the agent bus, schedules,
-// AgentOS itself) stay on this machine; a sent suggestion is the reader's.
+// AgentOS itself) stay on this machine; a sent suggestion is the reader's,
+// and a Drive prompt the driving guest's.
 function userFrom(item: Extract<ChatItem, { kind: "user" }>): string | null {
   const o = item.origin;
   if (!o) return item.peer || item.from ? null : "host";
   if (o.kind === "guest") return `guest:${o.label}`;
+  if (o.kind === "guest-drive") return `driver:${o.label}`;
   if (o.kind === "decision") return "host";
   return null;
 }
@@ -108,7 +110,12 @@ export function itemMapper(ctx: ShareContext): ItemMapper {
       if (!f) return null;
       from = f;
     }
-    const raw = toRaw(item);
+    // A Drive prompt shows as the guest typed it, not as framed for the agent.
+    const raw = toRaw(
+      item.kind === "user" && item.origin?.kind === "guest-drive"
+        ? { ...item, text: item.origin.body ?? "" }
+        : item
+    );
     if (!raw || raw.tools || raw.type === "artifact") return null;
     const body = clipBytes(take(text ?? raw.text), MAX_TEXT_BYTES);
     if (item.kind === "user")