zidane 5.14.4 → 6.0.0

package/dist/{timeout-kGGSXagK.js → timeout-BDetbuN6.js}

@@ -55,6 +55,63 @@ function withTimeout(promise, options) {
 	});
 }
 /**
+* Inactivity watchdog around a streaming operation: the timeout fires only
+* after `timeoutMs` of SILENCE, not total elapsed time. Callers report
+* liveness by invoking the returned `touch()` on every streamed delta —
+* a healthy-but-slow stream (huge prompt, long generation) never trips
+* the watchdog, while a hung stream still fails deterministically.
+*
+* Implementation is churn-free under high delta rates: `touch()` only
+* records a timestamp; the timer lazily re-arms for the remaining idle
+* window when it wakes and finds recent activity. A non-positive /
+* non-finite `timeoutMs` disables the guard (mirrors {@link withTimeout}).
+*/
+function withInactivityTimeout(promise, options) {
+	const { operation, timeoutMs, onTimeout, message } = options;
+	if (!isPositiveFiniteMs(timeoutMs)) return {
+		promise,
+		touch: () => {}
+	};
+	let lastActivity = Date.now();
+	let settled = false;
+	let timer;
+	return {
+		promise: new Promise((resolve, reject) => {
+			const arm = (delayMs) => {
+				timer = setTimeout(() => {
+					if (settled) return;
+					const idleMs = Date.now() - lastActivity;
+					if (idleMs < timeoutMs) {
+						arm(timeoutMs - idleMs);
+						return;
+					}
+					settled = true;
+					try {
+						onTimeout?.();
+					} finally {
+						reject(new OperationTimeoutError(operation, timeoutMs, message));
+					}
+				}, delayMs);
+			};
+			arm(timeoutMs);
+			promise.then((value) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				resolve(value);
+			}, (err) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				reject(err);
+			});
+		}),
+		touch: () => {
+			lastActivity = Date.now();
+		}
+	};
+}
+/**
 * Await `work` under `timeoutMs`, swallowing a timeout (logged under
 * `ZIDANE_DEBUG`) and continuing. Non-timeout errors propagate unchanged so a
 * well-behaved-but-throwing handler keeps its prior semantics. Use for
@@ -79,6 +136,6 @@ async function settleWithinTimeout(operation, work, timeoutMs) {
 	}
 }
 //#endregion
-export { withTimeout as a, settleWithinTimeout as i, linkAbortSignal as n, resolveTimeoutMs as r, OperationTimeoutError as t };
+export { withInactivityTimeout as a, settleWithinTimeout as i, linkAbortSignal as n, withTimeout as o, resolveTimeoutMs as r, OperationTimeoutError as t };
 
-//# sourceMappingURL=timeout-kGGSXagK.js.map
+//# sourceMappingURL=timeout-BDetbuN6.js.map

package/dist/timeout-BDetbuN6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout-BDetbuN6.js","names":[],"sources":["../src/timeout.ts"],"sourcesContent":["export class OperationTimeoutError extends Error {\n  readonly code = 'operation_timeout' as const\n  readonly timeoutMs: number\n  readonly operation: string\n\n  constructor(operation: string, timeoutMs: number, message?: string) {\n    super(message ?? `${operation} timed out after ${timeoutMs}ms`)\n    this.name = 'OperationTimeoutError'\n    this.operation = operation\n    this.timeoutMs = timeoutMs\n  }\n}\n\nexport function isPositiveFiniteMs(value: unknown): value is number {\n  return typeof value === 'number' && Number.isFinite(value) && value > 0\n}\n\nexport function resolveTimeoutMs(\n  configured: number | undefined,\n  fallback: number,\n  ceiling?: number,\n): number {\n  const base = typeof configured === 'number'\n    ? (isPositiveFiniteMs(configured) ? configured : 0)\n    : fallback\n  if (base <= 0)\n    return 0\n  return isPositiveFiniteMs(ceiling) ? Math.min(base, ceiling) : base\n}\n\nexport function linkAbortSignal(\n  source: AbortSignal,\n  target: AbortController,\n): () => void {\n  if (source.aborted) {\n    target.abort(source.reason)\n    return () => {}\n  }\n  const onAbort = () => target.abort(source.reason)\n  source.addEventListener('abort', onAbort, { once: true })\n  return () => source.removeEventListener('abort', onAbort)\n}\n\nexport function withTimeout<T>(\n  promise: Promise<T>,\n  options: {\n    operation: string\n    timeoutMs: number\n    onTimeout?: () => void\n    message?: string\n  },\n): Promise<T> {\n  const { operation, timeoutMs, onTimeout, message } = options\n  if (!isPositiveFiniteMs(timeoutMs))\n    return promise\n\n  return new Promise<T>((resolve, reject) => {\n    let settled = false\n    const timer = setTimeout(() => {\n      if (settled)\n        return\n      settled = true\n      try {\n        onTimeout?.()\n      }\n      finally {\n        reject(new OperationTimeoutError(operation, timeoutMs, message))\n      }\n    }, timeoutMs)\n\n    promise.then(\n      (value) => {\n        if (settled)\n          return\n        settled = true\n        clearTimeout(timer)\n        resolve(value)\n      },\n      (err) => {\n        if (settled)\n          return\n        settled = true\n        clearTimeout(timer)\n        reject(err)\n      },\n    )\n  })\n}\n\n/**\n * Inactivity watchdog around a streaming operation: the timeout fires only\n * after `timeoutMs` of SILENCE, not total elapsed time. Callers report\n * liveness by invoking the returned `touch()` on every streamed delta —\n * a healthy-but-slow stream (huge prompt, long generation) never trips\n * the watchdog, while a hung stream still fails deterministically.\n *\n * Implementation is churn-free under high delta rates: `touch()` only\n * records a timestamp; the timer lazily re-arms for the remaining idle\n * window when it wakes and finds recent activity. A non-positive /\n * non-finite `timeoutMs` disables the guard (mirrors {@link withTimeout}).\n */\nexport function withInactivityTimeout<T>(\n  promise: Promise<T>,\n  options: {\n    operation: string\n    timeoutMs: number\n    onTimeout?: () => void\n    message?: string\n  },\n): { promise: Promise<T>, touch: () => void } {\n  const { operation, timeoutMs, onTimeout, message } = options\n  if (!isPositiveFiniteMs(timeoutMs))\n    return { promise, touch: () => {} }\n\n  let lastActivity = Date.now()\n  let settled = false\n  let timer: ReturnType<typeof setTimeout> | undefined\n\n  const guarded = new Promise<T>((resolve, reject) => {\n    const arm = (delayMs: number) => {\n      timer = setTimeout(() => {\n        if (settled)\n          return\n        const idleMs = Date.now() - lastActivity\n        if (idleMs < timeoutMs) {\n          arm(timeoutMs - idleMs)\n          return\n        }\n        settled = true\n        try {\n          onTimeout?.()\n        }\n        finally {\n          reject(new OperationTimeoutError(operation, timeoutMs, message))\n        }\n      }, delayMs)\n    }\n    arm(timeoutMs)\n\n    promise.then(\n      (value) => {\n        if (settled)\n          return\n        settled = true\n        clearTimeout(timer)\n        resolve(value)\n      },\n      (err) => {\n        if (settled)\n          return\n        settled = true\n        clearTimeout(timer)\n        reject(err)\n      },\n    )\n  })\n\n  return {\n    promise: guarded,\n    touch: () => {\n      lastActivity = Date.now()\n    },\n  }\n}\n\n/**\n * Await `work` under `timeoutMs`, swallowing a timeout (logged under\n * `ZIDANE_DEBUG`) and continuing. Non-timeout errors propagate unchanged so a\n * well-behaved-but-throwing handler keeps its prior semantics. Use for\n * observability / lifecycle / teardown awaits that must never block forward\n * progress or strand a run gate (hooks, store writes, MCP close, ctx destroy).\n *\n * A non-positive / non-finite `timeoutMs` disables the bound — `work` is\n * awaited as-is (matching {@link resolveTimeoutMs}'s `0` = \"disabled\").\n */\nexport async function settleWithinTimeout(\n  operation: string,\n  work: Promise<unknown> | void,\n  timeoutMs: number,\n): Promise<void> {\n  try {\n    await withTimeout(Promise.resolve(work), { operation, timeoutMs })\n  }\n  catch (err) {\n    if (err instanceof OperationTimeoutError) {\n      if (process.env.ZIDANE_DEBUG)\n        console.error(`[zidane] ${operation} timed out after ${timeoutMs}ms; continuing`)\n      return\n    }\n    throw err\n  }\n}\n"],"mappings":"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"}

