@dudousxd/nestjs-agent-react 0.13.0 → 0.15.0

package/dist/index.d.cts

@@ -1,16 +1,174 @@
 import * as ai from 'ai';
-import { ChatTransport, UIMessage, UIMessageChunk, ToolUIPart, DynamicToolUIPart, DataUIPart, UIDataTypes } from 'ai';
+import { ChatTransport, UIMessage, UIMessageChunk, DataUIPart, UIDataTypes } from 'ai';
 import * as _dudousxd_nestjs_agent_core from '@dudousxd/nestjs-agent-core';
-import { StoredMessage, ThreadSummary, SkillCatalogEntry, ToolCatalogEntry, ThreadDetail, MessageAttachment, QuotaView, ElicitationQuestion, ElicitationInputType, ToolPresentation, ToolResultField, ToolResultView, ToolPresentationTone, ElicitationInput } from '@dudousxd/nestjs-agent-core';
+import { ThreadSummary, ThreadDetail, MessageAttachment, ToolCatalogEntry, SkillCatalogEntry, QuotaView, MessageFeedbackValue, MessageFeedback, StoredMessage } from '@dudousxd/nestjs-agent-core';
 export { ElicitationInput, ElicitationInputType, validateElicitationAnswer as validateAnswer, validateElicitationValue as validateAnswerValue } from '@dudousxd/nestjs-agent-core';
