@mcp-b/react-components 0.16.1 → 0.18.0

package/dist/{Select-BeEsefzh.d.ts → Select-B_13gg_J.d.ts}

@@ -3,60 +3,34 @@ import { Select } from "@base-ui/react/select";
 
 //#region src/components/Select.d.ts
 type SelectProps<Value = unknown> = Select.Root.Props<Value>;
-interface SelectLabelProps extends Omit<Select.Label.Props, "className"> {
-  className?: string;
-}
-interface SelectTriggerProps extends Omit<Select.Trigger.Props, "className"> {
-  className?: string;
+interface SelectLabelProps extends Select.Label.Props {}
+interface SelectTriggerProps extends Select.Trigger.Props {
   /**
    * The size of the select trigger.
-   * @default 'default'
+   * @default 'sm'
    */
-  size?: "sm" | "md" | "default";
+  size?: "sm" | "md";
 }
 interface SelectValueProps extends Omit<Select.Value.Props, "children"> {
   placeholder?: string;
   children?: Select.Value.Props["children"];
 }
-interface SelectIconProps extends Omit<Select.Icon.Props, "className"> {
-  className?: string;
-}
+interface SelectIconProps extends Select.Icon.Props {}
 interface SelectPortalProps extends Select.Portal.Props {}
-interface SelectBackdropProps extends Omit<Select.Backdrop.Props, "className"> {
-  className?: string;
-}
+interface SelectBackdropProps extends Select.Backdrop.Props {}
 interface SelectPositionerProps extends Select.Positioner.Props {}
-interface SelectPopupProps extends Omit<Select.Popup.Props, "className"> {
-  className?: string;
-}
-interface SelectListProps extends Omit<Select.List.Props, "className"> {
-  className?: string;
-}
-interface SelectItemProps extends Omit<Select.Item.Props, "className"> {
-  className?: string;
-}
-interface SelectItemTextProps extends Omit<Select.ItemText.Props, "className"> {
-  className?: string;
-}
-interface SelectItemIndicatorProps extends Omit<Select.ItemIndicator.Props, "className"> {
-  className?: string;
-}
-interface SelectGroupProps extends Omit<Select.Group.Props, "className"> {
-  className?: string;
+interface SelectPopupProps extends Select.Popup.Props {}
+interface SelectListProps extends Select.List.Props {}
+interface SelectItemProps extends Select.Item.Props {}
+interface SelectItemTextProps extends Select.ItemText.Props {}
+interface SelectItemIndicatorProps extends Select.ItemIndicator.Props {}
+interface SelectGroupProps extends Select.Group.Props {
   label?: string;
 }
-interface SelectGroupLabelProps extends Omit<Select.GroupLabel.Props, "className"> {
-  className?: string;
-}
-interface SelectSeparatorProps extends Omit<Select.Separator.Props, "className"> {
-  className?: string;
-}
-interface SelectScrollUpArrowProps extends Omit<Select.ScrollUpArrow.Props, "className"> {
-  className?: string;
-}
-interface SelectScrollDownArrowProps extends Omit<Select.ScrollDownArrow.Props, "className"> {
-  className?: string;
-}
+interface SelectGroupLabelProps extends Select.GroupLabel.Props {}
+interface SelectSeparatorProps extends Select.Separator.Props {}
+interface SelectScrollUpArrowProps extends Select.ScrollUpArrow.Props {}
+interface SelectScrollDownArrowProps extends Select.ScrollDownArrow.Props {}
 /**
  * A select component for choosing from a list of options.
  *
@@ -122,8 +96,6 @@ declare function SelectPositioner({
   ref,
   ...props
 }: SelectPositionerProps & {
-  className?: string;
-} & {
   ref?: React.Ref<HTMLDivElement>;
 }): React.JSX.Element;
 declare function SelectPopup({

package/dist/{Tabs-3Zc4tb9D.d.ts → Tabs-ColWK-XA.d.ts}

@@ -2,32 +2,19 @@ import * as React from "react";
 import { Tabs } from "@base-ui/react/tabs";
 
 //#region src/components/Tabs.d.ts
-interface TabsProps extends Omit<Tabs.Root.Props, "className"> {
-  className?: string;
+interface TabsProps extends Tabs.Root.Props {
   /**
    * The visual style variant.
    * @default 'default'
    */
   variant?: "default" | "bordered";
 }
-interface TabsListProps extends Omit<Tabs.List.Props, "className"> {
-  className?: string;
+interface TabsListProps extends Tabs.List.Props {
   variant?: "default" | "line" | null;
 }
-interface TabProps extends Omit<Tabs.Tab.Props, "className"> {
-  className?: string;
-}
-interface TabPanelProps extends Omit<Tabs.Panel.Props, "className"> {
-  className?: string;
-}
-interface TabsListVariantsOptions {
-  variant?: "default" | "line" | null;
-  className?: string;
-}
-declare function tabsListVariants({
-  variant,
-  className
-}?: TabsListVariantsOptions): string;
+interface TabProps extends Tabs.Tab.Props {}
+interface TabPanelProps extends Tabs.Panel.Props {}
+interface TabsIndicatorProps extends Tabs.Indicator.Props {}
 /**
  * A tabs component for organizing content into separate views.
  *
@@ -69,6 +56,13 @@ declare function Tab({
 }: TabProps & {
   ref?: React.Ref<HTMLButtonElement>;
 }): React.JSX.Element;
+declare function TabsIndicator({
+  className,
+  ref,
+  ...props
+}: TabsIndicatorProps & {
+  ref?: React.Ref<HTMLSpanElement>;
+}): React.JSX.Element;
 declare function TabPanel({
   className,
   ref,
@@ -80,8 +74,8 @@ declare const Tabs$1: {
   Root: typeof TabsRoot;
   List: typeof TabsList;
   Tab: typeof Tab;
-  Indicator: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").TabsIndicatorProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+  Indicator: typeof TabsIndicator;
   Panel: typeof TabPanel;
 };
 //#endregion
-export { TabsListVariantsOptions as a, TabsListProps as i, TabProps as n, TabsProps as o, Tabs$1 as r, tabsListVariants as s, TabPanelProps as t };
+export { TabsListProps as a, TabsIndicatorProps as i, TabProps as n, TabsProps as o, Tabs$1 as r, TabPanelProps as t };

package/dist/{ThinkChat-CzC-zNGA.js → ThinkChat-15EhfvYJ.js}

@@ -1,11 +1,14 @@
 import { AgentChat } from "./components/AgentChat.js";
-import { AgentChatTurnError } from "./components/AgentChatTurnError.js";
+import { AgentToolRunsProvider, useOptionalAgentToolRuns } from "./components/AgentToolRunsContext.js";
+import { SubagentRunList } from "./components/SubagentRunList.js";
 import { ThinkChatContext, useThinkChatContext } from "./components/ThinkChatContext.js";
 import { ThinkChatActivity, createThinkChatActivityRenderer, renderThinkChatActivityPart } from "./components/ThinkChatActivity.js";
+import { ThinkRecoveryNotice } from "./components/ThinkRecoveryNotice.js";
 import * as React from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { useAgentChat } from "@cloudflare/think/react";
-import { useAgent } from "agents/react";
+import { useAgent, useAgentToolEvents } from "agents/react";
+import { queryOptions, useQuery, useQueryClient } from "@tanstack/react-query";
 //#region src/components/_internal/think-approvals.ts
 /**
 * Ambient approvals belong to their stub. An explicit different stub may only
@@ -21,79 +24,105 @@ function resolveThinkApprovalProps(overrides, ambient) {
 }
 //#endregion
 //#region src/components/ThinkChat.tsx
+const EMPTY_PENDING_APPROVALS = [];
 function toAgentChatStatus(chat) {
 	if (chat.status === "submitted") return "submitted";
 	if (chat.isStreaming || chat.isRecovering) return "streaming";
 	return chat.status ?? "ready";
 }
-function useThinkPendingApprovals(stub, refreshKey) {
-	const requestIdRef = React.useRef(0);
-	const [state, setState] = React.useState(() => ({
-		source: stub,
-		pendingApprovals: []
-	}));
-	const refresh = React.useCallback(async () => {
-		const requestId = ++requestIdRef.current;
-		try {
-			const pendingApprovals = await stub.pendingApprovals();
-			if (requestId !== requestIdRef.current) return;
-			setState({
-				source: stub,
-				pendingApprovals
-			});
-		} catch {
-			if (requestId !== requestIdRef.current) return;
-			setState({
-				source: stub,
-				pendingApprovals: []
-			});
-		}
-	}, [stub]);
-	React.useEffect(() => {
-		requestIdRef.current += 1;
-		setState((current) => current.source === stub ? current : {
-			source: stub,
-			pendingApprovals: []
-		});
-		refresh();
-		return () => {
-			requestIdRef.current += 1;
+function thinkPendingExecutionApprovalsQueryKey(sourceKey) {
+	return [
+		"think",
+		sourceKey,
+		"pending-approvals"
+	];
+}
+/** Shared pending-approval options for components and TanStack Router loaders. */
+function thinkPendingExecutionApprovalsQueryOptions(stub, sourceKey) {
+	return queryOptions({
+		queryKey: thinkPendingExecutionApprovalsQueryKey(sourceKey),
+		queryFn: () => stub.pendingApprovals(),
+		staleTime: 5e3
+	});
+}
+function useThinkPendingExecutionApprovals(stub, sourceKey, refreshSignal) {
+	const queryClient = useQueryClient();
+	const approvalsQuery = useQuery(thinkPendingExecutionApprovalsQueryOptions(stub, sourceKey));
+	const refreshState = React.useRef({
+		sourceKey,
+		observedSignal: refreshSignal,
+		pending: false
+	});
+	const refetch = React.useEffectEvent(() => approvalsQuery.refetch());
+	const refreshPendingApprovals = React.useCallback(async () => {
+		const filters = {
+			queryKey: thinkPendingExecutionApprovalsQueryKey(sourceKey),
+			exact: true
 		};
+		await queryClient.cancelQueries(filters);
+		await queryClient.invalidateQueries(filters);
+	}, [queryClient, sourceKey]);
+	React.useEffect(() => {
+		if (refreshState.current.sourceKey !== sourceKey) {
+			refreshState.current = {
+				sourceKey,
+				observedSignal: refreshSignal,
+				pending: false
+			};
+			return;
+		}
+		if (!Object.is(refreshState.current.observedSignal, refreshSignal)) {
+			refreshState.current.observedSignal = refreshSignal;
+			refreshState.current.pending = true;
+		}
+		if (approvalsQuery.isFetching || !refreshState.current.pending) return;
+		refreshState.current.pending = false;
+		refetch();
 	}, [
-		refresh,
-		refreshKey,
-		stub
+		approvalsQuery.isFetching,
+		refreshSignal,
+		sourceKey
 	]);
-	const pendingApprovals = state.source === stub ? state.pendingApprovals : [];
 	return React.useMemo(() => ({
-		pendingApprovals,
-		refreshPendingApprovals: refresh
-	}), [pendingApprovals, refresh]);
+		pendingApprovals: approvalsQuery.data ?? EMPTY_PENDING_APPROVALS,
+		refreshPendingApprovals
+	}), [approvalsQuery.data, refreshPendingApprovals]);
 }
 /**
 * Chat UI for Cloudflare Think agents. Provide a `useAgentChat` value (or let
 * `ThinkChat.Root` create one) and `ThinkChat.Messages` renders the message
 * stream with agent work folded into collapsed Activity blocks.
 */
