@mcp-b/react-components 0.49.0 → 0.50.0

package/dist/McpConnectorForm--HB0MEGC.d.ts

@@ -0,0 +1,39 @@
+import { c as McpServerSetupAuth, u as McpServerSetupAuthFieldName } from "./mcp-server-catalog-D9p4gGeJ.js";
+import * as React from "react";
+
+//#region src/components/agents-sdk/McpConnectorForm.d.ts
+type CredentialFieldName = Exclude<McpServerSetupAuthFieldName, "redirectUrl">;
+type McpConnectorFormValues = Readonly<Partial<Record<CredentialFieldName, string>> & {
+  readonly name: string;
+  readonly url: string;
+}>;
+type McpConnectorFormProps = Omit<React.FormHTMLAttributes<HTMLFormElement>, "onSubmit" | "status"> & {
+  /** Authentication metadata that decides which credential fields render. */readonly auth?: McpServerSetupAuth; /** Initial connector values. Publisher client credentials remain app-owned. */
+  readonly defaults?: Partial<McpConnectorFormValues>; /** Optional pattern used to validate the MCP name field. */
+  readonly namePattern?: string; /** Keep a catalog-owned MCP name and URL visible but immutable. */
+  readonly readOnlyServer?: boolean; /** Read-only redirect URL shown for manual OAuth client setup. */
+  readonly redirectUrl?: string; /** Inline connection status announced politely to assistive tech. */
+  readonly status?: React.ReactNode; /** Label for the submit button. */
+  readonly submitLabel?: string; /** Label shown while submit is pending. */
+  readonly submittingLabel?: string; /** Called with normalized connector values after native form validation passes. */
+  readonly onSubmit: (values: McpConnectorFormValues) => void | Promise<void>;
+};
+/** Collects MCP connector settings and optional credentials with native form validation. */
+declare function McpConnectorForm({
+  auth,
+  className,
+  defaults,
+  namePattern,
+  readOnlyServer,
+  redirectUrl,
+  status,
+  submitLabel,
+  submittingLabel,
+  onSubmit,
+  ref,
+  ...props
+}: McpConnectorFormProps & {
+  /** Ref forwarded to the component's rendered root element. */ref?: React.Ref<HTMLFormElement>;
+}): React.JSX.Element;
+//#endregion
+export { McpConnectorFormProps as n, McpConnectorFormValues as r, McpConnectorForm as t };

package/dist/{Menu-yb6QXWA3.d.ts → Menu-CgfUZhZd.d.ts}

