zidane-ui 9.1.1 → 9.1.4

package/src/chat/headless/transcript/rows.ts

@@ -1,377 +0,0 @@
-/**
- * The transcript row model: what collapseEvents() turns zidane stream events
- * into and every later pass (batching, folding, clustering) rewrites. Pure
- * data; the styled rows render it.
- */
-import type { SessionEventStatus, StreamEvent, ToolFormatLine } from 'zidane/chat';
-import type { PromptSegmentRef } from 'zidane/chat/pure';
-import type { ChatAttachment } from '../host';
-import type { PromptOrigin } from '../prompt-origin';
-
-/**
- * Every row carries the optional ownership metadata from its source
- * `StreamEvent`. `childId` + `depth` drive the subagent block grouping;
- * `turnId` drives select-turn mode highlighting.
- */
-export interface Owned {
-  /** Id of the worker (subagent) session the row came from. Absent for the main session's own rows. */
-  childId?: string;
-  /** Nesting level of the worker that owns the row: 1 for a direct subagent, 2 for one it spawned. */
-  depth?: number;
-  /** Id of the turn the row belongs to. Select-turn mode highlights rows by it. */
-  turnId?: string;
-}
-
-/** One row of the transcript model. The `kind` field says what it is: a prompt, assistant markdown, thinking, a tool call, a notice, a worker marker, or a synthetic group such as `tool-batch` or `exchange-fold`. */
-export type Row =
-  | (Owned & {
-      kind: 'user-prompt';
-      id: string;
-      text: string;
-      refs?: readonly PromptSegmentRef[];
-      attachments?: readonly ChatAttachment[];
-      /** A marker the user never typed: a command invocation's echo or a context note. */
-      synthetic?: true;
-      /** Who sent it, when not the session's own user in a window (a channel, an event). */
-      origin?: PromptOrigin;
-    })
-  | (Owned & {
-      kind: 'markdown';
-      id: string;
-      text: string;
-      streaming: boolean;
-      /**
-       * A custom command block (`CommandOutputBlock.custom`): the extension renderer for `renderer` (an
-       * `ctx.add(Renderer, { for: { block } })`) draws it from `data`; `text` is its markdown fallback.
-       */
-      custom?: { renderer: string; data?: unknown };
-    })
-  | (Owned & {
-      kind: 'thinking';
-      id: string;
-      text: string;
-      /**
-       * Wall-clock duration of the reasoning segment, stamped by the
-       * StreamProvider when the segment closes. Absent on replayed
-       * transcripts — persisted thinking blocks carry no timing metadata
-       * (canonical shape is `{ type: 'thinking', text, signature? }`),
-       * so reloaded rows render a plain "Thoughts" header.
-       */
-      thinkingMs?: number;
-      /** True while the segment is still streaming (opened, not yet closed). */
-      live?: boolean;
-    })
-  | (Owned & {
-      /**
-       * Synthetic chained-thoughts group — a run of ≥2 closed `thinking`
-       * rows separated only by tool rows (or nothing) within one
-       * exchange. Mirrors `tool-batch`: one quiet header ("Thought 4
-       * times" and the summed time) that expands to the individual
-       * thought rows, each still individually collapsible. Produced by
-       * {@link batchThinkingRuns} after tool batching; a live (still
-       * streaming) thinking row never joins a group so the streaming
-       * text stays in view.
-       */
-      kind: 'thinking-batch';
-      id: string;
-      thoughts: ReadonlyArray<Extract<Row, { kind: 'thinking' }>>;
-      /** Sum of the known segment durations; undefined when none carry timing. */
-      totalMs?: number;
-    })
-  | (Owned & { kind: 'info'; id: string; text: string; notice?: StreamEvent['notice'] })
-  | (Owned & {
-      kind: 'error';
-      id: string;
-      text: string;
-      /** What a run's error line leaves out, for its tooltip. */
-      detail?: StreamEvent['detail'];
-      /** A structured notice: a `/` command's error is not a run's end, a `run` or `repeat guard` one is. */
-      notice?: StreamEvent['notice'];
-      /** The tool whose error this is (an unpaired tool error): not a run's end. */
-      tool?: string;
-      /** The call whose error this is: not a run's end either. */
-      callId?: string;
-      /**
-       * Set when this row is how a run ended early (`markRunFailures`):
-       * `cause` says whether it failed or the user stopped it; `continue`
-       * when the run had done work, `retry` (resend `prompt`) when not.
-       */
-      failure?: { cause: 'error' | 'aborted'; resume: 'continue' | 'retry'; prompt?: string };
-    })
-  | (Owned & {
-      /**
-       * Orchestration: a worker session (created/steered by the pinned
-       * "Main" session) reported an outcome. Renders as a one-line,
-       * clickable jump to that session — see `SessionEventRow` in
-       * `chat/transcript/notices.tsx`. `sessionEvent` is absent for a malformed signal;
-       * the row then renders as plain (non-clickable) text.
-       */
-      kind: 'session-event';
-      id: string;
-      text: string;
-      sessionEvent?: StreamEvent['sessionEvent'];
-    })
-  | (Owned & {
-      /** Per-run receipt — one muted line flush under the run it describes. */
-      kind: 'run-summary';
-      id: string;
-      text: string;
-      runSummary?: StreamEvent['runSummary'];
-    })
-  | (Owned & {
-      /**
-       * Supporting output from a `/` command — rendered as a collapsed
-       * tool-call-style row (chevron header, markdown body) so reports,
-       * diffs, and logs don't drown the transcript.
-       */
-      kind: 'command-detail';
-      id: string;
-      label?: string;
-      text: string;
-      /**
-       * Body syntax hint mirrored from the event: `'diff'` bodies are
-       * whitespace-aligned `+N −M path` stat tables that must render
-       * as a code block, not through the markdown pipeline (which
-       * would collapse the alignment into a paragraph).
-       */
-      syntax?: 'diff';
-    })
-  | (Owned & {
-      /** What a `/` command recorded for the model: one quiet receipt line closing its exchange. */
-      kind: 'command-note';
-      id: string;
-      text: string;
-    })
-  | { kind: 'separator'; id: string }
-  | (Owned & { kind: 'spawn-start'; id: string; text: string; spawn?: SpawnMeta; model?: string })
-  | (Owned & { kind: 'spawn-end'; id: string; text: string; spawn?: SpawnMeta; model?: string })
-  | (Owned & {
-      /**
-       * User-initiated `!` shell run — a synthetic `shell` tool event
-       * whose callId carries the `bash_` prefix (TUI parity, see
-       * canonical `isUserBashEvent`). Rendered as a dedicated monospace
-       * block instead of a generic tool row.
-       */
-      kind: 'user-bash';
-      id: string;
-      command: string;
-      /** Latest paired result text — rolling tail while running, final output after. */
-      result: string | null;
-      /** True until the final (non-`streaming`) result lands. */
-      running: boolean;
-      /** Parsed exit metadata from the final text; null while running / unparsable. */
-      exit: BashExitMeta | null;
-      /** True when the run failed host-side (spawn error — paired `error` event). */
-      errored?: boolean;
-      callId?: string;
-      resultClipped?: boolean;
-    })
-  | (Owned & {
-      kind: 'tool';
-      id: string;
-      name: string;
-      displayName: string;
-      formatted: ToolFormatLine | null;
-      rawInput?: Record<string, unknown>;
-      edit?: StreamEvent['edit'];
-      result: string | null;
-      ok: boolean | null;
-      /** Wire id of the call — the key for the lazy full-result fetch. */
-      callId?: string;
-      /** True when `result` was clipped main-side (expand offers a full fetch). */
-      resultClipped?: boolean;
-      /**
-       * Timing, from the host: `startedAt` while the call is unpaired (its
-       * `tool` event's), `durationMs` once its result landed (its
-       * `tool-result` event's, also on replay). `ChatEvent.receivedAt` stands
-       * in for a host that sends none. Absent when neither is known.
-       */
-      startedAt?: number;
-      durationMs?: number;
-      /**
-       * A `spawn` call waiting for a free slot (its `spawn-queued` marker,
-       * live only): the slots taken and the cap. Gone once its worker starts.
-       */
-      waitingFor?: { active: number; max: number };
-      /**
-       * A call of a batch a durable run resumed after a process death, still to
-       * settle (its `tool` event's `resuming`). Only while unpaired.
-       */
-      resuming?: true;
-      /** The decision model approved or denied the call (Model decision approvals). */
-      approval?: StreamEvent['approval'];
-      /** `callId` of the call that made this one (a codemode script's `tools.*`): the row nests under it. */
-      parentId?: string;
-      /** The calls this one made, in order, nested under it by {@link nestToolCalls}. */
-      children?: ReadonlyArray<Extract<Row, { kind: 'tool' }>>;
-    })
-  | (Owned & {
-      /**
-       * Synthetic batch — a run of ≥2 consecutive `tool` rows wedged
-       * between text/thinking/user boundaries (Claude-Code-style
-       * "Ran a command, read a file ›" header). Produced by
-       * {@link batchToolRuns} after the main collapse pass; single
-       * tool rows stay as `kind: 'tool'` unchanged.
-       */
-      kind: 'tool-batch';
-      id: string;
-      summary: string;
-      tools: ReadonlyArray<Extract<Row, { kind: 'tool' }>>;
-    })
-  | {
-      kind: 'compact-summary';
-      id: string;
-      text: string;
-      compact: NonNullable<StreamEvent['compact']>;
-    }
-  | (Owned & {
-      /**
-       * Compact-density fold — everything an exchange did between two user
-       * prompts except its prose: thinking, tool calls and batches, worker
-       * output, command details. One quiet header (the current action while
-       * live, a "Read a file, ran a command +3" summary once settled) that
-       * expands in place to the rows exactly as full density paints them. Produced by {@link foldExchanges}; it
-       * sits right under the exchange's prompt and its id keys off that
-       * prompt, so a live exchange grows without remounting the fold (open
-       * state, enter animation) from the first frame of the run.
-       */
-      kind: 'exchange-fold';
-      id: string;
-      rows: Row[];
-      /** The run is still going and this is its exchange: the dot spins, `recent` shows. */
-      live: boolean;
-      stats: ExchangeFoldStats;
-      /** What the exchange did, phrased like a tool group's header (core `foldSummary`). */
-      summary: string;
-    })
-  | (Owned & {
-      /**
-       * Compact density: an exchange's earlier messages, ahead of its last
-       * one (which stays its own `markdown` row: receipt, caret, turn menu).
-       * Live, the latest of them show as a stack of previews; settled, one
-       * `N earlier messages` line that opens onto them in full. Produced by
-       * {@link foldExchanges} when an exchange wrote two or more messages.
-       */
-      kind: 'message-group';
-      id: string;
-      messages: Row[];
-      live: boolean;
-      /**
-       * The exchange's latest message, painted in full as a regular row at
-       * the end of the group (receipt, caret, turn menu). When the next one
-       * starts it shrinks into the stack of earlier messages.
-       */
-      current: Row;
-    });
-
-/** Counts shown on the summary line of a folded exchange. */
-export interface ExchangeFoldStats {
-  /** Number of tool calls folded. */
-  tools: number;
-  /** Number of thinking segments folded. */
-  thoughts: number;
-  /** Distinct worker (subagent) sessions whose rows folded. */
-  subagents: number;
-  /** Tool calls that failed. */
-  failed: number;
-  /** Sum of known tool + thinking durations; undefined when nothing carries timing (replayed transcripts). */
-  durationMs?: number;
-}
-
-/** Structured subagent lifecycle metadata, as carried on `StreamEvent.spawn`. */
-export type SpawnMeta = NonNullable<StreamEvent['spawn']>;
-
-/** A paired tool call's row: what `ToolRow`, `ToolDetails` and the `ToolBody` slot read. */
-export type ToolRowModel = Extract<Row, { kind: 'tool' }>;
-
-/**
- * A transcript row, or a subagent block. A block's `rows` are the worker's
- * OWN rows (its header reads its lifecycle off them); `body` is what the
- * block paints in order — those rows as singles, plus the blocks of the
- * workers it started, nested where they ran.
- */
-export type Cluster =
-  { kind: 'single'; row: Row } | { kind: 'group'; childId: string; depth: number; rows: Row[]; body: Cluster[] };
-
-/** A subagent block: the `group` member of {@link Cluster}. */
-export type GroupCluster = Extract<Cluster, { kind: 'group' }>;
-
-/**
- * A block's first row in paint order (its own or a nested block's): a stable key.
- *
- * @param cluster - The subagent block to read.
- */
-export function firstRowId(cluster: GroupCluster): string | undefined {
-  for (const item of cluster.body) {
-    const id = item.kind === 'single' ? item.row.id : firstRowId(item);
-    if (id !== undefined) return id;
-  }
-  return undefined;
-}
-
-/** Exit details of a shell command, parsed from its result text by {@link parseBashExitMeta}. */
-export interface BashExitMeta {
-  /** null = killed by signal (abort / output-ceiling kill). */
-  code: number | null;
-  /** How long the command ran, in milliseconds. */
-  durationMs: number;
-  /** The user cancelled the command. */
-  cancelled: boolean;
-}
-
-/**
- * Parse the exit metadata the shell contract embeds in the persisted
- * result text (see `runBashCommand` in the TUI / `startShellRun` in
- * main): `(exit 0, Nms)` footer on success, `Exit code N (Nms)` /
- * `Killed (Nms)` header on failure, `(cancelled by user after Nms)`
- * footer on abort. Live and reloaded transcripts render identically
- * because both read the same text. Returns null when nothing matches
- * (still streaming, or a clipped tail dropped the footer).
- *
- * @param text - The shell tool's result text.
- */
-export function parseBashExitMeta(text: string): BashExitMeta | null {
-  const cancelled = /\(cancelled by user after (\d+)ms\)\s*$/.exec(text);
-
-  if (cancelled) {
-    return { code: null, durationMs: Number(cancelled[1]), cancelled: true };
-  }
-
-  const ok = /\(exit 0, (\d+)ms\)\s*$/.exec(text);
-
-  if (ok) {
-    return { code: 0, durationMs: Number(ok[1]), cancelled: false };
-  }
-
-  const failed = /^Exit code (\d+) \((\d+)ms\)/.exec(text);
-
-  if (failed) {
-    return { code: Number(failed[1]), durationMs: Number(failed[2]), cancelled: false };
-  }
-
-  const killed = /^Killed \((\d+)ms\)/.exec(text);
-
-  if (killed) {
-    return { code: null, durationMs: Number(killed[1]), cancelled: false };
-  }
-
-  return null;
-}
-
-/** The status dot a row shows, chosen by {@link dotVariantFor}: a row kind, a tool state, or a session event status. */
-export type DotVariant =
-  | 'user'
-  | 'thinking'
-  | 'text'
-  | 'tool-running'
-  | 'tool-ok'
-  | 'tool-err'
-  | 'info'
-  | 'note'
-  | 'error'
-  | 'stopped'
-  | 'spawn-start'
-  | 'spawn-end'
-  | 'compact'
-  | 'messages'
-  | `session-${SessionEventStatus}`;