-import React from 'react';
+import React__default from 'react';
+import { a as TranscriptBlock, U as UsageSummary, b as TimestampInfo, C as ChatStatus, M as MessageUsageInfo, c as ToolCatalog, A as ApproveOptions, d as AnyToolUIPart, e as TranscriptFile, T as TranscriptUiBlock } from './model-gHqjNjLJ.cjs';
+export { f as ApprovalBlockOptions, B as BuildBlocksOptions, g as CoercibleQuestion, D as DescribeToolCallOptions, E as ElicitationBlockOptions, G as GroupToolActivityOptions, R as RawAnswer, h as ResolvedReading, i as ResolvedResultView, j as RetrievedPassage, S as SettleAction, k as ToolActivityGroup, l as ToolCallDescription, m as ToolCallState, n as ToolCallStatus, o as TranscriptApproval, p as TranscriptApprovalStatus, q as TranscriptElicitationBlock, r as TranscriptElicitationOutcome, s as TranscriptFilesBlock, t as TranscriptQuestion, u as TranscriptQuestionOption, v as TranscriptReasoningBlock, w as TranscriptSettleState, x as TranscriptSource, y as TranscriptSourcesBlock, z as TranscriptTextBlock, F as TranscriptToolBlock, H as TranscriptToolCall, I as buildTranscriptBlocks, J as coerceAnswer, K as correctedCallIds, L as describeTimestamp, N as describeToolCall, O as describeUsage, P as extractMessageText, Q as fillTemplate, V as formatRelativeTime, W as groupToolActivity, X as inferResultView, Y as isActionCall, Z as phraseFor, _ as readPath, $ as resolveResultView, a0 as toolCallState, a1 as toolCatalogFrom } from './model-gHqjNjLJ.cjs';
+
+/**
+ * Partial update accepted by `PATCH <base>/threads/:threadId`. `defaultAgent: null` clears a
+ * previously-set default back to the module's own default; omitting it leaves the thread's
+ * current default untouched.
+ */
+interface ThreadPatch {
+    title?: string;
+    defaultAgent?: string | null;
+}
+/** Starting a turn: the body `POST <base>/chat` takes (see docs/stream-protocol.md). */
+interface ChatStreamRequest {
+    /** `{ message, threadId?, agent?, attachments?, pageContext?, regenerate?, … }`. */
+    body: Record<string, unknown>;
+    /** Per-request headers the AI SDK was handed for this send. */
+    headers?: Record<string, string>;
+    /** Aborted when the user stops the turn. */
+    signal?: AbortSignal;
+}
+/** Attaching to a run that is already streaming: `GET <base>/chat/:runId/stream?after=<seq>`. */
+interface ResumeStreamRequest {
+    runId: string;
+    /**
+     * The sequence number (SSE `id:`) of the last frame the client already has. Omitted → replay
+     * from the first frame. A backend that cannot skip may ignore it: the transport also drops frames
+     * at or below it.
+     */
+    after?: number;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+/**
+ * An open chat stream: the raw `text/event-stream` bytes in the stream-protocol framing, plus the
+ * identity a backend may learn before the first frame (the `X-Agent-Run-Id` / `X-Agent-Thread-Id`
+ * headers). The body's own `event: meta` frame supplies them otherwise.
+ */
+interface ChatStreamResponse {
+    body: ReadableStream<Uint8Array>;
+    runId?: string;
+    threadId?: string;
+}
+/** What `POST <base>/messages/:id/feedback` takes. `value: null` clears the rating. */
+interface MessageFeedbackInput {
+    value: MessageFeedbackValue | null;
+    comment?: string;
+}
+interface UploadAttachmentOptions {
+    signal?: AbortSignal;
+    /** Called with 0..1 as the upload progresses, when the backend can observe it. */
+    onProgress?: (fraction: number) => void;
+}
+/**
+ * Everything the React layer asks of a server — the seam between `useAgentChat` (and the other
+ * hooks) and whatever serves the agent. {@link AgentClient} is the default implementation, over the
+ * library's own REST routes with `fetch`. An app with its own client — a generated one, a different
+ * auth scheme (cookie session + CSRF header), a backend that is not this library at all but speaks
+ * docs/stream-protocol.md — implements this instead and passes it as `useAgentChat({ backend })`.
+ *
+ * The streaming, thread and cancel members are required: without them there is no chat. The rest
+ * are optional; a hook that needs one the backend does not have throws
+ * {@link AgentBackendUnsupportedError} when it is called, so a backend only implements what its
+ * server supports.
+ */
+interface AgentBackend {
+    /** Start a turn and return its SSE stream. Throw on a non-2xx answer. */
+    openChatStream(request: ChatStreamRequest): Promise<ChatStreamResponse>;
+    /** Attach to a streaming run. Resolve `null` when nothing is streaming under that id (HTTP 404). */
+    resumeChatStream(request: ResumeStreamRequest): Promise<ChatStreamResponse | null>;
+    /** Hard-stop a run server-side. */
+    cancelStream(runId: string): Promise<unknown>;
+    listThreads(): Promise<ThreadSummary[]>;
+    getThread(id: string): Promise<ThreadDetail>;
+    updateThread(id: string, patch: ThreadPatch): Promise<unknown>;
+    deleteThread(id: string): Promise<unknown>;
+    forkFromMessage?(threadId: string, messageId: string): Promise<ThreadSummary>;
+    promoteThread?(id: string): Promise<unknown>;
+    truncateFromMessage?(threadId: string, messageId: string): Promise<unknown>;
+    approveToolCall?(input: {
+        toolCallId: string;
+        remember?: boolean;
+        via?: string;
+    }): Promise<unknown>;
+    rejectToolCall?(input: {
+        toolCallId: string;
+        reason?: string;
+        via?: string;
+    }): Promise<unknown>;
+    answerToolCall?(input: {
+        toolCallId: string;
+        answers?: Record<string, string[]>;
+    }): Promise<unknown>;
+    skipToolCall?(input: {
+        toolCallId: string;
+    }): Promise<unknown>;
+    uploadAttachment?(file: File, options?: UploadAttachmentOptions): Promise<MessageAttachment>;
+    listTools?(agent?: string): Promise<ToolCatalogEntry[]>;
+    listSkills?(threadId?: string): Promise<SkillCatalogEntry[]>;
+    getQuotaToday?(): Promise<QuotaView>;
+    setMessageFeedback?(messageId: string, input: MessageFeedbackInput): Promise<{
+        feedback: MessageFeedback | null;
+    }>;
+}
+/** An optional {@link AgentBackend} member the bound backend does not implement was called. */
+declare class AgentBackendUnsupportedError extends Error {
+    readonly method: string;
+    constructor(method: string);
+}
+type OptionalMethod = {
+    [K in keyof AgentBackend]-?: undefined extends AgentBackend[K] ? K : never;
+}[keyof AgentBackend];
+/**
+ * The optional backend method `name`, bound — or a throw naming it. For hook code that has to call
+ * something a backend may not offer.
+ */
+declare function requireBackendMethod<K extends OptionalMethod>(backend: AgentBackend, name: K): NonNullable<AgentBackend[K]>;
 
 /** Identity surfaced by the backend's `meta` SSE frame / response headers. */
 interface AgentStreamMeta {
     runId: string;
     threadId: string;
 }
+/**
+ * How the transport retries a stream that dropped mid-run. It reconnects only to a server that
+ * numbers its frames (SSE `id:`) — without a cursor a reconnect would replay the run into the
+ * message it is already writing.
+ */
+interface ReconnectOptions {
+    /** Attempts before giving up with an error chunk. Default 6. */
+    maxAttempts?: number;
+    /** Delay before the first attempt, doubled each attempt. Default 500 ms. */
+    baseDelayMs?: number;
+    /** Cap on the delay between attempts. Default 8000 ms. */
+    maxDelayMs?: number;
+}
+/** Where a live stream stands. `reconnecting` → it dropped and the transport is retrying. */
+type StreamConnectionState = {
+    status: 'live';
+} | {
+    status: 'reconnecting';
+    runId: string;
+    attempt: number;
+    after: number;
+}
+/** The run ended while the client was away (the resume answered 404): reload the thread. */
+ | {
+    status: 'gone';
+    runId: string;
+}
+/** Every attempt failed; the stream ended with an error chunk. */
+ | {
+    status: 'failed';
+    runId: string;
+};
 interface AgentChatTransportOptions {
+    /**
+     * What the transport talks to. Default: an {@link AgentClient} built from `baseUrl`, `headers`,
+     * `getHeaders`, `credentials` and `fetch` below — which are ignored when a backend is given.
+     */
+    backend?: AgentBackend;
+    /** Retry a dropped stream from its last frame. Default on; `false` turns it off. */
+    reconnect?: ReconnectOptions | false;
+    /** Fires as a stream drops, reconnects, or gives up. */
+    onConnectionChange?: (state: StreamConnectionState) => void;
     /**
      * Origin + base path the agent endpoints hang off, e.g.
      * `https://api.example.com`. Endpoints are appended as
@@ -94,6 +252,7 @@ declare class AgentChatTransport implements ChatTransport<UIMessage> {
      * several entries under each id — which React renders as duplicate keys.
      */
     private attemptLive;
+    private readonly backend;
     constructor(options?: AgentChatTransportOptions);
     /** Run id of the most recent stream — HITL approve/reject target this. */
     get runId(): string | undefined;
@@ -108,10 +267,8 @@ declare class AgentChatTransport implements ChatTransport<UIMessage> {
     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;
-    private baseUrl;
-    private resolveHeaders;
     private captureHeaderMeta;
+    private reconnectPolicy;
     private recordMeta;
     /**
      * Parse the backend's SSE byte stream and re-emit it as a valid v7 UI-message chunk stream.
@@ -129,6 +286,84 @@ declare class AgentChatTransport implements ChatTransport<UIMessage> {
     private toChunkStream;
 }
 
+interface UseMessageFeedbackOptions {
+    /** `useAgentChat(...).backend`, or your own. Must implement `setMessageFeedback`. */
+    backend: AgentBackend;
+    /**
+     * The thread the messages belong to — `useAgentChat(...).getThreadId`, or an id. Needed to rate a
+     * message streamed in this session: its id is the client's own, so the persisted row it became is
+     * looked up by the run that wrote it.
+     */
+    threadId?: string | (() => string | undefined);
+}
+interface MessageFeedbackState {
+    /** The rating to show: the one set in this session, else the persisted one, else `null`. */
+    feedbackOf: (message: UIMessage) => MessageFeedback | null;
+    /** A rating for this message is on its way to the server. */
+    isPending: (message: UIMessage) => boolean;
+    /** Set `'up'`/`'down'` (optionally with a comment), or clear with `null`. Optimistic. */
+    rate: (message: UIMessage, value: MessageFeedbackValue | null, comment?: string) => Promise<void>;
+    /** Thumbs-button semantics: the same value again clears it, another value replaces it. */
+    toggle: (message: UIMessage, value: MessageFeedbackValue) => Promise<void>;
+    /** The last failure; cleared by the next successful rating. */
+    error: Error | null;
+}
+/**
+ * Thumbs-up/down (+ comment) on assistant messages, over `POST <base>/messages/:id/feedback`.
+ * Headless: it holds the state and the calls, the host draws the buttons. A rating shows at once
+ * and rolls back if the server refuses it.
+ */
+declare function useMessageFeedback(options: UseMessageFeedbackOptions): MessageFeedbackState;
+
+/**
+ * What changed about a backend's thread list. `changed` → refetch (a thread was created, or a run
+ * settled and the server wrote its title); `title` → the stream announced a title, patch in place.
+ */
+type ThreadsEvent = {
+    type: 'changed';
+} | {
+    type: 'title';
+    threadId: string;
+    title: string;
+} | {
+    type: 'removed';
+    threadId: string;
+};
+type Listener = (event: ThreadsEvent) => void;
+/** Tell every {@link useThreads} on `backend` that its list moved. */
+declare function notifyThreads(backend: AgentBackend, event: ThreadsEvent): void;
+/** Subscribe to {@link notifyThreads} for `backend`; returns the unsubscribe. */
+declare function onThreadsEvent(backend: AgentBackend, listener: Listener): () => void;
+
+interface UseThreadsOptions {
+    /**
+     * The backend to list — `useAgentChat(...).backend`, or your own. Must be STABLE across renders:
+     * the list refreshes itself when a chat on the SAME backend creates a thread, settles a run or
+     * streams a title.
+     */
+    backend: AgentBackend;
+    /** `false` holds the first request (e.g. until the user is signed in). Default `true`. */
+    enabled?: boolean;
+}
+interface ThreadsState {
+    /** Newest first, as the server orders them. `[]` until loaded. */
+    threads: ThreadSummary[];
+    isLoading: boolean;
+    error: Error | null;
+    /** Ask the server again. */
+    refresh: () => Promise<void>;
+    /** Rename on the server; the list shows the new title at once and rolls back on failure. */
+    rename: (id: string, title: string) => Promise<void>;
+    /** Delete on the server; the thread leaves the list at once and comes back on failure. */
+    remove: (id: string) => Promise<void>;
+}
+/**
+ * The actor's conversations, kept current without the host wiring refetches: a chat on the same
+ * backend reports thread creation and settled runs (refetch) and streamed titles (patched in
+ * place). Headless — it renders nothing.
+ */
+declare function useThreads(options: UseThreadsOptions): ThreadsState;
+
 /**
  * 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
@@ -178,34 +413,46 @@ interface CancelResult {
 interface OkResult {
     ok: boolean;
 }
-/**
- * Partial update accepted by `PATCH /agent/threads/:threadId`. `defaultAgent: null` clears a
- * previously-set default back to the module's own default; omitting it leaves the thread's
- * current default untouched.
- */
-interface ThreadPatch {
-    title?: string;
-    defaultAgent?: string | null;
-}
 interface AgentClientOptions {
     /** Origin + base path, e.g. `https://api.example.com`. Defaults to `''`. */
     baseUrl?: string;
     /** Static headers merged into every request. */
     headers?: Record<string, string>;
-    /** Resolved per request — for short-lived bearer tokens. */
+    /**
+     * Resolved per request — for short-lived bearer tokens, or a CSRF header read from a cookie
+     * (`{ 'X-XSRF-TOKEN': readCookie('XSRF-TOKEN') }`), which has to be read at request time because
+     * the server may rotate it.
+     */
     getHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
-    /** Forwarded to fetch so cookie auth works. */
+    /**
+     * Forwarded to fetch so cookie auth works. Same-origin requests send cookies by default; set
+     * `'include'` when the API lives on another origin (and have it answer with credentialed CORS).
+     */
     credentials?: RequestCredentials;
     /** Injectable for tests / non-browser runtimes. */
     fetch?: typeof fetch;
 }
 /**
- * Framework-agnostic REST client for the nestjs-agent endpoints. Used by
- * `useAgentChat`, but standalone-usable (vanilla fetch, no React).
+ * Framework-agnostic REST client for the nestjs-agent endpoints — the default {@link AgentBackend}.
+ * Used by `useAgentChat`, but standalone-usable (vanilla fetch, no React).
  */
-declare class AgentClient {
+declare class AgentClient implements AgentBackend {
     private readonly options;
     constructor(options?: AgentClientOptions);
+    /** `POST /agent/chat` → the turn's SSE stream. Throws {@link AgentHttpError} on a non-2xx. */
+    openChatStream(request: ChatStreamRequest): Promise<ChatStreamResponse>;
+    /**
+     * `GET /agent/chat/:runId/stream[?after=<seq>]` → the run's SSE stream, or `null` when nothing is
+     * streaming under that id (404).
+     */
+    resumeChatStream(request: ResumeStreamRequest): Promise<ChatStreamResponse | null>;
+    /**
+     * Rate a message (`'up'`/`'down'`, optional comment) or clear its rating (`value: null`). Answers
+     * the stored rating.
+     */
+    setMessageFeedback(messageId: string, input: MessageFeedbackInput): Promise<{
+        feedback: MessageFeedback | null;
+    }>;
     listThreads(): Promise<ThreadSummary[]>;
     /**
      * The skills this caller can invoke right now, scope-resolved — the same list, built by the same
@@ -231,7 +478,7 @@ declare class AgentClient {
      * 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>;
+    uploadAttachment(file: File, options?: UploadAttachmentOptions): Promise<MessageAttachment>;
     promoteThread(id: string): Promise<OkResult>;
     truncateFromMessage(threadId: string, messageId: string): Promise<OkResult>;
     getQuotaToday(): Promise<QuotaToday>;
@@ -268,6 +515,10 @@ declare class AgentClient {
     skipToolCall(input: {
         toolCallId: string;
     }): Promise<void>;
+    private fetchImpl;
+    private baseUrl;
+    private resolveHeaders;
+    private credentials;
     private request;
     private handleResponse;
 }
@@ -282,7 +533,7 @@ interface ChatInputProps {
     /** BCP-47 locale for dictation. Default `en-US`. */
     speechLang?: string;
     /** Label/content for the send button. Default `"Send"`. */
-    sendLabel?: React.ReactNode;
+    sendLabel?: React__default.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.
@@ -291,7 +542,7 @@ interface ChatInputProps {
     /** 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;
+    stopLabel?: React__default.ReactNode;
     /** Wrapper class. The component ships no styles of its own. */
     className?: string;
     textareaClassName?: string;
@@ -304,7 +555,7 @@ interface ChatInputProps {
      */
     renderMic?: (state: {
         isListening: boolean;
-    }) => React.ReactNode;
+    }) => React__default.ReactNode;
 }
 /**
  * Styling-agnostic chat composer. Enter submits, Shift+Enter inserts a
@@ -313,560 +564,7 @@ interface ChatInputProps {
  * 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.Element;
-
-/** What a form control can hand over: a field's value, a checkbox's state, a picked date, a list. */
-type RawAnswer = string | number | boolean | Date | null | undefined | readonly RawAnswer[];
-/** The question fields {@link coerceAnswer} reads. A transcript question and a core one both fit. */
-type CoercibleQuestion = Pick<ElicitationQuestion, 'multiple'> & {
-    input?: {
-        type: ElicitationInputType;
-    } | null;
-};
-/**
- * Turn whatever a form control produced into the `string[]` the answer route takes, in the
- * question's canonical form: numbers as decimals, booleans as `"true"`/`"false"`, dates as
- * `YYYY-MM-DD` (a `Date` is read as the local calendar day), trimmed where whitespace means
- * nothing. An empty value becomes `[]` — no answer, not an empty string. A single-choice question
- * keeps the first value.
- *
- * Coercion never judges: pair it with {@link validateAnswer} (the same rules the server applies) to
- * say what is wrong before sending.
- */
-declare function coerceAnswer(question: CoercibleQuestion, raw: RawAnswer): string[];
-
-/** Tool name → how the server said it is spoken about. */
-type ToolCatalog = Record<string, ToolPresentation>;
-/** Index `GET <base>/tools` by tool name, keeping only the tools that declared a presentation. */
-declare function toolCatalogFrom(entries: readonly ToolCatalogEntry[]): ToolCatalog;
-/** Dotted-path read. `undefined` rather than a throw, so a template can outlive a field. */
-declare function readPath(value: unknown, path: string): unknown;
-/**
- * Fill `{dotted.path}` placeholders from `context`. A placeholder with nothing behind it collapses
- * along with the whitespace in front of it, so "Reading {key}" degrades to "Reading" rather than
- * printing braces at a person; a filled one keeps the whitespace the author wrote ("({n} files)").
- */
-declare function fillTemplate(template: string, context: unknown): string;
-/**
- * The sentence for one call: the presentation's `running` or `done` template over the call's input.
- *
- * Nothing here reads the tool's name. A tool the catalog does not describe — added since the catalog
- * loaded, or declared without a presentation — is narrated generically (`fallback`), because the only
- * other thing available to say is its identifier.
- */
-declare function phraseFor(presentation: ToolPresentation | undefined, input: unknown, isSettled: boolean, fallback?: {
-    running: string;
-    done: string;
-}): string;
-
-/** One labelled reading of a `metrics` view. */
-interface ResolvedReading {
-    label: string;
-    /** The value as text (`—` for nothing). */
-    value: string;
-    unit: string | null;
-}
-/**
- * A tool's output resolved through its view into plain data a renderer draws — never the payload
- * itself. `null` from {@link resolveResultView} means "draw nothing".
- */
-type ResolvedResultView = {
-    kind: 'metrics';
-    readings: ResolvedReading[];
-} | {
-    kind: 'table';
-    columns: ToolResultField[];
-    rows: string[][];
-    empty: string | null;
-} | {
-    kind: 'log';
-    lines: string[];
-} | {
-    kind: 'note';
-    text: string;
-};
-/**
- * A view for an output whose tool declared none, from its shape: an array of flat records is a
- * table, an array of strings a log, a flat record a set of readings. `undefined` when nothing fits —
- * a serialized payload is what a person-facing surface exists to avoid, so failing to infer must not
- * fall back to one.
- */
-declare function inferResultView(output: unknown): ToolResultView | undefined;
-/**
- * Read `output` through `view` (or one inferred from its shape when `view` is omitted and `infer` is
- * on). `null` when there is nothing to draw: an `elsewhere` view, an empty reading set, a missing
- * array. A table whose rows array is present but empty resolves with no rows and its `empty` line.
- */
-declare function resolveResultView(output: unknown, view: ToolResultView | undefined, options?: {
-    infer?: boolean;
-}): ResolvedResultView | null;
-
-/**
- * Where one call stands, as a person reads it:
- *  - `running` — input streaming or the tool executing;
- *  - `awaiting-approval` — an `action` call parked on a person;
- *  - `done` / `failed` / `denied` — settled. A tool that RETURNS `{ error }` has failed just as much
- *    as one that threw; the two arrive differently and read the same to a person.
- */
-type ToolCallStatus = 'running' | 'awaiting-approval' | 'done' | 'failed' | 'denied';
-interface ToolCallState {
-    status: ToolCallStatus;
-    isSettled: boolean;
-    isFailed: boolean;
-    isDenied: boolean;
-    output: unknown;
-    error: string | null;
-}
-/** Whether the stream classified this call as an `action` (it parks for approval before it runs). */
-declare function isActionCall(part: AnyToolUIPart): boolean;
-declare function toolCallState(part: AnyToolUIPart): ToolCallState;
-/**
- * Which failed calls the model went on to correct, by call id: a call that failed and was followed,
- * in the same run, by a SUCCESS of the same tool. The operator wants to know a retry happened, not
- * to read every attempt. A failed read is not corrected by a successful query.
- */
-declare function correctedCallIds(parts: readonly AnyToolUIPart[]): Set<string>;
-/** Everything a surface needs to talk about one call without naming it. */
-interface ToolCallDescription {
-    status: ToolCallStatus;
-    /** "Querying orders" / "Queried orders" — or the generic fallback when the tool declared nothing. */
-    phrase: string;
-    /** The server's noun phrase for the tool; `null` when it declared no presentation. */
-    label: string | null;
-    icon: string | null;
-    tone: ToolPresentationTone;
-    detail: string | null;
-    /** The approval prompt, templated over the call's input; `null` when the tool declared none. */
-    confirm: {
-        title: string;
-        verb: string;
-        detail: string | null;
-    } | null;
-    /** The output read through its view, once the call is `done`; `null` otherwise or when nothing to draw. */
-    result: ResolvedResultView | null;
-    error: string | null;
-    presentation: ToolPresentation | null;
-}
-interface DescribeToolCallOptions {
-    /** Words for a tool the catalog does not describe. Default `Working` / `Done`. */
-    fallback?: {
-        running: string;
-        done: string;
-    };
-    /** Infer a result view from the output's shape when the tool declared none. Default `false`. */
-    inferResult?: boolean;
-}
-declare function describeToolCall(part: AnyToolUIPart, catalog: ToolCatalog | undefined, options?: DescribeToolCallOptions): ToolCallDescription;
-/**
- * Calls folded under one key — "Database query ×3" — with the state that matters most across them.
- */
-interface ToolActivityGroup {
-    key: string;
-    /** The server's label for the group's tool; `null` when it declared no presentation. */
-    label: string | null;
-    icon: string | null;
-    /** Worst-first across the calls: running › awaiting-approval › failed › denied › done. */
-    status: ToolCallStatus;
-    count: number;
-    /** The phrase of the group's LATEST call — what is happening now. */
-    phrase: string;
-    calls: TranscriptToolCall[];
-    /** Calls nested under the group's calls (all depths), when nesting was not expanded. */
-    innerCount: number;
-}
-interface GroupToolActivityOptions {
-    catalog?: ToolCatalog;
-    /**
-     * What makes two calls "the same activity". Default: the tool's presentation `label`, else its
-     * name. Flippy-style source grouping passes its own (e.g. `github:search`).
-     */
-    keyOf?: (call: TranscriptToolCall, presentation: ToolPresentation | undefined) => string;
-    /**
-     * Replace a call that has nested calls with those calls (recursively), so the activity reads as
-     * what the code-mode run DID rather than "ran code". Default `false`: groups are built over the
-     * top-level calls, and `innerCount` says how much ran beneath them.
-     */
-    expandNested?: boolean;
-    /** Drop failed calls the model corrected with a later success of the same tool. Default `false`. */
-    hideCorrected?: boolean;
-    fallback?: {
-        running: string;
-        done: string;
-    };
-}
-/**
- * Fold a tool run into activity groups, in order of first appearance. Pass `block.roots` (the
- * transcript's call tree) so nesting is honoured; a flat `block.calls` works too and simply has
- * nothing nested.
- */
-declare function groupToolActivity(calls: readonly TranscriptToolCall[], options?: GroupToolActivityOptions): ToolActivityGroup[];
-
-/** 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;
-    /**
-     * How long the model thought, in ms — the backend's measurement once the run closed (live) or as
-     * persisted (reloaded). `null` while it still streams, or when nothing was recorded: pair it with
-     * `useElapsed(block.isStreaming)` for a ticking label (`block.durationMs ?? elapsed`).
-     */
-    durationMs: number | null;
-    isOpen: boolean;
-    toggle: (open?: boolean) => void;
-}
-/**
- * A decision a run is waiting on a human for, and which one a parked call is currently sending.
- *
- * One call settles one way at a time, and WHICH one is what lets a surface report progress on the
- * affordance the person pressed instead of on all of them.
- */
-type SettleAction = 'approve' | 'reject' | 'answer' | 'skip';
-/** One such decision: whether it can be made, whether it is on its way, and how to send it. */
-interface TranscriptSettleState {
-    available: boolean;
-    /** True from the click until the run resumes and settles the call. */
-    isSubmitting: boolean;
-    run: () => void;
-}
-/** How an approval stands. */
-type TranscriptApprovalStatus = 'pending' | 'approved' | 'rejected' | 'expired';
-/**
- * Who has to settle a parked call, until when, and — once it settled — how. From the stream's
- * `approval-requested` / `approval-settled` frames, or the same parts a reloaded thread carries.
- * `null` on a call whose runner never said (the call can still be awaiting approval).
- */
-interface TranscriptApproval {
-    /** Open vocabulary the host defines: `'requester'`, `'admin'`, a role… */
-    approver: string;
-    /** ISO-8601; `null` when the request never lapses. Pair with `useApprovalCountdown`. */
-    expiresAt: string | null;
-    /** Why the call needs a person, when the runner said. */
-    reason: string | null;
-    /**
-     * `pending` until a settlement arrives; then what it said. Falls back to the call's own state
-     * (denied → `rejected`, an output → `approved`) for a runner that streams no settlement.
-     */
-    status: TranscriptApprovalStatus;
-    /** The approval also covers later calls of this tool in this thread. */
-    remember: boolean;
-    /** Opaque ref of who decided; `null` while pending, on an expiry, or when the runner did not say. */
-    decidedBy: string | null;
-    /** The surface the decision came through (`'web'`, `'slack'`, `'remembered'`, …). */
-    decidedVia: string | null;
-    /** What the person said when declining. */
-    decisionReason: string | null;
-}
-/** What an approval can carry beyond yes. */
-interface ApproveOptions {
-    /** Approve later calls of the same tool in the same thread without asking again. */
-    remember?: boolean;
-}
-/** One call in a tool run, with whatever human decision it is parked on. */
-interface TranscriptToolCall {
-    part: AnyToolUIPart;
-    toolCallId: string;
-    name: string;
-    /** `read` / `action` as the stream classified the call; `null` when the backend did not say. */
-    toolKind: string | null;
-    /** The call this one ran inside (a code-mode `execute`, a delegated agent); `null` for a top-level call. */
-    parentId: string | null;
-    /**
-     * Calls nested under this one within the same block, in stream order. Always empty for a call
-     * nothing names as its parent.
-     */
-    children: TranscriptToolCall[];
-    /** Who has to decide, when the runner said so. See {@link TranscriptApproval}. */
-    approval: TranscriptApproval | null;
-    /**
-     * How to talk about this call without naming it — status, phrase, label, icon, approval prompt,
-     * resolved result — from the server's presentation when `toolCatalog` was given, generic otherwise.
-     */
-    description: ToolCallDescription;
-    /**
-     * 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;
-    /** `run({ remember: true })` approves this tool for the rest of the thread. */
-    approve: TranscriptSettleState & {
-        run: (options?: ApproveOptions) => void;
-    };
-    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[];
-    /**
-     * The same calls as a tree: every call whose parent is NOT in this block, each carrying its
-     * nested calls in `children`. Equal to `calls` when nothing is nested.
-     */
-    roots: TranscriptToolCall[];
-    /**
-     * The run folded into activity groups ("Database query ×3"), over `roots`, keyed by each tool's
-     * presentation label (else its name). For another grouping, call `groupToolActivity` yourself.
-     */
-    activity: ToolActivityGroup[];
-}
-/**
- * A component the server pushed into the message (the stream's `ui` frame, or a persisted
- * `data-ui` part). Rendered by looking `component` up in the host's own registry.
- */
-interface TranscriptUiBlock {
-    kind: 'ui';
-    key: string;
-    /** The component's identity within the message. */
-    id: string;
-    component: string;
-    props: Record<string, unknown>;
-    /** Schema version of `props`; `null` when the server did not stamp one. */
-    version: number | null;
-    /** The tool call that pushed it (`ctx.emitUi`); `null` for a component pushed outside a tool. */
-    toolCallId: string | null;
-}
-/** 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;
-    /** A line of help under the prompt; `null` when the request gave none. */
-    description: string | null;
-    /**
-     * How the answer is typed — `{ type, placeholder?, required?, min?, max?, pattern? }` — or `null`
-     * for a plain pick from `options`. Render the control from `input.type`; `select` still picks
-     * from `options`.
-     */
-    input: ElicitationInput | null;
-    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;
-    /** The first selected value, or `''` — what a single text/number/date field shows. */
-    value: string;
-    /**
-     * Set a typed answer from whatever the control produced (a string, a number, a checkbox's
-     * boolean, a `Date`, a list); coerced to the question's canonical strings with `coerceAnswer`.
-     * `null`/`''` clears it. Does nothing once the set settled.
-     */
-    setValue: (raw: RawAnswer) => void;
-    /**
-     * Why the current selection would be refused (the server's own rules — `validateAnswer`), or
-     * `null`. A pristine required question with no default reads `requires an answer`; show it once
-     * the user tried to submit, or right away — the model does not decide that for you.
-     */
-    error: string | null;
-}
-/** 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;
-    /** Every question's current selection is acceptable (no question has an `error`). */
-    isValid: 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 | TranscriptUiBlock;
-/** 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;
-    /** Which decision this call is sending, or `null` for none. */
-    submitting: (toolCallId: string) => SettleAction | null;
-    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, options?: ApproveOptions) => void;
-    reject: (toolCallId: string) => void;
-    /** Which decision this call is sending, or `null` for none. */
-    submitting: (toolCallId: string) => SettleAction | null;
-    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;
-    /** Server-declared tool presentations (`useToolCatalog`), for each call's `description`. */
-    toolCatalog?: ToolCatalog;
-}
-/**
- * Walk a message's parts into renderable blocks, buffering consecutive tool parts into one run and
- * consecutive files into one strip. A `data-ui` part becomes a `ui` block. A
- * `data-approval-requested` part is metadata about a call — it is folded into that call's
- * `approval` and takes no position of its own. Other `data-*` parts 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;
+declare function ChatInput({ onSubmit, disabled, placeholder, rows, enableSpeech, speechLang, sendLabel, onStop, isStreaming, stopLabel, className, textareaClassName, sendButtonClassName, micButtonClassName, stopButtonClassName, renderMic, }: ChatInputProps): React__default.JSX.Element;
 
 interface StickToBottomOptions {
     /**
@@ -921,8 +619,8 @@ interface TranscriptEditState {
     getTextareaProps: () => {
         ref: (element: HTMLTextAreaElement | null) => void;
         value: string;
-        onChange: (event: React.ChangeEvent<HTMLTextAreaElement>) => void;
-        onKeyDown: (event: React.KeyboardEvent<HTMLTextAreaElement>) => void;
+        onChange: (event: React__default.ChangeEvent<HTMLTextAreaElement>) => void;
+        onKeyDown: (event: React__default.KeyboardEvent<HTMLTextAreaElement>) => void;
     };
 }
 interface TranscriptActionState {
@@ -1052,26 +750,26 @@ interface UseTranscriptItemOptions extends TranscriptItemOptions {
  */
 declare function useTranscriptItem(options: UseTranscriptItemOptions): TranscriptItem;
 