@@ -281,7 +281,7 @@ declare function MenuSubmenuTrigger({
  */
 declare const Menu$1: {
   createHandle: typeof Menu.createHandle;
-  Root: <Payload>(props: Menu.Root.Props<Payload>) => import("react/jsx-runtime").JSX.Element;
+  Root: <Payload>(props: Menu.Root.Props<Payload>) => React.JSX.Element;
   Trigger: typeof MenuTrigger;
   Portal: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").ContextMenuPortalProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
   Positioner: typeof MenuPositioner;

package/dist/Popover-CgHG5DtS.d.ts

@@ -0,0 +1,220 @@
+import * as React from "react";
+import { Popover } from "@base-ui/react/popover";
+
+//#region src/components/foundations/Popover.d.ts
+/**
+ * Props for the Popover.Root component.
+ */
+type PopoverProps<Payload = unknown> = Popover.Root.Props<Payload>;
+/**
+ * Props for the Popover.Trigger component.
+ */
+type PopoverTriggerProps<Payload = unknown> = Popover.Trigger.Props<Payload> & React.RefAttributes<HTMLElement> & {
+  /** Keep Base UI trigger behavior without the default popover trigger chrome. */unstyled?: boolean;
+};
+/**
+ * Props for the Popover.Portal component.
+ */
+interface PopoverPortalProps extends React.ComponentPropsWithoutRef<typeof Popover.Portal> {}
+/**
+ * Props for the Popover.Backdrop component.
+ */
+interface PopoverBackdropProps extends React.ComponentPropsWithoutRef<typeof Popover.Backdrop> {}
+/**
+ * Props for the Popover.Positioner component.
+ */
+interface PopoverPositionerProps extends React.ComponentPropsWithoutRef<typeof Popover.Positioner> {}
+/**
+ * Props for the Popover.Popup component.
+ */
+interface PopoverPopupProps extends React.ComponentPropsWithoutRef<typeof Popover.Popup> {}
+/**
+ * Props for the Popover.Viewport component. Use this only when one popover
+ * moves between triggers and its content changes during that transition.
+ */
+interface PopoverViewportProps extends React.ComponentPropsWithoutRef<typeof Popover.Viewport> {}
+/**
+ * Props for the Popover.Arrow component.
+ */
+interface PopoverArrowProps extends React.ComponentPropsWithoutRef<typeof Popover.Arrow> {}
+/**
+ * Props for the Popover.Title component.
+ */
+interface PopoverTitleProps extends React.ComponentPropsWithoutRef<typeof Popover.Title> {}
+/**
+ * Props for the Popover.Description component.
+ */
+interface PopoverDescriptionProps extends React.ComponentPropsWithoutRef<typeof Popover.Description> {}
+/**
+ * Props for the Popover.Close component.
+ */
+interface PopoverCloseProps extends React.ComponentPropsWithoutRef<typeof Popover.Close> {}
+interface PopoverHeaderProps extends React.HTMLAttributes<HTMLDivElement> {}
+/**
+ * Button that toggles the popover visibility.
+ * Renders a `<button>` element.
+ */
+declare function PopoverTrigger<Payload>({
+  className,
+  unstyled,
+  ref,
+  ...props
+}: PopoverTriggerProps<Payload>): React.JSX.Element;
+/**
+ * Optional backdrop that appears behind the popover.
+ */
+declare function PopoverBackdrop({
+  className,
+  ref,
+  ...props
+}: PopoverBackdropProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+/**
+ * Positions the popup relative to the trigger element.
+ *
+ * @example
+ * ```tsx
+ * // Position on the right with offset
+ * <Popover.Positioner side="right" sideOffset={8}>
+ *   <Popover.Popup>...</Popover.Popup>
+ * </Popover.Positioner>
+ * ```
+ */
+declare function PopoverPositioner({
+  className,
+  ref,
+  ...props
+}: PopoverPositionerProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+/**
+ * The popup container that holds the popover content.
+ */
+declare function PopoverPopup({
+  className,
+  ref,
+  ...props
+}: PopoverPopupProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+/**
+ * Transition container for content that changes as a popover moves between
+ * triggers. Pair the adaptive classes from `base-ui-motion.css` with the
+ * positioner, popup, and this viewport when that behavior is needed.
+ */
+declare function PopoverViewport({
+  className,
+  ref,
+  ...props
+}: PopoverViewportProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+declare function PopoverHeader({
+  className,
+  ref,
+  ...props
+}: PopoverHeaderProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+/**
+ * Directional arrow pointing to the trigger element.
+ */
+declare function PopoverArrow({
+  className,
+  ref,
+  ...props
+}: PopoverArrowProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+/**
+ * Semantic title for the popover content.
+ * Renders an `<h2>` element.
+ */
+declare function PopoverTitle({
+  className,
+  ref,
+  ...props
+}: PopoverTitleProps & {
+  ref?: React.Ref<HTMLHeadingElement>;
+}): React.JSX.Element;
+/**
+ * Description text for the popover content.
+ * Renders a `<p>` element.
+ */
+declare function PopoverDescription({
+  className,
+  ref,
+  ...props
+}: PopoverDescriptionProps & {
+  ref?: React.Ref<HTMLParagraphElement>;
+}): React.JSX.Element;
+/**
+ * Button that closes the popover.
+ */
+declare function PopoverClose({
+  render,
+  className,
+  ref,
+  ...props
+}: PopoverCloseProps & {
+  ref?: React.Ref<HTMLButtonElement>;
+}): React.JSX.Element;
+/**
+ * An accessible popup anchored to a trigger button.
+ * Supports flexible positioning, animations, and optional backdrop.
+ *
+ * @example
+ * ```tsx
+ * // Basic popover
+ * <Popover.Root>
+ *   <Popover.Trigger>Click me</Popover.Trigger>
+ *   <Popover.Portal>
+ *     <Popover.Positioner>
+ *       <Popover.Popup>
+ *         <Popover.Title>Settings</Popover.Title>
+ *         <Popover.Description>
+ *           Configure your preferences here.
+ *         </Popover.Description>
+ *         <Popover.Close>Close</Popover.Close>
+ *       </Popover.Popup>
+ *     </Popover.Positioner>
+ *   </Popover.Portal>
+ * </Popover.Root>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With arrow and custom positioning
+ * <Popover.Root>
+ *   <Popover.Trigger>Info</Popover.Trigger>
+ *   <Popover.Portal>
+ *     <Popover.Positioner side="right" sideOffset={8}>
+ *       <Popover.Popup>
+ *         <Popover.Arrow />
+ *         <p>Additional information</p>
+ *       </Popover.Popup>
+ *     </Popover.Positioner>
+ *   </Popover.Portal>
+ * </Popover.Root>
+ * ```
+ *
+ * @see {@link https://base-ui.com/react/components/popover | Base UI Popover}
+ */
+declare const Popover$1: {
+  createHandle: typeof Popover.createHandle;
+  Root: typeof Popover.Root;
+  Trigger: typeof PopoverTrigger;
+  Portal: (props: PopoverPortalProps) => React.JSX.Element;
+  Backdrop: typeof PopoverBackdrop;
+  Positioner: typeof PopoverPositioner;
+  Popup: typeof PopoverPopup;
+  Viewport: typeof PopoverViewport;
+  Header: typeof PopoverHeader;
+  Arrow: typeof PopoverArrow;
+  Title: typeof PopoverTitle;
+  Description: typeof PopoverDescription;
+  Close: typeof PopoverClose;
+};
+//#endregion
+export { PopoverDescriptionProps as a, PopoverPortalProps as c, PopoverTitleProps as d, PopoverTriggerProps as f, PopoverCloseProps as i, PopoverPositionerProps as l, PopoverArrowProps as n, PopoverHeaderProps as o, PopoverViewportProps as p, PopoverBackdropProps as r, PopoverPopupProps as s, Popover$1 as t, PopoverProps as u };

package/dist/{PromptInput-C4Mofitz.d.ts → PromptInput-DGPrCTPl.d.ts}

@@ -1,4 +1,4 @@
-import { d as MenuProps, s as MenuItemProps, t as Menu } from "./Menu-yb6QXWA3.js";
+import { d as MenuProps, s as MenuItemProps, t as Menu } from "./Menu-CgfUZhZd.js";
 import { a as TabsListProps, n as TabProps, t as TabPanelProps } from "./Tabs-Ptrbaynh.js";
 import { r as ButtonProps } from "./Button-DjONW5UW.js";
 import * as React from "react";
@@ -508,7 +508,8 @@ interface PromptInputCommandComposerProps extends Omit<PromptInputTextareaProps,
   commands: readonly PromptInputCommandDefinition[];
   /** MCP, tab, or other mentionable entries revealed by an `@` draft. */
   mentionCommands?: readonly PromptInputCommandDefinition[];
-  onCommandSelect: (command: PromptInputCommandDefinition, trigger: PromptInputCommandTrigger) => void;
+  /** Observe selection after the composer inserts the command into its draft. */
+  onCommandSelect?: (command: PromptInputCommandDefinition, trigger: PromptInputCommandTrigger) => void;
   emptyMessage?: React.ReactNode;
   mentionEmptyMessage?: React.ReactNode;
 }

package/dist/ResponsiveSidebarShell-CAmmtQTR.d.ts

@@ -0,0 +1,128 @@
+import { s as AppTopBarTitleProps } from "./AppTopBar-CVkLRdk7.js";
+import * as React from "react";
+
+//#region src/components/general-purpose/ResponsiveSidebarShell.d.ts
+interface ResponsiveSidebarShellControls {
+  /** The shell's current container layout, shared by in-shell and portalled controls. */
+  compact: boolean;
+  /** Close the sidebar and move focus to the main content. */
+  closeSidebar: () => void;
+  /** Close only when the shell is currently using its compact drawer layout. */
+  closeSidebarOnCompact: () => void;
+}
+/** Reuse the shell's measured layout and drawer controls instead of observing it again. */
+declare function useResponsiveSidebarShell(): ResponsiveSidebarShellControls;
+/**
+ * Bar slot content shared by every shell-owning surface's `bar` prop, so an
+ * app writes one shape whether it is configuring ThinkFullApp, the routine
+ * library, or the shell directly.
+ */
+interface AppBarSlots {
+  /**
+   * App-owned route element rendered as a labelled back control. Back owns
+   * the leading slot the same way `leading` does: the shell's own sidebar
+   * toggle stands down and compact sidebars stay reachable through
+   * `compactTitleTrigger`.
+   */
+  back?: {
+    label: string;
+    link: React.ReactElement;
+  };
+  /** App-owned leading navigation that owns the leading slot at every width. */
+  leading?: React.ReactNode;
+  /** Compact-only navigation that replaces the drawer trigger without hiding the wide rail toggle. */
+  compactLeading?: React.ReactNode;
+  /** Bar title content. Hidden at compact widths when `compactTitleTrigger` stands in. */
+  title?: React.ReactNode;
+  /** Trailing group, before `primary`. Overflow menus and secondary icon controls. */
+  actions?: React.ReactNode;
+  /**
+   * Rightmost trailing control. Sits after `actions` so a host can keep a
+   * single primary action (new thread, new schedule) on the trailing edge
+   * without fighting whatever else the surface puts in the bar.
+   */
+  primary?: React.ReactNode;
+}
+interface ResponsiveSidebarShellBar extends AppBarSlots {
+  /** Native title render contract, including element and render-function composition. */
+  titleRender?: AppTopBarTitleProps["render"];
+  /**
+   * Label content for a compact-width drawer trigger that replaces the plain
+   * title and the icon toggle: the title itself becomes the control that opens
+   * the sidebar. The shell renders the button and the disclosure chevron.
+   */
+  compactTitleTrigger?: React.ReactNode;
+  /** Accessible name for the bar toolbar. Defaults to "Application controls". */
+  label?: string;
+  /** Class for the bar root, the owning surface's styling hook. */
+  className?: string;
+  /**
+   * No bar row at all — for content that brings its own application bar.
+   * Distinct from passing no slots: an empty shell with a sidebar still shows
+   * a bar carrying the toggle.
+   */
+  hidden?: boolean;
+}
+interface ResponsiveSidebarShellProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "title"> {
+  /**
+   * Navigation or other secondary surface shown beside the selected content.
+   * Omit for a shell that is only a bar row over content — the app bar then
+   * has one mount point whether or not a sidebar exists.
+   *
+   * Open/closed is shell-internal: it is ephemeral presentation state, not a
+   * route, so no host controls it and no resize ever writes into a router.
+   */
+  sidebar?: React.ReactNode | ((controls: ResponsiveSidebarShellControls) => React.ReactNode);
+  /** Main content. */
+  children?: React.ReactNode;
+  /** Short noun used by the toggle and resize control, such as “threads” or “schedules”. */
+  sidebarLabel?: string;
+  /** Whether the sidebar is open. Omit for internal state. */
+  sidebarOpen?: boolean;
+  /** Move the wide-layout toggle into the sidebar while it is open. */
+  sidebarTogglePlacement?: "main" | "sidebar";
+  /** Initial sidebar state when `sidebarOpen` is uncontrolled. */
+  defaultSidebarOpen?: boolean;
+  /** Called when the sidebar is opened or closed. */
+  onSidebarOpenChange?: (open: boolean) => void;
+  /** Initial desktop sidebar width in CSS pixels. */
+  defaultSidebarWidth?: number;
+  /** Shell-owned application bar composed from slots. */
+  bar?: ResponsiveSidebarShellBar;
+  /**
+   * Host-owned error shown in the main column above the content, without
+   * replacing it. The shell renders the alert anatomy; pass the message.
+   */
+  error?: React.ReactNode;
+  /** Accessible name for the mobile peek target that returns to the main content. */
+  showMainLabel?: string;
+}
+/**
+ * The one application shell: responsive master-detail with a resizable desktop
+ * sidebar, a compact floating drawer that leaves the main content in place as
+ * a dismiss target, and a shell-owned application bar composed from slots.
+ * The root exposes `data-sidebar-open="true" | "false"` as its public styling
+ * hook, and its container name `responsive-sidebar-shell` is public contract:
+ * surfaces that compose the shell size themselves against it.
+ */
+declare function ResponsiveSidebarShell({
+  sidebar,
+  sidebarLabel,
+  sidebarOpen,
+  sidebarTogglePlacement,
+  defaultSidebarOpen,
+  defaultSidebarWidth,
+  onSidebarOpenChange,
+  bar,
+  error,
+  showMainLabel,
+  className,
+  children,
+  ref,
+  style,
+  ...props
+}: ResponsiveSidebarShellProps & {
+  /** Ref forwarded to the component's rendered root element. */ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+//#endregion
+export { ResponsiveSidebarShellProps as a, ResponsiveSidebarShellControls as i, ResponsiveSidebarShell as n, useResponsiveSidebarShell as o, ResponsiveSidebarShellBar as r, AppBarSlots as t };

package/dist/SessionCompaction-CmTJFpzj.d.ts

@@ -0,0 +1,89 @@
+import { ChatStatus, UIMessage } from "ai";
+
+//#region src/components/agents-sdk/SessionCompaction.d.ts
+type SessionStatusPhase = "idle" | "compacting";
+interface SessionStatusFrame {
+  phase: SessionStatusPhase;
+  /** Present on the idle frame that follows a successful compaction. */
+  compacted: boolean;
+  /**
+   * Session's own estimate for the history this frame describes, or null when
+   * the frame omits it or carries a non-finite value. Not provider-reported
+   * usage — never render it as an exact token count, and never feed it to the
+   * `Context` ring, which reads `metadata.usage`.
+   */
+  tokenEstimate: number | null;
+  /**
+   * The same estimate taken before the compaction this frame reports, from its
+   * `compacted` payload. Null on every other frame. Both numbers come from one
+   * estimator over one history, so their difference is a meaningful size even
+   * though neither is exact.
+   */
+  tokensBefore: number | null;
+}
+/**
+ * Parse a raw websocket payload as a `cf_agent_session` status frame.
+ * Returns null for every other frame on the connection.
+ */
+declare function parseSessionStatusFrame(data: unknown): SessionStatusFrame | null;
+/**
+ * Parse a raw websocket payload as a `cf_agent_session_error` frame,
+ * returning its error text. Null for every other frame on the connection.
+ */
+declare function parseSessionErrorFrame(data: unknown): string | null;
+/** The message-frame surface of a `useAgent` connection. */
+interface SessionFrameSource {
+  addEventListener(type: "message", listener: (event: MessageEvent) => void): void;
+  removeEventListener(type: "message", listener: (event: MessageEvent) => void): void;
+}
+interface UseSessionCompactionOptions<MessageT extends UIMessage> {
+  /** The conversation agent's `useAgent` connection. */
+  agent: SessionFrameSource;
+  /** The conversation's `useAgentChat` value (status + local view setter). */
+  chat: {
+    status: ChatStatus;
+    setMessages: (messages: MessageT[]) => void;
+  };
+  /** Server read used to reload the transcript after a compaction lands. */
+  getMessages: () => Promise<MessageT[]>;
+}
+/**
+ * How much a landed compaction shortened the history, per Session's own
+ * estimator. A UI may show the difference as an approximate size; it must not
+ * present either number as exact usage.
+ */
+interface SessionCompactionSize {
+  tokensBefore: number;
+  tokensAfter: number;
+}
+interface UseSessionCompactionResult {
+  compacting: boolean;
+  /**
+   * Size of the compaction that landed most recently on this connection, or
+   * null when none has landed or the frames carried no usable estimates. A new
+   * object per compaction, so a consumer can dismiss one acknowledgement by
+   * identity and still show the next. Cleared when the next compaction starts.
+   */
+  lastCompaction: SessionCompactionSize | null;
+  /**
+   * Set when the post-compaction transcript reload rejected — the local view
+   * is stale relative to the server until a retry succeeds. Surface it
+   * ("Transcript may be out of date"); the hook retries on the next status
+   * transition to `"ready"`.
+   */
+  reloadError: unknown;
+  /**
+   * Error text from the last `cf_agent_session_error` frame — the only signal
+   * a user who ran /compact gets when the server-side compaction itself fails
+   * (the phase just flips back to idle with no `compacted` payload). Cleared
+   * when the next compaction starts.
+   */
+  sessionError: string | null;
+}
+declare function useSessionCompaction<MessageT extends UIMessage>({
+  agent,
+  chat,
+  getMessages
+}: UseSessionCompactionOptions<MessageT>): UseSessionCompactionResult;
+//#endregion
+export { UseSessionCompactionOptions as a, parseSessionStatusFrame as c, SessionStatusPhase as i, useSessionCompaction as l, SessionFrameSource as n, UseSessionCompactionResult as o, SessionStatusFrame as r, parseSessionErrorFrame as s, SessionCompactionSize as t };

package/dist/SetupChecklist-O6qmgwz4.js

@@ -0,0 +1,77 @@
+import { n as mergeBaseClassName } from "./class-names-BiMDVpUo.js";
+import { B as PlusIcon, d as CheckIcon, et as WarningIcon, f as ChevronDownIcon } from "./icons-CeGfXO21.js";
+import { Button } from "./components/foundations/Button.js";
+import { Menu } from "./components/foundations/Menu.js";
+import * as React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/components/_internal/menu-disclosure-group.tsx
+/**
+* A menu-native disclosure: its trigger stays in the menu roving-focus model,
+* while its rows mount only after the user expands the section.
+*/
+function MenuDisclosureGroup({ children, className, defaultOpen = false, label, triggerClassName, ...props }) {
+	const [open, setOpen] = React.useState(defaultOpen);
+	return /* @__PURE__ */ jsxs(Menu.Group, {
+		className: mergeBaseClassName("menu-disclosure-group", className),
+		...props,
+		children: [/* @__PURE__ */ jsxs(Menu.Item, {
+			"aria-expanded": open,
+			className: mergeBaseClassName("menu-disclosure-group__trigger", triggerClassName),
+			closeOnClick: false,
+			onClick: () => setOpen((current) => !current),
+			children: [/* @__PURE__ */ jsx("span", {
+				className: "sigvelo-truncate-grow",
+				children: label
+			}), /* @__PURE__ */ jsx(ChevronDownIcon, { "aria-hidden": "true" })]
+		}), open ? /* @__PURE__ */ jsx("div", {
+			className: "menu-disclosure-group__items",
+			children
+		}) : null]
+	});
+}
+//#endregion
+//#region src/components/general-purpose/SetupChecklist.tsx
+/** Checklist rows for any Menu surface (composer plus menu, tray menu). */
+function SetupChecklistGroup({ label, entries, defaultOpen = false, onSelect }) {
+	return /* @__PURE__ */ jsx(MenuDisclosureGroup, {
+		label,
+		defaultOpen,
+		children: entries.map((entry) => /* @__PURE__ */ jsxs(Menu.Item, {
+			"aria-label": `${entry.name}, ${entry.complete ? "complete" : "not set up"}`,
+			onClick: () => onSelect(entry.id),
+			children: [
+				entry.icon,
+				/* @__PURE__ */ jsx("span", {
+					className: "sigvelo-truncate-grow",
+					children: entry.description
+				}),
+				entry.complete ? /* @__PURE__ */ jsx(CheckIcon, { "aria-hidden": "true" }) : /* @__PURE__ */ jsx(PlusIcon, { "aria-hidden": "true" })
+			]
+		}, entry.id))
+	});
+}
+/** Progress-aware tray trigger opening the checklist in its own menu. */
+function SetupChecklistAction({ actionLabel, label, entries, onSelect }) {
+	const completed = entries.filter((entry) => entry.complete).length;
+	return /* @__PURE__ */ jsxs(Menu.Root, { children: [/* @__PURE__ */ jsxs(Button, {
+		type: "button",
+		variant: "ghost",
+		color: "neutral",
+		size: "sm",
+		"aria-label": `${actionLabel} — ${completed} of ${entries.length} set up`,
+		render: /* @__PURE__ */ jsx(Menu.Trigger, { unstyled: true }),
+		children: [completed === entries.length ? /* @__PURE__ */ jsx(CheckIcon, { "aria-hidden": "true" }) : /* @__PURE__ */ jsx(WarningIcon, { "aria-hidden": "true" }), /* @__PURE__ */ jsx("span", { children: actionLabel })]
+	}), /* @__PURE__ */ jsx(Menu.Portal, { children: /* @__PURE__ */ jsx(Menu.Positioner, {
+		side: "bottom",
+		align: "start",
+		sideOffset: 4,
+		children: /* @__PURE__ */ jsx(Menu.Popup, { children: /* @__PURE__ */ jsx(SetupChecklistGroup, {
+			defaultOpen: true,
+			label,
+			entries,
+			onSelect
+		}) })
+	}) })] });
+}
+//#endregion
+export { SetupChecklistGroup as n, SetupChecklistAction as t };

package/dist/ThinkChatActivity-DENkintt.d.ts

@@ -0,0 +1,77 @@
+import { i as AgentMessageRenderPartContext } from "./AgentMessageParts-C7L-Mv9U.js";
+import { AgentChatMessageContentProps } from "./components/agents-sdk/AgentChat.js";
+import { n as AgentToolRunValue } from "./AgentToolRunsContext-GMe_hSnD.js";
+import { l as ThinkChatPart } from "./ThinkChatToolParts-D4qcnnxt.js";
+import { t as ThinkChatActivityDescription } from "./ThinkChatActivitySummary-BtBQgMg6.js";
+import * as React from "react";
+import { DynamicToolUIPart, ToolUIPart, UIMessage } from "ai";
+
+//#region src/components/agents-sdk/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 action or just the panel.
+ */
+interface ThinkChatToolRenderer {
+  /** One-line step action. `null` hides the step from the log. */
+  describe?: (part: ToolUIPart | DynamicToolUIPart) => ThinkChatActivityDescription | 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<MessageT extends UIMessage = UIMessage> {
+  /**
+   * 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 action/panel overrides inside the activity log, keyed by tool name. */
+  toolRenderers?: ThinkChatToolRenderers;
+  /** App-authored TanStack Router Link for each retained child destination. */
+  renderAgentToolRunLink?: (run: AgentToolRunValue<MessageT["parts"][number]>) => React.ReactElement;
+}
+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 action/panel overrides, keyed by tool name. */
+  toolRenderers?: ThinkChatToolRenderers;
+  /** Replaces the summary action after the activity settles. */
+  settledAction?: string;
+  /**
+   * Uniquely identifies this run across the whole transcript for persisted
+   * disclosure state (the activity renderer passes `${message.id}:${runStart}`).
+   * Required because any derivable fallback collides for reasoning-led runs
+   * in different messages, bleeding open/closed state across virtualization
+   * remounts.
+   */
+  stateKey: string;
+}
+declare function ThinkChatActivity({
+  parts,
+  defaultOpen,
+  isStreaming,
+  toolRenderers,
+  settledAction,
+  stateKey
+}: 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<MessageT extends UIMessage = UIMessage>({
+  excludeTools,
+  renderAgentToolRunLink,
+  toolRenderers
+}?: ThinkChatActivityRendererOptions<MessageT>): NonNullable<AgentChatMessageContentProps<MessageT>["renderPart"]>;
+/** Default activity renderer — `createThinkChatActivityRenderer()` with no overrides. */
+declare const renderThinkChatActivityPart: (context: AgentMessageRenderPartContext<UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>>) => React.ReactNode | undefined;
+//#endregion
+export { ThinkChatToolRenderers as a, ThinkChatToolRenderer as i, ThinkChatActivityProps as n, createThinkChatActivityRenderer as o, ThinkChatActivityRendererOptions as r, renderThinkChatActivityPart as s, ThinkChatActivity as t };