@mcp-b/react-components 0.6.4 → 0.7.0

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/ThinkChatToolParts-DnUiZgCC.d.ts

@@ -0,0 +1,83 @@
+import { InferUITools, ToolUIPart, UIMessage } from "ai";
+import { ProxyToolInput, ProxyToolOutput } from "@cloudflare/codemode";
+import { QuickActionExtractInput, QuickActionPage, QuickActionScrapeInput, QuickActionToolName } from "@cloudflare/think/tools/browser";
+import { FetchResult } from "@cloudflare/think/tools/fetch";
+import { WorkspaceTools } from "@cloudflare/think/tools/workspace";
+
+//#region src/components/ThinkChatToolParts.d.ts
+type ThinkChatPart = UIMessage["parts"][number];
+type WorkspaceUITools = InferUITools<Required<WorkspaceTools>>;
+type WorkspaceToolPart = ToolUIPart<WorkspaceUITools>;
+type ThinkWorkspaceToolName = keyof WorkspaceUITools;
+type ThinkBashToolPart = Extract<WorkspaceToolPart, {
+  type: "tool-bash";
+}>;
+type ThinkBashToolOutput = WorkspaceUITools["bash"]["output"];
+declare function isWorkspaceToolPart(part: ThinkChatPart): part is WorkspaceToolPart;
+type SkillUITools = {
+  activate_skill: {
+    input: {
+      name: string;
+    };
+    output: string;
+  };
+  read_skill_resource: {
+    input: {
+      name?: string;
+      path: string;
+    };
+    output: string;
+  };
+  run_skill_script: {
+    input: {
+      name: string;
+      path: string;
+      input?: unknown;
+    };
+    output: unknown;
+  };
+};
+type SkillToolPart = ToolUIPart<SkillUITools>;
+declare function isSkillToolPart(part: ThinkChatPart): part is SkillToolPart;
+type FetchToolPart = ToolUIPart<Record<string, {
+  input: {
+    url?: string;
+    path?: string;
+  };
+  output: FetchResult;
+}>>;
+declare function isFetchToolPart(part: ThinkChatPart): part is FetchToolPart;
+type QuickActionInputs = {
+  markdown: QuickActionPage;
+  extract: QuickActionExtractInput;
+  links: QuickActionPage;
+  scrape: QuickActionScrapeInput;
+  content: QuickActionPage;
+};
+type BrowserUITools = {
+  browser_execute: {
+    input: ProxyToolInput;
+    output: ProxyToolOutput;
+  };
+} & { [K in QuickActionToolName as `browser_${K}`]: {
+  input: QuickActionInputs[K];
+  output: unknown;
+} };
+type BrowserToolPart = ToolUIPart<BrowserUITools>;
+declare function isBrowserToolPart(part: ThinkChatPart): part is BrowserToolPart;
+type ExecuteToolPart = ToolUIPart<{
+  execute: {
+    input: ProxyToolInput;
+    output: ProxyToolOutput;
+  };
+}>;
+declare function isExecuteToolPart(part: ThinkChatPart): part is ExecuteToolPart;
+/** Agent work (reasoning, tool calls, step boundaries) vs. content shown to the user. */
+declare function isThinkChatActivityPart(part: ThinkChatPart | undefined, excludeTools?: ReadonlySet<string>): boolean;
+/** In-flight: the stream opened this part but hasn't delivered its result yet. */
+declare function isPartWorking(part: ThinkChatPart): boolean;
+/** Errored or denied — upstream's simplified tool-part state vocabulary. */
+declare function isPartFailed(part: ThinkChatPart): boolean;
+declare function displayUrl(url: string | undefined): string;
+//#endregion
+export { isThinkChatActivityPart as _, ThinkBashToolOutput as a, ThinkWorkspaceToolName as c, isBrowserToolPart as d, isExecuteToolPart as f, isSkillToolPart as g, isPartWorking as h, SkillToolPart as i, WorkspaceToolPart as l, isPartFailed as m, ExecuteToolPart as n, ThinkBashToolPart as o, isFetchToolPart as p, FetchToolPart as r, ThinkChatPart as s, BrowserToolPart as t, displayUrl as u, isWorkspaceToolPart as v };

package/dist/components/AgentChat.d.ts

@@ -1,6 +1,7 @@
-import { ExecutionApprovals, PromptInputMessage, PromptInputStatus } from "./PromptInput.js";
+import { et as PromptInputMessage, n as ExecutionApprovals } from "../PromptInput-D6-G24p7.js";
 import * as React from "react";
-import { ChatAddToolApproveResponseFunction, UIMessage } from "ai";
+import { ChatAddToolApproveResponseFunction, ChatStatus, UIMessage } from "ai";
+import { PendingApproval } from "@cloudflare/think";
 
 //#region src/components/AgentChat.d.ts
 type AgentChatPart<MessageT extends UIMessage = UIMessage> = MessageT["parts"][number];
@@ -19,7 +20,7 @@ interface AgentChatProps<MessageT extends UIMessage = UIMessage> {
   /** AI SDK `UIMessage`s to render, oldest first. */
   messages: readonly MessageT[];
   /** Drives the composer's send/stop affordance and streaming indicators. */
-  status?: PromptInputStatus;
+  status?: ChatStatus;
   /** Called with the composed message when the user submits. Omit for a read-only transcript. */
   onSubmit?: (message: PromptInputMessage) => void | Promise<void>;
   /** Called when the user hits stop while `status` is streaming/submitted. */
@@ -49,11 +50,10 @@ interface AgentChatProps<MessageT extends UIMessage = UIMessage> {
    * confirmation.
    */
   onApprovalResponse?: ChatAddToolApproveResponseFunction;
-  /**
-   * When set, paused codemode executions surface in the same composer
-   * confirmation as tool approvals. See {@link ExecutionApprovals}.
-   */
+  /** Resolves Think execution approvals. See {@link ExecutionApprovals}. */
   executionApprovals?: ExecutionApprovals;
+  /** Think durable-pause approvals from `pendingApprovals()`, rendered when `executionApprovals` is set. */
+  pendingApprovals?: readonly PendingApproval[];
   /**
    * When set, a Context ring in the composer footer shows how much of the
    * model's window the conversation occupies. Used tokens come from the
@@ -70,13 +70,9 @@ interface AgentChatProps<MessageT extends UIMessage = UIMessage> {
   renderMessageAfter?: (context: AgentChatRenderMessageContext<MessageT>) => React.ReactNode;
 }
 /**
- * A complete agent chat surface: auto-scrolling conversation of AI SDK
- * `UIMessage`s (text, reasoning, and tool parts rendered by default) plus a
- * prompt composer. Customize per-part rendering with `renderPart`.
- *
- * This is the presentational layer under `ThinkChat` — props in, no
- * transport. Use it directly with plain AI SDK `useChat` or a read-only
- * transcript; if you have a Cloudflare Think agent, use `ThinkChat` instead.
+ * Low-level transcript/composer surface used by `ThinkChat`: props in, no
+ * transport. Product code that talks to a Cloudflare Think agent should render
+ * `ThinkChat`; use this directly only for plain AI SDK or read-only messages.
  */
 declare function AgentChat<MessageT extends UIMessage = UIMessage>({
   className,
@@ -93,6 +89,7 @@ declare function AgentChat<MessageT extends UIMessage = UIMessage>({
   onRegenerate,
   onApprovalResponse,
   executionApprovals,
+  pendingApprovals: durableApprovals,
   contextWindow,
   renderPart,
   renderMessageAfter,