-function ThinkChatProvider({ chat, children }) {
-	return /* @__PURE__ */ jsx(ThinkChatContext.Provider, {
+function ThinkChatProvider({ agentTools, chat, children }) {
+	const chatProvider = /* @__PURE__ */ jsx(ThinkChatContext.Provider, {
 		value: chat,
 		children
 	});
+	return agentTools ? /* @__PURE__ */ jsx(AgentToolRunsProvider, {
+		agentTools,
+		children: chatProvider
+	}) : chatProvider;
 }
 /**
 * Batteries-included root: connects to the named Think agent (upstream's
 * `useAgent` + `useAgentChat`) and provides the live chat to everything
-* inside. If the app already owns the chat hook, use `ThinkChat.Provider`.
+* inside. Render it beneath the app's `QueryClientProvider`. If the app
+* already owns the chat hook, use `ThinkChat.Provider`.
 *
 * @example
 * ```tsx
-* <ThinkChat.Root agent="my-agent" name="session-1">
-*   <ThinkChat.Messages />
-* </ThinkChat.Root>
+* <QueryClientProvider client={queryClient}>
+*   <ThinkChat.Root
+*     agent="my-agent"
+*     name="session-1"
+*     sourceKey="api.example.com:account:acme:agent:session-1"
+*   >
+*     <ThinkChat.Messages />
+*   </ThinkChat.Root>
+* </QueryClientProvider>
 * ```
 */
-function ThinkChatRoot({ agent: agentOption, name, children }) {
+function ThinkChatRoot({ agent: agentOption, name, sourceKey, children }) {
 	const agent = useAgent(typeof agentOption === "string" ? {
 		agent: agentOption,
 		name
@@ -102,15 +131,25 @@ function ThinkChatRoot({ agent: agentOption, name, children }) {
 		name: name ?? agentOption.name
 	});
 	const chat = useAgentChat({ agent });
-	const approvals = useThinkPendingApprovals(agent.stub, `${chat.messages.length}:${chat.status}`);
-	return /* @__PURE__ */ jsx(ThinkChatContext.Provider, {
-		value: chat,
-		children: /* @__PURE__ */ jsx(ThinkChatApprovalsContext.Provider, {
-			value: {
-				...approvals,
-				thinkStub: agent.stub
-			},
-			children
+	const agentTools = useAgentToolEvents({ agent });
+	const agentIdentity = JSON.stringify(agent.path);
+	const approvals = useThinkPendingExecutionApprovals(agent.stub, sourceKey, `${chat.messages.length}:${chat.status}`);
+	const resetAgentTools = React.useEffectEvent(() => agentTools.resetLocalState());
+	React.useEffect(() => {
+		resetAgentTools();
+	}, [agentIdentity]);
+	const approvalsContext = React.useMemo(() => ({
+		...approvals,
+		thinkStub: agent.stub
+	}), [agent.stub, approvals]);
+	return /* @__PURE__ */ jsx(AgentToolRunsProvider, {
+		agentTools,
+		children: /* @__PURE__ */ jsx(ThinkChatContext.Provider, {
+			value: chat,
+			children: /* @__PURE__ */ jsx(ThinkChatApprovalsContext.Provider, {
+				value: approvalsContext,
+				children
+			})
 		})
 	});
 }
@@ -125,8 +164,9 @@ const ThinkChatApprovalsContext = React.createContext(null);
 * inside the log) or `excludeTools` + your own `renderPart` (standalone
 * card) — see README "App-specific tools" and the Custom Tool Panel story.
 */
-function ThinkChatMessages({ renderPart, excludeTools, toolRenderers, thinkStub, onExecutionSettled, pendingApprovals, notice, ...props }) {
+function ThinkChatMessages({ composerHeader, renderPart, excludeTools, renderAgentToolRunLink, toolRenderers, thinkStub, onExecutionSettled, pendingApprovals, notice, ...props }) {
 	const chat = useThinkChatContext("ThinkChat.Messages");
+	const agentTools = useOptionalAgentToolRuns();
 	const approvals = React.useContext(ThinkChatApprovalsContext);
 	const status = toAgentChatStatus(chat);
 	const resolvedApprovals = resolveThinkApprovalProps({
@@ -140,8 +180,13 @@ function ThinkChatMessages({ renderPart, excludeTools, toolRenderers, thinkStub,
 	});
 	const defaultRenderPart = React.useMemo(() => createThinkChatActivityRenderer({
 		excludeTools,
+		renderAgentToolRunLink,
+		toolRenderers
+	}), [
+		excludeTools,
+		renderAgentToolRunLink,
 		toolRenderers
-	}), [excludeTools, toolRenderers]);
+	]);
 	const resolvedRenderPart = React.useMemo(() => renderPart ? (context) => {
 		const renderBuiltIn = () => {
 			const builtIn = defaultRenderPart(context);
@@ -153,18 +198,20 @@ function ThinkChatMessages({ renderPart, excludeTools, toolRenderers, thinkStub,
 		});
 		return custom === void 0 ? renderBuiltIn() : custom;
 	} : defaultRenderPart, [defaultRenderPart, renderPart]);
-	const retryMessageId = chat.error ? chat.messages.findLast((message) => message.role !== "system")?.id : void 0;
-	const defaultNotice = chat.isRecovering ? /* @__PURE__ */ jsx(Fragment, { children: "Reconnecting to the agent…" }) : chat.connectionError ? /* @__PURE__ */ jsxs("span", {
-		"data-tone": "danger",
-		children: ["Connection lost", chat.connectionError.reason ? ` — ${chat.connectionError.reason}` : ""]
-	}) : chat.error ? /* @__PURE__ */ jsx(AgentChatTurnError, {
-		error: chat.error,
-		onDismiss: chat.clearError,
-		onRetry: retryMessageId ? () => {
-			chat.clearError();
-			chat.regenerate({ messageId: retryMessageId });
-		} : void 0
-	}) : void 0;
+	const defaultNotice = /* @__PURE__ */ jsx(ThinkRecoveryNotice, { chat });
+	const backgroundRuns = renderAgentToolRunLink ? agentTools?.unboundRuns : void 0;
+	const resolvedComposerHeader = composerHeader || backgroundRuns?.length ? /* @__PURE__ */ jsxs(Fragment, { children: [composerHeader, backgroundRuns?.length && renderAgentToolRunLink ? /* @__PURE__ */ jsxs("div", {
+		className: "subagent-run__tray",
+		"data-slot": "background-agent-runs",
+		children: [/* @__PURE__ */ jsx("span", {
+			className: "subagent-run__tray-label",
+			children: "Background agents"
+		}), /* @__PURE__ */ jsx(SubagentRunList, {
+			"aria-label": "Background agent runs",
+			runs: backgroundRuns,
+			renderRunLink: renderAgentToolRunLink
+		})]
+	}) : null] }) : void 0;
 	return /* @__PURE__ */ jsx(AgentChat, {
 		...props,
 		renderPart: resolvedRenderPart,
@@ -176,10 +223,12 @@ function ThinkChatMessages({ renderPart, excludeTools, toolRenderers, thinkStub,
 		onExecutionSettled: resolvedApprovals.onExecutionSettled,
 		pendingApprovals: resolvedApprovals.pendingApprovals,
 		notice: notice ?? defaultNotice,
+		composerHeader: resolvedComposerHeader,
 		onRegenerate: (messageId) => void chat.regenerate({ messageId }),
 		onSubmit: ({ text, files, references }) => {
 			const prompt = [...references?.map(({ trigger, value }) => trigger ? `${trigger}${value}` : value) ?? [], text.trim()].filter(Boolean).join(" ");
-			if (prompt || files.length) return chat.sendMessage({
+			if (!prompt && !files.length) return;
+			return chat.sendMessage({
 				text: prompt,
 				files
 			});
@@ -205,8 +254,9 @@ const ThinkChat = {
 	Root: ThinkChatRoot,
 	Messages: ThinkChatMessages,
 	Activity: ThinkChatActivity,
+	RecoveryNotice: ThinkRecoveryNotice,
 	renderActivityPart: renderThinkChatActivityPart,
 	createActivityRenderer: createThinkChatActivityRenderer
 };
 //#endregion
-export { useThinkChat as a, ThinkChatRoot as i, ThinkChatMessages as n, useThinkPendingApprovals as o, ThinkChatProvider as r, resolveThinkApprovalProps as s, ThinkChat as t };
+export { thinkPendingExecutionApprovalsQueryOptions as a, resolveThinkApprovalProps as c, ThinkChatRoot as i, ThinkChatMessages as n, useThinkChat as o, ThinkChatProvider as r, useThinkPendingExecutionApprovals as s, ThinkChat as t };

package/dist/{ThinkChatActivity-BFQnb2ct.d.ts → ThinkChatActivity-Bzot45kX.d.ts}

@@ -1,7 +1,9 @@
-import { i as AgentChatProps, o as AgentChatRenderPartContext } from "./AgentChat-CrlpbvQJ.js";
+import { i as AgentMessageRenderPartContext } from "./AgentMessageParts-CyD2UB3V.js";
+import { r as AgentChatProps } from "./AgentChat-ClxViuUM.js";
 import { l as ThinkChatPart } from "./ThinkChatToolParts-CSzVwMXf.js";
 import * as React from "react";
 import { DynamicToolUIPart, ToolUIPart, UIMessage } from "ai";
+import { AgentToolRunState } from "agents/agent-tools";
 
 //#region src/components/ThinkChatActivity.d.ts
 /**
@@ -16,7 +18,7 @@ interface ThinkChatToolRenderer {
   panel?: (part: ToolUIPart | DynamicToolUIPart) => React.ReactNode;
 }
 type ThinkChatToolRenderers = Record<string, ThinkChatToolRenderer>;
-interface ThinkChatActivityRendererOptions {
+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
@@ -26,6 +28,8 @@ interface ThinkChatActivityRendererOptions {
   excludeTools?: readonly string[];
   /** Per-tool label/panel overrides inside the activity log, keyed by tool name. */
   toolRenderers?: ThinkChatToolRenderers;
+  /** App-authored TanStack Router Link for each retained child destination. */
+  renderAgentToolRunLink?: (run: AgentToolRunState<MessageT["parts"][number]>) => React.ReactElement;
 }
 interface ThinkChatActivityProps {
   /** Render with the log expanded. */
@@ -58,9 +62,10 @@ declare function ThinkChatActivity({
  */
 declare function createThinkChatActivityRenderer<MessageT extends UIMessage = UIMessage>({
   excludeTools,
+  renderAgentToolRunLink,
   toolRenderers
-}?: ThinkChatActivityRendererOptions): NonNullable<AgentChatProps<MessageT>["renderPart"]>;
+}?: ThinkChatActivityRendererOptions<MessageT>): NonNullable<AgentChatProps<MessageT>["renderPart"]>;
 /** Default activity renderer — `createThinkChatActivityRenderer()` with no overrides. */
-declare const renderThinkChatActivityPart: (context: AgentChatRenderPartContext<UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>>) => React.ReactNode | undefined;
+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 };

package/dist/{ThinkChatActivitySummary-BPmu9a-c.d.ts → ThinkChatActivitySummary-D1xOrNrq.d.ts}

@@ -1,4 +1,4 @@
-import { i as AgentActivityIconKind, s as AgentActivitySummary } from "./AgentActivity-BNUNrP9O.js";
+import { i as AgentActivityIconKind, s as AgentActivitySummary } from "./AgentActivity-D2SHSGFX.js";
 import { l as ThinkChatPart } from "./ThinkChatToolParts-CSzVwMXf.js";
 import { DynamicToolUIPart, ToolUIPart } from "ai";
 

package/dist/{ThinkChatContext-C3Eb1Xpi.d.ts → ThinkChatContext-DrsZqdaO.d.ts}

@@ -1,6 +1,6 @@
 import * as React from "react";
-import { useAgentChat } from "@cloudflare/think/react";
 import { UIMessage } from "ai";
+import { useAgentChat } from "@cloudflare/think/react";
 
 //#region src/components/ThinkChatContext.d.ts
 /** The complete upstream Think chat hook value, preserving app state and message extensions. */

package/dist/ThinkRecoveryNotice-DFIcG9UX.d.ts

@@ -0,0 +1,19 @@
+import { n as ThinkChatValue } from "./ThinkChatContext-DrsZqdaO.js";
+import { UIMessage } from "ai";
+
+//#region src/components/ThinkRecoveryNotice.d.ts
+interface ThinkRecoveryNoticeProps<State = unknown, MessageT extends UIMessage = UIMessage> {
+  /** The complete `useAgentChat` value from `@cloudflare/think/react`. */
+  chat: ThinkChatValue<State, MessageT>;
+}
+/**
+ * Native Think recovery, connection, and turn-error content for AgentChat's
+ * persistent polite notice region. Think exposes no recovery phase, progress,
+ * checkpoint, attempt count, or timeline to the browser, so this adapter does
+ * not claim those details.
+ */
+declare function ThinkRecoveryNotice<State = unknown, MessageT extends UIMessage = UIMessage>({
+  chat
+}: ThinkRecoveryNoticeProps<State, MessageT>): import("react").JSX.Element | null;
+//#endregion
+export { ThinkRecoveryNoticeProps as n, ThinkRecoveryNotice as t };

package/dist/{Toggle-CAAlNl-M.d.ts → Toggle-JKZ43D5S.d.ts}

@@ -4,13 +4,13 @@ import { Toggle } from "@base-ui/react/toggle";
 //#region src/components/Toggle.d.ts
 interface ToggleVariantsOptions {
   variant?: "default" | "outline" | null;
-  size?: "default" | "sm" | "lg" | null;
+  size?: "sm" | "md" | "lg" | null;
   className?: string;
 }
 /**
  * Props for the Toggle component.
  */
-interface ToggleProps extends Omit<React.ComponentPropsWithoutRef<typeof Toggle>, "className">, ToggleVariantsOptions {}
+interface ToggleProps extends React.ComponentPropsWithoutRef<typeof Toggle>, Omit<ToggleVariantsOptions, "className"> {}
 declare function toggleVariants({
   variant,
   size,

package/dist/{ToggleGroup-8hPv-b69.d.ts → ToggleGroup-DNd6cDJZ.d.ts}

@@ -1,12 +1,11 @@
-import { r as ToggleVariantsOptions } from "./Toggle-CAAlNl-M.js";
+import { r as ToggleVariantsOptions } from "./Toggle-JKZ43D5S.js";
 import * as React from "react";
 import { ToggleGroup } from "@base-ui/react/toggle-group";
 import { Toggle } from "@base-ui/react/toggle";
 
 //#region src/components/ToggleGroup.d.ts
-type ToggleGroupSize = ToggleVariantsOptions["size"] | "md";
-interface ToggleGroupProps extends Omit<React.ComponentPropsWithRef<typeof ToggleGroup>, "className"> {
-  className?: string;
+type ToggleGroupSize = ToggleVariantsOptions["size"];
+interface ToggleGroupProps extends React.ComponentPropsWithRef<typeof ToggleGroup> {
   variant?: ToggleVariantsOptions["variant"];
   /**
    * The size of the toggle group.
@@ -15,7 +14,7 @@ interface ToggleGroupProps extends Omit<React.ComponentPropsWithRef<typeof Toggl
   size?: ToggleGroupSize;
   spacing?: number;
 }
-interface ToggleGroupItemProps extends Omit<React.ComponentPropsWithRef<typeof Toggle>, "className">, ToggleVariantsOptions {}
+interface ToggleGroupItemProps extends React.ComponentPropsWithRef<typeof Toggle>, Omit<ToggleVariantsOptions, "className"> {}
 /**
  * A toggle group component for selecting one or multiple options.
  *