zidane 7.2.4 → 8.0.4

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

@@ -1,759 +0,0 @@
-import { Fd as SessionMeta, Hf as ModelInfo, Id as Settings, Ld as StreamEvent, Lf as ProviderAuth, Rf as ProviderKey, U_ as SessionTurn } from "./index-BgN1T3lk.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>;
-/**
- * Keep turn-selection mode alive after deleting its active row. Prefer the
- * row that slides into the deleted index; at the tail, select the new last
- * row. Returns null only when no selectable rows survive.
- */
-declare function selectionAfterTurnRemoval(before: readonly string[], removedId: string, after: readonly string[]): string | null;
-/**
- * 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;
-/**
- * `callId` prefix minted by the TUI's `!` bash mode (see `runBashCommand`
- * in `src/tui/app.tsx`). The prefix is the durable signal — it survives
- * persistence and replay — that a `shell` tool exchange was USER-initiated,
- * so renderers can keep it visible even when the tool-display settings
- * hide model-driven plumbing: the user typed the command and expects to
- * see it and what it printed.
- */
-declare const BASH_CALL_ID_PREFIX = "bash_";
-/** Is this event a user-initiated `!` bash exchange (vs. a model-driven shell call)? */
-declare function isUserBashEvent(event: Pick<StreamEvent, 'tool' | 'callId'>): boolean;
-/**
- * Retro-tag live `user-prompt` events with the id of their persisted turn.
- *
- * Live prompt echoes are appended to the stream BEFORE `agent.run()` mints
- * and persists the user turn, so they carry no `turnId` — which makes them
- * invisible to select-turn navigation, hover, and click (all keyed on
- * `turnId`), while the SAME prompt becomes selectable after a session reload
- * (replay tags every event). Hosts call this when the seeded turns land
- * (e.g. the `session:turns` hook, which fires right after the prompt turn
- * persists, before the first model turn).
- *
- * Matching rule, per prompt-bearing turn: the NEWEST `user-prompt` event
- * that has no `turnId` yet and whose text equals one of the turn's text
- * blocks — or the turn's `display` echo when the caller supplies one
- * (run-minted prompt turns never carry `display` themselves; the TUI's
- * command `runAgent` path injects the origin display onto a copy after the
- * sub-run resolves, since the echo event's text is the short display line,
- * not the full prompt). A prompt turn qualifies with at least one non-blank
- * text block, OR — the attachment-only submit — with media blocks
- * (document/image/audio/video) and no tool plumbing; the latter matches the
- * newest untagged blank-text event that carries attachment chips. Tool-
- * result-only user turns contribute nothing and synthetic loop-continue
- * turns match no untagged event, so both fall through harmlessly.
- *
- * Pure — returns the SAME array instance when nothing matched, so hosts
- * can cheaply skip a re-render.
- */
-declare function retagUserPromptEvents(events: readonly StreamEvent[], appendedTurns: readonly SessionTurn[]): readonly StreamEvent[];
-/**
- * Reduce persisted turns to the prompt refs the retag needs, dropping
- * non-prompt turns (assistant, tool results) entirely.
- *
- * Shared by the in-process path and the daemon broadcast so both select the
- * same turns as "prompts" — a divergence here would make a prompt selectable
- * on one surface and not the other.
- */
-declare function promptTurnRefs(turns: readonly SessionTurn[]): PromptTurnRef[];
-/**
- * The minimum a prompt turn must carry to be matched against its live echo.
- *
- * Exists because the daemon has to send this over a wire: a full `SessionTurn`
- * carries every content block, including base64 image and document payloads,
- * which would be megabytes per prompt to ship for the sake of attaching an id.
- */
-interface PromptTurnRef {
-  id: string;
-  /** Text blocks plus the `display` override, if any. */
-  texts: readonly string[];
-  attachmentOnly: boolean;
-}
-/**
- * Attach persisted turn ids to the live `user-prompt` events they correspond
- * to, so a just-sent prompt becomes selectable (hover, click, edit, delete)
- * without waiting for a session reload.
- *
- * Matching is newest-first and one-to-one: identical prompt text sent twice
- * must bind to two different turns, so each ref consumes exactly one untagged
- * event.
- */
-declare function retagUserPromptEventsFromRefs(events: readonly StreamEvent[], refs: readonly PromptTurnRef[]): readonly StreamEvent[];
-/**
- * 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.
- */
-/** `notice.label` the host stamps on prompt-cache break/expiry rows (`host/engine.ts`). */
-declare const CACHE_NOTICE_LABEL = "cache";
-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, visible?: (event: StreamEvent) => boolean): string[];
-//#endregion
-//#region src/chat/cred-keys.d.ts
-/**
- * Credential-file key arithmetic, split from `./credentials` so the rules can
- * be enforced where credentials themselves must not be pulled in.
- *
- * `./credentials` reaches the provider registry (and through it the pi-ai
- * factories) for `credKeyOf`; the extension loader — an edge entrypoint that
- * validates descriptor keys at registration time — must stay clear of that
- * graph. This module is string arithmetic with no imports.
- */
-/**
- * Separator between a provider's canonical key and a slot qualifier. Every
- * non-canonical slot (`#alt`, `#account:N`) starts with it, so the character is
- * reserved in descriptor credential keys outright.
- */
-declare const CRED_KEY_SLOT_SEPARATOR = "#";
-/**
- * Reserved suffix marking a provider's SECOND credential slot.
- *
- * Not usable as (or as the tail of) a descriptor's credential key: `foo#alt`
- * holds `foo`'s alternate credential, so a provider claiming that name would
- * share storage with it.
- */
-declare const ALTERNATE_CRED_KEY_SUFFIX = "#alt";
-/**
- * Reserved infix marking one of a provider's ADDITIONAL OAuth accounts:
- * `foo#account:1`, `foo#account:2`, …
- */
-declare const ACCOUNT_CRED_KEY_INFIX = "#account:";
-/**
- * File key holding a provider's second credential, when it has one of each kind.
- *
- * The canonical key always holds the credential the user prefers; this sibling
- * holds the other. That one invariant is what makes preference selection free:
- * every existing reader (`applyApiKeyEnv`, the harness provider factories)
- * already resolves the canonical key, so "switch priority" is just moving two
- * objects between two keys — no precedence flag to interpret, no resolution
- * order to keep in sync across layers.
- *
- * A sibling key rather than a nested field because the canonical entry gets
- * REPLACED wholesale on token refresh; anything nested inside it would be
- * dropped by the next rotation. And older zidane versions look credentials up
- * by `credKeyOf`, so a suffixed key is simply invisible to them — they read the
- * preferred credential and behave exactly as before, which is why this needs no
- * migration or schema version.
- */
-declare function alternateCredKey(fileKey: string): string;
-/**
- * File key holding one of a provider's non-active OAuth accounts.
- *
- * Same sibling-key reasoning as {@link alternateCredKey}: the canonical key is
- * the active one, so a provider with three OAuth grants stores the active one
- * canonically and the other two under `#account:N`. `#alt` stays dedicated to
- * the other-kind (API key) alternate so files written by builds that predate
- * multi-account keep meaning the same thing.
- */
-declare function accountCredKey(fileKey: string, n: number): string;
-/** True when `key` is one of `fileKey`'s `#account:N` slots. */
-declare function isAccountCredKey(fileKey: string, key: string): boolean;
-/**
- * Name shown for an OAuth account that was never given one.
- *
- * Also what a first OAuth login is stored under, so a second account has
- * something to be told apart from. Pre-multi-account files hold unnamed
- * grants; {@link oauthAccountLabel} makes them read the same.
- */
-declare const DEFAULT_OAUTH_ACCOUNT_LABEL = "Default";
-/** Trimmed user-given account name, or {@link DEFAULT_OAUTH_ACCOUNT_LABEL}. */
-declare function oauthAccountLabel(credential: {
-  label?: unknown;
-}): string;
-/**
- * True when a key claims a reserved slot namespace.
- *
- * Built-in keys are plain identifiers (`anthropic`, `openai-codex`), but
- * `ProviderDescriptor.key` / `credentialFileKey` are open strings — so the
- * reservation is checked, not assumed.
- */
-declare function isReservedCredKey(fileKey: string): boolean;
-//#endregion
-//#region src/chat/daemon-health.d.ts
-/**
- * Daemon connection health — the one model behind the status dot in both
- * clients' footers.
- *
- * Three states, because "connected: boolean" cannot express the one users
- * actually want to see: a daemon that is being spawned or reconnected is not
- * DOWN, and painting it red for the seconds that takes teaches people to
- * ignore red. So:
- *
- *   - `connected`    — handshake done, signals live.            green (accent)
- *   - `connecting`   — spawning / reconnecting / first attempt. amber (warn)
- *   - `disconnected` — reachable daemon absent, last attempt failed. red (error)
- *
- * Tones are theme SLOTS, not colors, so the dot recolors with the palette on
- * both surfaces. Node-free; re-exported from `zidane/chat/pure`.
- */
-type DaemonHealth = 'connected' | 'connecting' | 'disconnected';
-type DaemonHealthTone = 'accent' | 'warn' | 'error';
-interface DaemonHealthStyle {
-  tone: DaemonHealthTone;
-  /** Tooltip / accessibility text. The dot itself carries no words. */
-  label: string;
-}
-declare const DAEMON_HEALTH_GLYPH = "\u25CF";
-declare const DAEMON_HEALTH_STYLE: Readonly<Record<DaemonHealth, DaemonHealthStyle>>;
-//#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;
-  /**
-   * Cross-window correlation id (the daemon's approval request id) for
-   * entries surfaced by the daemon runtime. Lets `dropByCorrelation`
-   * retract this entry when ANOTHER window resolves the same shared
-   * approval, without re-sending a decision. Absent for local-runtime
-   * approvals.
-   */
-  correlationId?: string;
-}
-/** Function signature consumed by `tool:gate` handlers + the child-tool wrap. */
-type RequestApproval = (tool: string, input: Record<string, unknown>, originator?: ApprovalOriginator, correlationId?: string) => 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;
-  /**
-   * Remove the entry whose `correlationId` matches, WITHOUT resolving it
-   * (the daemon already did, in another window). No-op when absent.
-   */
-  dropByCorrelation: (correlationId: string) => 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.Element;
-declare function useSafeModeQueue(): readonly ApprovalRequest[];
-declare function useSafeModeActions(): SafeModeActions;
-//#endregion
-//#region src/chat/history-search.d.ts
-interface HighlightRange {
-  start: number;
-  end: number;
-}
-interface HighlightSegment {
-  text: string;
-  highlighted: boolean;
-}
-interface SearchExcerpt {
-  text: string;
-  highlighted: HighlightRange[];
-}
-interface SearchTurnMatch {
-  turn: SessionTurn;
-  text: string;
-  highlighted: HighlightRange[];
-  excerpts: SearchExcerpt[];
-  score: number;
-  matchKind: 'exact-phrase' | 'exact-terms' | 'fuzzy';
-}
-type SearchTurnResult = SearchTurnMatch;
-interface SearchSessionResult {
-  id: string;
-  score: number;
-  matchKind: 'exact-phrase' | 'exact-terms' | 'fuzzy';
-  turn: SessionTurn;
-  text: string;
-  highlighted: HighlightRange[];
-  excerpts: SearchExcerpt[];
-}
-interface SessionSearchExcerpt extends SearchExcerpt {
-  turnId: string;
-  role: SessionTurn['role'];
-}
-/** Aggregated row-level match used by the conversations list. */
-interface SessionHistoryMatch {
-  score: number;
-  matchedTurnIds: string[];
-  excerpts: SessionSearchExcerpt[];
-}
-interface IndexedSearchTurn {
-  turn: SessionTurn;
-  /** Attachment/base64-free text shown in search results. */
-  text: string;
-  /** Pre-normalized once, reused for every query. */
-  lowerText: string;
-}
-interface SessionSearchIndex {
-  turns: IndexedSearchTurn[];
-}
-declare function buildSessionSearchIndex(turns: readonly SessionTurn[]): SessionSearchIndex;
-/** Yielding index builder for TUI callers — never monopolizes a frame. */
-declare function buildSessionSearchIndexAsync(turns: readonly SessionTurn[], options?: {
-  yieldEvery?: number;
-  onProgress?: (indexed: number, total: number) => void;
-  signal?: AbortSignal;
-}): Promise<SessionSearchIndex>;
-declare function searchSessionIndex(index: SessionSearchIndex, query: string, limit?: number): SearchTurnMatch[];
-/** Yielding matcher for very large indexes; progress is checked per chunk. */
-declare function searchSessionIndexAsync(index: SessionSearchIndex, query: string, options?: {
-  limit?: number;
-  yieldEvery?: number;
-  onProgress?: (searched: number, total: number) => void;
-  signal?: AbortSignal;
-}): Promise<SearchTurnMatch[]>;
-declare function searchTurns(turns: readonly SessionTurn[], query: string, limit?: number): SearchTurnMatch[];
-declare function searchSessionTurns(turns: readonly SessionTurn[], query: string, maxExcerpts?: number): SearchSessionResult[];
-declare function searchSessionHistory(turns: readonly SessionTurn[], query: string, maxExcerpts?: number): SessionHistoryMatch | null;
-declare function searchSessionHistoryIndex(index: SessionSearchIndex, query: string, maxExcerpts?: number): SessionHistoryMatch | null;
-declare function searchSessionHistoryIndexAsync(index: SessionSearchIndex, query: string, maxExcerpts?: number, onProgress?: (searched: number, total: number) => void, signal?: AbortSignal): Promise<SessionHistoryMatch | null>;
-declare function filterSessionSearchCatalog(sessions: readonly SessionMeta[], query: string, contentMatches: ReadonlyMap<string, SessionHistoryMatch>): SessionMeta[];
-declare function searchHighlightRanges(text: string, query: string): HighlightRange[];
-declare function highlightSegments(text: string, ranges: readonly HighlightRange[]): HighlightSegment[];
-/**
- * Search-specific serializer. Unlike `turnAsText`, it never serializes media,
- * document attachments, encrypted reasoning, or base64-looking payloads.
- */
-declare function searchableTurnText(turn: SessionTurn): string;
-//#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/model-catalog.d.ts
-/** A model entry as displayed in the cross-provider picker. */
-interface CatalogEntry {
-  providerKey: ProviderKey;
-  providerLabel: string;
-  model: ModelInfo;
-  /**
-   * The provider does not (or no longer) list this model: the entry was
-   * synthesized from an `include` pair, so `model` is a stub carrying the id
-   * and nothing else. Renderers should say so rather than print stub
-   * metadata as if it were real.
-   */
-  offCatalog?: boolean;
-  /**
-   * Pre-computed lowercase corpus for substring search across the
-   * provider key, label, model id, and display name. Built once at
-   * catalog-assembly time so filtering on every keystroke is
-   * O(catalogSize × queryLength), not O(catalogSize × fieldCount ×
-   * lowercase-overhead × queryLength).
-   */
-  searchCorpus: string;
-}
-/**
- * Build the unified catalog from a list of available providers.
- *
- * Provider order is preserved (callers typically pass the picker order
- * — alphabetical, auth-detection order, etc.); model order inside each
- * provider matches whatever `modelsFor` returns. The current selection
- * (when set) is bubbled to the top of its provider's section so it
- * shows first without disturbing relative ordering elsewhere.
- *
- * `modelsFor` is injected (not imported from `./providers`) so the same
- * helper works with hosts that supply their own model resolver via
- * `ResolvedConfig.modelsFor`.
- *
- * `include` guarantees a pair is listed even when the provider stopped
- * serving it. Persisted picks outlive catalogs (a provider retires an id, a
- * user typed one by hand), and an entry that isn't in the list can't be
- * selected away from, and the picker would keep re-persisting it. Synthesized
- * entries carry `offCatalog: true` and a stub `ModelInfo`.
- */
-declare function buildModelCatalog(opts: {
-  providers: readonly ProviderAuth[];
-  modelsFor: (key: ProviderKey) => readonly ModelInfo[]; /** Optional currently-selected pair — promoted to the top of its provider group. */
-  current?: {
-    providerKey: ProviderKey;
-    modelId: string;
-  } | null; /** Pairs that must appear even if unserved, e.g. the active pick + fallback chain. */
-  include?: readonly {
-    providerKey: ProviderKey;
-    modelId: string;
-  }[];
-}): CatalogEntry[];
-/**
- * Filter `catalog` by a user query. Empty / whitespace-only queries
- * pass everything through unchanged (`O(1)` short-circuit). Multi-term
- * queries (space-separated) require EVERY term to appear somewhere in
- * the entry's search corpus — so `"claude opus"` matches `claude-opus-4`
- * regardless of how the words are interleaved with provider names.
- *
- * Match is case-insensitive (the corpus is pre-lowercased; the query
- * is lowercased once per call).
- */
-declare function filterModelCatalog(catalog: readonly CatalogEntry[], query: string): CatalogEntry[];
-/**
- * Find a catalog entry's index by its `{providerKey, modelId}` tuple.
- * Returns `-1` when not present. Useful when re-rendering the picker
- * (a query just narrowed the list, where did the selection land?).
- */
-declare function indexOfEntry(catalog: readonly CatalogEntry[], target: {
-  providerKey: ProviderKey;
-  modelId: string;
-} | null | undefined): number;
-/**
- * Read a query that matched nothing as "use this model id anyway".
- *
- * A bare id is meaningless without a provider, so the first term is checked
- * against every provider's key and label (case-insensitive): `xai grok-9` and
- * `Anthropic claude-next` name their provider explicitly, anything else is
- * attributed to `fallbackProviderKey` (the picker's current pick). Returns
- * `null` when nothing usable is left, including when the whole query is just a
- * provider name.
- */
-declare function parseCustomModelQuery(query: string, providers: readonly Pick<ProviderAuth, 'key' | 'label'>[], fallbackProviderKey: ProviderKey | null): {
-  providerKey: ProviderKey;
-  providerLabel: string;
-  modelId: string;
-} | null;
-//#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[];
-  /**
-   * Optional SECOND line — the payload behind the action (a prompt sent to
-   * another session). Renderers paint it dimmed under the header and clamp
-   * it (two lines in the GUI, one terminal row in the TUI); it is never
-   * squeezed into the header line, which stays single-line.
-   */
-  detail?: string;
-  /**
-   * The session this call targets, when the tool addresses one. `target`
-   * carries the short id as a fallback; a renderer with the session list in
-   * scope shows the session's TITLE instead.
-   */
-  sessionId?: 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 { ACCOUNT_CRED_KEY_INFIX as $, filterSessionSearchCatalog as A, searchableTurnText as B, SearchSessionResult as C, SessionSearchIndex as D, SessionSearchExcerpt as E, searchSessionHistoryIndexAsync as F, SafeModeProvider as G, ApprovalRequest as H, searchSessionIndex as I, DAEMON_HEALTH_GLYPH as J, useSafeModeActions as K, searchSessionIndexAsync as L, searchHighlightRanges as M, searchSessionHistory as N, buildSessionSearchIndex as O, searchSessionHistoryIndex as P, DaemonHealthTone as Q, searchSessionTurns as R, SearchExcerpt as S, SessionHistoryMatch as T, RequestApproval as U, ApprovalDecision as V, SafeModeActions as W, DaemonHealth as X, DAEMON_HEALTH_STYLE as Y, DaemonHealthStyle as Z, normalizeMarkdownCodeFences as _, retagUserPromptEvents as _t, formatToolCall as a, isAccountCredKey as at, HighlightSegment as b, selectionAfterTurnRemoval as bt, splitPromptSegments as c, BASH_CALL_ID_PREFIX as ct, filterModelCatalog as d, PromptTurnRef as dt, ALTERNATE_CRED_KEY_SUFFIX as et, indexOfEntry as f, isEditErrorResult as ft, chunkMarkdownForRender as g, promptTurnRefs as gt, MarkdownSegment as h, isVisible as ht, displayNameFor as i, alternateCredKey as it, highlightSegments as j, buildSessionSearchIndexAsync as k, CatalogEntry as l, CACHE_NOTICE_LABEL as lt, MARKDOWN_RENDER_CHUNK_TARGET_BYTES as m, isUserBashEvent as mt, ToolDisplayMeta as n, DEFAULT_OAUTH_ACCOUNT_LABEL as nt, PromptSegment as o, isReservedCredKey as ot, parseCustomModelQuery as p, isTurnHighlighted as pt, useSafeModeQueue as q, ToolFormatLine as r, accountCredKey as rt, PromptSegmentRef as s, oauthAccountLabel as st, TOOL_DISPLAY as t, CRED_KEY_SLOT_SEPARATOR as tt, buildModelCatalog as u, EDIT_TOOL_NAMES as ut, splitMarkdownCodeBlocks as v, retagUserPromptEventsFromRefs as vt, SearchTurnResult as w, IndexedSearchTurn as x, turnSelectionOwnership as xt, HighlightRange as y, selectableTurnIds as yt, searchTurns as z };
-//# sourceMappingURL=tool-formatters-DoRLnfuD.d.ts.map