@dudousxd/nestjs-agent-react 0.5.4 → 0.6.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as ai from 'ai';
 import { ChatTransport, UIMessage, UIMessageChunk, ToolUIPart, DynamicToolUIPart } from 'ai';
 import * as _dudousxd_nestjs_agent_core from '@dudousxd/nestjs-agent-core';
-import { ThreadSummary, ThreadDetail, MessageAttachment, QuotaView, StoredMessage } from '@dudousxd/nestjs-agent-core';
+import { StoredMessage, ThreadSummary, SkillCatalogEntry, ThreadDetail, MessageAttachment, QuotaView } from '@dudousxd/nestjs-agent-core';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import React from 'react';
 
@@ -75,11 +75,26 @@ declare class AgentChatTransport implements ChatTransport<UIMessage> {
     private readonly options;
     private currentRunId;
     private currentThreadId;
+    /**
+     * One attempt at a time. The AI SDK keeps a single in-flight response per chat and decides
+     * whether its streamed message REPLACES the list's last entry or is appended by comparing that
+     * response's message id against the last entry alone. Two attempts writing into one chat
+     * therefore append alternating copies of each other's message, and the list ends up holding
+     * several entries under each id — which React renders as duplicate keys.
+     */
+    private attemptLive;
     constructor(options?: AgentChatTransportOptions);
     /** Run id of the most recent stream — HITL approve/reject target this. */
     get runId(): string | undefined;
     /** Thread id of the most recent stream. */
     get threadId(): string | undefined;
+    /**
+     * True from the moment a send or resume attempt starts until its chunk stream terminates. A
+     * caller that can refuse a turn BEFORE the SDK commits to one — `useAgentChat` wrapping
+     * `sendMessage` — reads this; the transport itself can only refuse a resume, which is the one
+     * attempt the SDK lets a transport decline.
+     */
+    get isAttemptLive(): boolean;
     sendMessages(options: Parameters<ChatTransport<UIMessage>['sendMessages']>[0]): Promise<ReadableStream<UIMessageChunk>>;
     reconnectToStream(options: Parameters<ChatTransport<UIMessage>['reconnectToStream']>[0]): Promise<ReadableStream<UIMessageChunk> | null>;
     private fetchImpl;
@@ -102,6 +117,37 @@ declare class AgentChatTransport implements ChatTransport<UIMessage> {
     private toChunkStream;
 }
 
+/**
+ * A sub-agent the conversation started and did not wait for. The chat is free while it works, so a
+ * client has to be able to say what is still running and to show the answer when it lands — neither
+ * of which the turn that started it can report, because that turn is over.
+ */
+interface BackgroundRun {
+    /** The run doing the work. Also what stamps the message it eventually posts. */
+    runId: string;
+    /** The agent working on it. */
+    agent: string;
+    /** The `agent`-kind call that started it — what a UI keys its card off. */
+    toolCallId: string;
+    toolName: string;
+    /**
+     * `delivered` the moment the thread holds a message stamped with this run. A run that FAILED
+     * reads as delivered too: it posts a message saying so, which is the point — there is no third
+     * state a reader could act on differently, and "running" for ever is the state to avoid.
+     */
+    status: 'running' | 'delivered';
+    /** The message it posted, once it did. */
+    message?: StoredMessage;
+}
+/**
+ * Every sub-agent this thread started in the background, and whether each has reported back.
+ *
+ * Derived from the transcript rather than tracked in session state, so it survives a reload and a
+ * second tab: the receipt is a persisted tool result, and the answer is a persisted message stamped
+ * with the run that wrote it. Nothing here needs a live connection to be true.
+ */
+declare function backgroundRunsFromThread(messages: readonly StoredMessage[]): BackgroundRun[];
+
 /**
  * Thrown by {@link AgentClient} on a non-2xx response. Carries the HTTP `status` so callers can
  * branch (e.g. 403 → "not your thread", 429 → quota) instead of string-matching a generic Error.
@@ -149,6 +195,13 @@ declare class AgentClient {
     private readonly options;
     constructor(options?: AgentClientOptions);
     listThreads(): Promise<ThreadSummary[]>;
+    /**
+     * The skills this caller can invoke right now, scope-resolved — the same list, built by the same
+     * call, that the model is offered, so what a user can type after a `/` and what the agent can
+     * reach cannot drift apart. `threadId` reaches the host's own resolver, which may scope a skill to
+     * one conversation; omitted, the server reads it as a brand-new thread.
+     */
+    listSkills(threadId?: string): Promise<SkillCatalogEntry[]>;
     getThread(id: string): Promise<ThreadDetail>;
     deleteThread(id: string): Promise<void>;
     forkFromMessage(threadId: string, messageId: string): Promise<ThreadSummary>;
@@ -156,25 +209,876 @@ declare class AgentClient {
     /** General `PATCH /agent/threads/:threadId` — title and/or the thread's pinned default agent. */
     updateThread(id: string, patch: ThreadPatch): Promise<OkResult>;
     /**
-     * Uploads a file (image/PDF) for a vision-capable model turn. Multipart, field name `file` —
-     * mirrors the backend's `POST /agent/attachments`. The returned {@link MessageAttachment} is
-     * what a caller then rides on `sendMessage({ text }, { body: { attachments: [...] } })`.
+     * Uploads a file (image/PDF) for a vision-capable model turn. Multipart, field name `file` —
+     * mirrors the backend's `POST /agent/attachments`. The returned {@link MessageAttachment} is
+     * what a caller then rides on `sendMessage({ text }, { body: { attachments: [...] } })`.
+     */
+    uploadAttachment(file: File): Promise<MessageAttachment>;
+    promoteThread(id: string): Promise<OkResult>;
+    truncateFromMessage(threadId: string, messageId: string): Promise<OkResult>;
+    getQuotaToday(): Promise<QuotaToday>;
+    cancelStream(runId: string): Promise<CancelResult>;
+    approveToolCall(input: {
+        toolCallId: string;
+    }): Promise<void>;
+    rejectToolCall(input: {
+        toolCallId: string;
+        reason?: string;
+    }): Promise<void>;
+    /**
+     * Settle a parked question set. `answers` is questionId → chosen option values; a question left
+     * out takes the pre-picked default the request carried, resolved server-side against the request
+     * the run already holds. Omit the whole object and the user has confirmed every pre-picked
+     * answer — which is the point of the surface, so it is a valid submission rather than a blank.
+     */
+    answerToolCall(input: {
+        toolCallId: string;
+        answers?: Record<string, string[]>;
+    }): Promise<void>;
+    /**
+     * Decline to answer and let the agent proceed on its own pre-picked values. Lands on the same
+     * values a confirmation would, and persists differently on purpose — only one of them is
+     * evidence the user chose them.
+     */
+    skipToolCall(input: {
+        toolCallId: string;
+    }): Promise<void>;
+    private request;
+    private handleResponse;
+}
+
+interface ChatInputProps {
+    onSubmit: (text: string) => void;
+    disabled?: boolean;
+    placeholder?: string;
+    rows?: number;
+    /** Enable the dictation mic button (Web Speech API). Default `true`. */
+    enableSpeech?: boolean;
+    /** BCP-47 locale for dictation. Default `en-US`. */
+    speechLang?: string;
+    /** Label/content for the send button. Default `"Send"`. */
+    sendLabel?: React.ReactNode;
+    /**
+     * Cancel the turn in flight — wire to `useAgentChat`'s `cancel`. Rendered only alongside
+     * `isStreaming`, so the affordance exists exactly while there is something to cancel.
+     */
+    onStop?: () => void | Promise<void>;
+    /** Whether a turn is currently in flight. Gates the stop affordance. */
+    isStreaming?: boolean;
+    /** Label/content for the stop button. Default `"Stop generating"` — the mic's own is `"Stop"`. */
+    stopLabel?: React.ReactNode;
+    /** Wrapper class. The component ships no styles of its own. */
+    className?: string;
+    textareaClassName?: string;
+    sendButtonClassName?: string;
+    micButtonClassName?: string;
+    stopButtonClassName?: string;
+    /**
+     * Custom mic affordance. Receives `isListening`; return any node. When
+     * omitted a plain text button ("Speak" / "Stop") is rendered.
+     */
+    renderMic?: (state: {
+        isListening: boolean;
+    }) => React.ReactNode;
+}
+/**
+ * Styling-agnostic chat composer. Enter submits, Shift+Enter inserts a
+ * newline. Optional dictation streams interim transcripts into the draft
+ * and commits finalized chunks, and `onStop` surfaces the backend's
+ * cancel next to send. No design-system or icon-library deps —
+ * style it entirely through the `*ClassName` props.
+ */
+declare function ChatInput({ onSubmit, disabled, placeholder, rows, enableSpeech, speechLang, sendLabel, onStop, isStreaming, stopLabel, className, textareaClassName, sendButtonClassName, micButtonClassName, stopButtonClassName, renderMic, }: ChatInputProps): react_jsx_runtime.JSX.Element;
+
+/** A tool UI part on a `UIMessage` — a static `tool-*` part or the `dynamic-tool` part. */
+type AnyToolUIPart = ToolUIPart | DynamicToolUIPart;
+type ChatStatus = 'ready' | 'submitted' | 'streaming' | 'error';
+/** Server-aggregated usage for an assistant turn. */
+interface MessageUsageInfo {
+    inputTokens: number;
+    outputTokens: number;
+    /**
+     * `null` when no price is on record for the model that ran the turn. Distinct from `0`, which is
+     * a turn that genuinely cost nothing — printing `$0` for an unpriced turn states a number the
+     * store never had.
+     */
+    costUsd: number | null;
+}
+/** A run of contiguous prose. `isStreaming` is the PART's own state, not the message's. */
+interface TranscriptTextBlock {
+    kind: 'text';
+    key: string;
+    text: string;
+    isStreaming: boolean;
+}
+/** One file on a message — an uploaded attachment, or one the model produced. */
+interface TranscriptFile {
+    /** Presigned or otherwise directly fetchable. Display-only: the model reads its own copy. */
+    url: string;
+    mediaType: string;
+    filename: string | null;
+    /** `image/*`, which a renderer can show inline rather than as a link. */
+    isImage: boolean;
+}
+/** A run of contiguous files. Grouped so a renderer can lay several out as one strip. */
+interface TranscriptFilesBlock {
+    kind: 'files';
+    key: string;
+    files: TranscriptFile[];
+}
+/**
+ * A run of contiguous reasoning. Carries its own disclosure state because a thread can hold many
+ * of them and each is toggled independently; `isOpen` defaults to `isStreaming` (thinking is worth
+ * watching live, worth folding away once answered) until `toggle` is called for that run.
+ */
+interface TranscriptReasoningBlock {
+    kind: 'reasoning';
+    key: string;
+    text: string;
+    isStreaming: boolean;
+    isOpen: boolean;
+    toggle: (open?: boolean) => void;
+}
+/** An action a run is waiting on a human for: approve, reject, answer, skip. */
+interface TranscriptSettleState {
+    available: boolean;
+    /** True from the click until the run resumes and settles the call. */
+    isSubmitting: boolean;
+    run: () => void;
+}
+/** One call in a tool run, with whatever human decision it is parked on. */
+interface TranscriptToolCall {
+    part: AnyToolUIPart;
+    toolCallId: string;
+    name: string;
+    /**
+     * Parked on a person. An `action` tool's input lands and its output never follows on its own —
+     * the loop waits for an approval between the two — so a settled-looking card that never settles
+     * IS the pending approval.
+     */
+    isAwaitingApproval: boolean;
+    approve: TranscriptSettleState;
+    reject: TranscriptSettleState;
+    /** A failed decision — the call is still parked, so the affordance stays live. */
+    error: string | null;
+}
+/**
+ * A run of CONSECUTIVE tool parts, grouped so a UI can collapse "5 tools ran" into one affordance.
+ * Any non-tool part between two tool parts ends the run — including the AI SDK's `step-start`
+ * markers, so tools from different steps never merge into one group.
+ */
+interface TranscriptToolBlock {
+    kind: 'tools';
+    key: string;
+    parts: AnyToolUIPart[];
+    /** The same calls, each with its human-decision state. Same order as `parts`. */
+    calls: TranscriptToolCall[];
+}
+/** One choice a question offers, with its live selection state. */
+interface TranscriptQuestionOption {
+    value: string;
+    label: string;
+    /** A single character the request suggested as a shortcut; `null` when it suggested none. */
+    hotkey: string | null;
+    isSelected: boolean;
+    /** Pre-picked by the agent — what an untouched question submits as. */
+    isDefault: boolean;
+    /** Single choice: replaces the selection. Multiple: adds or removes this value. */
+    select: () => void;
+}
+/** One question of a set, numbered against the whole. */
+interface TranscriptQuestion {
+    id: string;
+    prompt: string;
+    multiple: boolean;
+    /** 1-based. The request carries every question up front, so "Question 1 of N" is honest. */
+    position: number;
+    options: TranscriptQuestionOption[];
+    selected: string[];
+    /**
+     * The user has not touched this question, so a submission leaves it out and the server applies
+     * the same defaults it showed. Distinct from "selected happens to equal the defaults": only the
+     * first is recorded as `defaulted` rather than as a choice the user made.
+     */
+    isPristine: boolean;
+}
+/** How a question set settled, once it did. */
+interface TranscriptElicitationOutcome {
+    answers: Record<string, string[]>;
+    /** The user declined to answer and let the agent proceed on its own picks. */
+    skipped: boolean;
+    /** Questions filled from their own defaults rather than by the human. */
+    defaulted: string[];
+    /** The questions against the chosen labels, as the model read them back. */
+    summary: string | null;
+}
+/**
+ * A question set the run put to the user, parked until someone settles it — the intake an agent
+ * declares and the model's own `ask` produce the same block, because the loop streams the same
+ * frame for both.
+ */
+interface TranscriptElicitationBlock {
+    kind: 'elicitation';
+    key: string;
+    /** The parked tool call — what `answer`/`skip` route by. */
+    toolCallId: string;
+    preamble: string | null;
+    questions: TranscriptQuestion[];
+    questionCount: number;
+    /** Still waiting on a human. */
+    isPending: boolean;
+    outcome: TranscriptElicitationOutcome | null;
+    /** A failed submission — the run is still parked, so the form stays live. */
+    error: string | null;
+    answer: TranscriptSettleState;
+    skip: TranscriptSettleState;
+}
+/** One retrieved passage, as it rides a retrieval tool call's output. Mirrors core's `Passage`. */
+interface RetrievedPassage {
+    id: string;
+    text: string;
+    score: number;
+    /** Citation-facing origin — a document title, URL or row id. */
+    source?: string;
+    metadata?: Record<string, unknown>;
+}
+/** The passages of one origin, folded together so a citation line reads once per source. */
+interface TranscriptSource {
+    /** The `source` string the retriever stamped, falling back to the passage id when it stamped none. */
+    id: string;
+    label: string;
+    passageCount: number;
+    /** Highest relevance among this source's passages; the scale is the retriever's. */
+    topScore: number;
+    passages: RetrievedPassage[];
+}
+/**
+ * The provenance behind an answer: a run of CONSECUTIVE retrieval tool parts, aggregated by origin.
+ * Detection is structural — a tool output shaped `{ passages: [{ id, text, ... }] }` — because the
+ * tool's NAME is not fixed: inject-mode retrieval persists as `retrieve`, and `createRetrievalTool`
+ * lets the host rename `search_knowledge` to anything.
+ */
+interface TranscriptSourcesBlock {
+    kind: 'sources';
+    key: string;
+    /** What was searched, when the tool call recorded a `{ query }` input. */
+    query: string | null;
+    sources: TranscriptSource[];
+    passageCount: number;
+}
+type TranscriptBlock = TranscriptTextBlock | TranscriptFilesBlock | TranscriptReasoningBlock | TranscriptToolBlock | TranscriptSourcesBlock | TranscriptElicitationBlock;
+/** Where a question set's selection state is held, and where its settlement is sent. */
+interface ElicitationBlockOptions {
+    /** The values a question is showing, or `undefined` while the user has not touched it. */
+    picked: (toolCallId: string, questionId: string) => string[] | undefined;
+    pick: (toolCallId: string, questionId: string, values: string[]) => void;
+    canAnswer: boolean;
+    canSkip: boolean;
+    answer: (toolCallId: string) => void;
+    skip: (toolCallId: string) => void;
+    isSubmitting: (toolCallId: string) => boolean;
+    errorOf: (toolCallId: string) => string | null;
+}
+/** Where an approval decision is sent, and what the last one did. */
+interface ApprovalBlockOptions {
+    canApprove: boolean;
+    canReject: boolean;
+    approve: (toolCallId: string) => void;
+    reject: (toolCallId: string) => void;
+    isSubmitting: (toolCallId: string) => boolean;
+    errorOf: (toolCallId: string) => string | null;
+}
+interface BuildBlocksOptions {
+    /** Disclosure lookup for a reasoning run; `isStreaming` is the fallback when untouched. */
+    isReasoningOpen: (key: string, isStreaming: boolean) => boolean;
+    toggleReasoning: (key: string, open?: boolean) => void;
+    /**
+     * Lift retrieval tool parts out of the tool run into a `sources` block. Off by default, so a
+     * renderer wired to draw tool cards keeps receiving them as the tool calls they are.
+     */
+    sources?: boolean;
+    /**
+     * Lift a question set out of the tool run into an `elicitation` block. Omitted → it stays a tool
+     * card, which is all a host that has nowhere to send an answer could render anyway.
+     */
+    elicitation?: ElicitationBlockOptions;
+    /** Wire approve/reject onto the calls parked on a human. Omitted → they are reported, not actionable. */
+    approval?: ApprovalBlockOptions;
+}
+/**
+ * Walk a message's parts into renderable blocks, buffering consecutive tool parts into one run and
+ * consecutive files into one strip. Parts this library has no model for (`data-*`) are dropped
+ * rather than guessed at, but they still terminate a tool run — their position in the transcript is
+ * meaningful even when their content is not modelled here.
+ */
+declare function buildTranscriptBlocks(message: UIMessage, options: BuildBlocksOptions): TranscriptBlock[];
+/** The message's prose, joined for the clipboard. Reasoning is excluded — it is not the answer. */
+declare function extractMessageText(parts: UIMessage['parts'] | undefined): string;
+interface UsageSummary extends MessageUsageInfo {
+    totalTokens: number;
+    /** `$0`, `$0.0123`, `$0.012`, `$1.23` — precision follows magnitude so sub-cent turns stay legible. */
+    costLabel: string;
+    tokensLabel: string;
+}
+declare function describeUsage(usage: MessageUsageInfo): UsageSummary;
+interface TimestampInfo {
+    iso: string;
+    date: Date;
+    /** "just now" / "5 min. ago" / "Mar 3" — see {@link formatRelativeTime}. */
+    relative: string;
+    absolute: string;
+}
+/** `null` for an unparseable stamp, so a bad `created_at` renders nothing instead of "Invalid Date". */
+declare function describeTimestamp(createdAt: string | null | undefined): TimestampInfo | null;
+/**
+ * "just now" within ±10s (server `created_at` can land a few ms ahead of the client clock), a
+ * relative phrase up to a week, then a calendar date. Uses Intl.RelativeTimeFormat — no date-fns.
+ */
+declare function formatRelativeTime(date: Date): string;
+
+interface StickToBottomOptions {
+    /**
+     * Changes whenever the rendered content grows — the signal to re-pin. A string rather than the
+     * message array because a streaming turn mutates in place: the array identity is stable while its
+     * last part's text keeps growing.
+     */
+    contentKey: string;
+    /**
+     * How far off the bottom (px) still counts as "at the bottom". Sub-pixel layout and fractional
+     * device ratios leave a residue of a pixel or two after a programmatic scroll, so an exact
+     * comparison unpins the view on the very scroll event it just caused.
+     */
+    threshold?: number;
+}
+interface StickToBottom {
+    /** While true, new content scrolls into view; the user scrolling up turns it off. */
+    isAtBottom: boolean;
+    /** Whether a "jump to latest" affordance is warranted. */
+    showJumpToLatest: boolean;
+    scrollToBottom: () => void;
+    /** Spread onto the scrolling element. Behaviour only — no classes, no styles. */
+    getContainerProps: () => {
+        ref: (element: HTMLElement | null) => void;
+        onScroll: () => void;
+    };
+}
+/**
+ * Follow a streaming transcript only while the reader is already at the bottom. Reading back
+ * through history during a stream is the case this exists for: an unconditional scroll-to-bottom
+ * yanks the viewport away mid-sentence on every token.
+ */
+declare function useStickToBottom({ contentKey, threshold, }: StickToBottomOptions): StickToBottom;
+
+interface TranscriptCopyState {
+    /** False when the message has no prose to put on the clipboard. */
+    available: boolean;
+    copied: boolean;
+    copy: () => void;
+}
+interface TranscriptEditState {
+    available: boolean;
+    isEditing: boolean;
+    draft: string;
+    /** Whitespace-only drafts are refused, so an empty resubmit can never be sent. */
+    canSave: boolean;
+    start: () => void;
+    cancel: () => void;
+    setDraft: (value: string) => void;
+    save: () => void;
+    /** Controlled-textarea wiring: focus with the caret at the end, Enter saves, Escape cancels. */
+    getTextareaProps: () => {
+        ref: (element: HTMLTextAreaElement | null) => void;
+        value: string;
+        onChange: (event: React.ChangeEvent<HTMLTextAreaElement>) => void;
+        onKeyDown: (event: React.KeyboardEvent<HTMLTextAreaElement>) => void;
+    };
+}
+interface TranscriptActionState {
+    available: boolean;
+    run: () => void;
+}
+interface TranscriptItem {
+    id: string;
+    message: UIMessage;
+    role: UIMessage['role'];
+    /** Index in the FULL message array, not in the rendered window. */
+    index: number;
+    isUser: boolean;
+    isAssistant: boolean;
+    isLastAssistant: boolean;
+    isStreaming: boolean;
+    blocks: TranscriptBlock[];
+    /** The prose alone — what `copy` puts on the clipboard and what an edit starts from. */
+    text: string;
+    usage: UsageSummary | null;
+    timestamp: TimestampInfo | null;
+    copy: TranscriptCopyState;
+    edit: TranscriptEditState;
+    fork: TranscriptActionState;
+    regenerate: TranscriptActionState;
+}
+interface TranscriptItemOptions {
+    /** User messages get an inline edit-and-resubmit machine. */
+    editable?: boolean;
+    onEditSubmit?: (messageId: string, text: string) => void | Promise<void>;
+    onFork?: (messageId: string) => void | Promise<void>;
+    /** Only the LAST assistant message gets a regenerate machine. */
+    regeneratable?: boolean;
+    onRegenerate?: (messageId: string) => void | Promise<void>;
+    getUsage?: (message: UIMessage) => MessageUsageInfo | null;
+    getCreatedAt?: (message: UIMessage) => string | null;
+    /** How long `copy.copied` stays true. Default 1500ms. */
+    copyResetMs?: number;
+    /** Clipboard writer; defaults to `navigator.clipboard.writeText`. */
+    writeClipboard?: (text: string) => Promise<void>;
+    /**
+     * Lift retrieval tool parts into their own `sources` block instead of leaving them in the tool
+     * run. Off by default, so a renderer already drawing tool cards keeps drawing them.
+     */
+    sources?: boolean;
+    /**
+     * Settle a parked question set — wire to `useAgentChat`'s `answer`. Supplying it is what lifts a
+     * question set out of the tool run into an `elicitation` block: without somewhere to send an
+     * answer, a form is a card the user cannot act on.
+     *
+     * `answers` holds ONLY the questions the user touched. An omitted one takes its own pre-picked
+     * default server-side, which is what keeps "just confirmed" and "picked exactly what was
+     * pre-picked" distinguishable in the settled row.
+     */
+    onAnswer?: (toolCallId: string, answers: Record<string, string[]>) => void | Promise<void>;
+    /** Decline the question set and let the agent proceed on its own picks — `useAgentChat`'s `skip`. */
+    onSkip?: (toolCallId: string) => void | Promise<void>;
+    /** Settle a tool call parked on a human — `useAgentChat`'s `approve` / `reject`. */
+    onApprove?: (toolCallId: string) => void | Promise<void>;
+    onReject?: (toolCallId: string) => void | Promise<void>;
+}
+interface TranscriptWindow {
+    visibleCount: number;
+    /** How many older messages are not mounted. */
+    hiddenCount: number;
+    canLoadEarlier: boolean;
+    loadEarlier: () => void;
+    showAll: () => void;
+}
+interface TranscriptStopState {
+    available: boolean;
+    /** True from the click until the turn actually leaves a busy status. */
+    isStopping: boolean;
+    stop: () => void;
+}
+interface UseChatTranscriptOptions extends TranscriptItemOptions {
+    messages: UIMessage[];
+    status: ChatStatus;
+    initialVisibleCount?: number;
+    loadEarlierStep?: number;
+    /** Cancel the in-flight turn — wire to `useAgentChat`'s `cancel`. */
+    onStop?: () => void | Promise<void>;
+    /** Suggested follow-ups. The model only decides WHETHER they belong on screen. */
+    followUps?: string[] | null;
+    stickToBottomThreshold?: number;
+}
+interface ChatTranscript {
+    /** The mounted window, oldest first. `window.hiddenCount` says what is held back. */
+    items: TranscriptItem[];
+    status: ChatStatus;
+    isEmpty: boolean;
+    /** A turn is in flight: sent but not settled. */
+    isBusy: boolean;
+    isStreaming: boolean;
+    showEmptyState: boolean;
+    /** Waiting on the first token of a turn that has no assistant message yet. */
+    showTypingIndicator: boolean;
+    showFollowUps: boolean;
+    lastAssistantId: string | null;
+    window: TranscriptWindow;
+    scroll: StickToBottom;
+    stop: TranscriptStopState;
+}
+/**
+ * The model behind a chat transcript: messages normalized into items with their parts grouped into
+ * runs, per-message derived values (copyable text, usage labels, relative time), each action as a
+ * state machine rather than a button, list windowing, and stick-to-bottom. It renders nothing and
+ * names no class — `MessageList`/`MessageItem` are one renderer over it, and an app with its own
+ * design system writes another without reimplementing any of this.
+ */
+declare function useChatTranscript(options: UseChatTranscriptOptions): ChatTranscript;
+interface UseTranscriptItemOptions extends TranscriptItemOptions {
+    message: UIMessage;
+    isStreaming?: boolean;
+}
+/**
+ * The single-message half of {@link useChatTranscript}, for a renderer that owns the list itself.
+ * `regeneratable` applies directly here: one assistant message is trivially the last one.
+ */
+declare function useTranscriptItem(options: UseTranscriptItemOptions): TranscriptItem;
+
+type RenderToolPartFn = (part: AnyToolUIPart, key: string) => React.ReactNode;
+/** Render a run of consecutive tool parts as one block (e.g. a collapsible tool group). */
+type RenderToolGroupFn = (parts: AnyToolUIPart[], key: string) => React.ReactNode;
+/** Render a message's text — pass a markdown renderer (e.g. `AgentMarkdown`) here if desired. */
+type RenderTextFn = (text: string, ctx: {
+    isStreaming: boolean;
+}) => React.ReactNode;
+/** Render a run of files — attachments on a user turn, or files the model produced. */
+type RenderFilesFn = (files: TranscriptFile[]) => React.ReactNode;
+/** Render the body of a reasoning run; the disclosure toggle around it stays this component's. */
+type RenderReasoningFn = (text: string, ctx: {
+    isStreaming: boolean;
+    isOpen: boolean;
+}) => React.ReactNode;
+interface MessageItemClassNames {
+    root?: string;
+    /** Resolved per role so user/assistant/system bubbles can differ. */
+    byRole?: Partial<Record<UIMessage['role'], string>>;
+    text?: string;
+    /** The action row under the bubble (copy / fork / regenerate / usage / timestamp). */
+    actions?: string;
+    actionButton?: string;
+    usage?: string;
+    timestamp?: string;
+    editTextarea?: string;
+    editActions?: string;
+    reasoning?: string;
+    reasoningToggle?: string;
+    reasoningText?: string;
+    files?: string;
+    file?: string;
+    fileImage?: string;
+}
+interface MessageRenderSlots {
+    renderToolPart?: RenderToolPartFn;
+    /** Takes precedence over `renderToolPart` for a run of consecutive tool parts. */
+    renderToolGroup?: RenderToolGroupFn;
+    renderText?: RenderTextFn;
+    renderReasoning?: RenderReasoningFn;
+    /** Draw files yourself — a gallery, a viewer. Omitted → images inline, everything else a link. */
+    renderFiles?: RenderFilesFn;
+    /**
+     * Extra content for the action row, after the built-in affordances and before usage — a badge
+     * naming which agent answered, a status pill. Rendered for every message that has an action row.
+     */
+    meta?: React.ReactNode;
+    /** Label on the reasoning disclosure toggle. Default `"Reasoning"`. */
+    reasoningLabel?: React.ReactNode;
+    classNames?: MessageItemClassNames;
+}
+interface MessageItemProps extends MessageRenderSlots {
+    message: UIMessage;
+    /** Marks the in-flight assistant bubble (e.g. for a caret animation / deferred markdown render). */
+    isStreaming?: boolean;
+    /** User bubble gets a pencil → inline textarea; submitting calls back with the new text. */
+    editable?: boolean;
+    onEditSubmit?: (newText: string) => void | Promise<void>;
+    /** Assistant bubble gets a "Regenerate" affordance. */
+    regeneratable?: boolean;
+    onRegenerate?: () => void | Promise<void>;
+    /** When provided, a "Fork" affordance calls back with this message's id. */
+    onFork?: (uiMessageId: string) => void | Promise<void>;
+    /** Server-aggregated usage for this assistant turn (cost + tokens line). */
+    usage?: MessageUsageInfo | null;
+    /** ISO timestamp of the persisted message; rendered as a relative-time line when set. */
+    createdAt?: string | null;
+}
+interface MessageItemViewProps extends MessageRenderSlots {
+    item: TranscriptItem;
+}
+/**
+ * Styling-agnostic renderer for a single v7 `UIMessage`. Ports flip's full chat-item UX —
+ * copy, fork, regenerate, inline edit-and-resubmit, collapsible reasoning, usage line, relative
+ * timestamp, and tool grouping — but with ALL styling left to `classNames` and every action
+ * surfaced as a callback, so no design-system / icon / date library is pulled in (relative time
+ * uses Intl.RelativeTimeFormat).
+ *
+ * All of the logic lives in `useTranscriptItem`; this is one rendering of it. An app that wants
+ * different markup drives that hook and writes its own.
+ */
+declare function MessageItem({ message, isStreaming, editable, onEditSubmit, regeneratable, onRegenerate, onFork, usage, createdAt, ...slots }: MessageItemProps): react_jsx_runtime.JSX.Element;
+/** The default markup for one modelled message — what `MessageItem` renders once it has an item. */
+declare function MessageItemView({ item, ...slots }: MessageItemViewProps): react_jsx_runtime.JSX.Element;
+
+interface MessageListClassNames {
+    root?: string;
+    empty?: string;
+    loadEarlier?: string;
+    typing?: string;
+    error?: string;
+    errorRetry?: string;
+    followUps?: string;
+    followUpChip?: string;
+    message?: MessageItemClassNames;
+}
+interface MessageListProps {
+    messages: UIMessage[];
+    status: ChatStatus;
+    renderToolPart?: RenderToolPartFn;
+    renderToolGroup?: RenderToolGroupFn;
+    renderText?: RenderTextFn;
+    /** Render the body of a reasoning run; the disclosure toggle is the list's. */
+    renderReasoning?: RenderReasoningFn;
+    /** Draw a message's files yourself. Omitted → images inline, everything else a link. */
+    renderFiles?: RenderFilesFn;
+    reasoningLabel?: React.ReactNode;
+    /** Extra content for one message's action row — e.g. a badge naming which agent answered. */
+    getMeta?: (message: UIMessage) => React.ReactNode;
+    /** When set, every message gets a "Fork" affordance calling back with its id. */
+    onFork?: (uiMessageId: string) => void | Promise<void>;
+    /** User messages get an inline edit-and-resubmit affordance. */
+    editable?: boolean;
+    onEditSubmit?: (uiMessageId: string, newText: string) => void | Promise<void>;
+    /** The last assistant message gets a "Regenerate" affordance. */
+    regeneratable?: boolean;
+    onRegenerate?: (uiMessageId: string) => void | Promise<void>;
+    /** Per-message resolvers for the usage line and the persisted timestamp. */
+    getUsage?: (message: UIMessage) => MessageUsageInfo | null;
+    getCreatedAt?: (message: UIMessage) => string | null;
+    /** Shown (with example/follow-up chips) when idle and empty. */
+    emptyState?: React.ReactNode;
+    /** Node rendered while waiting for the first assistant token. */
+    typingIndicator?: React.ReactNode;
+    /** AI-generated follow-up prompts under the last assistant message. */
+    followUps?: string[] | null;
+    onFollowUpClick?: (text: string) => void;
+    /** Last turn's error — paired with `onRetry`, renders a retry banner. */
+    error?: Error | null;
+    onRetry?: () => void | Promise<void>;
+    classNames?: MessageListClassNames;
+}
+/**
+ * Styling-agnostic message list. Keeps the proven UX — windowed render
+ * with "load earlier", a typing indicator, an inline error+retry banner,
+ * and follow-up chips — but ships no styles: drive everything through
+ * `classNames` and the `emptyState`/`typingIndicator` slots.
+ *
+ * Every decision here comes from `useChatTranscript`; the file below it is markup. A host that
+ * wants a different layout drives that hook directly and never imports this component.
+ */
+declare function MessageList({ messages, status, renderToolPart, renderToolGroup, renderText, renderReasoning, renderFiles, reasoningLabel, getMeta, onFork, editable, onEditSubmit, regeneratable, onRegenerate, getUsage, getCreatedAt, emptyState, typingIndicator, followUps, onFollowUpClick, error, onRetry, classNames, }: MessageListProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Languages the dictation mic offers. The Web Speech API expects a
+ * BCP-47 tag and does NOT auto-detect — the engine forces incoming
+ * audio onto the phonemes of whatever `recognition.lang` is set to, so
+ * the host app picks the locale explicitly.
+ */
+interface SpeechLanguage {
+    /** BCP-47 tag fed straight into `SpeechRecognition.lang`. */
+    tag: string;
+    /** Human label for a dropdown. */
+    label: string;
+}
+declare const DEFAULT_SPEECH_LANG = "en-US";
+declare const SPEECH_LANGUAGES: ReadonlyArray<SpeechLanguage>;
+/**
+ * Recover the last picked language from localStorage (sync — safe at
+ * `useState` init). Falls back to the default if nothing's stored or the
+ * stored tag isn't in the offered list.
+ */
+declare function loadStoredSpeechLang(): string;
+declare function persistSpeechLang(tag: string): void;
+
+interface UseSpeechRecognitionOptions {
+    lang?: string;
+    onFinalTranscript: (text: string) => void;
+    onInterimTranscript?: (text: string) => void;
+}
+interface SpeechRecognitionHook {
+    isSupported: boolean;
+    isListening: boolean;
+    start(): void;
+    stop(): void;
+}
+/**
+ * Tiny wrapper around the Web Speech API. `start()` opens the mic and
+ * streams interim transcripts via `onInterimTranscript`; on a finalized
+ * chunk it fires `onFinalTranscript`. `isSupported` is false where the
+ * API is missing (e.g. Firefox) — callers should hide the mic button.
+ */
+declare function useSpeechRecognition({ lang, onFinalTranscript, onInterimTranscript, }: UseSpeechRecognitionOptions): SpeechRecognitionHook;
+
+/** One completion a source offers. */
+interface AutocompleteItem {
+    /** Unique within its source. */
+    id: string;
+    /** What the reader sees, and what the default filter matches against. */
+    label: string;
+    /** What replaces the typed token. Defaults to `label` — set it when the label is prose. */
+    value?: string;
+    description?: string;
+    /**
+     * A short trailing note a renderer right-aligns — where this came from, a keyboard shortcut, a
+     * type. Deliberately outside the default filter: typing a query should narrow by what the item
+     * IS, not by an aside about it.
+     */
+    hint?: string;
+    /** Whatever the host's renderer needs: an icon key, a scope, the row this came from. */
+    data?: unknown;
+}
+/**
+ * Where a trigger character is allowed to open the menu.
+ *
+ * - `'start'` — only as the very first character of the input. This is the rule a slash command
+ *   wants: `/deploy` is a command, `src/foo` and `and/or` are not.
+ * - `'word'` — at the start of any word: the input's start, or immediately after whitespace. This
+ *   is the rule a mention wants: `@ada` in the middle of a sentence is a mention, `ada@example` is
+ *   an address.
+ *
+ * There is no default on purpose. Which rule a trigger takes is the difference between an
+ * autocomplete that feels invisible and one that fires while somebody types a file path.
+ */
+type TriggerPosition = 'start' | 'word';
+interface AutocompleteSource {
+    /** Identifies the source to the host; also names the listbox when `label` is omitted. */
+    id: string;
+    /** Human-facing name for the open menu. */
+    label?: string;
+    /** The single character that opens this source. Two sources never share one. */
+    trigger: string;
+    position: TriggerPosition;
+    /**
+     * The candidates for `query`. May be async; a result that arrives after the query moved on is
+     * discarded, and `signal` aborts the request that produced it. Throwing is allowed — the menu
+     * reports the failure and typing carries on.
+     */
+    getItems: (query: string, signal: AbortSignal) => AutocompleteItem[] | Promise<AutocompleteItem[]>;
+    /**
+     * Narrow what `getItems` returned. Defaults to {@link filterAutocompleteItems}. A source that
+     * already filtered server-side — a fuzzy match this one would undo — passes `(items) => items`.
+     */
+    filter?: (items: AutocompleteItem[], query: string) => AutocompleteItem[];
+    /**
+     * Appended after the inserted value. Defaults to a single space, which both closes the menu and
+     * puts the caret where the command's argument goes.
+     */
+    insertSuffix?: string;
+}
+/** A trigger character found before the caret, with the token being typed after it. */
+interface TriggerMatch {
+    source: AutocompleteSource;
+    /** Index of the trigger character itself. */
+    index: number;
+    /** The text between the trigger and the caret. Never contains whitespace. */
+    query: string;
+}
+interface CompletionEdit {
+    text: string;
+    caret: number;
+}
+/**
+ * The trigger token the caret currently sits in, or `null`. Scans backwards from the caret and
+ * stops at the first whitespace, so a token is always one unbroken word: typing a space is what
+ * ends a command and hands the rest of the line back to the user as prose.
+ */
+declare function findActiveTrigger(text: string, caret: number, sources: readonly AutocompleteSource[]): TriggerMatch | null;
+/** Case-insensitive substring over label and description. The default when a source names none. */
+declare function filterAutocompleteItems(items: readonly AutocompleteItem[], query: string): AutocompleteItem[];
+/**
+ * The text and caret after accepting `item`. The trigger character stays — `/deploy ` is what the
+ * user meant to type — and everything after the caret is left untouched, so completing a token in
+ * the middle of a sentence does not eat the rest of it.
+ */
+declare function applyCompletion(text: string, caret: number, match: TriggerMatch, item: AutocompleteItem): CompletionEdit;
+
+/** What each item carries on `data`, so a renderer can show where a skill came from. */
+interface SkillSuggestionData {
+    /** The scope token it resolved from — the provenance a user is entitled to see. */
+    scope: string;
+    /** Scope tokens of same-named skills this one outranks, widest last. */
+    shadows?: string[];
+}
+interface SkillsSourceOptions {
+    client: AgentClient;
+    /**
+     * Read at query time, not captured once: a threadless chat learns its id only when the backend
+     * creates one on the first send, and a skill may be scoped to a conversation.
      */
-    uploadAttachment(file: File): Promise<MessageAttachment>;
-    promoteThread(id: string): Promise<OkResult>;
-    truncateFromMessage(threadId: string, messageId: string): Promise<OkResult>;
-    getQuotaToday(): Promise<QuotaToday>;
-    cancelStream(runId: string): Promise<CancelResult>;
-    approveToolCall(input: {
-        toolCallId: string;
-    }): Promise<void>;
-    rejectToolCall(input: {
-        toolCallId: string;
-        reason?: string;
-    }): Promise<void>;
-    private request;
-    private handleResponse;
+    getThreadId?: () => string | undefined;
+    /** Default `/`. */
+    trigger?: string;
+    /** Default `Skills`. */
+    label?: string;
+}
+/**
+ * `GET /agent/skills` as an autocomplete source — the concrete one behind `/`, and an example of
+ * the shape any other takes. `position: 'start'` because a skill is a command: `/deploy` is one and
+ * `src/foo` is a path.
+ */
+declare function createSkillsSource(options: SkillsSourceOptions): AutocompleteSource;
+
+interface UseComposerAutocompleteOptions {
+    /** The composer's draft. Accepting an item rewrites it through `onValueChange`. */
+    value: string;
+    onValueChange: (next: string) => void;
+    /**
+     * What can be completed, and after which character. The composer knows nothing about what a
+     * source offers — a skills list and an agent mention are the same shape.
+     */
+    sources: readonly AutocompleteSource[];
+    /** A source that threw. The menu reports it; typing is unaffected either way. */
+    onError?: (error: unknown, source: AutocompleteSource) => void;
+    /** Tab accepts the highlighted item, as Enter does. Default `true`. */
+    acceptOnTab?: boolean;
+    /** Base for the generated `id`s the ARIA wiring points at. */
+    id?: string;
+}
+interface AutocompleteInputProps {
+    ref: (element: HTMLTextAreaElement | HTMLInputElement | null) => void;
+    onChange: (event: React.ChangeEvent<HTMLTextAreaElement | HTMLInputElement>) => void;
+    onKeyDown: (event: React.KeyboardEvent<HTMLTextAreaElement | HTMLInputElement>) => void;
+    onSelect: (event: React.SyntheticEvent<HTMLTextAreaElement | HTMLInputElement>) => void;
+    onClick: (event: React.MouseEvent<HTMLTextAreaElement | HTMLInputElement>) => void;
+    role: 'combobox';
+    'aria-expanded': boolean;
+    'aria-autocomplete': 'list';
+    'aria-haspopup': 'listbox';
+    'aria-controls'?: string;
+    'aria-activedescendant'?: string;
 }
+interface AutocompleteListboxProps {
+    id: string;
+    role: 'listbox';
+    'aria-label': string;
+}
+interface AutocompleteOptionProps {
+    id: string;
+    role: 'option';
+    'aria-selected': boolean;
+}
+interface ComposerAutocomplete {
+    isOpen: boolean;
+    /** The source behind the open menu, so a renderer can group or label by it. */
+    source: AutocompleteSource | null;
+    trigger: string | null;
+    /** The text between the trigger and the caret. */
+    query: string;
+    items: AutocompleteItem[];
+    activeIndex: number;
+    activeItem: AutocompleteItem | null;
+    /** An async source has been asked and has not answered yet. */
+    isLoading: boolean;
+    /** The message from a source that threw. The menu stays open and empty. */
+    error: string | null;
+    highlight: (index: number) => void;
+    /** Wraps at both ends, so ↓ from the last item lands on the first. */
+    moveHighlight: (delta: number) => void;
+    /** Insert an item — the highlighted one by default. A click handler calls this directly. */
+    accept: (item?: AutocompleteItem) => void;
+    /** Close for the token being typed, without touching the text. */
+    dismiss: () => void;
+    getInputProps: () => AutocompleteInputProps;
+    getListboxProps: () => AutocompleteListboxProps;
+    getOptionProps: (index: number) => AutocompleteOptionProps;
+}
+/**
+ * The state machine behind a `/`-style autocomplete in a chat composer: which trigger the caret is
+ * inside, what the query is, which items answer it, which one is highlighted, and what accepting
+ * one does to the text and the caret. It renders nothing and knows nothing about skills, agents or
+ * threads — a host supplies sources, and the same machine drives `@` as drives `/`.
+ *
+ * The keys the open menu owns (↑ ↓ Enter Tab Escape) are consumed with `preventDefault`, which is
+ * how a composer that sends on Enter knows to stand down: call this handler first and return early
+ * when the event comes back `defaultPrevented`.
+ */
+declare function useComposerAutocomplete(options: UseComposerAutocompleteOptions): ComposerAutocomplete;
 
 /**
  * Convert a persisted `StoredMessage` (the agent-lib's on-disk shape) into an AI SDK v7
@@ -326,6 +1230,34 @@ interface UseAgentChatOptions {
         runId: string;
         status: 'completed' | 'failed';
     }) => void;
+    /**
+     * Track DETACHED sub-agents this conversation started: which are still working, and their answers
+     * as they land (see {@link ChatBackground}). Default `false`.
+     *
+     * Opt-in for the same reason {@link UseAgentChatOptions.resume} is — it reads the thread, and a
+     * plain mount must not spend a request on a feature the host is not using. Leaving it off still
+     * leaves {@link ChatBackground.refresh} callable, for a host that would rather drive it itself.
+     */
+    background?: boolean;
+    /**
+     * How often to re-read the thread while a detached sub-agent is still working, in ms. Default
+     * 5000; `0` turns the interval off, leaving {@link ChatBackground.refresh} as the only trigger.
+     *
+     * A poll rather than a second stream, because what a background run produces is a persisted
+     * MESSAGE, not tokens this chat should render as they arrive: its answer belongs to its own run,
+     * it can land while the user is mid-turn or has the tab closed, and it has to be there on the next
+     * reload either way. The interval exists only while something is outstanding, which is rare and
+     * bounded by how many delegations a conversation has started.
+     */
+    backgroundPollMs?: number;
+}
+/** Sub-agents this conversation started and did not wait for. See {@link BackgroundRun}. */
+interface ChatBackground {
+    runs: BackgroundRun[];
+    /** True while any of them is still working — what a "2 agents running" affordance reads. */
+    isWorking: boolean;
+    /** Re-read the thread now, instead of waiting for the next poll. */
+    refresh: () => Promise<void>;
 }
 interface AddToolResultArgs {
     tool: string;
@@ -339,7 +1271,28 @@ interface AddToolResultArgs {
  * `AgentClient`. Mirrors flip's `useAdminChat`, generalized.
  */
 declare function useAgentChat(options: UseAgentChatOptions): {
+    sendMessage: (message?: (Omit<UIMessage<unknown, ai.UIDataTypes, ai.UITools>, "id" | "role"> & {
+        id?: string;
+        role?: "system" | "user" | "assistant";
+    } & {
+        text?: never;
+        files?: never;
+        messageId?: string;
+    }) | {
+        text: string;
+        files?: FileList | ai.FileUIPart[];
+        metadata?: unknown;
+        parts?: never;
+        messageId?: string;
+    } | {
+        files: FileList | ai.FileUIPart[];
+        metadata?: unknown;
+        parts?: never;
+        messageId?: string;
+    } | undefined, options?: ai.ChatRequestOptions) => Promise<void>;
     addToolResult: ({ tool, toolCallId, output }: AddToolResultArgs) => void | PromiseLike<void>;
+    /** Sub-agents this conversation started and did not wait for. */
+    background: ChatBackground;
     runId: string | undefined;
     /** The `resume`-fetched thread's active run id, or `null` once resolved with none. */
     activeRunId: string | null;
@@ -362,221 +1315,24 @@ declare function useAgentChat(options: UseAgentChatOptions): {
         toolCallId: string;
         reason?: string;
     }) => Promise<void>;
+    answer: ({ toolCallId, answers, }: {
+        toolCallId: string;
+        answers?: Record<string, string[]>;
+    }) => Promise<void>;
+    skip: ({ toolCallId }: {
+        toolCallId: string;
+    }) => Promise<void>;
     regenerate: () => void;
     id: string;
     setMessages: (messages: UIMessage<unknown, ai.UIDataTypes, ai.UITools>[] | ((messages: UIMessage<unknown, ai.UIDataTypes, ai.UITools>[]) => UIMessage<unknown, ai.UIDataTypes, ai.UITools>[])) => void;
     error: Error | undefined;
     stop: () => Promise<void>;
-    messages: UIMessage<unknown, ai.UIDataTypes, ai.UITools>[];
     status: ai.ChatStatus;
-    sendMessage: (message?: (Omit<UIMessage<unknown, ai.UIDataTypes, ai.UITools>, "id" | "role"> & {
-        id?: string;
-        role?: "user" | "assistant" | "system";
-    } & {
-        text?: never;
-        files?: never;
-        messageId?: string;
-    }) | {
-        text: string;
-        files?: FileList | ai.FileUIPart[];
-        metadata?: unknown;
-        parts?: never;
-        messageId?: string;
-    } | {
-        files: FileList | ai.FileUIPart[];
-        metadata?: unknown;
-        parts?: never;
-        messageId?: string;
-    } | undefined, options?: ai.ChatRequestOptions) => Promise<void>;
+    messages: UIMessage<unknown, ai.UIDataTypes, ai.UITools>[];
     resumeStream: (options?: ai.ChatRequestOptions) => Promise<void>;
     addToolOutput: ai.ChatAddToolOutputFunction<UIMessage<unknown, ai.UIDataTypes, ai.UITools>>;
     addToolApprovalResponse: ai.ChatAddToolApproveResponseFunction;
     clearError: () => void;
 };
 
-interface ChatInputProps {
-    onSubmit: (text: string) => void;
-    disabled?: boolean;
-    placeholder?: string;
-    rows?: number;
-    /** Enable the dictation mic button (Web Speech API). Default `true`. */
-    enableSpeech?: boolean;
-    /** BCP-47 locale for dictation. Default `en-US`. */
-    speechLang?: string;
-    /** Label/content for the send button. Default `"Send"`. */
-    sendLabel?: React.ReactNode;
-    /** Wrapper class. The component ships no styles of its own. */
-    className?: string;
-    textareaClassName?: string;
-    sendButtonClassName?: string;
-    micButtonClassName?: string;
-    /**
-     * Custom mic affordance. Receives `isListening`; return any node. When
-     * omitted a plain text button ("Speak" / "Stop") is rendered.
-     */
-    renderMic?: (state: {
-        isListening: boolean;
-    }) => React.ReactNode;
-}
-/**
- * Styling-agnostic chat composer. Enter submits, Shift+Enter inserts a
- * newline. Optional dictation streams interim transcripts into the draft
- * and commits finalized chunks. No design-system or icon-library deps —
- * style it entirely through the `*ClassName` props.
- */
-declare function ChatInput({ onSubmit, disabled, placeholder, rows, enableSpeech, speechLang, sendLabel, className, textareaClassName, sendButtonClassName, micButtonClassName, renderMic, }: ChatInputProps): react_jsx_runtime.JSX.Element;
-
-/** A tool UI part on a `UIMessage` — a static `tool-*` part or the `dynamic-tool` part. */
-type AnyToolUIPart = ToolUIPart | DynamicToolUIPart;
-type RenderToolPartFn = (part: AnyToolUIPart, key: string) => React.ReactNode;
-/** Render a run of consecutive tool parts as one block (e.g. a collapsible tool group). */
-type RenderToolGroupFn = (parts: AnyToolUIPart[], key: string) => React.ReactNode;
-/** Render a message's text — pass a markdown renderer (e.g. `AgentMarkdown`) here if desired. */
-type RenderTextFn = (text: string, ctx: {
-    isStreaming: boolean;
-}) => React.ReactNode;
-/** Server-aggregated usage for an assistant turn, shown as a small inline line. */
-interface MessageUsageInfo {
-    inputTokens: number;
-    outputTokens: number;
-    costUsd: number;
-}
-interface MessageItemClassNames {
-    root?: string;
-    /** Resolved per role so user/assistant/system bubbles can differ. */
-    byRole?: Partial<Record<UIMessage['role'], string>>;
-    text?: string;
-    /** The action row under the bubble (copy / fork / regenerate / usage / timestamp). */
-    actions?: string;
-    actionButton?: string;
-    usage?: string;
-    timestamp?: string;
-    editTextarea?: string;
-    editActions?: string;
-}
-interface MessageItemProps {
-    message: UIMessage;
-    renderToolPart?: RenderToolPartFn;
-    /** Takes precedence over `renderToolPart` for a run of consecutive tool parts. */
-    renderToolGroup?: RenderToolGroupFn;
-    renderText?: RenderTextFn;
-    classNames?: MessageItemClassNames;
-    /** Marks the in-flight assistant bubble (e.g. for a caret animation / deferred markdown render). */
-    isStreaming?: boolean;
-    /** User bubble gets a pencil → inline textarea; submitting calls back with the new text. */
-    editable?: boolean;
-    onEditSubmit?: (newText: string) => void | Promise<void>;
-    /** Assistant bubble gets a "Regenerate" affordance. */
-    regeneratable?: boolean;
-    onRegenerate?: () => void | Promise<void>;
-    /** When provided, a "Fork" affordance calls back with this message's id. */
-    onFork?: (uiMessageId: string) => void | Promise<void>;
-    /** Server-aggregated usage for this assistant turn (cost + tokens line). */
-    usage?: MessageUsageInfo | null;
-    /** ISO timestamp of the persisted message; rendered as a relative-time line when set. */
-    createdAt?: string | null;
-}
-/**
- * Styling-agnostic renderer for a single v7 `UIMessage`. Ports flip's full chat-item UX —
- * copy, fork, regenerate, inline edit-and-resubmit, usage line, relative timestamp, and tool
- * grouping — but with ALL styling left to `classNames` and every action surfaced as a callback,
- * so no design-system / icon / date library is pulled in (relative time uses Intl.RelativeTimeFormat).
- */
-declare function MessageItem({ message, renderToolPart, renderToolGroup, renderText, classNames, isStreaming, editable, onEditSubmit, regeneratable, onRegenerate, onFork, usage, createdAt, }: MessageItemProps): react_jsx_runtime.JSX.Element;
-/**
- * "just now" within ±10s (server `created_at` can land a few ms ahead of the client clock), a
- * relative phrase up to a week, then a calendar date. Uses Intl.RelativeTimeFormat — no date-fns.
- */
-declare function formatRelativeTime(date: Date): string;
-
-type ChatStatus = 'ready' | 'submitted' | 'streaming' | 'error';
-interface MessageListClassNames {
-    root?: string;
-    empty?: string;
-    loadEarlier?: string;
-    typing?: string;
-    error?: string;
-    errorRetry?: string;
-    followUps?: string;
-    followUpChip?: string;
-    message?: MessageItemClassNames;
-}
-interface MessageListProps {
-    messages: UIMessage[];
-    status: ChatStatus;
-    renderToolPart?: RenderToolPartFn;
-    renderToolGroup?: RenderToolGroupFn;
-    renderText?: RenderTextFn;
-    /** When set, every message gets a "Fork" affordance calling back with its id. */
-    onFork?: (uiMessageId: string) => void | Promise<void>;
-    /** User messages get an inline edit-and-resubmit affordance. */
-    editable?: boolean;
-    onEditSubmit?: (uiMessageId: string, newText: string) => void | Promise<void>;
-    /** The last assistant message gets a "Regenerate" affordance. */
-    regeneratable?: boolean;
-    onRegenerate?: (uiMessageId: string) => void | Promise<void>;
-    /** Per-message resolvers for the usage line and the persisted timestamp. */
-    getUsage?: (message: UIMessage) => MessageUsageInfo | null;
-    getCreatedAt?: (message: UIMessage) => string | null;
-    /** Shown (with example/follow-up chips) when idle and empty. */
-    emptyState?: React.ReactNode;
-    /** Node rendered while waiting for the first assistant token. */
-    typingIndicator?: React.ReactNode;
-    /** AI-generated follow-up prompts under the last assistant message. */
-    followUps?: string[] | null;
-    onFollowUpClick?: (text: string) => void;
-    /** Last turn's error — paired with `onRetry`, renders a retry banner. */
-    error?: Error | null;
-    onRetry?: () => void | Promise<void>;
-    classNames?: MessageListClassNames;
-}
-/**
- * Styling-agnostic message list. Keeps the proven UX — windowed render
- * with "load earlier", a typing indicator, an inline error+retry banner,
- * and follow-up chips — but ships no styles: drive everything through
- * `classNames` and the `emptyState`/`typingIndicator` slots.
- */
-declare function MessageList({ messages, status, renderToolPart, renderToolGroup, renderText, onFork, editable, onEditSubmit, regeneratable, onRegenerate, getUsage, getCreatedAt, emptyState, typingIndicator, followUps, onFollowUpClick, error, onRetry, classNames, }: MessageListProps): react_jsx_runtime.JSX.Element;
-
-/**
- * Languages the dictation mic offers. The Web Speech API expects a
- * BCP-47 tag and does NOT auto-detect — the engine forces incoming
- * audio onto the phonemes of whatever `recognition.lang` is set to, so
- * the host app picks the locale explicitly.
- */
-interface SpeechLanguage {
-    /** BCP-47 tag fed straight into `SpeechRecognition.lang`. */
-    tag: string;
-    /** Human label for a dropdown. */
-    label: string;
-}
-declare const DEFAULT_SPEECH_LANG = "en-US";
-declare const SPEECH_LANGUAGES: ReadonlyArray<SpeechLanguage>;
-/**
- * Recover the last picked language from localStorage (sync — safe at
- * `useState` init). Falls back to the default if nothing's stored or the
- * stored tag isn't in the offered list.
- */
-declare function loadStoredSpeechLang(): string;
-declare function persistSpeechLang(tag: string): void;
-
-interface UseSpeechRecognitionOptions {
-    lang?: string;
-    onFinalTranscript: (text: string) => void;
-    onInterimTranscript?: (text: string) => void;
-}
-interface SpeechRecognitionHook {
-    isSupported: boolean;
-    isListening: boolean;
-    start(): void;
-    stop(): void;
-}
-/**
- * Tiny wrapper around the Web Speech API. `start()` opens the mic and
- * streams interim transcripts via `onInterimTranscript`; on a finalized
- * chunk it fires `onFinalTranscript`. `isSupported` is false where the
- * API is missing (e.g. Firefox) — callers should hide the mic button.
- */
-declare function useSpeechRecognition({ lang, onFinalTranscript, onInterimTranscript, }: UseSpeechRecognitionOptions): SpeechRecognitionHook;
-
-export { AgentChatTransport, type AgentChatTransportOptions, AgentClient, type AgentClientOptions, AgentHttpError, type AgentStreamMeta, type AggregatedTurnUsage, type AnyToolUIPart, type CancelResult, ChatInput, type ChatInputProps, type ChatStatus, DEFAULT_SPEECH_LANG, MessageItem, type MessageItemClassNames, type MessageItemProps, MessageList, type MessageListClassNames, type MessageListProps, type MessageUsageInfo, type QuotaToday, type RenderTextFn, type RenderToolGroupFn, type RenderToolPartFn, SPEECH_LANGUAGES, type SpeechLanguage, type SpeechRecognitionHook, type StoredTurnMetadata, type ThreadPatch, type UseAgentChatOptions, type UseSpeechRecognitionOptions, formatRelativeTime, loadStoredSpeechLang, persistSpeechLang, storedMessageToUiMessage, storedThreadToUiMessages, useAgentChat, useSpeechRecognition };
+export { AgentChatTransport, type AgentChatTransportOptions, AgentClient, type AgentClientOptions, AgentHttpError, type AgentStreamMeta, type AggregatedTurnUsage, type AnyToolUIPart, type ApprovalBlockOptions, type AutocompleteInputProps, type AutocompleteItem, type AutocompleteListboxProps, type AutocompleteOptionProps, type AutocompleteSource, type BackgroundRun, type BuildBlocksOptions, type CancelResult, type ChatBackground, ChatInput, type ChatInputProps, type ChatStatus, type ChatTranscript, type CompletionEdit, type ComposerAutocomplete, DEFAULT_SPEECH_LANG, type ElicitationBlockOptions, MessageItem, type MessageItemClassNames, type MessageItemProps, MessageItemView, type MessageItemViewProps, MessageList, type MessageListClassNames, type MessageListProps, type MessageUsageInfo, type QuotaToday, type RenderFilesFn, type RenderReasoningFn, type RenderTextFn, type RenderToolGroupFn, type RenderToolPartFn, type RetrievedPassage, SPEECH_LANGUAGES, type SkillSuggestionData, type SkillsSourceOptions, type SpeechLanguage, type SpeechRecognitionHook, type StickToBottom, type StickToBottomOptions, type StoredTurnMetadata, type ThreadPatch, type TimestampInfo, type TranscriptActionState, type TranscriptBlock, type TranscriptCopyState, type TranscriptEditState, type TranscriptElicitationBlock, type TranscriptElicitationOutcome, type TranscriptFile, type TranscriptFilesBlock, type TranscriptItem, type TranscriptItemOptions, type TranscriptQuestion, type TranscriptQuestionOption, type TranscriptReasoningBlock, type TranscriptSettleState, type TranscriptSource, type TranscriptSourcesBlock, type TranscriptStopState, type TranscriptTextBlock, type TranscriptToolBlock, type TranscriptToolCall, type TranscriptWindow, type TriggerMatch, type TriggerPosition, type UsageSummary, type UseAgentChatOptions, type UseChatTranscriptOptions, type UseComposerAutocompleteOptions, type UseSpeechRecognitionOptions, type UseTranscriptItemOptions, applyCompletion, backgroundRunsFromThread, buildTranscriptBlocks, createSkillsSource, describeTimestamp, describeUsage, extractMessageText, filterAutocompleteItems, findActiveTrigger, formatRelativeTime, loadStoredSpeechLang, persistSpeechLang, storedMessageToUiMessage, storedThreadToUiMessages, useAgentChat, useChatTranscript, useComposerAutocomplete, useSpeechRecognition, useStickToBottom, useTranscriptItem };