zidane-ui 9.1.1 → 9.1.4

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

@@ -1,41 +0,0 @@
-import type { Transcript, TranscriptState } from '../host';
-import type { SessionStreamStore } from './store';
-
-/**
- * A session's {@link TranscriptState} read off the store, reusing `prev` while
- * none of its parts changed (snapshots compare by identity).
- */
-export function transcriptSnapshot<K extends string>(
-  store: SessionStreamStore<K>,
-  sessionId: K,
-  prev: TranscriptState | undefined,
-): TranscriptState {
-  const events = store.getEventsSnapshot(sessionId);
-  const running = store.getRunningSnapshot(sessionId);
-  const hydrated = store.isHydrated(sessionId);
-  const page = store.getPageSnapshot(sessionId);
-  if (
-    prev &&
-    prev.events === events &&
-    prev.running === running &&
-    prev.hydrated === hydrated &&
-    prev.hasEarlier === page.hasMore &&
-    prev.loadingEarlier === page.loadingEarlier
-  )
-    return prev;
-  return { events, running, hydrated, hasEarlier: page.hasMore, loadingEarlier: page.loadingEarlier };
-}
-
-/** A session's transcript as the components read it: a store over the session's slice, subscribed to that session only. */
-export function storeTranscript<K extends string>(
-  store: SessionStreamStore<K>,
-  sessionId: K,
-  loadEarlier?: () => void,
-): Transcript {
-  let last: TranscriptState | undefined;
-  return {
-    get: () => (last = transcriptSnapshot(store, sessionId, last)),
-    subscribe: (onChange) => store.subscribeSession(sessionId, onChange),
-    ...(loadEarlier ? { loadEarlier } : {}),
-  };
-}

package/src/chat/headless/streams/types.ts

@@ -1,84 +0,0 @@
-import type { StreamEvent, SystemMdFile } from 'zidane/chat';
-import type { PromptTurnRef } from 'zidane/chat/pure';
-
-import type { ChatEvent } from '../host';
-
-/** The model serving a run after it fell back from the one picked. */
-export interface SessionFallbackModel {
-  /** The provider key. */
-  provider: string;
-  /** The model id. */
-  model: string;
-}
-
-/** A provider stream being retried. */
-export interface SessionRetryState {
-  /** The attempt in progress, from 1. */
-  attempt: number;
-  /** The attempts allowed. */
-  max: number;
-  /** Whose stream stalled: `'parent'` or a subagent's child id. */
-  source: string;
-}
-
-/**
- * Lazy-scrollback bookkeeping for one session: where the hydrated window
- * starts (`firstSeq` — the `beforeSeq` for the previous page), whether
- * older turns exist, and an in-flight guard so wheel spam near the top
- * can't stack duplicate page fetches.
- */
-export interface SessionPageState {
-  /** The sequence number the hydrated window starts at: the `beforeSeq` of the page before it. */
-  firstSeq: number;
-  /** Whether older turns exist before the window. */
-  hasMore: boolean;
-  /** Whether a fetch of the previous page is in flight. */
-  loadingEarlier: boolean;
-}
-
-/** One page of a session's persisted transcript (the tail, or the page before a sequence number). */
-export interface SessionStreamPage {
-  /** The page's events, oldest first. */
-  events: readonly ChatEvent[];
-  /** The sequence number of the page's first turn. */
-  firstSeq: number;
-  /** Whether older turns exist before the page. */
-  hasMore: boolean;
-}
-
-/**
- * The live signals the session stream store reduces: zidane's host signals
- * for one session (the desktop app's `chat:stream` channel, zidane-server's
- * signals). Any other signal kind is ignored.
- */
-export type SessionStreamSignal<K extends string = string> =
-  /** A run started. */
-  | { kind: 'run:start'; sessionId: K; runId?: string; startedAt?: number }
-  /** A run ended; a failed one (`ok: false` with an `error`) appends an error row. */
-  | { kind: 'run:end'; sessionId: K; runId?: string; ok: boolean; error?: string; detail?: StreamEvent['detail'] }
-  /** A turn of the parent (or of the subagent `childId`) ended: its streaming markdown is final. */
-  | { kind: 'turn:end'; sessionId: K; turnId?: string; childId?: string; depth?: number }
-  /** A transcript event; `echo` marks the host repeating a prompt this client may have shown already. */
-  | { kind: 'event'; sessionId: K; event: ChatEvent | StreamEvent; echo?: boolean }
-  /** The run fell back to another model. */
-  | {
-      kind: 'model:fallback';
-      sessionId: K;
-      from?: SessionFallbackModel;
-      to: SessionFallbackModel;
-      discardTurnId?: string;
-    }
-  /** A provider stream stalled and is being retried. */
-  | { kind: 'stream:retry'; sessionId: K; attempt: number; max: number; source: string; discardTurnId?: string }
-  /** A retried stream reached a terminal state. */
-  | { kind: 'stream:retry:cleared'; sessionId: K; source: string }
-  /** Prompt turns just persisted: binds them to their live `user-prompt` rows. */
-  | { kind: 'prompt-turns'; sessionId: K; refs: readonly PromptTurnRef[] }
-  /** The `SYSTEM.md` override the session's prompt was composed with, or `null`. */
-  | { kind: 'system-md'; sessionId: K; file: SystemMdFile | null; shadowed?: readonly SystemMdFile[] };
-
-/** A signal of a kind the store does not reduce (compaction pings, cache breaks …): ignored. */
-export interface OtherStreamSignal {
-  /** The signal's kind. */
-  readonly kind: string;
-}

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