-type RenderToolPartFn = (part: AnyToolUIPart, key: string) => React.ReactNode;
+type RenderToolPartFn = (part: AnyToolUIPart, key: string) => React__default.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;
+type RenderToolGroupFn = (parts: AnyToolUIPart[], key: string) => React__default.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;
+}) => React__default.ReactNode;
 /** Render a run of files — attachments on a user turn, or files the model produced. */
-type RenderFilesFn = (files: TranscriptFile[]) => React.ReactNode;
+type RenderFilesFn = (files: TranscriptFile[]) => React__default.ReactNode;
 /**
  * Render a component the server pushed into the message — look `block.component` up in your own
  * registry. Omitted → pushed components are not drawn (there is no sensible default for an app's
  * own component).
  */
-type RenderUiFn = (block: TranscriptUiBlock) => React.ReactNode;
+type RenderUiFn = (block: TranscriptUiBlock) => React__default.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;
+}) => React__default.ReactNode;
 interface MessageItemClassNames {
     root?: string;
     /** Resolved per role so user/assistant/system bubbles can differ. */
@@ -1105,9 +803,9 @@ interface MessageRenderSlots {
      * 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;
+    meta?: React__default.ReactNode;
     /** Label on the reasoning disclosure toggle. Default `"Reasoning"`. */
-    reasoningLabel?: React.ReactNode;
+    reasoningLabel?: React__default.ReactNode;
     classNames?: MessageItemClassNames;
 }
 interface MessageItemProps extends MessageRenderSlots {
@@ -1140,9 +838,9 @@ interface MessageItemViewProps extends MessageRenderSlots {
  * 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.Element;
+declare function MessageItem({ message, isStreaming, editable, onEditSubmit, regeneratable, onRegenerate, onFork, usage, createdAt, ...slots }: MessageItemProps): React__default.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.Element;
+declare function MessageItemView({ item, ...slots }: MessageItemViewProps): React__default.JSX.Element;
 
 interface MessageListClassNames {
     root?: string;
@@ -1167,9 +865,9 @@ interface MessageListProps {
     renderFiles?: RenderFilesFn;
     /** Draw a server-pushed component (a `ui` stream frame). Omitted → not drawn. */
     renderUi?: RenderUiFn;
-    reasoningLabel?: React.ReactNode;
+    reasoningLabel?: React__default.ReactNode;
     /** Extra content for one message's action row — e.g. a badge naming which agent answered. */
-    getMeta?: (message: UIMessage) => React.ReactNode;
+    getMeta?: (message: UIMessage) => React__default.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. */
@@ -1182,9 +880,9 @@ interface MessageListProps {
     getUsage?: (message: UIMessage) => MessageUsageInfo | null;
     getCreatedAt?: (message: UIMessage) => string | null;
     /** Shown (with example/follow-up chips) when idle and empty. */
-    emptyState?: React.ReactNode;
+    emptyState?: React__default.ReactNode;
     /** Node rendered while waiting for the first assistant token. */
-    typingIndicator?: React.ReactNode;
+    typingIndicator?: React__default.ReactNode;
     /** AI-generated follow-up prompts under the last assistant message. */
     followUps?: string[] | null;
     onFollowUpClick?: (text: string) => void;
@@ -1202,7 +900,7 @@ interface MessageListProps {
  * 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, renderUi, reasoningLabel, getMeta, onFork, editable, onEditSubmit, regeneratable, onRegenerate, getUsage, getCreatedAt, emptyState, typingIndicator, followUps, onFollowUpClick, error, onRetry, classNames, }: MessageListProps): React.JSX.Element;
+declare function MessageList({ messages, status, renderToolPart, renderToolGroup, renderText, renderReasoning, renderFiles, renderUi, reasoningLabel, getMeta, onFork, editable, onEditSubmit, regeneratable, onRegenerate, getUsage, getCreatedAt, emptyState, typingIndicator, followUps, onFollowUpClick, error, onRetry, classNames, }: MessageListProps): React__default.JSX.Element;
 
 /**
  * Languages the dictation mic offers. The Web Speech API expects a
@@ -1336,7 +1034,8 @@ interface SkillSuggestionData {
     shadows?: string[];
 }
 interface SkillsSourceOptions {
-    client: AgentClient;
+    /** Any backend with `listSkills` — `useAgentChat(...).backend`. */
+    client: Pick<AgentBackend, 'listSkills'>;
     /**
      * 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.
@@ -1372,10 +1071,10 @@ interface UseComposerAutocompleteOptions {
 }
 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;
+    onChange: (event: React__default.ChangeEvent<HTMLTextAreaElement | HTMLInputElement>) => void;
+    onKeyDown: (event: React__default.KeyboardEvent<HTMLTextAreaElement | HTMLInputElement>) => void;
+    onSelect: (event: React__default.SyntheticEvent<HTMLTextAreaElement | HTMLInputElement>) => void;
+    onClick: (event: React__default.MouseEvent<HTMLTextAreaElement | HTMLInputElement>) => void;
     role: 'combobox';
     'aria-expanded': boolean;
     'aria-autocomplete': 'list';
@@ -1430,12 +1129,15 @@ interface ComposerAutocomplete {
  */
 declare function useComposerAutocomplete(options: UseComposerAutocompleteOptions): ComposerAutocomplete;
 
+/** What the catalog needs of a backend. */
+type ToolsBackend = Pick<AgentBackend, 'listTools'>;
+
 interface UseToolCatalogOptions {
     /**
      * The client to ask — `useAgentChat(...).client`, or one of your own. Must be STABLE across
      * renders (the shared copy is keyed by it): a client constructed inline refetches every render.
      */
-    client: AgentClient;
+    client: ToolsBackend;
     /** The agent whose tools to list. Omitted → the server's default agent. */
     agent?: string;
     /** `false` holds the request (e.g. until the user is signed in). Default `true`. */
@@ -1529,6 +1231,16 @@ interface AggregatedTurnUsage {
 interface StoredTurnMetadata {
     usage: AggregatedTurnUsage;
 }
+/**
+ * Everything a message's `metadata` may carry from this library: `usage` on a merged replayed turn,
+ * `feedback` on a replayed message that was rated (a merged turn is rated through its last row,
+ * whose id it carries), `runId` on a live-streamed one, `costUsd` from the stream's step ends.
+ */
+interface AgentMessageMetadata extends Partial<StoredTurnMetadata> {
+    feedback?: MessageFeedback;
+    runId?: string;
+    costUsd?: number | null;
+}
 /**
  * Convert a thread's full `StoredMessage[]` history into `UIMessage[]`, merging consecutive
  * assistant rows (no user message between them) into ONE `UIMessage` per turn.
@@ -1569,7 +1281,19 @@ interface StoredTurnMetadata {
  */
 declare function storedThreadToUiMessages(messages: StoredMessage[]): UIMessage[];
 
-interface UseAgentChatOptions {
+interface UseAgentChatOptions<B extends AgentBackend = AgentClient> {
+    /**
+     * What the chat talks to — see {@link AgentBackend}. Omitted → an {@link AgentClient} over this
+     * library's REST routes, built from `baseUrl`, `headers`, `getHeaders`, `credentials` and `fetch`
+     * (which are ignored when a backend is given). Must be stable across renders.
+     */
+    backend?: B;
+    /**
+     * Retry a stream that dropped mid-run from its last frame (`GET <base>/chat/:runId/stream?after=`),
+     * with exponential backoff. `status` reads `'reconnecting'` meanwhile. Default on; `false` turns
+     * it off.
+     */
+    reconnect?: ReconnectOptions | false;
     /** Origin + base path, e.g. `https://api.example.com`. Defaults to `''`. */
     baseUrl?: string;
     /** Static headers merged into every request. */
@@ -1580,8 +1304,8 @@ interface UseAgentChatOptions {
     credentials?: RequestCredentials;
     /** Injectable for tests / non-browser runtimes. */
     fetch?: typeof fetch;
-    /** Reuse an existing client instead of constructing one. */
-    client?: AgentClient;
+    /** Reuse an existing client instead of constructing one. Prefer {@link backend}. */
+    client?: B;
     /** Named agent to run each turn. */
     agent?: string;
     /** Thread this chat is bound to. Omitted → backend creates one on send. */
@@ -1689,10 +1413,13 @@ interface AddToolResultArgs {
  * fork, quota, cancel, and HITL approve/reject — all driven through
  * `AgentClient`. Mirrors flip's `useAdminChat`, generalized.
  */
-declare function useAgentChat(options: UseAgentChatOptions): {
+declare function useAgentChat<B extends AgentBackend = AgentClient>(options: UseAgentChatOptions<B>): {
+    status: ChatStatus;
+    /** Where the live stream stands — see {@link StreamConnectionState}. */
+    connection: StreamConnectionState;
     sendMessage: (message?: (Omit<UIMessage<unknown, UIDataTypes, ai.UITools>, "id" | "role"> & {
         id?: string;
-        role?: "system" | "user" | "assistant";
+        role?: "user" | "assistant" | "system";
     } & {
         text?: never;
         files?: never;
@@ -1715,7 +1442,15 @@ declare function useAgentChat(options: UseAgentChatOptions): {
     runId: string | undefined;
     /** The `resume`-fetched thread's active run id, or `null` once resolved with none. */
     activeRunId: string | null;
-    client: AgentClient;
+    /**
+     * The thread this chat is on right now: the `threadId` option, else the one the backend created
+     * on the first send. A getter, because the created id is learned mid-stream.
+     */
+    getThreadId: () => string | undefined;
+    /** The backend this chat talks to — pass it to `useThreads`, `useMessageFeedback`, … */
+    backend: B;
+    /** Same object as {@link backend}; kept for callers that read it under its old name. */
+    client: B;
     threads: ThreadSummary[];
     loadThreads: () => Promise<ThreadSummary[]>;
     loadThread: (id: string) => Promise<ThreadDetail>;
@@ -1750,7 +1485,6 @@ declare function useAgentChat(options: UseAgentChatOptions): {
     setMessages: (messages: UIMessage<unknown, UIDataTypes, ai.UITools>[] | ((messages: UIMessage<unknown, UIDataTypes, ai.UITools>[]) => UIMessage<unknown, UIDataTypes, ai.UITools>[])) => void;
     error: Error | undefined;
     stop: () => Promise<void>;
-    status: ai.ChatStatus;
     messages: UIMessage<unknown, UIDataTypes, ai.UITools>[];
     resumeStream: (options?: ai.ChatRequestOptions) => Promise<void>;
     addToolOutput: ai.ChatAddToolOutputFunction<UIMessage<unknown, UIDataTypes, ai.UITools>>;
@@ -1758,4 +1492,4 @@ declare function useAgentChat(options: UseAgentChatOptions): {
     clearError: () => void;
 };
 
-export { AgentChatTransport, type AgentChatTransportOptions, AgentClient, type AgentClientOptions, AgentHttpError, type AgentStreamMeta, type AggregatedTurnUsage, type AnyToolUIPart, type ApprovalBlockOptions, type ApprovalCountdown, type ApproveOptions, 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 CoercibleQuestion, type CompletionEdit, type ComposerAutocomplete, DEFAULT_SPEECH_LANG, type DescribeToolCallOptions, type ElicitationBlockOptions, type GroupToolActivityOptions, MessageItem, type MessageItemClassNames, type MessageItemProps, MessageItemView, type MessageItemViewProps, MessageList, type MessageListClassNames, type MessageListProps, type MessageUsageInfo, type QuotaToday, type RawAnswer, type RenderFilesFn, type RenderReasoningFn, type RenderTextFn, type RenderToolGroupFn, type RenderToolPartFn, type RenderUiFn, type ResolvedReading, type ResolvedResultView, type RetrievedPassage, SPEECH_LANGUAGES, type SettleAction, type SkillSuggestionData, type SkillsSourceOptions, type SpeechLanguage, type SpeechRecognitionHook, type StickToBottom, type StickToBottomOptions, type StoredTurnMetadata, type ThreadPatch, type TimestampInfo, type ToolActivityGroup, type ToolCallDescription, type ToolCallState, type ToolCallStatus, type ToolCatalog, type ToolCatalogState, type TranscriptActionState, type TranscriptApproval, type TranscriptApprovalStatus, 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 TranscriptUiBlock, type TranscriptWindow, type TriggerMatch, type TriggerPosition, type UsageSummary, type UseAgentChatOptions, type UseApprovalCountdownOptions, type UseChatTranscriptOptions, type UseComposerAutocompleteOptions, type UseElapsedOptions, type UseSpeechRecognitionOptions, type UseToolCatalogOptions, type UseTranscriptItemOptions, applyCompletion, approvalCountdown, backgroundRunsFromThread, buildTranscriptBlocks, coerceAnswer, correctedCallIds, createSkillsSource, describeTimestamp, describeToolCall, describeUsage, extractMessageText, fillTemplate, filterAutocompleteItems, findActiveTrigger, formatElapsed, formatRelativeTime, groupToolActivity, inferResultView, isActionCall, loadStoredSpeechLang, persistSpeechLang, phraseFor, readPath, readReasoningMs, resolveResultView, storedMessageToUiMessage, storedThreadToUiMessages, toolCallState, toolCatalogFrom, useAgentChat, useApprovalCountdown, useChatTranscript, useComposerAutocomplete, useElapsed, useSpeechRecognition, useStickToBottom, useToolCatalog, useTranscriptItem };
+export { type AgentBackend, AgentBackendUnsupportedError, AgentChatTransport, type AgentChatTransportOptions, AgentClient, type AgentClientOptions, AgentHttpError, type AgentMessageMetadata, type AgentStreamMeta, type AggregatedTurnUsage, AnyToolUIPart, type ApprovalCountdown, ApproveOptions, type AutocompleteInputProps, type AutocompleteItem, type AutocompleteListboxProps, type AutocompleteOptionProps, type AutocompleteSource, type BackgroundRun, type CancelResult, type ChatBackground, ChatInput, type ChatInputProps, ChatStatus, type ChatStreamRequest, type ChatStreamResponse, type ChatTranscript, type CompletionEdit, type ComposerAutocomplete, DEFAULT_SPEECH_LANG, type MessageFeedbackInput, type MessageFeedbackState, MessageItem, type MessageItemClassNames, type MessageItemProps, MessageItemView, type MessageItemViewProps, MessageList, type MessageListClassNames, type MessageListProps, MessageUsageInfo, type QuotaToday, type ReconnectOptions, type RenderFilesFn, type RenderReasoningFn, type RenderTextFn, type RenderToolGroupFn, type RenderToolPartFn, type RenderUiFn, type ResumeStreamRequest, SPEECH_LANGUAGES, type SkillSuggestionData, type SkillsSourceOptions, type SpeechLanguage, type SpeechRecognitionHook, type StickToBottom, type StickToBottomOptions, type StoredTurnMetadata, type StreamConnectionState, type ThreadPatch, type ThreadsEvent, type ThreadsState, TimestampInfo, ToolCatalog, type ToolCatalogState, type TranscriptActionState, TranscriptBlock, type TranscriptCopyState, type TranscriptEditState, TranscriptFile, type TranscriptItem, type TranscriptItemOptions, type TranscriptStopState, TranscriptUiBlock, type TranscriptWindow, type TriggerMatch, type TriggerPosition, type UploadAttachmentOptions, UsageSummary, type UseAgentChatOptions, type UseApprovalCountdownOptions, type UseChatTranscriptOptions, type UseComposerAutocompleteOptions, type UseElapsedOptions, type UseMessageFeedbackOptions, type UseSpeechRecognitionOptions, type UseThreadsOptions, type UseToolCatalogOptions, type UseTranscriptItemOptions, applyCompletion, approvalCountdown, backgroundRunsFromThread, createSkillsSource, filterAutocompleteItems, findActiveTrigger, formatElapsed, loadStoredSpeechLang, notifyThreads, onThreadsEvent, persistSpeechLang, readReasoningMs, requireBackendMethod, storedMessageToUiMessage, storedThreadToUiMessages, useAgentChat, useApprovalCountdown, useChatTranscript, useComposerAutocomplete, useElapsed, useMessageFeedback, useSpeechRecognition, useStickToBottom, useThreads, useToolCatalog, useTranscriptItem };