package/src/chat/headless/transcript/run-failures.ts

@@ -1,72 +0,0 @@
-/**
- * A run that ended early (failed, or stopped by the user) shows as ONE
- * quiet row, not as prose. The loop writes a `[✗ Streaming failed …]` or
- * `[⏹ Streaming was aborted.]` marker into the assistant turn (for the
- * model) and a failed run's end carries the error again (live from
- * `run:end`, on replay from the run record): split the marker off the
- * reply, keep whatever the model did write, and let one row speak for the
- * stop. That row knows how to pick the work back up: `continue` when the
- * run had done something, `retry` (resend the prompt) when it had not.
- * The TUI applies the same classifier to events (`src/tui/run-stops.ts`).
- */
-import { createRunStopMarker } from 'zidane/chat/pure';
-
-import type { Row } from './rows';
-
-type ErrorRow = Extract<Row, { kind: 'error' }>;
-/** How a run ended early and how to pick it back up: `cause` (`error` or `aborted`), `resume` (`continue` or `retry`), and the `prompt` to resend on retry. */
-export type RunFailure = NonNullable<ErrorRow['failure']>;
-
-/** A reset time: the clock time today, with the date on any other day. */
-function formatResetTime(resetsAt: number): string {
-  const at = new Date(resetsAt);
-  return at.toDateString() === new Date().toDateString()
-    ? at.toLocaleTimeString(undefined, { hour: 'numeric', minute: '2-digit' })
-    : at.toLocaleString(undefined, { month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit' });
-}
-
-/**
- * The failure row's tooltip: the line, then what it leaves out (when the
- * limit resets, the provider's own words). Never inline: the row stays one
- * quiet line.
- *
- * @param text - The failure line.
- * @param detail - What the line leaves out.
- * @param resetsAtLabel - Words a reset time (`Resets at 14:30`).
- */
-export function failureTooltip(
-  text: string,
-  detail: ErrorRow['detail'],
-  resetsAtLabel: (time: string) => string,
-): string | undefined {
-  const lines = [
-    text,
-    detail?.resetsAt !== undefined ? resetsAtLabel(formatResetTime(detail.resetsAt)) : '',
-    detail?.raw ?? '',
-  ].filter(Boolean);
-  return lines.length > 0 ? lines.join('\n\n') : undefined;
-}
-
-const markRows = createRunStopMarker<Row>({
-  isMarked: (row) => row.kind === 'error' && row.failure !== undefined,
-  withText: (row, text) => ({ ...row, text }) as Row,
-  mint: (reply, text, failure) => ({
-    kind: 'error',
-    id: `${reply.id}-failure`,
-    text,
-    ...('turnId' in reply && reply.turnId ? { turnId: reply.turnId } : {}),
-    failure,
-  }),
-  mark: (error, text, failure) => ({ ...(error as ErrorRow), text, failure }),
-});
-
-/**
- * Returns `rows` itself when no run failed, so memoised consumers stay put.
- * The rules are core's (`createRunStopMarker`), shared with the TUI; an
- * exchange whose rows did not change keeps its previous output rows.
- *
- * @param rows - The transcript rows, oldest first.
- */
-export function markRunFailures(rows: readonly Row[]): readonly Row[] {
-  return markRows(rows);
-}

package/src/chat/headless/transcript/select-stops.ts

@@ -1,151 +0,0 @@
-/**
- * Select-turn navigation model: which turns the cursor stops on, and which
- * painted rows light up for each stop.
- *
- * Built from the rows the Transcript actually paints (batches, folds, hidden
- * thinking), so the cursor never lands on something invisible. Two merges
- * make one stop per thing a reader thinks of as one message:
- *   - result-only turns belong to the assistant turn that made the call
- *     (core `turnSelectionOwnership`);
- *   - an assistant turn that only did work (tool calls, thinking) belongs to
- *     the next assistant turn in the same exchange that wrote prose, so
- *     "read three files, then answered" is one stop, not four. Work with no
- *     answer yet (a run still going) forms one stop of its own.
- *
- * Pure and cheap: one pass over the rows.
- */
-import type { Row } from './rows';
-
-/** The turns select-turn mode can stop on, and how any turn id maps to its stop. */
-export interface SelectStops {
-  /** Stop ids in transcript order; the cursor walks this. */
-  order: string[];
-  /** Any turn id a row carries → the stop it belongs to. */
-  stopOf: ReadonlyMap<string, string>;
-}
-
-/**
- * Every turn a painted row stands for (batches and folds see through to their members).
- *
- * @param row - A painted transcript row.
- */
-export function rowTurnIds(row: Row): string[] {
-  const ids: string[] = [];
-  if ('turnId' in row && row.turnId) ids.push(row.turnId);
-  if (row.kind === 'tool-batch') for (const t of row.tools) if (t.turnId) ids.push(t.turnId);
-  if (row.kind === 'thinking-batch') for (const t of row.thoughts) if (t.turnId) ids.push(t.turnId);
-  if (row.kind === 'exchange-fold') for (const r of row.rows) ids.push(...rowTurnIds(r));
-  if (row.kind === 'message-group') {
-    for (const r of row.messages) ids.push(...rowTurnIds(r));
-    ids.push(...rowTurnIds(row.current));
-  }
-  return ids;
-}
-
-const BOUNDARY: ReadonlySet<Row['kind']> = new Set(['user-prompt', 'separator', 'compact-summary']);
-
-/** Rows that are the agent working, not speaking: they join the answer that follows them. */
-function isWork(row: Row): boolean {
-  switch (row.kind) {
-    case 'tool':
-    case 'tool-batch':
-    case 'thinking':
-    case 'thinking-batch':
-    case 'exchange-fold':
-    case 'message-group':
-    case 'command-detail':
-    case 'spawn-start':
-    case 'spawn-end':
-      return true;
-    case 'info':
-      return row.notice === undefined;
-    default:
-      return false;
-  }
-}
-
-/**
- * Works out the stops of select-turn mode from the painted rows. Result-only turns join the turn that made the call, and work-only turns join the next answer in the same exchange.
- *
- * @param rows - The transcript rows as painted, oldest first.
- * @param ownership - Maps a result-only turn id to the turn that owns it.
- * @param isHidden - Tells whether a row is hidden, so the cursor skips it. Defaults to showing every row.
- */
-export function computeSelectStops(
-  rows: readonly Row[],
-  ownership: ReadonlyMap<string, string>,
-  isHidden: (row: Row) => boolean = () => false,
-): SelectStops {
-  const stopOf = new Map<string, string>();
-  // Owner turn ids in the order their first row paints.
-  const seen: string[] = [];
-  const seenSet = new Set<string>();
-  // Work turns of the current exchange still waiting for an answer.
-  let pending: string[] = [];
-
-  const settlePending = (into: string | null) => {
-    if (pending.length === 0) return;
-    const target = into ?? pending[0]!;
-    for (const id of pending) if (!stopOf.has(id)) stopOf.set(id, target);
-    pending = [];
-  };
-
-  for (const row of rows) {
-    if ('childId' in row && row.childId !== undefined) continue; // worker rows: their block, not a stop
-    if (isHidden(row)) continue;
-    if (BOUNDARY.has(row.kind)) settlePending(null);
-
-    const owners = rowTurnIds(row).map((id) => ownership.get(id) ?? id);
-    for (const id of owners) {
-      if (!seenSet.has(id)) {
-        seenSet.add(id);
-        seen.push(id);
-      }
-    }
-    if (owners.length === 0) continue;
-
-    if (row.kind === 'markdown' && row.text.trim() !== '') {
-      // An answer (words, as core's `messageSelectionOwnership` counts it): its own stop, absorbing the work before it.
-      const answer = owners[0]!;
-      stopOf.set(answer, stopOf.get(answer) ?? answer);
-      settlePending(stopOf.get(answer)!);
-    } else if (isWork(row)) {
-      for (const id of owners) if (!stopOf.has(id) && !pending.includes(id)) pending.push(id);
-    } else {
-      settlePending(null);
-      for (const id of owners) if (!stopOf.has(id)) stopOf.set(id, id);
-    }
-  }
-  settlePending(null);
-
-  // Raw ids (result turns folded into their owner) resolve through both maps.
-  for (const [raw, owner] of ownership) {
-    const stop = stopOf.get(owner);
-    if (stop) stopOf.set(raw, stop);
-  }
-
-  const order: string[] = [];
-  const inOrder = new Set<string>();
-  for (const id of seen) {
-    const stop = stopOf.get(id);
-    if (stop && !inOrder.has(stop)) {
-      inOrder.add(stop);
-      order.push(stop);
-    }
-  }
-  return { order, stopOf };
-}
-
-/**
- * The stop a painted row belongs to, or `null` for rows that are not selectable.
- *
- * @param row - A painted transcript row.
- * @param stops - The stops from {@link computeSelectStops}.
- */
-export function stopForRow(row: Row, stops: SelectStops): string | null {
-  for (const id of rowTurnIds(row)) {
-    const stop = stops.stopOf.get(id);
-    if (stop) return stop;
-  }
-  return null;
-}

package/src/chat/headless/transcript/tool-media.ts

@@ -1,42 +0,0 @@
-/**
- * A tool result's media, read from its text: the transcript carries each
- * image, video or audio block as a stand-in line (`[image: image/png, 742500
- * b64 bytes]`, core's `toolResultToText`), which an app that serves the
- * bytes turns back into the media (`TranscriptActions.toolMediaUrl`).
- */
-
-/** One media block of a tool result, as parsed from its text stand-in. */
-export interface ToolMediaItem {
-  /** What the block is. */
-  kind: 'image' | 'video' | 'audio';
-  /** The block's MIME type, for example `image/png`. */
-  mediaType: string;
-  /** Position among the result's media blocks: the address the app serves it at. */
-  index: number;
-  /** The stand-in line, shown again if the media fails to load. */
-  marker: string;
-}
-
-const MARKER = /^\[(image|video|audio): ([^,\]]+), (?:\d+ b64 bytes|ref [^\]]*)\]$/;
-
-/**
- * The media stand-ins of a result's text, in order, and the text without them.
- *
- * @param text - The tool result's text.
- */
-export function parseToolMedia(text: string): { media: ToolMediaItem[]; rest: string } {
-  const media: ToolMediaItem[] = [];
-  const rest: string[] = [];
-  for (const line of text.split('\n')) {
-    const m = MARKER.exec(line.trim());
-    if (m)
-      media.push({
-        kind: m[1] as ToolMediaItem['kind'],
-        mediaType: m[2]!.trim(),
-        index: media.length,
-        marker: line.trim(),
-      });
-    else rest.push(line);
-  }
-  return { media, rest: rest.join('\n').trim() };
-}