@mcp-b/react-components 0.6.5 → 0.7.1

package/dist/PromptInput-D6-G24p7.d.ts

@@ -0,0 +1,528 @@
+import { A as SelectTriggerProps, M as SelectValueProps, S as SelectProps, f as SelectOption, j as SelectValue, r as SelectContentProps, s as SelectItemProps, t as Select } from "./Select-CRsKCJ9x.js";
+import { c as ComboboxGroup, d as ComboboxLabel, f as ComboboxList, g as ComboboxTrigger, h as ComboboxSeparator, l as ComboboxInput, m as ComboboxPositioner, p as ComboboxPopup, s as ComboboxEmpty, t as Combobox, u as ComboboxItem } from "./Combobox-D9anamNr.js";
+import { h as MenuItemProps, l as MenuContentProps, w as MenuProps } from "./Menu-B5vDqZe_.js";
+import { c as TabsList, n as TabPanel, t as Tab } from "./Tabs-D9EAq09D.js";
+import { r as ButtonProps } from "./Button-Ct5I6aTu.js";
+import * as React from "react";
+import { ChatAddToolApproveResponseFunction, ChatStatus, DynamicToolUIPart, FileUIPart, ToolUIPart, UIMessage } from "ai";
+import { PendingApproval } from "@cloudflare/think";
+
+//#region src/components/PromptInput.d.ts
+interface PromptInputReferencedSource {
+  id?: string;
+  title?: string;
+  url?: string;
+  [key: string]: unknown;
+}
+/** The payload produced when the prompt input is submitted. */
+interface PromptInputMessage {
+  text: string;
+  files: FileUIPart[];
+}
+interface AttachmentsContext {
+  files: Array<FileUIPart & {
+    id: string;
+  }>;
+  add: (files: File[] | FileList) => void;
+  remove: (id: string) => void;
+  clear: () => void;
+  openFileDialog: () => void;
+  fileInputRef: React.RefObject<HTMLInputElement | null>;
+}
+interface TextInputContext {
+  value: string;
+  setInput: (value: string) => void;
+  clear: () => void;
+}
+interface PromptInputControllerProps {
+  textInput: TextInputContext;
+  attachments: AttachmentsContext;
+  __registerFileInput: (ref: React.RefObject<HTMLInputElement | null>, open: () => void) => void;
+}
+interface ReferencedSourcesContext {
+  sources: Array<PromptInputReferencedSource & {
+    id: string;
+  }>;
+  add: (sources: PromptInputReferencedSource[] | PromptInputReferencedSource) => void;
+  remove: (id: string) => void;
+  clear: () => void;
+}
+declare function usePromptInputController(): PromptInputControllerProps;
+declare function useProviderAttachments(): AttachmentsContext;
+declare function usePromptInputAttachments(): AttachmentsContext;
+declare function usePromptInputReferencedSources(): ReferencedSourcesContext;
+interface PromptInputProviderProps extends React.PropsWithChildren {
+  initialInput?: string;
+}
+declare function PromptInputProvider({
+  initialInput,
+  children
+}: PromptInputProviderProps): React.JSX.Element;
+interface PromptInputProps extends Omit<React.FormHTMLAttributes<HTMLFormElement>, "onSubmit" | "onError"> {
+  /** Accepted file MIME types/extensions, passed to the hidden file input. */
+  accept?: string;
+  /** Allows multiple files in a single file picker/drop action. */
+  multiple?: boolean;
+  /** Listen for file drops on the whole document instead of only the form. */
+  globalDrop?: boolean;
+  /** Clears the hidden file input when attachments are cleared. */
+  syncHiddenInput?: boolean;
+  /** Maximum number of attached files. */
+  maxFiles?: number;
+  /** Maximum accepted file size in bytes. */
+  maxFileSize?: number;
+  /** Called when file validation rejects an attachment. */
+  onError?: (error: {
+    code: "max_files" | "max_file_size" | "accept";
+    message: string;
+  }) => void;
+  /** Called with the trimmed message text and files when the form is submitted. */
+  onSubmit?: (message: PromptInputMessage, event: React.FormEvent<HTMLFormElement>) => void | Promise<void>;
+}
+/**
+ * Chat-style composer form. Wraps a textarea and footer controls, with
+ * Enter-to-submit semantics, auto-resizing behavior, and optional attachments.
+ * Adapted from Vercel AI Elements and restyled with Sigvelo CSS tokens.
+ *
+ * Use for assistant/chat submit forms. Do not use it as a generic textarea or
+ * non-chat form. Sigvelo changes: uses shared Menu, Select, Combobox, Tabs,
+ * Button, and Tooltip components; maps styles to CSS tokens; adds local
+ * attachment and referenced-source helpers.
+ *
+ * The form handles Enter-to-submit while multiline editing remains in the
+ * textarea. Attachment controls need accessible labels through their buttons
+ * and menus. Add new shared tools here when multiple apps need them.
+ *
+ * @example
+ * ```tsx
+ * <PromptInput onSubmit={({ text, files }) => sendMessage({ text, files })}>
+ *   <PromptInputBody>
+ *     <PromptInputTextarea placeholder="Ask Sigvelo..." />
+ *   </PromptInputBody>
+ *   <PromptInputFooter>
+ *     <PromptInputTools>
+ *       <PromptInputActionAddAttachments />
+ *     </PromptInputTools>
+ *     <PromptInputSubmit status="ready" />
+ *   </PromptInputFooter>
+ * </PromptInput>
+ * ```
+ *
+ * @see {@link https://elements.ai-sdk.dev/components/prompt-input | AI Elements Prompt Input}
+ */
+declare function PromptInput({
+  className,
+  accept,
+  multiple,
+  globalDrop,
+  syncHiddenInput,
+  maxFiles,
+  maxFileSize,
+  onError,
+  onSubmit,
+  children,
+  id,
+  ref,
+  ...props
+}: PromptInputProps & {
+  ref?: React.Ref<HTMLFormElement>;
+}): React.JSX.Element;
+interface PromptInputHeaderProps extends React.HTMLAttributes<HTMLDivElement> {}
+declare function PromptInputHeader({
+  className,
+  children,
+  ref,
+  ...props
+}: PromptInputHeaderProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+interface PromptInputAttachmentProps extends React.HTMLAttributes<HTMLDivElement> {
+  /** The pending attachment — the AI SDK `file` part plus the local list id. */
+  file: FileUIPart & {
+    id: string;
+  };
+}
+/**
+ * One pending attachment chip: image files show a thumbnail, everything else
+ * a file icon and name. The corner button removes it from the pending list.
+ */
+declare function PromptInputAttachment({
+  file,
+  className,
+  ref,
+  ...props
+}: PromptInputAttachmentProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+interface PromptInputAttachmentsProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+  /** Override chip rendering per attachment. */
+  children?: (file: FileUIPart & {
+    id: string;
+  }) => React.ReactNode;
+}
+/**
+ * The pending-attachment chip row. Renders nothing while the list is empty,
+ * so it can sit in the composer unconditionally — files added via the file
+ * dialog, paste, or drop appear here until submit sends and clears them.
+ */
+declare function PromptInputAttachments({
+  className,
+  children,
+  ref,
+  ...props
+}: PromptInputAttachmentsProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element | null;
+interface PromptInputBodyProps extends React.HTMLAttributes<HTMLDivElement> {}
+declare function PromptInputBody({
+  className,
+  children,
+  ref,
+  ...props
+}: PromptInputBodyProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+interface PromptInputFooterProps extends React.HTMLAttributes<HTMLDivElement> {}
+declare function PromptInputFooter({
+  className,
+  children,
+  ref,
+  ...props
+}: PromptInputFooterProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+interface PromptInputToolsProps extends React.HTMLAttributes<HTMLDivElement> {}
+declare function PromptInputTools({
+  className,
+  children,
+  ref,
+  ...props
+}: PromptInputToolsProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+interface PromptInputTextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+  minHeight?: number;
+  maxHeight?: number;
+}
+declare function PromptInputTextarea({
+  className,
+  placeholder,
+  rows,
+  minHeight,
+  maxHeight,
+  onChange,
+  onCompositionEnd,
+  onCompositionStart,
+  onKeyDown,
+  onInput,
+  onPaste,
+  ref,
+  ...props
+}: PromptInputTextareaProps & {
+  ref?: React.Ref<HTMLTextAreaElement>;
+}): React.JSX.Element;
+type TooltipSide = "top" | "right" | "bottom" | "left";
+type PromptInputButtonTooltip = string | {
+  content: React.ReactNode;
+  shortcut?: string;
+  side?: TooltipSide;
+};
+type PromptInputTooltipConfig = Exclude<PromptInputButtonTooltip, string>;
+interface PromptInputButtonProps extends Omit<ButtonProps, "children" | "className"> {
+  className?: string;
+  tooltip?: PromptInputButtonTooltip;
+  children?: React.ReactNode;
+}
+declare function PromptInputButton({
+  className,
+  tooltip,
+  variant,
+  color,
+  size,
+  children,
+  "aria-label": ariaLabel,
+  ref,
+  ...props
+}: PromptInputButtonProps & {
+  ref?: React.Ref<HTMLButtonElement>;
+}): React.JSX.Element;
+type PromptInputActionMenuProps = MenuProps;
+declare function PromptInputActionMenu(props: PromptInputActionMenuProps): React.JSX.Element;
+type PromptInputActionMenuTriggerProps = PromptInputButtonProps;
+declare function PromptInputActionMenuTrigger({
+  className,
+  children,
+  ...props
+}: PromptInputActionMenuTriggerProps): React.JSX.Element;
+type PromptInputActionMenuContentProps = MenuContentProps;
+declare function PromptInputActionMenuContent({
+  className,
+  children,
+  ...props
+}: PromptInputActionMenuContentProps): React.JSX.Element;
+type PromptInputActionMenuItemProps = MenuItemProps;
+declare function PromptInputActionMenuItem({
+  className,
+  ...props
+}: PromptInputActionMenuItemProps): React.JSX.Element;
+interface PromptInputActionAddAttachmentsProps extends PromptInputActionMenuItemProps {
+  label?: string;
+}
+declare function PromptInputActionAddAttachments({
+  label,
+  onClick,
+  children,
+  ...props
+}: PromptInputActionAddAttachmentsProps): React.JSX.Element;
+interface PromptInputActionAddScreenshotProps extends PromptInputActionMenuItemProps {
+  label?: string;
+}
+declare function PromptInputActionAddScreenshot({
+  label,
+  onClick,
+  children,
+  ...props
+}: PromptInputActionAddScreenshotProps): React.JSX.Element;
+/** How the agent's approval requests are handled. */
+type PermissionMode = "ask" | "bypass";
+interface PromptInputPermissionSelectorProps {
+  /** Current mode. `"ask"` surfaces approvals in the composer; `"bypass"` auto-approves. */
+  value: PermissionMode;
+  onValueChange: (mode: PermissionMode) => void;
+  /** Overrides the menu's header question. */
+  question?: string;
+}
+/**
+ * Footer control for choosing how approval requests are handled — ask each
+ * time, or bypass. Purely a picker: the auto-approve behavior lives with
+ * whoever owns the approvals (`AgentChat` wires both ends).
+ */
+declare function PromptInputPermissionSelector({
+  value,
+  onValueChange,
+  question
+}: PromptInputPermissionSelectorProps): React.JSX.Element;
+interface PromptInputSubmitProps extends Omit<ButtonProps, "children" | "className" | "type"> {
+  className?: string;
+  status?: ChatStatus;
+  onStop?: () => void;
+  children?: React.ReactNode;
+  label?: string;
+}
+declare function PromptInputSubmit({
+  className,
+  status,
+  onStop,
+  variant,
+  color,
+  size,
+  onClick,
+  children,
+  label,
+  ref,
+  ...props
+}: PromptInputSubmitProps & {
+  ref?: React.Ref<HTMLButtonElement>;
+}): React.JSX.Element;
+/**
+ * Resolve Think execution approvals that do not use the AI SDK
+ * `approval-requested` part: paused codemode executions and durable-pause
+ * approvals from `pendingApprovals()`. Wire to the Think agent's
+ * client-callable RPCs:
+ *
+ * ```tsx
+ * executionApprovals={{
+ *   approve: (id) => agent.stub.approveExecution(id),
+ *   reject: (id, reason) => agent.stub.rejectExecution(id, reason),
+ * }}
+ * ```
+ *
+ * On approve, upstream resumes or runs the parked execution and auto-continues
+ * the chat. Both RPCs are idempotent, so a stale click resolves to "already
+ * handled".
+ */
+interface ExecutionApprovals {
+  approve: (executionId: string) => unknown;
+  reject: (executionId: string, reason?: string) => unknown;
+}
+/** The id a response must carry: the approval id, or the paused run's executionId. */
+declare function getApprovalRequestId(part: ToolUIPart | DynamicToolUIPart): string | undefined;
+/** Component-local identity: paused executions can ask for multiple approvals. */
+declare function getApprovalStateKey(part: ToolUIPart | DynamicToolUIPart): string | undefined;
+interface PendingToolApproval<MessageT extends UIMessage = UIMessage> {
+  message: MessageT;
+  messageIndex: number;
+  part: ToolUIPart | DynamicToolUIPart;
+  partIndex: number;
+}
+/** Derives pending tool approvals straight from the messages — no app-owned shapes. */
+declare function getPendingToolApprovals<MessageT extends UIMessage>(messages: readonly MessageT[], {
+  pausedExecutions
+}?: {
+  pausedExecutions?: boolean;
+}): Array<PendingToolApproval<MessageT>>;
+interface PromptInputApprovalProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "part"> {
+  /**
+   * The `approval-requested` tool part — or a paused codemode execution —
+   * passed whole. Renders nothing for other states.
+   */
+  part?: ToolUIPart | DynamicToolUIPart;
+  /** A Think `pendingApprovals()` entry for durable parked action approvals. */
+  approval?: PendingApproval;
+  /** Pass `addToolApprovalResponse` from `useAgentChat`/`useChat` directly. */
+  onRespond?: ChatAddToolApproveResponseFunction;
+  /** Resolves Think execution approvals instead of `onRespond`. See {@link ExecutionApprovals}. */
+  executionApprovals?: ExecutionApprovals;
+  /**
+   * Renders a Skip action that dismisses the confirmation without responding —
+   * the approval stays pending upstream.
+   */
+  onSkip?: () => void;
+  /** Overrides the default "Do you want to allow…" question. */
+  question?: React.ReactNode;
+  /** Total pending approvals, for the "1 of N" hint. */
+  count?: number;
+}
+/**
+ * The composer's approval state: when a tool call awaits human approval the
+ * prompt input area becomes the confirmation. "Yes" approves on click; typing
+ * in the "No, and tell the agent what to do differently" row selects deny and
+ * sends the text as the native approval `reason`. Submit (or Enter) sends the
+ * current selection — approve by default.
+ */
+declare function PromptInputApproval({
+  part,
+  approval: durableApproval,
+  onRespond,
+  executionApprovals,
+  onSkip,
+  question,
+  count,
+  className,
+  ref,
+  ...props
+}: PromptInputApprovalProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element | null;
+type PromptInputSelectProps = SelectProps;
+declare const PromptInputSelect: typeof Select;
+type PromptInputSelectTriggerProps = SelectTriggerProps;
+declare function PromptInputSelectTrigger(props: PromptInputSelectTriggerProps): React.JSX.Element;
+type PromptInputSelectContentProps = SelectContentProps;
+declare function PromptInputSelectContent(props: PromptInputSelectContentProps): React.JSX.Element;
+type PromptInputSelectItemProps = SelectItemProps;
+declare const PromptInputSelectItem: typeof SelectOption;
+type PromptInputSelectValueProps = SelectValueProps;
+declare const PromptInputSelectValue: typeof SelectValue;
+interface PromptInputHoverCardProps extends React.HTMLAttributes<HTMLDivElement> {
+  openDelay?: number;
+  closeDelay?: number;
+}
+declare function PromptInputHoverCard({
+  openDelay,
+  closeDelay,
+  className,
+  children,
+  ref,
+  ...props
+}: PromptInputHoverCardProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+interface PromptInputHoverCardTriggerProps extends React.HTMLAttributes<HTMLSpanElement> {}
+declare function PromptInputHoverCardTrigger({
+  className,
+  ref,
+  ...props
+}: PromptInputHoverCardTriggerProps & {
+  ref?: React.Ref<HTMLSpanElement>;
+}): React.JSX.Element;
+interface PromptInputHoverCardContentProps extends React.HTMLAttributes<HTMLDivElement> {}
+declare function PromptInputHoverCardContent({
+  className,
+  ref,
+  ...props
+}: PromptInputHoverCardContentProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element | null;
+type PromptInputTabsListProps = React.ComponentPropsWithoutRef<typeof TabsList>;
+declare const PromptInputTabsList: typeof TabsList;
+type PromptInputTabProps = React.ComponentPropsWithoutRef<typeof Tab>;
+declare const PromptInputTab: typeof Tab;
+type PromptInputTabBodyProps = React.ComponentPropsWithoutRef<typeof TabPanel>;
+declare const PromptInputTabBody: typeof TabPanel;
+interface PromptInputTabLabelProps extends React.HTMLAttributes<HTMLHeadingElement> {}
+declare function PromptInputTabLabel({
+  className,
+  ref,
+  ...props
+}: PromptInputTabLabelProps & {
+  ref?: React.Ref<HTMLHeadingElement>;
+}): React.JSX.Element;
+interface PromptInputTabItemProps extends React.HTMLAttributes<HTMLDivElement> {}
+declare function PromptInputTabItem({
+  className,
+  ref,
+  ...props
+}: PromptInputTabItemProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+type PromptInputCommandProps = React.ComponentPropsWithoutRef<typeof Combobox>;
+declare const PromptInputCommand: typeof import("@base-ui/react").ComboboxRoot & {
+  Root: typeof import("@base-ui/react").ComboboxRoot;
+  Input: typeof ComboboxInput;
+  Trigger: typeof ComboboxTrigger;
+  Clear: ({
+    className,
+    ref,
+    ...props
+  }: Omit<React.ComponentPropsWithRef<typeof import("@base-ui/react").ComboboxClear>, "className"> & {
+    className?: string;
+  } & {
+    ref?: React.Ref<HTMLButtonElement>;
+  }) => React.JSX.Element;
+  Portal: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").AutocompletePortalProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+  Positioner: typeof ComboboxPositioner;
+  Popup: typeof ComboboxPopup;
+  Content: typeof ComboboxPopup;
+  List: typeof ComboboxList;
+  Item: typeof ComboboxItem;
+  ItemIndicator: ({
+    className,
+    ref,
+    ...props
+  }: Omit<React.ComponentPropsWithRef<typeof import("@base-ui/react").ComboboxItemIndicator>, "className"> & {
+    className?: string;
+  } & {
+    ref?: React.Ref<HTMLSpanElement>;
+  }) => React.JSX.Element;
+  Empty: typeof ComboboxEmpty;
+  Group: typeof ComboboxGroup;
+  GroupLabel: typeof ComboboxLabel;
+  Label: typeof ComboboxLabel;
+  Value: typeof import("@base-ui/react").ComboboxValue;
+  Chips: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").ComboboxChipsProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+  Chip: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").ComboboxChipProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+  ChipsInput: typeof ComboboxInput;
+  Collection: typeof import("@base-ui/react").ComboboxCollection;
+  Separator: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SeparatorProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+};
+type PromptInputCommandInputProps = React.ComponentPropsWithoutRef<typeof ComboboxInput>;
+declare const PromptInputCommandInput: typeof ComboboxInput;
+interface PromptInputCommandListProps extends React.HTMLAttributes<HTMLDivElement> {}
+declare function PromptInputCommandList({
+  className,
+  ref,
+  ...props
+}: PromptInputCommandListProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+type PromptInputCommandEmptyProps = React.ComponentPropsWithoutRef<typeof ComboboxEmpty>;
+declare const PromptInputCommandEmpty: typeof ComboboxEmpty;
+type PromptInputCommandGroupProps = React.ComponentPropsWithoutRef<typeof ComboboxGroup>;
+declare const PromptInputCommandGroup: typeof ComboboxGroup;
+type PromptInputCommandItemProps = React.ComponentPropsWithoutRef<typeof ComboboxItem>;
+declare const PromptInputCommandItem: typeof ComboboxItem;
+type PromptInputCommandSeparatorProps = React.ComponentPropsWithoutRef<typeof ComboboxSeparator>;
+declare const PromptInputCommandSeparator: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SeparatorProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+//#endregion
+export { PromptInputHoverCardTriggerProps as $, PromptInputCommandEmpty as A, PromptInputTextareaProps as At, PromptInputCommandProps as B, usePromptInputAttachments as Bt, PromptInputAttachmentsProps as C, PromptInputTabItemProps as Ct, PromptInputButtonProps as D, PromptInputTabsList as Dt, PromptInputButton as E, PromptInputTabProps as Et, PromptInputCommandInputProps as F, TextInputContext as Ft, PromptInputFooterProps as G, PromptInputCommandSeparatorProps as H, usePromptInputReferencedSources as Ht, PromptInputCommandItem as I, TooltipSide as It, PromptInputHoverCard as J, PromptInputHeader as K, PromptInputCommandItemProps as L, getApprovalRequestId as Lt, PromptInputCommandGroup as M, PromptInputToolsProps as Mt, PromptInputCommandGroupProps as N, PromptInputTooltipConfig as Nt, PromptInputButtonTooltip as O, PromptInputTabsListProps as Ot, PromptInputCommandInput as P, ReferencedSourcesContext as Pt, PromptInputHoverCardTrigger as Q, PromptInputCommandList as R, getApprovalStateKey as Rt, PromptInputAttachments as S, PromptInputTabItem as St, PromptInputBodyProps as T, PromptInputTabLabelProps as Tt, PromptInputControllerProps as U, useProviderAttachments as Ut, PromptInputCommandSeparator as V, usePromptInputController as Vt, PromptInputFooter as W, PromptInputHoverCardContentProps as X, PromptInputHoverCardContent as Y, PromptInputHoverCardProps as Z, PromptInputActionMenuTriggerProps as _, PromptInputSubmit as _t, PromptInput as a, PromptInputProviderProps as at, PromptInputAttachment as b, PromptInputTabBody as bt, PromptInputActionAddScreenshot as c, PromptInputSelectContent as ct, PromptInputActionMenuContent as d, PromptInputSelectItemProps as dt, PromptInputMessage as et, PromptInputActionMenuContentProps as f, PromptInputSelectProps as ft, PromptInputActionMenuTrigger as g, PromptInputSelectValueProps as gt, PromptInputActionMenuProps as h, PromptInputSelectValue as ht, PermissionMode as i, PromptInputProvider as it, PromptInputCommandEmptyProps as j, PromptInputTools as jt, PromptInputCommand as k, PromptInputTextarea as kt, PromptInputActionAddScreenshotProps as l, PromptInputSelectContentProps as lt, PromptInputActionMenuItemProps as m, PromptInputSelectTriggerProps as mt, ExecutionApprovals as n, PromptInputPermissionSelectorProps as nt, PromptInputActionAddAttachments as o, PromptInputReferencedSource as ot, PromptInputActionMenuItem as p, PromptInputSelectTrigger as pt, PromptInputHeaderProps as q, PendingToolApproval as r, PromptInputProps as rt, PromptInputActionAddAttachmentsProps as s, PromptInputSelect as st, AttachmentsContext as t, PromptInputPermissionSelector as tt, PromptInputActionMenu as u, PromptInputSelectItem as ut, PromptInputApproval as v, PromptInputSubmitProps as vt, PromptInputBody as w, PromptInputTabLabel as wt, PromptInputAttachmentProps as x, PromptInputTabBodyProps as xt, PromptInputApprovalProps as y, PromptInputTab as yt, PromptInputCommandListProps as z, getPendingToolApprovals as zt };

package/dist/ThinkChatActivity-CeHzk6-K.d.ts

@@ -0,0 +1,73 @@
+import { a as AgentChatRenderPartContext, r as AgentChatProps } from "./AgentChat-403mckDG.js";
+import { s as ThinkChatPart } from "./ThinkChatToolParts-DnUiZgCC.js";
+import * as React from "react";
+import { DynamicToolUIPart, ToolUIPart, UIMessage } from "ai";
+
+//#region src/components/ThinkChatActivity.d.ts
+/**
+ * Bespoke rendering for one tool inside the activity log. Both hooks fall
+ * through to the built-in families when they return `undefined`, so an
+ * override can adjust just the label or just the panel.
+ */
+interface ThinkChatToolRenderer {
+  /** One-line step label. `null` hides the step from the log. */
+  describe?: (part: ToolUIPart | DynamicToolUIPart) => string | null | undefined;
+  /** Expanded detail under the step. `null` keeps the step a plain row. */
+  panel?: (part: ToolUIPart | DynamicToolUIPart) => React.ReactNode;
+}
+type ThinkChatToolRenderers = Record<string, ThinkChatToolRenderer>;
+interface ThinkChatActivityRendererOptions {
+  /**
+   * Tool names to keep out of activity folding entirely — the run splits
+   * around them and they fall through to your own renderPart / AgentChat's
+   * generic standalone activity row. For tools that should stay in the log
+   * with custom UI, use `toolRenderers` instead.
+   */
+  excludeTools?: readonly string[];
+  /** Per-tool label/panel overrides inside the activity log, keyed by tool name. */
+  toolRenderers?: ThinkChatToolRenderers;
+}
+/**
+ * One-line natural-language label for an activity part ("Ran vp test",
+ * "Fetched developers.cloudflare.com/agents/"); `null` for boundaries that
+ * aren't steps (step-start). Exported so a custom `renderPart` can reuse the
+ * built-in labels for tools it doesn't override.
+ */
+declare function describeThinkChatActivityPart(part: ThinkChatPart, toolRenderers?: ThinkChatToolRenderers): string | null;
+interface ThinkChatActivityProps {
+  /** Render with the log expanded. */
+  defaultOpen?: boolean;
+  parts: readonly ThinkChatPart[];
+  /** Defaults to deriving from part states (reasoning streaming, tool awaiting output). */
+  isStreaming?: boolean;
+  /** Per-tool label/panel overrides, keyed by tool name. */
+  toolRenderers?: ThinkChatToolRenderers;
+}
+/**
+ * One run of agent work as a collapsed Activity block: while streaming the
+ * label shimmers with the live step; settled, it becomes a short summary
+ * ("Thought, read 2 files and ran a command") over an expandable step log
+ * with per-tool panels. Normally reached through `ThinkChat.Messages`;
+ * exported for apps that lay out messages themselves.
+ */
+declare function ThinkChatActivity({
+  parts,
+  defaultOpen,
+  isStreaming,
+  toolRenderers
+}: ThinkChatActivityProps): React.JSX.Element | null;
+/**
+ * Builds a renderPart handler that folds every run of consecutive activity
+ * parts (reasoning + tool calls) into one collapsed Activity box. Everything
+ * is derived from the UIMessage stream: part order, tool states, reasoning
+ * state. Excluded tools split the run and return undefined so your own
+ * renderPart (or AgentChat's generic activity row) takes over for them.
+ */
+declare function createThinkChatActivityRenderer({
+  excludeTools,
+  toolRenderers
+}?: ThinkChatActivityRendererOptions): NonNullable<AgentChatProps["renderPart"]>;
+/** Default activity renderer — `createThinkChatActivityRenderer()` with no overrides. */
+declare const renderThinkChatActivityPart: (context: AgentChatRenderPartContext<UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>>) => React.ReactNode | undefined;
+//#endregion
+export { ThinkChatToolRenderers as a, renderThinkChatActivityPart as c, ThinkChatToolRenderer as i, ThinkChatActivityProps as n, createThinkChatActivityRenderer as o, ThinkChatActivityRendererOptions as r, describeThinkChatActivityPart as s, ThinkChatActivity as t };

package/dist/ThinkChatContext-CC94HL4u.d.ts

@@ -0,0 +1,28 @@
+import * as React from "react";
+import { UIMessage } from "ai";
+import { useAgentChat } from "@cloudflare/think/react";
+
+//#region src/components/ThinkChatContext.d.ts
+type ThinkChatValue = ReturnType<typeof useAgentChat<unknown, UIMessage>>;
+declare const ThinkChatContext: React.Context<(Omit<import("@ai-sdk/react").UseChatHelpers<UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>>, "addToolOutput"> & {
+  clearHistory: () => void;
+  addToolOutput: (opts: {
+    toolCallId: string;
+    toolName?: string;
+    output?: unknown;
+    state?: "output-available" | "output-error";
+    errorText?: string;
+  }) => void;
+  isServerStreaming: boolean;
+  isStreaming: boolean;
+  isRecovering: boolean;
+  isToolContinuation: boolean;
+  connectionError: (Error & {
+    code: number;
+    reason: string;
+    wasClean: boolean;
+  }) | null;
+}) | null>;
+declare function useThinkChatContext(component: string): ThinkChatValue;
+//#endregion
+export { ThinkChatValue as n, useThinkChatContext as r, ThinkChatContext as t };