@gedatou/cadenza-ai 0.7.1

package/dist/index.d.mts

@@ -0,0 +1,1056 @@
+import { a as Provider, i as ModelCost, n as Modality, o as ThinkingLevel, r as Model, s as TokenUsage, t as Catalog } from "./types-56Hn7Qq2.mjs";
+import { ComponentProps, MemoExoticComponent, ReactElement, ReactNode } from "react";
+import { ByokClient, ByokClient as ByokClient$1, ByokPrompt, ByokSnapshot, ByokSnapshot as ByokSnapshot$1, KeyStatus, KeyringStorage, KeyringStorage as KeyringStorage$1, defaultByokStorage, defineByok, isPasskeyStorageSupported, memoryStorage, passkeyStorage } from "@tanstack/ai-client/byok";
+import { AnyClientTool, AudioPart, ContentPart, DocumentPart, EventType, ImagePart, InferToolInput, InferToolOutput, StreamChunk, StructuredOutputPart, TextPart, ThinkingPart, ThinkingPart as ThinkingPart$1, ToolCallPart, ToolResultPart, UIResourcePart, VideoPart, fromSpecTokenUsage, generateMessageId, parsePartialJSON, toolDefinition } from "@tanstack/ai/client";
+import { ButtonProps, ChangeEventDetails, CollapsibleChangeEventDetails, CollapsibleTriggerProps, ComboboxChangeEventDetails, DialogChangeEventDetails, EmptyProps, GenericEventDetails, InputGroupAddonProps, InputGroupButtonProps, InputGroupTextareaProps, MessageAlign, MessageScrollerDefaultScrollPosition, MessageScrollerViewportProps, SelectChangeEventDetails, ToggleChangeEventDetails } from "@gedatou/cadenza-ui";
+import { StreamdownTranslations } from "streamdown";
+import { TokenUsage as TokenUsage$1 } from "@tanstack/ai";
+import { ChatClientPersistence, ChatClientState, ChatClientState as ChatClientState$1, ChatInterrupt, ChatInterrupt as ChatInterrupt$1, InterruptItemStatus, MultimodalContent, MultimodalContent as MultimodalContent$1, QueuedMessage, QueuedMessage as QueuedMessage$1, SendMessageOptions, ToolApprovalInterrupt, UIMessage as UIMessage$1, WhenBusy } from "@tanstack/ai-client";
+export * from "@tanstack/ai-react";
+//#region src/catalog/catalog.d.ts
+declare function modelRef(model: Pick<Model, 'provider' | 'id'>): string;
+/** 只切第一个斜杠：OpenRouter / Vercel Gateway 的模型 id 自带 `vendor/model`。 */
+declare function parseModelRef(ref: string): {
+  provider: string;
+  id: string;
+};
+declare function createCatalog(providers: readonly Provider[]): Catalog;
+//#endregion
+//#region src/catalog/cost.d.ts
+/**
+ * USD；`cost` 缺失返回 undefined。
+ *
+ * 提示 token 分三档计价：命中缓存的按 `cacheRead`，写入缓存的按 `cacheWrite`
+ * （Anthropic 是 input 的 1.25×），其余按 `input`；两个缓存价缺省都回落到 `input`。
+ * 两个明细都当作含在 `promptTokens` 里扣除——`usage.ts` 的 `addTokenUsage` 正是这样
+ * 累加它们的，而 `Math.max(…, 0)` 兜住厂商把它们单列在外的情形。
+ */
+declare function estimateCost(model: Model, usage: TokenUsage): number | undefined;
+//#endregion
+//#region src/catalog/thinking.d.ts
+declare const THINKING_LEVELS: readonly ThinkingLevel[];
+declare function supportedThinkingLevels(model: Model | undefined): readonly ThinkingLevel[];
+/**
+ * 向下取最近支持档；目标低于模型下限（Fable 5 这类不可关的模型）时取下限。
+ */
+declare function clampThinkingLevel(model: Model | undefined, level: ThinkingLevel): ThinkingLevel;
+//#endregion
+//#region src/catalog/usage-metrics.d.ts
+/** One modality's slice of a prompt or a completion. */
+interface ModalitySlice {
+  kind: 'text' | 'image' | 'audio' | 'video' | 'document';
+  tokens: number;
+  /** Of the side it belongs to (prompt or completion). */
+  share: number;
+}
+/**
+ * 派生指标。每一项在**分母未知或为零**时是 `undefined` 而不是 0——「没有提示 token
+ * 时的缓存命中率」不是零，是无从谈起，两者在界面上该有不同的下场（不显示，而不是
+ * 显示一个 0%）。
+ */
+interface UsageMetrics {
+  /** `completionTokens / promptTokens`：一份提示换回多少回答。 */
+  outputRatio: number | undefined;
+  /** `cachedTokens / promptTokens`：这次提示有多少是从缓存里读的。 */
+  cacheHitRate: number | undefined;
+  /** `cacheWriteTokens / promptTokens`：有多少被写进了缓存（下次才省钱）。 */
+  cacheWriteRate: number | undefined;
+  /** `reasoningTokens / completionTokens`：回答里有多少花在思考上。 */
+  reasoningShare: number | undefined;
+  /** `promptTokens / model.contextWindow`：上下文占用，同 `ContextUsage` 那根条。 */
+  contextRatio: number | undefined;
+  /**
+   * 缓存读比照原价省下的美元。要模型同时给出 `input` 与 `cacheRead` 才算得出——
+   * 没有 `cacheRead` 意味着缓存不打折，而不是省了 0。
+   */
+  cacheSavings: number | undefined;
+  /** 提示里各模态的占比，只列非零项，从大到小。 */
+  promptModalities: readonly ModalitySlice[];
+  /** 回答里各模态的占比，同上。 */
+  completionModalities: readonly ModalitySlice[];
+}
+/**
+ * `TokenUsage` 里读得出来的比例，一次算齐。
+ *
+ * 纯函数，和 `estimateCost` 并排住在目录层：这些数字两端都用得上，且与 React 无关。
+ * 输入可以是 `useUsageTracker` 的任意一个粒度——`total` / `lastRun` / `byMessage` 的某一条。
+ *
+ * `model` 只有两项指标需要（`contextRatio` 要 `contextWindow`，`cacheSavings` 要价格），
+ * 不给就是那两项为 `undefined`，其余照算。
+ */
+declare function usageMetrics(usage: TokenUsage, model?: Model): UsageMetrics;
+//#endregion
+//#region src/catalog/index.d.ts
+declare const providers: {
+  readonly openai: Provider;
+  readonly anthropic: Provider;
+  readonly gemini: Provider;
+  readonly grok: Provider;
+  readonly groq: Provider;
+  readonly mistral: Provider;
+  readonly openrouter: Provider;
+  readonly vercelGateway: Provider;
+  readonly llmgateway: Provider;
+  readonly bedrock: Provider;
+  readonly vertex: Provider;
+  readonly ollama: Provider;
+  readonly deepseek: Provider;
+};
+declare const defaultCatalog: Catalog;
+//#endregion
+//#region src/runtime/attachments.d.ts
+/** 3 MiB: base64 in a JSON body, comfortably under common function payload limits. */
+declare const DEFAULT_MAX_ATTACHMENT_BYTES: number;
+type AttachmentKind = 'image' | 'audio' | 'video' | 'document';
+type AttachmentState = 'idle' | 'uploading' | 'done' | 'error';
+declare function attachmentKindOf(mimeType: string): AttachmentKind | undefined;
+/** Inline a file as a `data` content part; rejects unsupported types and oversize files. */
+declare function fileToContentPart(file: File, options?: {
+  maxBytes?: number;
+}): Promise<ContentPart>;
+interface DraftAttachment {
+  id: string;
+  kind: AttachmentKind;
+  state: AttachmentState;
+  name: string;
+  mimeType: string;
+  size: number;
+  /** Present for files picked in the browser; converted on `toParts()`. */
+  file?: File;
+  /** Present for parts handed in ready-made (dictation, pasted URLs). */
+  part?: ContentPart;
+  error?: string;
+  /** Object URL for image thumbnails; revoked on remove / clear. */
+  previewUrl?: string;
+}
+interface UseAttachmentDraftOptions {
+  maxBytes?: number;
+  /** Kinds the picker accepts. Default: all four. */
+  accept?: readonly AttachmentKind[];
+}
+interface AttachmentDraft {
+  items: readonly DraftAttachment[];
+  add: (items: ReadonlyArray<File | ContentPart>) => void;
+  remove: (id: string) => void;
+  clear: () => void;
+  /** Convert every item to content parts, in order; rejects if any file fails. */
+  toParts: () => Promise<ContentPart[]>;
+  /** `accept` attribute for `<input type="file">`. */
+  accept: string;
+}
+declare function useAttachmentDraft(options?: UseAttachmentDraftOptions): AttachmentDraft;
+//#endregion
+//#region src/runtime/byok.d.ts
+interface CreateByokOptions {
+  /**
+   * `true` keeps the keyring across reloads, encrypted behind a passkey
+   * (`defaultByokStorage`: WebAuthn PRF → AES-256-GCM in IndexedDB); where the
+   * browser cannot do that it falls back to this tab's memory and says so in
+   * `byok.storage.warning`. Default `false` = memory only.
+   */
+  persistent?: boolean;
+  /** Your own `KeyringStorage`; wins over `persistent`. */
+  storage?: KeyringStorage$1;
+  /** Providers with `keyRequired: false` are marked server-covered up front. */
+  catalog?: Catalog;
+}
+/** True for the errors a send throws when the client could not attach a key — the dialog is already asking; the send can run again once the key is in. */
+declare function isByokError(error: unknown): boolean;
+/** A `ByokClient` with the house defaults, ready for `useChat({ byok })`. */
+declare function createByok(options?: CreateByokOptions): ByokClient$1;
+interface ServerCoverage {
+  coverage: Record<string, boolean> | undefined;
+  providers: readonly Provider[] | undefined;
+  error: Error | undefined;
+}
+/**
+ * Fetch `/api/ai/catalog` once and merge its `coverage` into the client, so
+ * `prepare()` stops asking for keys the server already holds.
+ */
+declare function useServerCoverage(byok: ByokClient$1, url?: string): ServerCoverage;
+//#endregion
+//#region src/runtime/messages.d.ts
+/** The message's text parts, joined by blank lines; tool calls and media are skipped. */
+declare function messageText(message: UIMessage$1): string;
+interface MessagesToMarkdownOptions {
+  title?: string;
+  /** Include thinking parts as block quotes. Default false. */
+  includeThinking?: boolean;
+}
+/** A plain Markdown transcript, for copy / download. */
+declare function messagesToMarkdown(messages: readonly UIMessage$1[], options?: MessagesToMarkdownOptions): string;
+/** The slice of `useChat()` that `editAndResend` needs. */
+interface EditableChat {
+  messages: readonly UIMessage$1[];
+  setMessages: (messages: UIMessage$1[]) => void;
+  sendMessage: (content: string | MultimodalContent$1) => Promise<void>;
+  status: ChatClientState$1;
+  stop: () => void;
+}
+/**
+ * Linear edit-and-resend (spec Q2): stop any run, drop the edited user message
+ * and everything after it, then send the new content in its place.
+ */
+declare function editAndResend(chat: EditableChat, messageId: string, content: string | MultimodalContent$1): Promise<void>;
+/**
+ * A thinking part is done when the run is no longer streaming, when the
+ * provider signed it, or when a later text / tool-call part has started.
+ */
+declare function isThinkingComplete(message: UIMessage$1, partIndex: number, status: ChatClientState$1): boolean;
+interface Source {
+  url: string;
+  title?: string;
+  snippet?: string;
+}
+/**
+ * Citations from provider-executed web search: an explicit `metadata.sources`
+ * list, or the result payload of a search tool the provider ran itself.
+ */
+declare function sourcesOf(message: UIMessage$1): Source[];
+//#endregion
+//#region src/runtime/renderers.d.ts
+/** Every visible string the default part renderers emit. Override through `PartRenderersProvider`. */
+interface PartLabels {
+  thinking: string;
+  /** Precedes the elapsed seconds `Reasoning` renders as data ("Thought for" → "Thought for 3s"). */
+  thought: string;
+  toolPending: string;
+  toolRunning: string;
+  toolApprovalRequested: string;
+  toolApproved: string;
+  toolDenied: string;
+  toolDone: string;
+  toolFailed: string;
+  toolGroup: (count: number) => string;
+  approve: string;
+  deny: string;
+  sources: (count: number) => string;
+}
+declare const DEFAULT_PART_LABELS: PartLabels;
+/**
+ * The approval interrupt as the views see it, for whichever tool set the chat
+ * was created with. `useChat().interrupts` is typed per tool and
+ * `ToolApprovalInterrupt<T>` is contravariant in `T` through `resolveInterrupt`,
+ * so no instantiation accepts every other one; this structural type lists only
+ * what the views read, with `resolveInterrupt` as a method (bivariant on
+ * purpose) so any tool's interrupt flows in untouched.
+ */
+interface AnyToolApprovalInterrupt {
+  readonly kind: 'tool-approval';
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly originalArgs: unknown;
+  readonly status: InterruptItemStatus;
+  resolveInterrupt(approved: boolean, options?: {
+    editedArgs?: unknown;
+  }): void;
+}
+interface ToolRendererProps {
+  part: ToolCallPart;
+  /** The matching `tool-result` part of the same message, once it exists. */
+  result: ToolResultPart | undefined;
+  /** The live approval interrupt while the call waits on the user. */
+  interrupt: AnyToolApprovalInterrupt | undefined;
+  streaming: boolean;
+}
+type ToolRenderer = (props: ToolRendererProps) => ReactNode;
+/** Per-part-type overrides; anything omitted falls back to the built-in renderer. */
+interface PartRenderers {
+  text?: (props: {
+    part: TextPart;
+    message: UIMessage$1;
+    streaming: boolean;
+  }) => ReactNode;
+  thinking?: (props: {
+    part: ThinkingPart$1;
+    complete: boolean;
+  }) => ReactNode;
+  /** Keyed by tool name; `default` catches the rest. */
+  toolCall?: {
+    default?: ToolRenderer;
+  } & Record<string, ToolRenderer | undefined>;
+  toolResult?: (props: {
+    part: ToolResultPart;
+  }) => ReactNode;
+  image?: (props: {
+    part: ImagePart;
+    message: UIMessage$1;
+  }) => ReactNode;
+  audio?: (props: {
+    part: AudioPart;
+    message: UIMessage$1;
+  }) => ReactNode;
+  video?: (props: {
+    part: VideoPart;
+    message: UIMessage$1;
+  }) => ReactNode;
+  document?: (props: {
+    part: DocumentPart;
+    message: UIMessage$1;
+  }) => ReactNode;
+  structuredOutput?: (props: {
+    part: StructuredOutputPart;
+  }) => ReactNode;
+  uiResource?: (props: {
+    part: UIResourcePart;
+  }) => ReactNode;
+}
+/** Identity with a type check, so a registry can be declared outside a component. */
+declare function definePartRenderers(renderers: PartRenderers): PartRenderers;
+interface PartRenderersContextValue {
+  renderers: PartRenderers;
+  labels: PartLabels;
+}
+interface PartRenderersProviderProps {
+  renderers?: PartRenderers;
+  labels?: Partial<PartLabels>;
+  children: ReactNode;
+}
+declare function PartRenderersProvider({ renderers, labels, children }: PartRenderersProviderProps): ReactElement;
+declare function usePartRenderers(): PartRenderersContextValue;
+//#endregion
+//#region src/runtime/selection.d.ts
+interface ModelSelection {
+  provider: string;
+  model: string;
+  thinking: ThinkingLevel;
+  /** 厂商侧联网搜索开关；模型没有这个能力时恒为 false。 */
+  search: boolean;
+}
+interface UseModelSelectionOptions {
+  catalog?: Catalog;
+  /** `localStorage` key. Default `cadenza-ai:selection`. */
+  key?: string;
+  /** Default: the catalog's first model with thinking off. */
+  initial?: ModelSelection;
+}
+interface UseModelSelectionReturn {
+  selection: ModelSelection;
+  model: Model | undefined;
+  provider: Provider | undefined;
+  /** `provider/model`; the thinking level is clamped to what the new model supports, and search drops if it has none. */
+  setModel: (ref: string) => void;
+  setThinking: (level: ThinkingLevel) => void;
+  setSearch: (on: boolean) => void;
+  /** 就是上面那个 `selection`，按 `useChat({ forwardedProps })` 的用法起的名字；渲染间稳定。 */
+  forwardedProps: ModelSelection;
+}
+/** The user's model + thinking choice, persisted, always valid for the chosen model. */
+declare function useModelSelection(options?: UseModelSelectionOptions): UseModelSelectionReturn;
+//#endregion
+//#region src/runtime/stored-state.d.ts
+/**
+ * `useState` whose value round-trips through `localStorage[key]` and stays in
+ * sync across hooks and tabs. Falls back to `initial` on the server and to an
+ * in-memory copy where storage is unavailable; writes never throw.
+ */
+declare function useStoredState<T>(key: string, initial: T): [T, (next: T) => void];
+//#endregion
+//#region src/runtime/threads.d.ts
+interface ThreadMeta {
+  id: string;
+  title: string;
+  createdAt: number;
+  updatedAt: number;
+  messageCount: number;
+  preview: string;
+  archived: boolean;
+  provider?: string;
+  model?: string;
+}
+/**
+ * The list side of thread storage. TanStack AI's `ChatClientPersistence` is a
+ * per-thread key/value store with no enumeration, so the index keeps the
+ * metadata (`ThreadMeta`) apart from the transcripts; `threadPersistence()`
+ * keeps the two in step.
+ */
+interface ThreadIndex {
+  /** Newest first; archived threads after live ones. Stable reference until the next write. */
+  list: () => readonly ThreadMeta[];
+  get: (id: string) => ThreadMeta | undefined;
+  /** Creates (or re-creates) a thread; clears the id's tombstone. */
+  create: (init?: Partial<ThreadMeta>) => ThreadMeta;
+  /**
+   * Upserts: an unknown id is created with `createdAt = now` — unless it was
+   * removed in this session, in which case nothing is written (a chat still
+   * mounted on a deleted thread flushes once more; the deletion wins).
+   */
+  touch: (id: string, patch: Partial<Omit<ThreadMeta, 'id'>>) => ThreadMeta;
+  rename: (id: string, title: string) => void;
+  archive: (id: string, archived: boolean) => void;
+  /** Drops the thread and leaves a tombstone so later writes do not resurrect it. */
+  remove: (id: string) => void;
+  /** Whether `remove(id)` happened in this session and no `create` followed. */
+  wasRemoved: (id: string) => boolean;
+  subscribe: (listener: () => void) => () => void;
+}
+interface ThreadIndexOptions {
+  /** `localStorage` key. Default `cadenza-ai:threads`. */
+  key?: string;
+  /** `'local'` (default) persists across reloads and tabs; `'memory'` is per page. */
+  storage?: 'local' | 'memory';
+}
+declare function newThreadId(): string;
+declare function createThreadIndex(options?: ThreadIndexOptions): ThreadIndex;
+declare function useThreadIndex(index: ThreadIndex): readonly ThreadMeta[];
+/** Title from the first user message; truncated with an ellipsis past `max` characters. */
+declare function threadTitleFrom(messages: readonly UIMessage$1[], max?: number): string;
+/**
+ * Wrap a `ChatClientPersistence` so every write also updates the index:
+ * message count, preview, timestamp, and — unless one was set by hand or
+ * `title: false` — a title derived from the first user message.
+ */
+interface ThreadPersistenceOptions {
+  /**
+   * Title for a thread nobody has named yet. Default: derived from the first
+   * user message (`threadTitleFrom`). `false` leaves it empty — for a caller
+   * that generates titles, showing the list's `untitled` label meanwhile.
+   */
+  title?: false | ((messages: readonly UIMessage$1[]) => string);
+}
+declare function threadPersistence(index: ThreadIndex, base: ChatClientPersistence, options?: ThreadPersistenceOptions): ChatClientPersistence;
+type ThreadDayLabel = 'today' | 'yesterday' | 'earlier';
+interface ThreadDayGroup {
+  label: ThreadDayLabel;
+  threads: readonly ThreadMeta[];
+}
+/** Buckets by local calendar day of `updatedAt`; empty buckets are omitted. */
+declare function groupThreadsByDay(threads: readonly ThreadMeta[], now?: number): readonly ThreadDayGroup[];
+//#endregion
+//#region src/runtime/usage.d.ts
+/** Field-wise sum, including the nested detail breakdowns and the provider's own cost. */
+declare function addTokenUsage(a: TokenUsage$1 | undefined, b: TokenUsage$1): TokenUsage$1;
+interface UsageTracker {
+  /** Wire to `useChat({ onChunk })`. */
+  onChunk: (chunk: StreamChunk) => void;
+  /** Wire to `useChat({ onFinish })`; assigns the run's usage to the finished message. */
+  onFinish: (message: UIMessage$1) => void;
+  total: TokenUsage$1;
+  lastRun: TokenUsage$1 | undefined;
+  byMessage: ReadonlyMap<string, TokenUsage$1>;
+  reset: () => void;
+}
+/**
+ * Sums every `RUN_FINISHED` of a run (tool loops finish once per iteration)
+ * and books the sum against the assistant message that closes the run.
+ */
+declare function useUsageTracker(): UsageTracker;
+//#endregion
+//#region src/view/approval.d.ts
+interface ApprovalActionsProps {
+  interrupt: AnyToolApprovalInterrupt;
+  /** `ApprovalApprove` / `ApprovalDeny`, with their own wording. */
+  children: ReactNode;
+  className?: string;
+}
+/**
+ * The approve / deny row under a tool call. Resolves through the interrupt;
+ * both buttons disable once `interrupt.status` leaves `pending`. The choice
+ * lands on the row as `data-approved` / `data-denied`.
+ */
+declare function ApprovalActions({ interrupt, children, className }: ApprovalActionsProps): ReactElement;
+type ApprovalApproveProps = ButtonProps & {
+  /** Arguments edited by the user, sent in place of the original ones. */
+  editedArgs?: unknown;
+};
+declare function ApprovalApprove({ editedArgs, disabled, onClick, ...props }: ApprovalApproveProps): ReactElement;
+type ApprovalDenyProps = ButtonProps;
+declare function ApprovalDeny({ disabled, onClick, ...props }: ApprovalDenyProps): ReactElement;
+//#endregion
+//#region src/view/byok-key-dialog.d.ts
+/** Every visible string the dialog emits. Override through `labels`. */
+interface ByokKeyDialogLabels {
+  title: string;
+  description: string;
+  save: string;
+  clear: string;
+  confirm: string;
+  unlock: string;
+  close: string;
+  /** `aria-label` of the icon marking a provider the server already holds a key for. */
+  serverKey: string;
+}
+declare const DEFAULT_BYOK_KEY_DIALOG_LABELS: ByokKeyDialogLabels;
+interface ByokKeyDialogProps {
+  byok: ByokClient$1;
+  catalog: Catalog;
+  /**
+   * Which providers the server can key from its own env — `useServerCoverage(byok).coverage`.
+   * `ByokClient` keeps its coverage private, so the dialog is told separately.
+   */
+  coverage?: Record<string, boolean>;
+  open?: boolean;
+  defaultOpen?: boolean;
+  /** Programmatic opens (a `byok.request()` prompt) carry `reason: 'none'`; the Confirm button closes with `reason: 'confirm'`. */
+  onOpenChange?: (open: boolean, details: DialogChangeEventDetails | ChangeEventDetails<'none' | 'confirm'>) => void;
+  labels?: Partial<ByokKeyDialogLabels>;
+  /** Omit it and every catalog provider gets a `ByokKeyDialogProvider` row. */
+  children?: ReactNode;
+}
+/**
+ * The key-entry dialog for a `ByokClient`. Subscribes to the client and opens
+ * itself whenever it raises a prompt (`prepare()` blocked on a missing key, or
+ * the server answered `byok_missing`), focusing that provider's input.
+ */
+declare function ByokKeyDialog({ byok, catalog, coverage, open: openProp, defaultOpen, onOpenChange, labels: labelsProp, children }: ByokKeyDialogProps): ReactElement;
+interface ByokKeyDialogProviderProps {
+  /** Catalog provider id. */
+  provider: string;
+  /** Appended at the end of the row — an OAuth / PKCE button, say. */
+  children?: ReactNode;
+  className?: string;
+}
+/**
+ * One provider's row: label, password input, save / clear icon buttons.
+ * `data-key-status` mirrors the client's `empty | set | locked | error`;
+ * `data-server-key` marks a provider the server can key on its own;
+ * `data-prompted` is on while the client is asking for this provider's key.
+ */
+declare function ByokKeyDialogProvider({ provider: id, children, className }: ByokKeyDialogProviderProps): ReactElement;
+//#endregion
+//#region src/view/composer.d.ts
+type ComposerSubmitReason = 'keyboard' | 'none';
+type ComposerChangeEventDetails = ChangeEventDetails<'input-change' | 'none'>;
+/** Mirrored as name-type `data-*` attributes on the root `<form>`; `ready` is the absence of the first three. */
+interface ComposerState {
+  submitted: boolean;
+  streaming: boolean;
+  error: boolean;
+  dragging: boolean;
+  editing: boolean;
+}
+interface ComposerProps extends Omit<ComponentProps<'form'>, 'onSubmit' | 'onChange' | 'defaultValue' | 'value'> {
+  value?: string;
+  defaultValue?: string;
+  onValueChange?: (value: string, details: ComposerChangeEventDetails) => void;
+  /** Enter, or the form's submit. The draft is cleared afterwards. */
+  onValueCommitted: (value: string, details: GenericEventDetails<ComposerSubmitReason>) => void;
+  status: ChatClientState$1;
+  /** Escape while `submitted` / `streaming`, or `ComposerSubmit` pressed in that state. */
+  onStop?: (details: GenericEventDetails<'escape-key' | 'none'>) => void;
+  editing?: boolean;
+  /** Escape while `editing` — takes precedence over `onStop`. */
+  onEditCancel?: (details: GenericEventDetails<'escape-key'>) => void;
+  disabled?: boolean;
+  /** Commit an empty draft too — for a composer whose attachments strip carries the content. Default false. */
+  allowEmpty?: boolean;
+  /** Files dropped on the form or pasted into it. */
+  onFiles?: (files: File[], details: GenericEventDetails<'drag' | 'input-paste'>) => void;
+  children: ReactNode;
+}
+interface ComposerContextValue {
+  value: string;
+  setValue: (value: string, details?: ComposerChangeEventDetails) => void;
+  status: ChatClientState$1;
+  editing: boolean;
+  disabled: boolean;
+  /** The draft can be committed: non-empty, or `allowEmpty`. */
+  committable: boolean;
+  submit: (details: GenericEventDetails<ComposerSubmitReason>) => void;
+  /** Forwards to the root's `onStop`; a no-op unless `submitted` / `streaming`. */
+  stop: (details: GenericEventDetails<'escape-key' | 'none'>) => void;
+  /** Forwards to the root's `onEditCancel`. */
+  cancelEdit: (details: GenericEventDetails<'escape-key'>) => void;
+}
+declare function useComposer(): ComposerContextValue;
+/**
+ * The input area: a `<form>` around an `InputGroup`, so `ComposerTextarea` and
+ * `ComposerToolbar` stay direct children of the group (its auto-height and
+ * block-end addon rules key off `>` combinators).
+ */
+declare function Composer({ allowEmpty, children, className, defaultValue, disabled, editing, onDragLeave, onDragOver, onDrop, onEditCancel, onFiles, onPaste, onStop, onValueChange, onValueCommitted, status, value: valueProp, ...props }: ComposerProps): ReactElement;
+type ComposerTextareaProps = InputGroupTextareaProps;
+/** The draft text. Enter commits, Shift+Enter breaks a line, IME composition is left alone, Escape cancels or stops. */
+declare function ComposerTextarea({ className, onChange, onKeyDown, ...props }: ComposerTextareaProps): ReactElement;
+type ComposerToolbarProps = InputGroupAddonProps;
+/** The row under the textarea: attach, dictate, pickers, submit. */
+declare function ComposerToolbar(props: ComposerToolbarProps): ReactElement;
+type ComposerSubmitProps = ButtonProps;
+/** Send while idle, stop while busy. Disabled on an empty draft. */
+declare function ComposerSubmit({ children, ...props }: ComposerSubmitProps): ReactElement;
+interface ComposerAttachmentsProps {
+  items: readonly DraftAttachment[];
+  onRemove: (id: string, details: GenericEventDetails<'none'>) => void;
+  className?: string;
+}
+/** The pending-attachments strip; `state` maps straight onto `Attachment`'s. Renders nothing while empty. */
+declare function ComposerAttachments({ items, onRemove, className }: ComposerAttachmentsProps): ReactElement | null;
+type ComposerAttachProps = InputGroupButtonProps & {
+  accept?: string;
+  multiple?: boolean;
+  onFiles: (files: File[], details: GenericEventDetails<'input-change'>) => void;
+};
+/** Opens the file picker; the chosen files go to `onFiles`. */
+declare function ComposerAttach({ accept, children, multiple, onClick, onFiles, ...props }: ComposerAttachProps): ReactElement;
+type ComposerDictateProps = InputGroupButtonProps & {
+  onRecording: (part: AudioPart, details: GenericEventDetails<'imperative-action'>) => void;
+};
+/** Press to record, press again to stop; the finished recording's audio part goes to `onRecording`. */
+declare function ComposerDictate({ children, onClick, onRecording, ...props }: ComposerDictateProps): ReactElement;
+//#endregion
+//#region src/view/context-usage.d.ts
+/** The row labels of the detail tooltip. Override through `labels` (the `ByokKeyDialog` route: this part has no renderer registry to read from). */
+interface ContextUsageLabels {
+  prompt: string;
+  completion: string;
+  cached: string;
+  total: string;
+  cost: string;
+  cacheHit: string;
+  outputRatio: string;
+  reasoningShare: string;
+  cacheSaved: string;
+}
+declare const DEFAULT_CONTEXT_USAGE_LABELS: ContextUsageLabels;
+interface ContextUsageProps {
+  /** Supplies `contextWindow` (the bar) and `cost` (the price row); without it only the numbers show. */
+  model?: Model;
+  usage: TokenUsage;
+  labels?: Partial<ContextUsageLabels>;
+  /** After the prompt-token count ("tokens") — the part ships no unit. */
+  children?: ReactNode;
+  /** Lands on the trigger. */
+  className?: string;
+}
+interface ContextUsageState {
+  /** `usage.promptTokens / model.contextWindow`; `undefined` when the model has no window. */
+  ratio: number | undefined;
+}
+/**
+ * How full the context is (spec O1): a bar for `promptTokens / contextWindow`
+ * beside the number, with the token breakdown and `estimateCost` in a tooltip.
+ * The whole thing is the tooltip's trigger; `data-ratio` (two decimals) is
+ * the bar's value for styling from outside.
+ */
+declare function ContextUsage({ model, usage, labels: labelsProp, children, className }: ContextUsageProps): ReactElement;
+//#endregion
+//#region src/view/markdown.d.ts
+interface MarkdownProps {
+  content: string;
+  /** Still receiving bytes: parse incomplete markdown leniently and animate. */
+  streaming?: boolean;
+  /** streamdown's own UI strings (copy button, fullscreen …); English by default. */
+  translations?: Partial<StreamdownTranslations>;
+  /** Lands on streamdown's root `<div>`. */
+  className?: string;
+}
+/** Product-grade Markdown: streamdown with code / math / CJK plugins and safe links. */
+declare function Markdown({ content, streaming, translations, className }: MarkdownProps): ReactElement;
+//#endregion
+//#region src/view/media-part.d.ts
+interface MediaPartProps {
+  part: ImagePart | AudioPart | VideoPart | DocumentPart;
+  className?: string;
+}
+/** A message's media part rendered by type: image card, native audio / video, document card. */
+declare function MediaPart({ part, className }: MediaPartProps): ReactElement;
+//#endregion
+//#region src/view/model-picker.d.ts
+/** The Combobox's own details, passed straight through — `item-press` in practice, `none` for programmatic changes. */
+type ModelPickerChangeEventDetails = ComboboxChangeEventDetails;
+interface ModelPickerProps {
+  catalog: Catalog;
+  /** A `provider/model` ref. */
+  value?: string;
+  defaultValue?: string;
+  onValueChange: (ref: string, details: ModelPickerChangeEventDetails) => void;
+  /** With a snapshot, providers whose key is required but `empty` get `data-key-missing` on their heading. */
+  byok?: ByokSnapshot$1;
+  disabledProviders?: readonly string[];
+  /** Lands on the trigger button. */
+  className?: string;
+}
+/** A searchable, provider-grouped model list; the value is the model ref. */
+declare function ModelPicker({ byok, catalog, className, defaultValue, disabledProviders, onValueChange, value }: ModelPickerProps): ReactElement;
+/** The Select's own details, passed straight through. */
+type ThinkingLevelPickerChangeEventDetails = SelectChangeEventDetails;
+interface ThinkingLevelPickerProps {
+  model?: Model;
+  value?: ThinkingLevel;
+  defaultValue?: ThinkingLevel;
+  onValueChange: (level: ThinkingLevel, details: ThinkingLevelPickerChangeEventDetails) => void;
+  /** Lands on the trigger button. */
+  className?: string;
+}
+/** The model's supported thinking levels; renders nothing when there is no choice to make. */
+declare function ThinkingLevelPicker({ className, defaultValue, model, onValueChange, value }: ThinkingLevelPickerProps): ReactElement | null;
+/** The Toggle's own details, passed straight through. */
+type ThinkingToggleChangeEventDetails = ToggleChangeEventDetails;
+interface ThinkingToggleProps {
+  model?: Model;
+  value?: ThinkingLevel;
+  defaultValue?: ThinkingLevel;
+  /** The level switching on lands at, clamped to the model. Default `'high'`. */
+  onLevel?: ThinkingLevel;
+  onValueChange: (level: ThinkingLevel, details: ThinkingToggleChangeEventDetails) => void;
+  /** The label — DeepSeek's reads 深度思考. */
+  children: ReactNode;
+  /** Lands on the toggle. */
+  className?: string;
+}
+/**
+ * The one-press deep-thinking switch, DeepSeek style: a pill that lights up
+ * while thinking is on. Renders nothing for a model without reasoning; a model
+ * that cannot switch thinking off (no `'off'` level) shows it pressed and
+ * disabled. `data-thinking` mirrors the on state.
+ */
+declare function ThinkingToggle({ children, className, defaultValue, model, onLevel, onValueChange, value }: ThinkingToggleProps): ReactElement | null;
+/** The Toggle's own details, passed straight through. */
+type SearchToggleChangeEventDetails = ToggleChangeEventDetails;
+interface SearchToggleProps {
+  model?: Model;
+  value?: boolean;
+  defaultValue?: boolean;
+  onValueChange: (on: boolean, details: SearchToggleChangeEventDetails) => void;
+  /** The label — DeepSeek's reads 联网搜索. */
+  children: ReactNode;
+  /** Lands on the toggle. */
+  className?: string;
+}
+/**
+ * The one-press web-search switch, the same pill as `ThinkingToggle`. Renders
+ * nothing for a model without `search`, so it appears and disappears with the
+ * model the way the thinking controls do. `data-search` mirrors the on state.
+ *
+ * The search itself runs on the provider's side; the caller's job is to put the
+ * answer into `forwardedProps` so the server can hand that provider its
+ * built-in tool (`createChatHandler`'s function form of `tools`).
+ */
+declare function SearchToggle({ children, className, defaultValue, model, onValueChange, value }: SearchToggleProps): ReactElement | null;
+//#endregion
+//#region src/view/queue.d.ts
+interface QueueListProps {
+  queue: readonly QueuedMessage$1[];
+  onCancel: (id: string, details: GenericEventDetails<'none'>) => void;
+  /** Rendered after the rows — a heading or a hint the caller writes. */
+  children?: ReactNode;
+  className?: string;
+}
+/** Messages waiting behind the current turn, each with a cancel. */
+declare function QueueList({ children, className, onCancel, queue }: QueueListProps): ReactElement;
+//#endregion
+//#region src/view/reasoning.d.ts
+/** `trigger-press` from the user, `none` for the automatic collapse on completion. */
+type ReasoningChangeEventDetails = CollapsibleChangeEventDetails | ChangeEventDetails<'none'>;
+interface ReasoningProps {
+  content: string;
+  complete: boolean;
+  /** `Date.now()` when the thinking started. Default: when this part mounted, which is when it arrived. */
+  startedAt?: number;
+  open?: boolean;
+  defaultOpen?: boolean;
+  onOpenChange?: (open: boolean, details: ReasoningChangeEventDetails) => void;
+  /** The trigger's text ("Thinking…" / "Thought for 3s") — the part ships none. */
+  children: ReactNode;
+  /** Lands on the Collapsible root. */
+  className?: string;
+}
+interface ReasoningState {
+  complete: boolean;
+  open: boolean;
+}
+/**
+ * A thinking block: open while streaming (shimmering trigger), folds itself
+ * once when `complete` flips — unless the user has already toggled it by hand.
+ */
+declare function Reasoning({ content, complete, startedAt: startedAtProp, open: openProp, defaultOpen, onOpenChange, children, className }: ReasoningProps): ReactElement;
+//#endregion
+//#region src/view/sources.d.ts
+type SourcesChangeEventDetails = CollapsibleChangeEventDetails | ChangeEventDetails<'none'>;
+interface SourcesProps {
+  sources: readonly Source[];
+  /** The trigger's text ("3 sources") — the part ships none. */
+  children: ReactNode;
+  open?: boolean;
+  defaultOpen?: boolean;
+  onOpenChange?: (open: boolean, details: SourcesChangeEventDetails) => void;
+  /** Lands on the Collapsible root. */
+  className?: string;
+}
+/** The links a provider-executed search returned (spec T12), folded behind a trigger. */
+declare function Sources({ sources, children, open: openProp, defaultOpen, onOpenChange, className }: SourcesProps): ReactElement;
+//#endregion
+//#region src/view/structured-output.d.ts
+interface StructuredOutputProps {
+  part: StructuredOutputPart;
+  className?: string;
+}
+/** `useChat({ outputSchema })`'s part (spec T23): partial JSON while streaming, the validated data once complete. */
+declare function StructuredOutput({ part, className }: StructuredOutputProps): ReactElement;
+//#endregion
+//#region src/view/suggestions.d.ts
+type SuggestionsChangeEventDetails = ChangeEventDetails<'item-press'>;
+interface SuggestionsProps {
+  /** The pressed chip's `value`. Values flow through the root, Base UI Menu / Select style. */
+  onValueChange: (value: string, details: SuggestionsChangeEventDetails) => void;
+  children: ReactNode;
+  /** Lands on the `ScrollArea` root, a plain element. */
+  className?: string;
+}
+/** A horizontally scrolling row of prompt chips. */
+declare function Suggestions({ children, className, onValueChange }: SuggestionsProps): ReactElement;
+type SuggestionsItemProps = Omit<ButtonProps, 'value'> & {
+  /** What the root's `onValueChange` receives — usually the prompt text itself. */
+  value: string;
+};
+declare function SuggestionsItem({ onClick, value, ...props }: SuggestionsItemProps): ReactElement;
+//#endregion
+//#region src/view/thread-list.d.ts
+type ThreadListChangeEventReason = 'item-press' | 'none';
+type ThreadListChangeEventDetails = ChangeEventDetails<ThreadListChangeEventReason>;
+/** The row a `ThreadListItem` action sits in. */
+declare function useThreadListItem(): {
+  thread: ThreadMeta;
+  active: boolean;
+};
+interface ThreadListProps {
+  index: ThreadIndex;
+  /** Already filtered by the caller (`useThreadIndex(index)` plus search / archive filters). */
+  threads: readonly ThreadMeta[];
+  value?: string;
+  defaultValue?: string;
+  onValueChange: (id: string, details: ThreadListChangeEventDetails) => void;
+  /** Omit it and every thread renders as a bare `ThreadListItem` — no groups, no actions. */
+  children?: ReactNode;
+  /** Lands on the `ScrollArea` root; give it the height. */
+  className?: string;
+  /** Shown as the title of a thread whose `title` is still empty. */
+  untitled?: ReactNode;
+}
+/**
+ * The scrolling list of threads. `ScrollArea` root > `div[role=list]`; the
+ * current thread is the controlled `value`, and selecting a row (or `ThreadListNew`
+ * creating one) reports through `onValueChange(id, details)`.
+ */
+declare function ThreadList({ index, threads, value, defaultValue, onValueChange, children, className, untitled }: ThreadListProps): ReactElement;
+interface ThreadListGroupProps {
+  /** A `ThreadListGroupLabel` first, then the group's items. */
+  children: ReactNode;
+  className?: string;
+}
+declare function ThreadListGroup({ children, className }: ThreadListGroupProps): ReactElement;
+type ThreadListGroupLabelProps = ComponentProps<'div'>;
+declare function ThreadListGroupLabel({ className, ...props }: ThreadListGroupLabelProps): ReactElement;
+interface ThreadListItemProps {
+  thread: ThreadMeta;
+  /** The actions area (`ThreadListRename` / `ThreadListArchive` / `ThreadListDelete`, or a menu holding them). */
+  children?: ReactNode;
+  className?: string;
+}
+interface ThreadListItemState {
+  active: boolean;
+  archived: boolean;
+  renaming: boolean;
+}
+/**
+ * One row: an `Item` whose content is a press target for selection, or — while
+ * renaming — an inline `Input` (Enter / blur commit, Escape cancels). Mirrors its
+ * state as `data-active` (+ `aria-current="page"`), `data-archived`, `data-renaming`.
+ */
+declare function ThreadListItem({ thread, children, className }: ThreadListItemProps): ReactElement;
+type ThreadListRenameProps = ButtonProps;
+/** Switches the row to its inline rename input. */
+declare function ThreadListRename({ children, onClick, ...props }: ThreadListRenameProps): ReactElement;
+type ThreadListArchiveProps = ButtonProps;
+/** Toggles `archived` through the index. */
+declare function ThreadListArchive({ children, onClick, ...props }: ThreadListArchiveProps): ReactElement;
+type ThreadListDeleteProps = ButtonProps;
+/** Removes the thread from the index. Confirmation is the caller's — wrap it in an `AlertDialog`. */
+declare function ThreadListDelete({ children, onClick, ...props }: ThreadListDeleteProps): ReactElement;
+type ThreadListNewProps = ButtonProps;
+/** Creates an empty thread and selects it (`reason: 'item-press'`). */
+declare function ThreadListNew({ onClick, ...props }: ThreadListNewProps): ReactElement;
+//#endregion
+//#region src/view/tool-call.d.ts
+/** `trigger-press` from the user, `none` for programmatic changes. */
+type ToolCallChangeEventDetails = CollapsibleChangeEventDetails | ChangeEventDetails<'none'>;
+interface OpenProps {
+  open?: boolean;
+  defaultOpen?: boolean;
+  onOpenChange?: (open: boolean, details: ToolCallChangeEventDetails) => void;
+}
+interface ToolCallCardProps extends OpenProps {
+  part: ToolCallPart;
+  /** The matching `tool-result` part, once it exists. */
+  result?: ToolResultPart;
+  /** The live approval interrupt while the call waits on the user. */
+  interrupt?: AnyToolApprovalInterrupt;
+  streaming?: boolean;
+  /** Rendered at the end of the body — the place for `ApprovalActions`. */
+  children?: ReactNode;
+  /** Lands on the Collapsible root. */
+  className?: string;
+}
+/** The seven `ToolCallState`s folded into five named attributes. */
+interface ToolCallCardState {
+  pending: boolean;
+  approvalRequested: boolean;
+  approvalResponded: boolean;
+  complete: boolean;
+  error: boolean;
+}
+/**
+ * A collapsible card for one tool call: header = tool name + state icon (no
+ * words), body = the JSON input and output as Markdown code blocks, then
+ * `children`.
+ */
+declare function ToolCallCard({ part, result, interrupt: _interrupt, streaming, open: openProp, defaultOpen, onOpenChange, children, className }: ToolCallCardProps): ReactElement;
+interface ToolCallGroupProps extends OpenProps {
+  count: number;
+  /** `ToolCallGroupTrigger` first, then the cards it folds. */
+  children: ReactNode | ReactNode[];
+  /** Lands on the Collapsible root. */
+  className?: string;
+}
+type ToolCallGroupTriggerProps = CollapsibleTriggerProps;
+/** The group's title — a `CollapsibleTrigger`, wording from the caller. */
+declare function ToolCallGroupTrigger({ className, ...props }: ToolCallGroupTriggerProps): ReactElement;
+/**
+ * Folds a run of consecutive tool calls (spec G6). Position contract like
+ * `DialogTrigger`: the first child is the `ToolCallGroupTrigger`, the rest
+ * go into the panel.
+ */
+declare function ToolCallGroup({ count, children, open: openProp, defaultOpen, onOpenChange, className }: ToolCallGroupProps): ReactElement;
+//#endregion
+//#region src/view/transcript.d.ts
+interface ApprovalResponseInput {
+  id: string;
+  approved: boolean;
+}
+/**
+ * `ChatInterrupt`'s default generic folds the approval member away, and the
+ * per-tool `ToolApprovalInterrupt<T>` instantiations do not unify (see
+ * `AnyToolApprovalInterrupt`), so the transcript names the union itself.
+ */
+type TranscriptInterrupt = ChatInterrupt$1 | AnyToolApprovalInterrupt;
+interface TranscriptContextValue {
+  status: ChatClientState$1;
+  interrupts: readonly TranscriptInterrupt[];
+  /** Fallback for `approval-requested` parts that carry no live interrupt (e.g. restored history). */
+  addToolApprovalResponse?: (input: ApprovalResponseInput) => Promise<void> | void;
+}
+interface TranscriptProviderProps {
+  status: ChatClientState$1;
+  interrupts?: readonly TranscriptInterrupt[];
+  addToolApprovalResponse?: TranscriptContextValue['addToolApprovalResponse'];
+  children: ReactNode;
+}
+/** Hands `useChat()`'s run state to every Transcript part below it. */
+declare function TranscriptProvider({ status, interrupts, addToolApprovalResponse, children }: TranscriptProviderProps): ReactElement;
+declare function useTranscript(): TranscriptContextValue;
+interface TranscriptProps extends Omit<MessageScrollerViewportProps, 'className' | 'children'> {
+  children: ReactNode;
+  /** Follow new messages while the reader is at the end. Default true. */
+  autoScroll?: boolean;
+  /** Where a freshly mounted transcript rests. Default `'end'`. */
+  defaultScrollPosition?: MessageScrollerDefaultScrollPosition;
+  /**
+   * Pin each sent user message to the top of the viewport and let the reply fill
+   * the space below (the ChatGPT turn anchor). Default true. `false` keeps the
+   * classic behaviour: the view stays at the end and follows the reply.
+   */
+  anchorTurns?: boolean;
+  /**
+   * How much of the previous row stays visible above a freshly anchored user
+   * message, in px. The scroller's default is 80 (a context cue); 0 pins the
+   * message flush to the top, ChatGPT style.
+   */
+  previousPeek?: number;
+  /** Rendered beside the viewport, inside the frame — the place for `MessageScrollerButton`. */
+  after?: ReactNode;
+  /** Lands on the scroller frame. */
+  className?: string;
+}
+/** The scrolling frame: `MessageScroller` with the house viewport, one row per `TranscriptMessage`. */
+declare function Transcript({ children, autoScroll, defaultScrollPosition, anchorTurns, previousPeek, after, className, ...viewport }: TranscriptProps): ReactElement;
+interface TranscriptMessageProps {
+  message: UIMessage$1;
+  /** Default: user rows end-aligned, everything else start-aligned. */
+  align?: MessageAlign;
+  /** True for the row the current run is writing into. */
+  streaming?: boolean;
+  /** Default: `<TranscriptParts message={message} />`. A `TranscriptActions` child is lifted into the footer. */
+  children?: ReactNode;
+  className?: string;
+}
+interface TranscriptMessageState {
+  role: string;
+  streaming: boolean;
+}
+declare function TranscriptMessageImpl({ message, align, streaming, children, className }: TranscriptMessageProps): ReactElement;
+/** One row. Memoised so a streaming row re-renders alone. */
+declare const TranscriptMessage: MemoExoticComponent<typeof TranscriptMessageImpl>;
+interface TranscriptPartsProps {
+  message: UIMessage$1;
+  className?: string;
+}
+/** Dispatches every part of a message through the renderer registry and the default parts. */
+declare function TranscriptParts({ message, className }: TranscriptPartsProps): ReactElement;
+interface TranscriptActionsProps {
+  children: ReactNode;
+  className?: string;
+}
+/** The row's toolbar, hidden while a run streams. Place it as a child of `TranscriptMessage`. */
+declare function TranscriptActions({ children, className }: TranscriptActionsProps): ReactElement;
+type TranscriptActionProps = ButtonProps;
+declare function TranscriptAction({ className, ...props }: TranscriptActionProps): ReactElement;
+type TranscriptEmptyProps = EmptyProps;
+declare function TranscriptEmpty(props: TranscriptEmptyProps): ReactElement;
+interface TranscriptPendingProps {
+  children: ReactNode;
+  className?: string;
+}
+/** Shown between submit and the first chunk. */
+declare function TranscriptPending({ children, className }: TranscriptPendingProps): ReactElement;
+interface TranscriptErrorProps {
+  error: Error;
+  children: ReactNode;
+  className?: string;
+}
+declare function TranscriptError({ error, children, className }: TranscriptErrorProps): ReactElement;
+//#endregion
+//#region src/view/usage-stats.d.ts
+/**
+ * The tile captions. A `labels` prop rather than children because this part has
+ * no composition surface to write them into — the same call `ContextUsage` and
+ * `ByokKeyDialog` make, and the reason is the same: the copy names a computed
+ * quantity, it is not content the caller authored.
+ */
+interface UsageStatsLabels {
+  cacheHit: string;
+  cacheWrite: string;
+  outputRatio: string;
+  reasoningShare: string;
+  contextUsed: string;
+  cacheSaved: string;
+  promptModalities: string;
+  completionModalities: string;
+  /** Reads the modality kinds; the keys are `ModalitySlice['kind']`. */
+  modality: Record<ModalitySlice['kind'], string>;
+}
+declare const DEFAULT_USAGE_STATS_LABELS: UsageStatsLabels;
+interface UsageStatsProps {
+  usage: TokenUsage;
+  /** Supplies `contextWindow` (context used) and `cost` (saved by cache); without it those two tiles stay away. */
+  model?: Model;
+  labels?: Partial<UsageStatsLabels>;
+  /** Lands on the grid. */
+  className?: string;
+}
+/**
+ * The ratios inside a `TokenUsage`, one tile each: how much of the prompt came
+ * from cache, how much answer a prompt bought, how much of the answer was
+ * thinking, how full the context is, and what the cache saved.
+ *
+ * Every tile is skipped when its number is unknown — a rate with no denominator
+ * is not zero — so a provider that reports no cache detail simply shows fewer
+ * tiles rather than a row of 0%.
+ *
+ * It renders one `usage`. Which one is the caller's to decide: `useUsageTracker`
+ * hands over `total`, `lastRun` and `byMessage`, and a switch between them is a
+ * few lines the caller writes anyway, keeping that wording and those variants
+ * where they belong.
+ */
+declare function UsageStats({ usage, model, labels: labelsProp, className }: UsageStatsProps): ReactElement;
+//#endregion
+export { type AnyClientTool, AnyToolApprovalInterrupt, ApprovalActions, ApprovalActionsProps, ApprovalApprove, ApprovalApproveProps, ApprovalDeny, ApprovalDenyProps, ApprovalResponseInput, AttachmentDraft, AttachmentKind, AttachmentState, type ByokClient, ByokKeyDialog, ByokKeyDialogLabels, ByokKeyDialogProps, ByokKeyDialogProvider, ByokKeyDialogProviderProps, type ByokPrompt, type ByokSnapshot, Catalog, type ChatClientState, type ChatInterrupt, Composer, ComposerAttach, ComposerAttachProps, ComposerAttachments, ComposerAttachmentsProps, ComposerChangeEventDetails, ComposerDictate, ComposerDictateProps, ComposerProps, ComposerState, ComposerSubmit, ComposerSubmitProps, ComposerSubmitReason, ComposerTextarea, ComposerTextareaProps, ComposerToolbar, ComposerToolbarProps, ContextUsage, ContextUsageLabels, ContextUsageProps, ContextUsageState, CreateByokOptions, DEFAULT_BYOK_KEY_DIALOG_LABELS, DEFAULT_CONTEXT_USAGE_LABELS, DEFAULT_MAX_ATTACHMENT_BYTES, DEFAULT_PART_LABELS, DEFAULT_USAGE_STATS_LABELS, DraftAttachment, EditableChat, EventType, type InferToolInput, type InferToolOutput, type KeyStatus, type KeyringStorage, Markdown, MarkdownProps, MediaPart, MediaPartProps, MessagesToMarkdownOptions, type Modality, ModalitySlice, Model, ModelCost, ModelPicker, ModelPickerChangeEventDetails, ModelPickerProps, ModelSelection, type MultimodalContent, PartLabels, PartRenderers, PartRenderersContextValue, PartRenderersProvider, PartRenderersProviderProps, Provider, QueueList, QueueListProps, type QueuedMessage, Reasoning, ReasoningChangeEventDetails, ReasoningProps, ReasoningState, SearchToggle, SearchToggleChangeEventDetails, SearchToggleProps, type SendMessageOptions, ServerCoverage, Source, Sources, SourcesChangeEventDetails, SourcesProps, StructuredOutput, StructuredOutputProps, Suggestions, SuggestionsChangeEventDetails, SuggestionsItem, SuggestionsItemProps, SuggestionsProps, THINKING_LEVELS, ThinkingLevel, ThinkingLevelPicker, ThinkingLevelPickerChangeEventDetails, ThinkingLevelPickerProps, type ThinkingPart, ThinkingToggle, ThinkingToggleChangeEventDetails, ThinkingToggleProps, ThreadDayGroup, ThreadDayLabel, ThreadIndex, ThreadIndexOptions, ThreadList, ThreadListArchive, ThreadListArchiveProps, ThreadListChangeEventDetails, ThreadListChangeEventReason, ThreadListDelete, ThreadListDeleteProps, ThreadListGroup, ThreadListGroupLabel, ThreadListGroupLabelProps, ThreadListGroupProps, ThreadListItem, ThreadListItemProps, ThreadListItemState, ThreadListNew, ThreadListNewProps, ThreadListProps, ThreadListRename, ThreadListRenameProps, ThreadMeta, ThreadPersistenceOptions, type TokenUsage, type ToolApprovalInterrupt, ToolCallCard, ToolCallCardProps, ToolCallCardState, ToolCallChangeEventDetails, ToolCallGroup, ToolCallGroupProps, ToolCallGroupTrigger, ToolCallGroupTriggerProps, ToolRenderer, ToolRendererProps, Transcript, TranscriptAction, TranscriptActionProps, TranscriptActions, TranscriptActionsProps, TranscriptContextValue, TranscriptEmpty, TranscriptEmptyProps, TranscriptError, TranscriptErrorProps, TranscriptInterrupt, TranscriptMessage, TranscriptMessageProps, TranscriptMessageState, TranscriptParts, TranscriptPartsProps, TranscriptPending, TranscriptPendingProps, TranscriptProps, TranscriptProvider, TranscriptProviderProps, UsageMetrics, UsageStats, UsageStatsLabels, UsageStatsProps, UsageTracker, UseAttachmentDraftOptions, UseModelSelectionOptions, UseModelSelectionReturn, type WhenBusy, addTokenUsage, attachmentKindOf, clampThinkingLevel, createByok, createCatalog, createThreadIndex, defaultByokStorage, defaultCatalog, defineByok, definePartRenderers, editAndResend, estimateCost, fileToContentPart, fromSpecTokenUsage, generateMessageId, groupThreadsByDay, isByokError, isPasskeyStorageSupported, isThinkingComplete, memoryStorage, messageText, messagesToMarkdown, modelRef, newThreadId, parseModelRef, parsePartialJSON, passkeyStorage, providers, sourcesOf, supportedThinkingLevels, threadPersistence, threadTitleFrom, toolDefinition, usageMetrics, useAttachmentDraft, useComposer, useModelSelection, usePartRenderers, useServerCoverage, useStoredState, useThreadIndex, useThreadListItem, useTranscript, useUsageTracker };