package/dist/tool-formatters-DY0TDb1r.d.ts

@@ -0,0 +1,378 @@
+import { fu as Settings, pu as StreamEvent } from "./index-B8UtiZy7.js";
+import { ReactNode } from "react";
+
+//#region src/chat/turn-selection.d.ts
+/** Tools whose `tool-result` event is suppressed when `showEditDiffs` is on. */
+declare const EDIT_TOOL_NAMES: ReadonlySet<string>;
+/**
+ * Recognize a tool-result body as carrying NON-success information so the
+ * renderer doesn't suppress it under `showEditDiffs`. Three categories:
+ *
+ *   - `edit` → "Edit error: …"
+ *   - `write_file` permission errors wrapped by the loop → "Tool failed: …"
+ *   - `multi_edit` → legacy single-line error `multi_edit error: …`, OR
+ *     a result carrying an `<edit-outcomes>…</edit-outcomes>` annotation
+ *     block. The TUI only appends the annotation when at least one hunk
+ *     was NOT applied, so its mere presence is the signal — the result
+ *     body needs to stay visible next to the diff so the user can read
+ *     denial / skip / failure reasons longer than the per-hunk badge.
+ *   - Fully-denied gate emit (`[fully denied] <edit-outcomes>…`) likewise
+ *     stays visible.
+ *
+ * Exported for unit-testability of the visibility matrix.
+ */
+declare function isEditErrorResult(text: string): boolean;
+/**
+ * Per-event visibility — filters honor user toggles and the
+ * `hideSubagentOutput` setting. When subagent output is hidden:
+ *   - Child-agent events are filtered down to the `spawn-start` /
+ *     `spawn-end` markers so the user still sees "🌱 working… 🌳 done".
+ *   - The parent's `tool-result` for `spawn` is hidden too. Its body
+ *     duplicates `spawn-end`'s stats line *and* the parent's next
+ *     markdown turn; showing it again produces an extra
+ *     `┃ [sub-agent child-1] Completed …` block users just want gone.
+ *
+ * Renderer-agnostic — returns plain `boolean` so TUI / GUI consumers
+ * can filter events identically.
+ */
+declare function isVisible(event: StreamEvent, settings: Settings): boolean;
+/**
+ * Build the `resultTurnId → owningAssistantTurnId` map used by the select-
+ * turn mode to coalesce a tool-call's surrounding turns into ONE navigation
+ * stop.
+ *
+ * Protocol shape: every `tool_call` block in an assistant turn is closed by
+ * a matching `tool_result` block in the *next* user turn (the agent loop's
+ * history validator depends on this). When the next user turn's only events
+ * are `tool-result`s — i.e. it's pure plumbing for the prior assistant
+ * turn — we map it back to that assistant turn here. The select-turn nav
+ * index ({@link selectableTurnIds}) skips owned turns, and the renderer's
+ * highlight gate ({@link isTurnHighlighted}) extends the selection accent
+ * from the assistant turn to the events of any turn it owns. Net effect:
+ *
+ *   - Navigation never lands the cursor on a result-only turn whose own
+ *     events may be hidden by `showToolResults: false` — the cursor
+ *     wouldn't be visible.
+ *   - Selecting an assistant turn highlights the call AND its result as
+ *     one unit, matching the user's mental model of "one message".
+ *
+ * Owner-lookup is conservative: result-only turns with no matching prior
+ * assistant turn (orphaned — usually because the parent was deleted)
+ * stay selectable so the user can act on them via the turn-details modal.
+ *
+ * Subagent (`childId` set) events are ignored — they live in a separate
+ * conversation tree.
+ */
+declare function turnSelectionOwnership(events: readonly StreamEvent[]): Map<string, string>;
+/**
+ * Render-time check: should `event` paint with the selection accent?
+ *
+ * `true` when the event's own turn is selected, OR when the selected turn
+ * `owns` the event's turn via {@link turnSelectionOwnership} (the call and
+ * its tool-result rows highlight together). `false` when nothing is
+ * selected or the relationship doesn't apply.
+ *
+ * Pure. Renderer-agnostic — the TUI's `<Transcript>` uses it; a GUI's
+ * equivalent walks the same rule.
+ */
+declare function isTurnHighlighted(event: Pick<StreamEvent, 'turnId'>, selectedTurnId: string | null, ownership: ReadonlyMap<string, string>): boolean;
+/**
+ * Deduplicated, in-order list of **parent-conversation** turn ids that appear
+ * in a rendered transcript — the navigation index for the TUI's select-turn
+ * mode. Three classes of turns are deliberately skipped:
+ *
+ *   - **Subagent turns** (`childId` set). Nested execution detail; the
+ *     user's mental model of a "message" is the conversational exchange,
+ *     not each spawn turn. Also filtered out by `isVisible` under
+ *     `hideSubagentOutput: true` — selecting them would highlight nothing.
+ *   - **Result-only turns** — see {@link turnSelectionOwnership}. These get
+ *     coalesced into the assistant turn that emitted their tool_calls.
+ *   - **Settings-hidden turns** (when `settings` is supplied). A turn whose
+ *     every event fails {@link isVisible} would render no rows — landing
+ *     the cursor there hides it from the user entirely. The check is opt-
+ *     in so SDK callers without a Settings object keep the legacy
+ *     "everything visible" behavior.
+ *
+ * Synthetic events (separator, spawn-start, spawn-end) have no `turnId` and
+ * are skipped naturally.
+ */
+declare function selectableTurnIds(events: readonly StreamEvent[], settings?: Settings): string[];
+//#endregion
+//#region src/chat/safe-mode-context.d.ts
+/**
+ * Outcome of an approval prompt. Four bulk decisions match the original
+ * single-edit modal contract; `partial` is the multi-edit branch — the
+ * user accepted a subset of an `edit` / `multi_edit` / `write_file` call.
+ *
+ * `partial.mask` is 1:1 with the call's hunks (in input order): `true`
+ * means apply, `false` means deny. The gate handler walks the mask to
+ * build per-hunk outcomes; the TUI rebinds `ctx.input.edits` to the
+ * approved subset and the renderer reconstructs the full per-hunk view
+ * from the `<edit-outcomes>` annotation appended to the tool result.
+ */
+type ApprovalDecision = 'accept-once' | 'accept-session' | 'accept-safelist' | 'deny' | {
+  kind: 'partial';
+  mask: readonly boolean[];
+};
+/**
+ * Identifies the caller behind an approval prompt — the parent agent or
+ * a specific subagent (`child-N`). The modal's right-side title pins the
+ * label so the user knows which agent issued the call when subagents
+ * bubble their gates up through the parent's hook bus.
+ */
+type ApprovalOriginator = {
+  kind: 'parent';
+} | {
+  kind: 'child';
+  label: string;
+};
+interface ApprovalRequest {
+  id: string;
+  tool: string;
+  input: Record<string, unknown>;
+  resolve: (decision: ApprovalDecision) => void;
+  /** Caller attribution. Absent ≡ `{ kind: 'parent' }`. */
+  originator?: ApprovalOriginator;
+}
+/** Function signature consumed by `tool:gate` handlers + the child-tool wrap. */
+type RequestApproval = (tool: string, input: Record<string, unknown>, originator?: ApprovalOriginator) => Promise<ApprovalDecision>;
+interface SafeModeActions {
+  /** Request a decision; resolves once the user picks. */
+  requestApproval: RequestApproval;
+  /** Resolve the head and shift the queue forward. */
+  resolveHead: (decision: ApprovalDecision) => void;
+  /** Resolve all pending with `deny`. Used on abort / hard exit. */
+  denyAll: () => void;
+}
+/**
+ * Owns the queue + actions. Splits the value across two contexts so a queue
+ * change doesn't invalidate every callback memo that closes over the actions.
+ */
+declare function SafeModeProvider({
+  children
+}: {
+  children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+declare function useSafeModeQueue(): readonly ApprovalRequest[];
+declare function useSafeModeActions(): SafeModeActions;
+//#endregion
+//#region src/chat/markdown-segments.d.ts
+/**
+ * One block returned by {@link splitMarkdownCodeBlocks}. Prose segments
+ * carry their original markdown (including blank lines that bracketed
+ * the fence) so the surrounding paragraph spacing stays faithful to the
+ * original input. Code segments carry the raw body — fence markers and
+ * info-string stripped — so a "copy code" action lands what the user
+ * actually sees, byte-for-byte.
+ */
+interface MarkdownSegment {
+  kind: 'prose' | 'code';
+  content: string;
+  /** Info-string (e.g. `ts`, `python`). Empty when the fence had none. */
+  lang?: string;
+  /**
+   * `true` on a code segment whose closing fence hasn't arrived yet —
+   * i.e. the trailing block during streaming. Consumers can render this
+   * in "streaming" mode (no copy affordance, partial-highlight pipeline)
+   * until the closer lands and it flips to a regular closed segment.
+   */
+  open?: boolean;
+}
+/**
+ * Split markdown text into alternating prose / fenced-code segments.
+ *
+ * Recognizes both ` ``` ` and `~~~` fences, with arbitrary length ≥ 3,
+ * matching CommonMark's "fence indicator must be at least as long to
+ * close" rule. Info-strings (the bit after the opening fence) are kept
+ * as the `lang` hint; any trailing whitespace is trimmed. Closing
+ * fences are detected on a line of their own (whitespace tolerated).
+ *
+ * Unclosed fences fall back to emitting the would-be-code body as a
+ * trailing prose segment so no content is dropped — finalized markdown
+ * isn't expected to ship one, but the fallback keeps the renderer
+ * truthful when the model produces malformed output.
+ *
+ * Exported for unit tests.
+ */
+declare function splitMarkdownCodeBlocks(text: string): MarkdownSegment[];
+/**
+ * Lift indented fenced code blocks to column 0 while preserving the code
+ * body's relative indentation.
+ *
+ * OpenTUI's markdown renderNode hook only receives top-level code tokens.
+ * A common assistant shape is:
+ *
+ *   - Run this:
+ *     ```bash
+ *     command
+ *     ```
+ *
+ * Marked parses that as code inside a list token, so the TUI loses the
+ * code-panel wrapper and copy affordance. Normalizing just the fence's list
+ * indentation keeps the prose readable while routing the snippet through
+ * the same top-level renderer as ordinary fences.
+ */
+declare function normalizeMarkdownCodeFences(text: string): string;
+/**
+ * Default per-chunk target for {@link chunkMarkdownForRender}. Chosen from
+ * measurement: marked's lexer (which OpenTUI's `<markdown>` runs
+ * internally) is O(n²) over paragraph-heavy input — ~500ms at 64KiB,
+ * ~2s at 128KiB, ~6s at 256KiB on an M-series laptop — while staying
+ * comfortably in the linear zone below ~32KiB (≤ ~200ms). Chunking a
+ * large document into ≤24KiB pieces keeps the total render linear in
+ * document size with a small constant.
+ */
+declare const MARKDOWN_RENDER_CHUNK_TARGET_BYTES = 24576;
+/**
+ * Split a large markdown document into render-safe chunks at blank-line
+ * boundaries outside code fences, each roughly `targetBytes` long.
+ *
+ * Rendering the chunks as SIBLING markdown renderables (with a one-row
+ * gap standing in for the consumed blank line) is visually equivalent to
+ * one renderable, but sidesteps the quadratic lexer cost documented on
+ * {@link MARKDOWN_RENDER_CHUNK_TARGET_BYTES}. Chunk boundaries are
+ * prefix-stable: appending text (streaming) can only ever change the
+ * LAST chunk, so keyed-by-index consumers reconcile cheaply.
+ *
+ * Returns `[text]` untouched for anything at or under the target.
+ */
+declare function chunkMarkdownForRender(text: string, targetBytes?: number): string[];
+//#endregion
+//#region src/chat/prompt-segments.d.ts
+/**
+ * Pure string + reference math for rendering a submitted prompt with chip
+ * pills around completion references. Renderer-agnostic — the TUI walks
+ * the segments into OpenTUI `<text>` nodes, a GUI walks them into JSX
+ * spans + `<span class="chip">` pills. No layout engine assumptions.
+ */
+/**
+ * Highlight span — half-open `[start, end)` over the source string.
+ *
+ * Offsets are JS string indices (UTF-16 code units) — the same convention used
+ * everywhere else in the chat layer (`text[i]`, `m.index`, `String.slice`).
+ * Surrogate pairs that straddle a span boundary would render malformed, but
+ * realistic prompts in this surface (terminal text + ASCII triggers) keep that
+ * risk theoretical; callers feeding emoji-heavy content should normalize to
+ * codepoint walks upstream.
+ */
+interface PromptSegmentRef {
+  start: number;
+  end: number;
+  /** Provider id tagging this span (`'skills'`, `'files'`, …). Free-form. */
+  providerId: string;
+}
+/**
+ * One atomic unit emitted by {@link splitPromptSegments}. Plain segments
+ * are word-sized so wraps land cleanly between words; chip segments
+ * carry the source `providerId` (`'skills'`, `'files'`, …) so renderers
+ * can pick per-kind colors without re-walking the ref list.
+ */
+type PromptSegment = {
+  kind: 'plain';
+  text: string;
+} | {
+  kind: 'chip';
+  text: string;
+  providerId: string;
+};
+/**
+ * Split a prompt buffer into word-sized atomic segments suitable for a
+ * flex-row + flex-wrap renderer (TUI) or a `display: inline` flow with
+ * inline-block chips (GUI). Each chip becomes one segment (atomic —
+ * never broken across rows); each plain run is split into "word +
+ * trailing space" units so wraps land at clean word boundaries.
+ *
+ * Robust to:
+ *   - Overlapping refs — sorted by start; later refs that overlap are
+ *     dropped via the first-wins rule.
+ *   - Out-of-bounds refs — dropped entirely when `end > text.length` or
+ *     `start >= text.length`. Partial clipping would silently truncate
+ *     a chip's label; the caller is in a better position to surface the
+ *     mismatch (typically a stale `refs` array referencing a previous text).
+ *   - Whitespace-only plain runs — emitted as their own plain segment
+ *     so chip-adjacent-to-chip cases keep the original spacing.
+ *
+ * Word splitter rationale: `\S+\s*` keeps trailing whitespace attached
+ * to its preceding word so wrap boundaries land between words (cleanly).
+ * A leading-whitespace-only segment is captured by `\s+` so we don't
+ * drop it entirely when the plain run starts with a space.
+ */
+declare function splitPromptSegments(text: string, refs: readonly PromptSegmentRef[]): PromptSegment[];
+//#endregion
+//#region src/chat/tool-formatters.d.ts
+/**
+ * Per-tool display metadata + one-line formatters consumed by any
+ * surface that renders a `tool` event in `'formatted'` mode (see
+ * `Settings.toolCallDisplay`).
+ *
+ * Each native tool gets a curated entry — a `displayName` verb that
+ * reads in sentence case (e.g. "Read", "Shell") and a `format` callback
+ * that pulls the most informative bits out of the model's raw input to
+ * a single scannable line. Unknown tools (MCP servers, host-added
+ * tools, future zidane additions) fall back to {@link formatToolCall}
+ * returning `null` — the renderer then shows a minimal `↳ <name>` line.
+ *
+ * Renderer-agnostic: returns plain data (`{ target, meta }`) so the
+ * TUI's React/OpenTUI surface and any future GUI consumer can paint
+ * the same shape in their own style. Lives in `zidane/chat` because
+ * it has no rendering concerns; the TUI just consumes it.
+ */
+interface ToolFormatLine {
+  /**
+   * Primary target — typically a path, command, pattern, or
+   * task description. Renderer paints this in the model accent color
+   * so the eye lands on it first.
+   */
+  target?: string;
+  /**
+   * Secondary annotations rendered after the target, joined with
+   * ` · ` separators. Use for line ranges (`L10-25`), limits, flags,
+   * or any short suffix that adds context without bloating the line.
+   */
+  meta?: readonly string[];
+}
+interface ToolDisplayMeta {
+  /**
+   * Title-case display verb (e.g. `Read`, `Shell`, `Edit`). When the
+   * label depends on an input field (e.g. `skills_use`'s
+   * `mode: 'activate' | 'deactivate'` → `Enable` / `Disable`), supply
+   * a function instead and read the field defensively. The function
+   * form is called whenever {@link displayNameFor} has the call's
+   * input in scope; callers without input fall back to the function's
+   * `input: undefined` branch, which should return a stable default.
+   */
+  displayName: string | ((input: Record<string, unknown> | undefined) => string);
+  /**
+   * Pull a {@link ToolFormatLine} out of the raw model input. Returns
+   * `null` when the shape isn't what the tool expects (typed defensively
+   * — we never want a malformed call to crash the transcript).
+   */
+  format: (input: Record<string, unknown>) => ToolFormatLine | null;
+}
+declare const TOOL_DISPLAY: Readonly<Record<string, ToolDisplayMeta>>;
+/**
+ * Resolve the display verb for a tool. Native tools use their curated
+ * entry from {@link TOOL_DISPLAY}; everything else gets a sentence-case
+ * version of the raw name (`my_host_tool` → `My host tool`) so an MCP /
+ * host tool still reads cleanly in the transcript without shouting
+ * Title Case at every word.
+ *
+ * MCP convention: every tool surfaced by `mcp/connectMcpServers` is
+ * namespaced as `mcp_<server>_<tool>` (see `src/mcp/index.ts`). The
+ * `mcp_` prefix is plumbing — strip it before casing so the label
+ * reads as `Github create issue` instead of `Mcp github create issue`.
+ * The server name leads, which doubles as a free visual grouping
+ * affordance ("everything starting with `Github` came from the github
+ * MCP server").
+ */
+declare function displayNameFor(name: string, input?: Record<string, unknown>): string;
+/**
+ * Run a tool's curated formatter and return the result, or `null` when
+ * no formatter is registered / the input shape doesn't match. Renderer
+ * decides what to do with `null` — typically: show `↳ <displayName>`
+ * with no target / meta tail.
+ */
+declare function formatToolCall(name: string, input: Record<string, unknown>): ToolFormatLine | null;
+//#endregion
+export { isTurnHighlighted as C, turnSelectionOwnership as E, isEditErrorResult as S, selectableTurnIds as T, SafeModeActions as _, formatToolCall as a, useSafeModeQueue as b, splitPromptSegments as c, chunkMarkdownForRender as d, normalizeMarkdownCodeFences as f, RequestApproval as g, ApprovalRequest as h, displayNameFor as i, MARKDOWN_RENDER_CHUNK_TARGET_BYTES as l, ApprovalDecision as m, ToolDisplayMeta as n, PromptSegment as o, splitMarkdownCodeBlocks as p, ToolFormatLine as r, PromptSegmentRef as s, TOOL_DISPLAY as t, MarkdownSegment as u, SafeModeProvider as v, isVisible as w, EDIT_TOOL_NAMES as x, useSafeModeActions as y };
+//# sourceMappingURL=tool-formatters-DY0TDb1r.d.ts.map

package/dist/tool-formatters-DY0TDb1r.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-formatters-DY0TDb1r.d.ts","names":[],"sources":["../src/chat/turn-selection.ts","../src/chat/safe-mode-context.tsx","../src/chat/markdown-segments.ts","../src/chat/prompt-segments.ts","../src/chat/tool-formatters.ts"],"mappings":";;;;;cAaa,eAAA,EAAiB,WAAW;;AAAzC;;;;AAAyC;AAmBzC;;;;AAA8C;AA+B9C;;;;;;iBA/BgB,iBAAA,CAAkB,IAAY;;;AA+BkB;AAuDhE;;;;;;;;AAA2E;AAiD3E;iBAxGgB,SAAA,CAAU,KAAA,EAAO,WAAA,EAAa,QAAA,EAAU,QAAQ;;;;;;;;;;;;;;AA2GxB;AA6BxC;;;;;;;;;AAEqB;;;;iBAnFL,sBAAA,CAAuB,MAAA,WAAiB,WAAA,KAAgB,GAAG;;;;AC9E9C;AAQ7B;;;;;;;iBDuHgB,iBAAA,CACd,KAAA,EAAO,IAAA,CAAK,WAAA,aACZ,cAAA,iBACA,SAAA,EAAW,WAAA;ACxHe;AAE5B;;;;;;;;;;;;;;;;;;AAMiC;AARL,iBDqJZ,iBAAA,CACd,MAAA,WAAiB,WAAA,IACjB,QAAA,GAAW,QAAQ;;;;;AA1I2C;AAuDhE;;;;;;;;KCnFY,gBAAA;EAKJ,IAAA;EAAiB,IAAI;AAAA;;;;;;;KAQjB,kBAAA;EACJ,IAAA;AAAA;EACA,IAAA;EAAe,KAAA;AAAA;AAAA,UAEN,eAAA;EACf,EAAA;EACA,IAAA;EACA,KAAA,EAAO,MAAA;EACP,OAAA,GAAU,QAAA,EAAU,gBAAA;EDgJH;EC9IjB,UAAA,GAAa,kBAAA;AAAA;;KAIH,eAAA,IACV,IAAA,UACA,KAAA,EAAO,MAAA,mBACP,UAAA,GAAa,kBAAA,KACV,OAAA,CAAQ,gBAAA;AAAA,UAEI,eAAA;;EAEf,eAAA,EAAiB,eAAA;;EAEjB,WAAA,GAAc,QAAA,EAAU,gBAAgB;EArCd;EAuC1B,OAAA;AAAA;AAlC2B;AAQ7B;;;AAR6B,iBAqDb,gBAAA,CAAA;EAAmB;AAAA;EAAc,QAAA,EAAU,SAAS;AAAA,gCAAE,GAAA,CAAA,OAAA;AAAA,iBAqEtD,gBAAA,CAAA,YAA6B,eAAe;AAAA,iBAI5C,kBAAA,CAAA,GAAsB,eAAe;;;;;;;ADzJrD;;;;UEUiB,eAAA;EACf,IAAA;EACA,OAAA;;EAEA,IAAA;EFK4C;AA+B9C;;;;;EE7BE,IAAA;AAAA;;;AF6B8D;AAuDhE;;;;;;;;AAA2E;AAiD3E;;;;iBElHgB,uBAAA,CAAwB,IAAA,WAAe,eAAe;;;;;;;;;;;AFqH9B;AA6BxC;;;;;;iBE7DgB,2BAAA,CAA4B,IAAY;;;AF+DnC;;;;ACtKrB;;;cC4Ja,kCAAA;ADvJgB;AAQ7B;;;;;;;;AAE4B;AAE5B;;;AAZ6B,iBCsLb,sBAAA,CAAuB,IAAA,UAAc,WAAwD;;;;;;;AFjN7G;;;;AAAyC;AAmBzC;;;;AAA8C;AA+B9C;;UG9CiB,gBAAA;EACf,KAAA;EACA,GAAA;EH4CwB;EG1CxB,UAAA;AAAA;;AH0C8D;AAuDhE;;;;KGxFY,aAAA;EACJ,IAAA;EAAe,IAAA;AAAA;EACf,IAAA;EAAc,IAAA;EAAc,UAAA;AAAA;;;;;;;;;;;;;AH0II;AA6BxC;;;;;;;;;iBG/IgB,mBAAA,CACd,IAAA,UACA,IAAA,WAAe,gBAAA,KACd,aAAa;;;;;;;AH9ChB;;;;AAAyC;AAmBzC;;;;AAA8C;AA+B9C;;;UI3CiB,cAAA;EJ2CgB;;;;;EIrC/B,MAAA;EJ4Fc;;;;;EItFd,IAAI;AAAA;AAAA,UAGW,eAAA;EJmF0D;AAiD3E;;;;;;;;EI1HE,WAAA,aAAwB,KAAA,EAAO,MAAA;EJ2HnB;;;;;EIrHZ,MAAA,GAAS,KAAA,EAAO,MAAA,sBAA4B,cAAA;AAAA;AAAA,cAOjC,YAAA,EAAc,QAAA,CAAS,MAAA,SAAe,eAAA;;;;;;;;;AJ+I9B;;;;ACtKrB;;;iBGoUgB,cAAA,CACd,IAAA,UACA,KAAA,GAAQ,MAAM;AHjUa;AAQ7B;;;;;AAR6B,iBGmVb,cAAA,CAAe,IAAA,UAAc,KAAA,EAAO,MAAA,oBAA0B,cAAc"}

package/dist/tools/fetch-url.d.ts

@@ -1,4 +1,4 @@
-import { T as ToolDef } from "../agent-EFWt6uQ_.js";
+import { lf as ToolDef } from "../index-B8UtiZy7.js";
 
 //#region src/tools/fetch-url.d.ts
 declare function isBlockedAddress(ip: string): boolean;

package/dist/tools/web-search.d.ts

@@ -1,4 +1,4 @@
-import { T as ToolDef } from "../agent-EFWt6uQ_.js";
+import { lf as ToolDef } from "../index-B8UtiZy7.js";
 
 //#region src/tools/web-search.d.ts
 declare const webSearch: ToolDef;

package/dist/tools.d.ts

@@ -1,3 +1,2 @@
-import { A as getReadState, D as HydrateReadStateOptions, E as ToolMap, F as resolveReadStateMap, M as hydrateReadStateFromSession, N as hydrateReadStateFromSessionAsync, O as ReadStateEntry, P as readStateKey, T as ToolDef, j as hashContent, k as ReadStateMap, w as ToolContext } from "./agent-EFWt6uQ_.js";
-import { $n as SpawnToolState, Gn as validateToolArgs, Hn as WAIT_TASK_TIMED_OUT_PREFIX, Jn as LazyToolEntry, Kn as TailTruncateOptions, Qn as SpawnToolOptions, Un as waitTask, Vn as writeFile, Wn as ValidationResult, Xn as createToolSearchTool, Yn as ToolSearchToolOptions, Zn as ChildAgent, _r as createInteractionTool, ar as SkillsRunScriptToolOptions, br as edit, cr as createSkillsReadTool, dr as createShellTool, er as SubagentDef, fr as shell, gr as InteractionToolOptions, hr as listFiles, ir as createSkillsUseTool, lr as shellKill, mr as multiEdit, nr as createSpawnTool, or as createSkillsRunScriptTool, pr as readFile, qn as tailTruncate, rr as SkillsUseToolOptions, sr as SkillsReadToolOptions, tr as SubagentRegistry, ur as CreateShellToolOptions, vr as grep, yr as glob } from "./index-BtzE3Uaq.js";
-export { type ChildAgent, type CreateShellToolOptions, type HydrateReadStateOptions, type InteractionToolOptions, type LazyToolEntry, type ReadStateEntry, type ReadStateMap, type SkillsReadToolOptions, type SkillsRunScriptToolOptions, type SkillsUseToolOptions, type SpawnToolOptions, type SpawnToolState, type SubagentDef, type SubagentRegistry, type TailTruncateOptions, type ToolContext, type ToolDef, type ToolMap, type ToolSearchToolOptions, type ValidationResult, WAIT_TASK_TIMED_OUT_PREFIX, createInteractionTool, createShellTool, createSkillsReadTool, createSkillsRunScriptTool, createSkillsUseTool, createSpawnTool, createToolSearchTool, edit, getReadState, glob, grep, hashContent, hydrateReadStateFromSession, hydrateReadStateFromSessionAsync, listFiles, multiEdit, readFile, readStateKey, resolveReadStateMap, shell, shellKill, tailTruncate, validateToolArgs, waitTask, writeFile };
+import { $n as validateToolArgs, Qn as ValidationResult, Sr as edit, Xn as WAIT_TASK_TIMED_OUT_PREFIX, Yn as writeFile, Zn as waitTask, _f as hydrateReadStateFromSessionAsync, _r as listFiles, ar as SkillsUseToolOptions, br as grep, cf as ToolContext, cr as createSkillsRunScriptTool, cs as SpawnTool, df as HydrateReadStateOptions, dr as shellKill, ds as SubagentDef, er as TailTruncateOptions, ff as ReadStateEntry, fr as CreateShellToolOptions, fs as SubagentOverride, gf as hydrateReadStateFromSession, gr as multiEdit, hf as hashContent, hr as readFile, hs as isSpawnTool, ir as createToolSearchTool, lf as ToolDef, lr as SkillsReadToolOptions, ls as SpawnToolOptions, mf as getReadState, mr as shell, ms as createSpawnTool, nr as LazyToolEntry, or as createSkillsUseTool, os as ChildAgent, pf as ReadStateMap, pr as createShellTool, ps as SubagentRegistry, rr as ToolSearchToolOptions, sr as SkillsRunScriptToolOptions, ss as ExtensionSubagentDef, tr as tailTruncate, uf as ToolMap, ur as createSkillsReadTool, us as SpawnToolState, vf as readStateKey, vr as InteractionToolOptions, xr as glob, yf as resolveReadStateMap, yr as createInteractionTool } from "./index-B8UtiZy7.js";
+export { type ChildAgent, type CreateShellToolOptions, type ExtensionSubagentDef, type HydrateReadStateOptions, type InteractionToolOptions, type LazyToolEntry, type ReadStateEntry, type ReadStateMap, type SkillsReadToolOptions, type SkillsRunScriptToolOptions, type SkillsUseToolOptions, type SpawnTool, type SpawnToolOptions, type SpawnToolState, type SubagentDef, type SubagentOverride, type SubagentRegistry, type TailTruncateOptions, type ToolContext, type ToolDef, type ToolMap, type ToolSearchToolOptions, type ValidationResult, WAIT_TASK_TIMED_OUT_PREFIX, createInteractionTool, createShellTool, createSkillsReadTool, createSkillsRunScriptTool, createSkillsUseTool, createSpawnTool, createToolSearchTool, edit, getReadState, glob, grep, hashContent, hydrateReadStateFromSession, hydrateReadStateFromSessionAsync, isSpawnTool, listFiles, multiEdit, readFile, readStateKey, resolveReadStateMap, shell, shellKill, tailTruncate, validateToolArgs, waitTask, writeFile };

package/dist/tools.js

@@ -1,4 +1,3 @@
-import { a as hydrateReadStateFromSessionAsync, c as resolveReadStateMap, i as hydrateReadStateFromSession, r as hashContent, s as readStateKey, t as getReadState } from "./read-state-BymF41Jb.js";
-import { _ as validateToolArgs, a as createSkillsUseTool, d as tailTruncate, i as createToolSearchTool, l as createShellTool, n as WAIT_TASK_TIMED_OUT_PREFIX, o as createSkillsRunScriptTool, r as waitTask, s as createSkillsReadTool, u as shell } from "./agent-Cch2ayTt.js";
-import { a as multiEdit, c as grep, i as readFile, l as glob, n as createSpawnTool, o as listFiles, r as shellKill, s as createInteractionTool, t as writeFile, u as edit } from "./tools-CCd8e-HT.js";
-export { WAIT_TASK_TIMED_OUT_PREFIX, createInteractionTool, createShellTool, createSkillsReadTool, createSkillsRunScriptTool, createSkillsUseTool, createSpawnTool, createToolSearchTool, edit, getReadState, glob, grep, hashContent, hydrateReadStateFromSession, hydrateReadStateFromSessionAsync, listFiles, multiEdit, readFile, readStateKey, resolveReadStateMap, shell, shellKill, tailTruncate, validateToolArgs, waitTask, writeFile };
+import { a as hydrateReadStateFromSessionAsync, c as resolveReadStateMap, i as hydrateReadStateFromSession, r as hashContent, s as readStateKey, t as getReadState } from "./read-state-Dq_TXUX1.js";
+import { Ct as listFiles, Dt as edit, Et as glob, Ot as validateToolArgs, St as multiEdit, Tt as grep, _t as shellKill, bt as tailTruncate, ct as writeFile, dt as createToolSearchTool, ft as createSpawnTool, gt as createSkillsReadTool, ht as createSkillsRunScriptTool, lt as WAIT_TASK_TIMED_OUT_PREFIX, mt as createSkillsUseTool, pt as isSpawnTool, ut as waitTask, vt as createShellTool, wt as createInteractionTool, xt as readFile, yt as shell } from "./agent-DkSmGkDM.js";
+export { WAIT_TASK_TIMED_OUT_PREFIX, createInteractionTool, createShellTool, createSkillsReadTool, createSkillsRunScriptTool, createSkillsUseTool, createSpawnTool, createToolSearchTool, edit, getReadState, glob, grep, hashContent, hydrateReadStateFromSession, hydrateReadStateFromSessionAsync, isSpawnTool, listFiles, multiEdit, readFile, readStateKey, resolveReadStateMap, shell, shellKill, tailTruncate, validateToolArgs, waitTask, writeFile };