@@ -1,429 +0,0 @@
-/**
- * Row passes after the collapse: subagent clustering, tool-run batching and
- * thinking chains.
- */
-import { spawnParents, summarizeTools } from 'zidane/chat/pure';
-import type { Owned, Row, Cluster, GroupCluster } from './rows';
-
-/**
- * Group contiguous rows with the same `childId` so the renderer can
- * wrap a subagent's output in a single bordered card — and nest the card
- * of a worker a worker started inside its spawner's (spawner from the
- * markers' `spawn.parentChildId`). A row's block chain is its worker's
- * ancestry; the open chain is reused as far as it matches, so a
- * grandchild's rows land inside the spawner's block that is still open,
- * and the spawner's later rows close the grandchild's block. A row of
- * another lane (main rows, an unrelated sibling) closes the chain: a later
- * grandchild row then reopens its spawner's block around itself.
- *
- * @param rows - The transcript rows, oldest first.
- */
-export function clusterByOwner(rows: readonly Row[]): Cluster[] {
-  const out: Cluster[] = [];
-  const parents = spawnParents(rows);
-  const present = new Set<string>();
-  const depthOf = new Map<string, number>();
-  for (const row of rows) {
-    if ('childId' in row && row.childId) {
-      present.add(row.childId);
-      if (!depthOf.has(row.childId)) depthOf.set(row.childId, 'depth' in row ? (row.depth ?? 1) : 1);
-    }
-  }
-  /** `[outermost present ancestor, …, cid]`. */
-  const chainOf = (cid: string): string[] => {
-    const chain = [cid];
-    for (let p = parents.get(cid); p !== undefined && present.has(p) && !chain.includes(p); p = parents.get(p)) {
-      chain.unshift(p);
-    }
-    return chain;
-  };
-  let open: GroupCluster[] = [];
-
-  for (const row of rows) {
-    const cid = 'childId' in row ? row.childId : undefined;
-
-    if (!cid) {
-      open = [];
-      out.push({ kind: 'single', row });
-      continue;
-    }
-
-    const chain = chainOf(cid);
-    let shared = 0;
-    while (shared < open.length && shared < chain.length && open[shared]!.childId === chain[shared]) shared++;
-    open = open.slice(0, shared);
-    for (const id of chain.slice(shared)) {
-      const group: GroupCluster = { kind: 'group', childId: id, depth: depthOf.get(id) ?? 1, rows: [], body: [] };
-      (open[open.length - 1]?.body ?? out).push(group);
-      open.push(group);
-    }
-    const own = open[open.length - 1]!;
-    own.rows.push(row);
-    own.body.push({ kind: 'single', row });
-  }
-
-  for (let i = 0; i < out.length; i++) {
-    const item = out[i]!;
-    if (item.kind === 'group') out[i] = stableGroup(item);
-  }
-  return out;
-}
-
-/*
- * A subagent block keeps its identity while its rows and nested blocks do,
- * like the batches below: clustering runs on every transcript change, and a
- * fresh block per pass re-rendered every block of the session each tick.
- * Keyed by the block's first body item: its first row, or the (already
- * stable) block nested first, which a spawner and that worker can't share.
- */
-const GROUP_CACHE = new WeakMap<object, GroupCluster>();
-
-function sameBody(a: readonly Cluster[], b: readonly Cluster[]): boolean {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    const x = a[i]!;
-    const y = b[i]!;
-    if (x.kind === 'single' ? y.kind !== 'single' || x.row !== y.row : x !== y) return false;
-  }
-  return true;
-}
-
-/** `group` (fresh from this pass, nested blocks included), or the cached block it equals. */
-function stableGroup(group: GroupCluster): GroupCluster {
-  for (let i = 0; i < group.body.length; i++) {
-    const item = group.body[i]!;
-    if (item.kind === 'group') group.body[i] = stableGroup(item);
-  }
-  const head = group.body[0]!;
-  const key = head.kind === 'single' ? head.row : head;
-  const hit = GROUP_CACHE.get(key);
-  if (
-    hit &&
-    hit.childId === group.childId &&
-    hit.depth === group.depth &&
-    sameMembers(hit.rows, group.rows) &&
-    sameBody(hit.body, group.body)
-  ) {
-    return hit;
-  }
-  GROUP_CACHE.set(key, group);
-  return group;
-}
-
-/**
- * The header line of a tool batch (`Ran a command, read a file`), from `summarizeTools` in `src/chat/fold-actions.ts`, shared with the TUI.
- *
- * @param tools - The batch's tool rows.
- * @param options - `overflow` is passed to `summarizeTools`.
- */
-export function summarizeToolBatch(
-  tools: ReadonlyArray<Extract<Row, { kind: 'tool' }>>,
-  options?: { overflow?: boolean },
-): string {
-  return summarizeTools(tools, options);
-}
-
-/** Row kinds that end an exchange-wide tool group (`Settings.groupToolCalls`). */
-export const TOOL_GROUP_BOUNDARIES: ReadonlySet<Row['kind']> = new Set(['user-prompt', 'separator', 'compact-summary']);
-
-/*
- * Batch rows keep their identity while their members do. The batchers run
- * on every transcript change (each stream tick, each page of history), and
- * a fresh batch object per pass re-rendered every batch row in a long
- * session each time. Keyed by the first member (row objects are stable, see
- * the collapse cache), reused while the member list is element-for-element
- * the same.
- */
-const TOOL_BATCH_CACHE = new WeakMap<object, Row>();
-const TOOL_GROUP_CACHE = new WeakMap<object, Row>();
-const THINKING_BATCH_CACHE = new WeakMap<object, Row>();
-export const FOLD_CACHE = new WeakMap<object, Row>();
-
-export function sameMembers(a: readonly Row[], b: readonly Row[]): boolean {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
-  return true;
-}
-
-function stableBatch<R extends Row>(
-  cache: WeakMap<object, Row>,
-  members: readonly Row[],
-  membersOf: (row: R) => readonly Row[],
-  build: () => R,
-): R {
-  const hit = cache.get(members[0]!) as R | undefined;
-  if (hit && sameMembers(membersOf(hit), members)) return hit;
-  const next = build();
-  cache.set(members[0]!, next);
-  return next;
-}
-
-/**
- * Exchange-wide grouping pre-pass (`Settings.groupToolCalls`) — mirrors
- * the TUI's `computeToolGroupKeys` rule set:
- *
- *   - Group boundaries are `user-prompt` / `separator` / `compact-summary`
- *     rows; everything between two boundaries is one exchange.
- *   - Only PARENT-owned tool rows group (no `childId`, depth 0). Subagent
- *     rows stay inside their subagent clusters and keep the adjacency
- *     batching below; user-initiated `!` bash runs are `user-bash` rows
- *     and never enter (the user ran the command to SEE it).
- *   - markdown / thinking / spawn rows between calls do NOT break the
- *     group — unlike the adjacency batcher, which flushes on any
- *     interposed row.
- *   - A single call in an exchange passes through as a plain row.
- *
- * Placement: the group takes the FIRST tool call's slot. First-call
- * position keeps reading order sane — prose streamed before the first
- * call stays above the group, and prose interleaved between later calls
- * keeps its original position after it; parking the group at the last
- * call would push it below text the model wrote mid-exchange.
- *
- * Like the adjacency batcher, this creates fresh batch/array identities
- * per pass — cheap, and the batch id keys off the FIRST call only so the
- * React key (row.id) stays stable while a live exchange appends more
- * calls (ToolBatchRow's expand state survives stream ticks).
- */
-function liftExchangeToolGroups(rows: readonly Row[]): Row[] {
-  const out: Array<Row | null> = [...rows];
-  let exchange: number[] = [];
-
-  const flush = () => {
-    if (exchange.length >= 2) {
-      const tools = exchange.map((i) => rows[i] as Extract<Row, { kind: 'tool' }>);
-      const first = tools[0];
-
-      out[exchange[0]] = stableBatch(
-        TOOL_GROUP_CACHE,
-        tools,
-        (row: Extract<Row, { kind: 'tool-batch' }>) => row.tools,
-        () => ({
-          ...(first.turnId !== undefined ? { turnId: first.turnId } : {}),
-          kind: 'tool-batch',
-          id: `tg-${first.id}`,
-          summary: summarizeToolBatch(tools),
-          tools,
-        }),
-      );
-
-      for (let k = 1; k < exchange.length; k++) {
-        out[exchange[k]] = null;
-      }
-    }
-
-    exchange = [];
-  };
-
-  for (let i = 0; i < rows.length; i++) {
-    const row = rows[i];
-
-    if (TOOL_GROUP_BOUNDARIES.has(row.kind)) {
-      flush();
-      continue;
-    }
-
-    if (row.kind === 'tool' && row.childId === undefined && (row.depth ?? 0) === 0) {
-      exchange.push(i);
-    }
-  }
-
-  flush();
-  return out.filter((r): r is Row => r !== null);
-}
-
-/**
- * Group consecutive `tool` rows (≥2) into a single `tool-batch` row so
- * the renderer can paint one Claude-Code-style collapsible header
- * instead of a wall of individual tool entries between two assistant
- * messages. Single tool rows pass through untouched (per the user's
- * "don't edit single tool calls" requirement).
- *
- * Constraints:
- *   - Only batches tool rows sharing the same `childId` (incl. both
- *     `undefined`). Mixing subagent + main-stream tools would muddle
- *     the SubagentBlock cluster — those stay separate.
- *   - Edit-style tools (`edit`, `multi_edit`, `write_file`) participate
- *     in batching like any other tool; the per-row diff stays available
- *     on expand.
- *
- * With `groupToolCalls` on, parent-owned tool rows are first lifted
- * exchange-wide by {@link liftExchangeToolGroups}; the adjacency pass
- * below then only batches subagent-owned (`childId`) tool rows, so
- * subagent clusters keep their existing behavior.
- *
- * @param rows - The transcript rows, oldest first.
- * @param groupToolCalls - Lifts parent-owned tool calls into one group per exchange before batching adjacent runs. Defaults to `false`.
- */
-export function batchToolRuns(rows: readonly Row[], groupToolCalls = false): Row[] {
-  const pre = groupToolCalls ? liftExchangeToolGroups(rows) : rows;
-  const out: Row[] = [];
-  let run: Array<Extract<Row, { kind: 'tool' }>> = [];
-
-  const flush = () => {
-    if (run.length === 0) {
-      return;
-    }
-
-    if (run.length === 1) {
-      out.push(run[0]);
-    } else {
-      const first = run[0];
-      /*
-       * Keyed by the FIRST call only: a live run grows one tool at a time,
-       * and an id that also named the last tool changed on every growth,
-       * remounting the batch (chevron state lost, enter animation replayed)
-       * — the "flickering tools box" while a turn streams.
-       */
-      const id = `tb-${first.id}`;
-      const owned: Owned = {};
-
-      if (first.childId !== undefined) {
-        owned.childId = first.childId;
-      }
-
-      if (first.depth !== undefined) {
-        owned.depth = first.depth;
-      }
-
-      if (first.turnId !== undefined) {
-        owned.turnId = first.turnId;
-      }
-
-      const tools = run;
-      out.push(
-        stableBatch(
-          TOOL_BATCH_CACHE,
-          tools,
-          (row: Extract<Row, { kind: 'tool-batch' }>) => row.tools,
-          () => ({ ...owned, kind: 'tool-batch', id, summary: summarizeToolBatch(tools), tools }),
-        ),
-      );
-    }
-
-    run = [];
-  };
-
-  for (const row of pre) {
-    // In exchange mode a surviving parent-owned tool row is a single-call
-    // exchange — it must stay a plain row, so it's ineligible here.
-    if (row.kind === 'tool' && (!groupToolCalls || row.childId !== undefined)) {
-      if (run.length === 0 || run[0].childId === row.childId) {
-        run.push(row);
-        continue;
-      }
-
-      flush();
-      run.push(row);
-      continue;
-    }
-
-    flush();
-    out.push(row);
-  }
-
-  flush();
-  return out;
-}
-
-/**
- * Row kinds that do NOT break a chained-thoughts run. Tool rows sit
- * between reasoning segments constantly (think → call → think → call…),
- * so they're transparent to the chain; anything conversational —
- * markdown prose, a user prompt, a separator — ends it.
- */
-const THINKING_CHAIN_TRANSPARENT: ReadonlySet<Row['kind']> = new Set(['tool', 'tool-batch']);
-
-/**
- * Fold runs of ≥2 closed `thinking` rows into one `thinking-batch` row —
- * the exact interaction model of {@link batchToolRuns}: the group lands
- * in the FIRST thought's slot, interleaved tool rows keep their
- * positions after it, and the group id is keyed off the first thought so
- * it stays stable while the exchange grows.
- *
- * Grouping rule (consecutive-only): thinking rows chain when separated
- * by nothing or only tool / tool-batch rows with the SAME owner
- * (`childId`); a markdown / user-prompt / separator / spawn row breaks
- * the chain. A live (still streaming) thinking row never joins — it
- * must stay expanded and in view; the chain it would have extended is
- * flushed before it.
- *
- * Run AFTER `batchToolRuns` so tool batches are already folded and the
- * chain check sees `tool-batch` rows, not raw runs.
- *
- * @param rows - The transcript rows after {@link batchToolRuns}, oldest first.
- */
-export function batchThinkingRuns(rows: readonly Row[]): Row[] {
-  const out: Row[] = [];
-  let chain: Array<Extract<Row, { kind: 'thinking' }>> = [];
-  /** Rows between chained thoughts, re-emitted after the group. */
-  let deferred: Row[] = [];
-
-  const flush = () => {
-    if (chain.length >= 2) {
-      const first = chain[0];
-      const owned: Owned = {};
-
-      if (first.childId !== undefined) {
-        owned.childId = first.childId;
-      }
-
-      if (first.depth !== undefined) {
-        owned.depth = first.depth;
-      }
-
-      if (first.turnId !== undefined) {
-        owned.turnId = first.turnId;
-      }
-
-      const totalMs = chain.reduce((sum, t) => sum + (t.thinkingMs ?? 0), 0);
-
-      const thoughts = chain;
-      out.push(
-        stableBatch(
-          THINKING_BATCH_CACHE,
-          thoughts,
-          (row: Extract<Row, { kind: 'thinking-batch' }>) => row.thoughts,
-          () => ({
-            ...owned,
-            kind: 'thinking-batch',
-            id: `kb-${first.id}`,
-            thoughts,
-            ...(totalMs > 0 ? { totalMs } : {}),
-          }),
-        ),
-      );
-    } else {
-      out.push(...chain);
-    }
-
-    out.push(...deferred);
-    chain = [];
-    deferred = [];
-  };
-
-  for (const row of rows) {
-    if (row.kind === 'thinking' && !row.live) {
-      if (chain.length > 0 && chain[0].childId !== row.childId) {
-        flush();
-      }
-
-      chain.push(row);
-      continue;
-    }
-
-    if (
-      chain.length > 0 &&
-      THINKING_CHAIN_TRANSPARENT.has(row.kind) &&
-      ('childId' in row ? row.childId : undefined) === chain[0].childId
-    ) {
-      deferred.push(row);
-      continue;
-    }
-
-    flush();
-    out.push(row);
-  }
-
-  flush();
-  return out;
-}