@dungle-scrubs/admin-ui-soft 0.0.0-stage → 0.1.0

package/dist/components/assistant-ui/elements/tool-fallback.aui.js

@@ -0,0 +1,542 @@
+"use client";
+import { __exportAll } from "../../../_virtual/_rolldown/runtime.js";
+import { Button } from "../../ui/button.js";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "../../ui/collapsible.js";
+import { Textarea } from "../../ui/textarea.js";
+import { cn } from "../../../lib/utils.js";
+import { memo, useCallback, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { AlertCircleIcon, CheckIcon, ChevronDownIcon, CircleMinusIcon, LoaderIcon, XCircleIcon } from "lucide-react";
+import { toolApprovalAcceptsText, useAuiState, useScrollLock, useToolCallElapsed } from "@assistant-ui/react";
+//#region src/components/assistant-ui/elements/tool-fallback.aui.tsx
+var tool_fallback_aui_exports = /* @__PURE__ */ __exportAll({
+	ToolFallback: () => ToolFallback,
+	ToolFallbackApproval: () => ToolFallbackApproval,
+	ToolFallbackArgs: () => ToolFallbackArgs,
+	ToolFallbackContent: () => ToolFallbackContent,
+	ToolFallbackError: () => ToolFallbackError,
+	ToolFallbackResult: () => ToolFallbackResult,
+	ToolFallbackRoot: () => ToolFallbackRoot,
+	ToolFallbackTrigger: () => ToolFallbackTrigger,
+	formatUnknownValue: () => formatUnknownValue,
+	offersInterruptAction: () => offersInterruptAction
+});
+const ANIMATION_DURATION = 200;
+const pressable = "active:scale-[0.98]";
+function ToolFallbackRoot({ className, open: controlledOpen, onOpenChange: controlledOnOpenChange, defaultOpen = false, children, ...props }) {
+	const collapsibleRef = useRef(null);
+	const [uncontrolledOpen, setUncontrolledOpen] = useState(defaultOpen);
+	const lockScroll = useScrollLock(collapsibleRef, ANIMATION_DURATION);
+	const isControlled = controlledOpen !== void 0;
+	const isOpen = isControlled ? controlledOpen : uncontrolledOpen;
+	const handleOpenChange = useCallback((open) => {
+		lockScroll();
+		if (!isControlled) setUncontrolledOpen(open);
+		controlledOnOpenChange?.(open);
+	}, [
+		lockScroll,
+		isControlled,
+		controlledOnOpenChange
+	]);
+	return /* @__PURE__ */ jsx(Collapsible, {
+		ref: collapsibleRef,
+		"data-slot": "tool-fallback-root",
+		open: isOpen,
+		onOpenChange: handleOpenChange,
+		className: cn("aui-tool-fallback-root group/tool-fallback-root w-full", className),
+		style: { "--animation-duration": `${ANIMATION_DURATION}ms` },
+		...props,
+		children
+	});
+}
+const statusIconMap = {
+	running: LoaderIcon,
+	complete: CheckIcon,
+	incomplete: XCircleIcon,
+	"requires-action": AlertCircleIcon
+};
+const formatToolDuration = (ms) => {
+	if (ms < 1e3) return "<1s";
+	const seconds = ms / 1e3;
+	if (seconds < 10) return `${(Math.floor(seconds * 10) / 10).toFixed(1)}s`;
+	if (seconds < 60) return `${Math.floor(seconds)}s`;
+	return `${Math.floor(seconds / 60)}m ${Math.floor(seconds % 60)}s`;
+};
+function ToolFallbackDuration({ className, ...props }) {
+	const elapsedMs = useToolCallElapsed();
+	if (elapsedMs === void 0) return null;
+	return /* @__PURE__ */ jsx("span", {
+		"data-slot": "tool-fallback-duration",
+		className: cn("aui-tool-fallback-duration text-muted-foreground text-xs tabular-nums", className),
+		...props,
+		children: formatToolDuration(elapsedMs)
+	});
+}
+function ToolFallbackTrigger({ toolName, status, denied, className, ...props }) {
+	const statusType = status?.type ?? "complete";
+	const isRunning = statusType === "running";
+	const isCancelled = status?.type === "incomplete" && status.reason === "cancelled";
+	const Icon = denied ? XCircleIcon : statusIconMap[statusType];
+	const label = denied ? "Denied tool" : statusType === "running" ? "Running tool" : statusType === "requires-action" ? "Waiting on tool" : statusType === "incomplete" ? `${isCancelled ? "Cancelled" : "Failed"} tool` : "Used tool";
+	return /* @__PURE__ */ jsxs(CollapsibleTrigger, {
+		"data-slot": "tool-fallback-trigger",
+		className: cn("aui-tool-fallback-trigger group/trigger text-muted-foreground hover:text-foreground focus-visible:ring-ring/50 flex w-fit origin-left items-center gap-2 rounded-md py-1.5 ps-1 -ms-1 text-sm transition-[color,scale] outline-none active:scale-[0.98] focus-visible:ring-[3px]", className),
+		...props,
+		children: [
+			/* @__PURE__ */ jsx(Icon, {
+				"data-slot": "tool-fallback-trigger-icon",
+				className: cn("aui-tool-fallback-trigger-icon size-4 shrink-0", isCancelled && "text-muted-foreground", isRunning && "animate-spin [animation-duration:0.6s]")
+			}),
+			/* @__PURE__ */ jsxs("span", {
+				"data-slot": "tool-fallback-trigger-label",
+				className: cn("aui-tool-fallback-trigger-label-wrapper inline-block text-start leading-none", isCancelled && "text-muted-foreground line-through", isRunning && "shimmer motion-reduce:animate-none"),
+				children: [
+					label,
+					": ",
+					/* @__PURE__ */ jsx("b", { children: toolName })
+				]
+			}),
+			/* @__PURE__ */ jsx(ToolFallbackDuration, {}),
+			/* @__PURE__ */ jsx(ChevronDownIcon, {
+				"data-slot": "tool-fallback-trigger-chevron",
+				className: cn("aui-tool-fallback-trigger-chevron size-4 shrink-0", "transition-transform duration-(--animation-duration) ease-[cubic-bezier(0.32,0.72,0,1)] motion-reduce:transition-none", "-rotate-90", "group-data-open/trigger:rotate-0", "group-data-panel-open/trigger:rotate-0")
+			})
+		]
+	});
+}
+function ToolFallbackContent({ className, children, ...props }) {
+	return /* @__PURE__ */ jsx(CollapsibleContent, {
+		"data-slot": "tool-fallback-content",
+		className: cn("aui-tool-fallback-content relative overflow-hidden text-sm outline-none", "group/collapsible-content ease-[cubic-bezier(0.32,0.72,0,1)] motion-reduce:animate-none", "data-closed:animate-collapsible-up", "data-open:animate-collapsible-down", "data-closed:fill-mode-forwards", "data-closed:pointer-events-none", "[--tw-duration:var(--animation-duration)]", className),
+		...props,
+		children: /* @__PURE__ */ jsx("div", {
+			className: cn("flex flex-col gap-2 ps-6 pt-1 pb-2 ease-[cubic-bezier(0.32,0.72,0,1)] motion-reduce:animate-none", "group-data-open/collapsible-content:animate-in group-data-open/collapsible-content:fade-in-0 group-data-open/collapsible-content:blur-in-[2px] group-data-open/collapsible-content:slide-in-from-top-1", "group-data-closed/collapsible-content:animate-out group-data-closed/collapsible-content:fade-out-0 group-data-closed/collapsible-content:blur-out-[2px] group-data-closed/collapsible-content:slide-out-to-top-1", "group-data-closed/collapsible-content:animation-duration-(--animation-duration) group-data-open/collapsible-content:animation-duration-(--animation-duration)"),
+			children
+		})
+	});
+}
+function ToolFallbackArgs({ argsText, className, ...props }) {
+	if (!argsText) return null;
+	return /* @__PURE__ */ jsx("div", {
+		"data-slot": "tool-fallback-args",
+		className: cn("aui-tool-fallback-args", className),
+		...props,
+		children: /* @__PURE__ */ jsx("pre", {
+			className: "aui-tool-fallback-args-value bg-muted/50 text-foreground/90 rounded-md p-2.5 text-xs whitespace-pre-wrap",
+			children: argsText
+		})
+	});
+}
+const formatUnknownValue = (value, space) => {
+	if (typeof value === "string") return value;
+	try {
+		if (value instanceof Error) return String(value);
+		const json = JSON.stringify(value, null, space);
+		if (json !== void 0) return json;
+	} catch {}
+	try {
+		return String(value);
+	} catch {
+		return "[Unserializable value]";
+	}
+};
+function ToolFallbackResult({ result, className, ...props }) {
+	if (result === void 0) return null;
+	return /* @__PURE__ */ jsxs("div", {
+		"data-slot": "tool-fallback-result",
+		className: cn("aui-tool-fallback-result", className),
+		...props,
+		children: [/* @__PURE__ */ jsx("p", {
+			className: "aui-tool-fallback-result-header text-muted-foreground text-xs font-medium",
+			children: "Result:"
+		}), /* @__PURE__ */ jsx("pre", {
+			className: "aui-tool-fallback-result-content bg-muted/50 text-foreground/90 mt-1 rounded-md p-2.5 text-xs whitespace-pre-wrap",
+			children: formatUnknownValue(result, 2)
+		})]
+	});
+}
+function ToolFallbackError({ status, className, ...props }) {
+	if (status?.type !== "incomplete") return null;
+	const error = status.error;
+	const errorText = error === void 0 || error === null ? null : formatUnknownValue(error);
+	if (!errorText) return null;
+	const headerText = status.reason === "cancelled" ? "Cancelled reason:" : "Error:";
+	return /* @__PURE__ */ jsxs("div", {
+		"data-slot": "tool-fallback-error",
+		className: cn("aui-tool-fallback-error", className),
+		...props,
+		children: [/* @__PURE__ */ jsx("p", {
+			className: "aui-tool-fallback-error-header text-muted-foreground font-semibold",
+			children: headerText
+		}), /* @__PURE__ */ jsx("p", {
+			className: "aui-tool-fallback-error-reason text-muted-foreground whitespace-pre-line",
+			children: errorText
+		})]
+	});
+}
+const APPROVED_RESULT = "Approved by user";
+const DENIED_RESULT = "User denied tool execution";
+const APPROVAL_OPTION_DEFAULT_LABELS = {
+	"allow-once": "Allow",
+	"allow-always": "Always allow",
+	"reject-once": "Deny",
+	"reject-always": "Always deny"
+};
+const isKnownKind = (kind) => Object.hasOwn(APPROVAL_OPTION_DEFAULT_LABELS, kind);
+const isAllowKind = (kind) => kind === "allow-once" || kind === "allow-always";
+const approvalOptionLabel = (option) => option.label ?? (isKnownKind(option.kind) ? APPROVAL_OPTION_DEFAULT_LABELS[option.kind] : void 0) ?? option.id;
+/**
+* A request that declares how it wants to be presented is asking a question,
+* not gating an action, so a refusal is not one of the answers it accepts
+* unless the request declares itself dismissible.
+*/
+const isQuestion = (approval) => approval?.display === "select" || approval?.display === "text";
+const isSettled = (approval) => approval != null && (approval.approved !== void 0 || approval.resolution !== void 0);
+/**
+* A settled request reads as a past-tense record of what happened to it, so
+* scrolling back never shows a live control for a decision already made.
+*/
+const approvalReceipt = (approval) => {
+	if (approval.resolution !== void 0) return {
+		outcome: "closed",
+		label: approval.resolution === "cancelled" ? "Cancelled before a decision" : "Expired before a decision"
+	};
+	const chosen = approval.optionId === void 0 ? void 0 : approval.options?.find((option) => option.id === approval.optionId);
+	const option = chosen !== void 0 ? approvalOptionLabel(chosen) : approval.optionId === void 0 ? void 0 : approval.optionId;
+	const answered = isQuestion(approval) || chosen !== void 0 && !isKnownKind(chosen.kind);
+	const automatic = approval.isAutomatic ? " automatically" : "";
+	if (approval.approved) return {
+		outcome: "allowed",
+		label: `${answered ? "Answered" : "Allowed"}${automatic}`,
+		option
+	};
+	return {
+		outcome: "refused",
+		label: `${answered ? "Dismissed" : "Denied"}${automatic}`,
+		option
+	};
+};
+const receiptIcons = {
+	allowed: CheckIcon,
+	refused: XCircleIcon,
+	closed: CircleMinusIcon
+};
+function ToolFallbackApprovalReceipt({ approval, className, ...props }) {
+	const receipt = approvalReceipt(approval);
+	const Icon = receiptIcons[receipt.outcome];
+	const notes = [...new Set([approval.text, approval.reason].filter((value) => typeof value === "string" && value !== ""))];
+	return /* @__PURE__ */ jsxs("div", {
+		"data-slot": "tool-fallback-approval-receipt",
+		"data-outcome": receipt.outcome,
+		className: cn("aui-tool-fallback-approval-receipt flex flex-col gap-1.5 pt-1", className),
+		...props,
+		children: [
+			approval.prompt ? /* @__PURE__ */ jsx("p", {
+				className: "aui-tool-fallback-approval-prompt text-muted-foreground whitespace-pre-line",
+				children: approval.prompt
+			}) : null,
+			/* @__PURE__ */ jsxs("p", {
+				className: "aui-tool-fallback-approval-receipt-label flex items-center gap-1.5",
+				children: [
+					/* @__PURE__ */ jsx(Icon, {
+						"aria-hidden": true,
+						className: "text-muted-foreground size-3.5 shrink-0"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "font-medium",
+						children: receipt.label
+					}),
+					receipt.option !== void 0 ? /* @__PURE__ */ jsxs("span", {
+						className: "text-muted-foreground",
+						children: ["· ", receipt.option]
+					}) : null
+				]
+			}),
+			notes.map((text) => /* @__PURE__ */ jsx("p", {
+				className: "aui-tool-fallback-approval-receipt-note text-muted-foreground whitespace-pre-line",
+				children: text
+			}, text))
+		]
+	});
+}
+const offersInterruptAction = (status, approval, interrupt) => status?.type !== "requires-action" || status.reason !== "interrupt" || approval != null || interrupt != null;
+function ToolFallbackApproval({ className, addResult, resume, interrupt, approval, respondToApproval, status, ...props }) {
+	const [submitted, setSubmitted] = useState(false);
+	const voiceActive = useAuiState((s) => s.thread.voice !== void 0);
+	const canAnswer = useAuiState((s) => s.thread.capabilities.answerToolCall);
+	const locked = submitted || voiceActive;
+	const [confirmingId, setConfirmingId] = useState(null);
+	const [answer, setAnswer] = useState("");
+	const [error, setError] = useState(null);
+	if (approval != null && isSettled(approval)) return /* @__PURE__ */ jsx(ToolFallbackApprovalReceipt, {
+		approval,
+		className,
+		...props
+	});
+	if (!offersInterruptAction(status, approval, interrupt)) return null;
+	const promptText = approval?.prompt ? /* @__PURE__ */ jsx("p", {
+		className: "aui-tool-fallback-approval-prompt text-foreground whitespace-pre-line",
+		children: approval.prompt
+	}) : null;
+	if (!canAnswer) return promptText && /* @__PURE__ */ jsx("div", {
+		"data-slot": "tool-fallback-approval",
+		className: cn("aui-tool-fallback-approval flex flex-col gap-2 pt-1", className),
+		...props,
+		children: promptText
+	});
+	const declaredOptions = respondToApproval ? approval?.options : void 0;
+	const acceptsText = approval != null && respondToApproval != null && toolApprovalAcceptsText(approval);
+	const submit = (send) => {
+		setSubmitted(true);
+		setError(null);
+		(async () => {
+			try {
+				await send();
+			} catch (sendError) {
+				setSubmitted(false);
+				setError(sendError instanceof Error ? sendError.message : String(sendError));
+			}
+		})();
+	};
+	const respond = (approved) => {
+		if (locked) return;
+		if (approval != null && approval.approved === void 0 && respondToApproval) submit(() => respondToApproval({
+			approved,
+			...typedNote()
+		}));
+		else if (interrupt) submit(() => resume?.({ approved }));
+		else if (status?.type === "requires-action" && status.reason === "interrupt") return;
+		else submit(() => addResult?.(approved ? APPROVED_RESULT : DENIED_RESULT));
+	};
+	const respondWithOption = (option) => {
+		if (locked) return;
+		setConfirmingId(null);
+		submit(() => respondToApproval?.(isKnownKind(option.kind) ? {
+			optionId: option.id,
+			...typedNote()
+		} : {
+			optionId: option.id,
+			approved: true,
+			...typedNote()
+		}));
+	};
+	const typedNote = () => answer.trim() ? { text: answer } : {};
+	const submitAnswer = () => {
+		if (locked) return;
+		submit(() => respondToApproval?.({ text: answer }));
+	};
+	const dismiss = () => {
+		if (locked) return;
+		submit(() => respondToApproval?.({ approved: false }));
+	};
+	const handleOption = (option) => {
+		if (option.confirm) setConfirmingId(option.id);
+		else respondWithOption(option);
+	};
+	const confirming = confirmingId != null ? declaredOptions?.find((o) => o.id === confirmingId) : void 0;
+	const question = isQuestion(approval);
+	const dismissButton = question && respondToApproval != null && approval?.dismissible === true ? /* @__PURE__ */ jsx(Button, {
+		size: "sm",
+		variant: "outline",
+		className: pressable,
+		onClick: dismiss,
+		disabled: locked,
+		children: "Dismiss"
+	}) : null;
+	const errorText = error ? /* @__PURE__ */ jsx("p", {
+		role: "alert",
+		className: "aui-tool-fallback-approval-error text-destructive text-xs whitespace-pre-line",
+		children: error
+	}) : null;
+	const answerField = acceptsText ? /* @__PURE__ */ jsxs("div", {
+		className: "aui-tool-fallback-approval-answer flex flex-col items-start gap-2",
+		children: [/* @__PURE__ */ jsx(Textarea, {
+			value: answer,
+			onChange: (event) => setAnswer(event.target.value),
+			disabled: locked,
+			"aria-label": question ? approval?.prompt ?? "Answer" : "Note",
+			placeholder: question ? "Type your answer" : "Add a note to your decision"
+		}), question && /* @__PURE__ */ jsxs("div", {
+			className: "flex items-center gap-2",
+			children: [/* @__PURE__ */ jsx(Button, {
+				size: "sm",
+				className: pressable,
+				onClick: submitAnswer,
+				disabled: locked,
+				children: "Send"
+			}), dismissButton]
+		})]
+	}) : null;
+	if (confirming) {
+		const confirmMeta = typeof confirming.confirm === "object" ? confirming.confirm : void 0;
+		const confirmDescription = confirmMeta?.description ?? confirming.description;
+		return /* @__PURE__ */ jsxs("div", {
+			"data-slot": "tool-fallback-approval-confirm",
+			className: cn("aui-tool-fallback-approval-confirm flex flex-col gap-2 pt-1", className),
+			...props,
+			children: [
+				/* @__PURE__ */ jsx("p", {
+					className: "aui-tool-fallback-approval-confirm-title font-semibold",
+					children: confirmMeta?.title ?? `${approvalOptionLabel(confirming)}?`
+				}),
+				confirmDescription && /* @__PURE__ */ jsx("p", {
+					className: "aui-tool-fallback-approval-confirm-description text-muted-foreground whitespace-pre-line",
+					children: confirmDescription
+				}),
+				confirming.grants && confirming.grants.length > 0 && /* @__PURE__ */ jsx("ul", {
+					className: "aui-tool-fallback-approval-confirm-grants flex flex-col gap-1",
+					children: confirming.grants.map((grant) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx("code", {
+						className: "aui-tool-fallback-approval-confirm-grant bg-muted rounded px-1.5 py-0.5 text-xs",
+						children: grant
+					}) }, grant))
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "flex items-center gap-2",
+					children: [/* @__PURE__ */ jsx(Button, {
+						size: "sm",
+						className: pressable,
+						onClick: () => respondWithOption(confirming),
+						disabled: locked,
+						children: "Confirm"
+					}), /* @__PURE__ */ jsx(Button, {
+						size: "sm",
+						variant: "outline",
+						className: pressable,
+						onClick: () => setConfirmingId(null),
+						disabled: locked,
+						children: "Back"
+					})]
+				})
+			]
+		});
+	}
+	if (declaredOptions && declaredOptions.length > 0) {
+		const allowOptions = declaredOptions.filter((o) => isAllowKind(o.kind));
+		const customOptions = declaredOptions.filter((o) => !isKnownKind(o.kind));
+		const rejectOptions = declaredOptions.filter((o) => isKnownKind(o.kind) && !isAllowKind(o.kind));
+		return /* @__PURE__ */ jsxs("div", {
+			"data-slot": "tool-fallback-approval",
+			className: cn("aui-tool-fallback-approval flex flex-col gap-2 pt-1", className),
+			...props,
+			children: [
+				promptText,
+				/* @__PURE__ */ jsxs("div", {
+					className: "flex flex-wrap items-center gap-2",
+					children: [
+						[
+							...allowOptions,
+							...customOptions,
+							...rejectOptions
+						].map((option) => /* @__PURE__ */ jsx(Button, {
+							size: "sm",
+							variant: option === allowOptions[0] ? "default" : "outline",
+							className: pressable,
+							onClick: () => handleOption(option),
+							disabled: locked,
+							children: approvalOptionLabel(option)
+						}, option.id)),
+						rejectOptions.length === 0 && !question && /* @__PURE__ */ jsx(Button, {
+							size: "sm",
+							variant: "outline",
+							className: pressable,
+							onClick: () => respond(false),
+							disabled: locked,
+							children: "Deny"
+						}),
+						!acceptsText && dismissButton
+					]
+				}),
+				answerField,
+				errorText
+			]
+		});
+	}
+	if (question) return /* @__PURE__ */ jsxs("div", {
+		"data-slot": "tool-fallback-approval",
+		className: cn("aui-tool-fallback-approval flex flex-col gap-2 pt-1", className),
+		...props,
+		children: [
+			promptText,
+			answerField,
+			!acceptsText && dismissButton && /* @__PURE__ */ jsx("div", {
+				className: "flex items-center gap-2",
+				children: dismissButton
+			}),
+			errorText
+		]
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		"data-slot": "tool-fallback-approval",
+		className: cn("aui-tool-fallback-approval flex flex-col gap-2 pt-1", className),
+		...props,
+		children: [
+			promptText,
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center gap-2",
+				children: [/* @__PURE__ */ jsx(Button, {
+					size: "sm",
+					className: pressable,
+					onClick: () => respond(true),
+					disabled: locked,
+					children: "Allow"
+				}), /* @__PURE__ */ jsx(Button, {
+					size: "sm",
+					variant: "outline",
+					className: pressable,
+					onClick: () => respond(false),
+					disabled: locked,
+					children: "Deny"
+				})]
+			}),
+			answerField,
+			errorText
+		]
+	});
+}
+const ToolFallbackImpl = ({ toolName, argsText, result, status, addResult, resume, interrupt, approval, respondToApproval }) => {
+	const isCancelled = status?.type === "incomplete" && status.reason === "cancelled";
+	const isRequiresAction = status?.type === "requires-action";
+	const shouldRenderApproval = isRequiresAction && offersInterruptAction(status, approval, interrupt);
+	const wasDenied = approval != null && approval.approved === false;
+	const [open, setOpen] = useState(isRequiresAction);
+	const [prevRequiresAction, setPrevRequiresAction] = useState(isRequiresAction);
+	if (isRequiresAction !== prevRequiresAction) {
+		setPrevRequiresAction(isRequiresAction);
+		if (isRequiresAction) setOpen(true);
+	}
+	return /* @__PURE__ */ jsxs(ToolFallbackRoot, {
+		open,
+		onOpenChange: setOpen,
+		children: [/* @__PURE__ */ jsx(ToolFallbackTrigger, {
+			toolName,
+			status,
+			denied: wasDenied
+		}), /* @__PURE__ */ jsxs(ToolFallbackContent, { children: [
+			/* @__PURE__ */ jsx(ToolFallbackError, { status }),
+			/* @__PURE__ */ jsx(ToolFallbackArgs, {
+				argsText,
+				className: cn(isCancelled && "opacity-60")
+			}),
+			(shouldRenderApproval || isSettled(approval)) && /* @__PURE__ */ jsx(ToolFallbackApproval, {
+				addResult,
+				resume,
+				interrupt,
+				approval,
+				respondToApproval,
+				status
+			}),
+			/* @__PURE__ */ jsx(ToolFallbackResult, { result })
+		] })]
+	});
+};
+const ToolFallback = memo(ToolFallbackImpl);
+ToolFallback.displayName = "ToolFallback";
+ToolFallback.Root = ToolFallbackRoot;
+ToolFallback.Trigger = ToolFallbackTrigger;
+ToolFallback.Content = ToolFallbackContent;
+ToolFallback.Args = ToolFallbackArgs;
+ToolFallback.Result = ToolFallbackResult;
+ToolFallback.Error = ToolFallbackError;
+ToolFallback.Approval = ToolFallbackApproval;
+//#endregion
+export { ToolFallback, ToolFallbackApproval, ToolFallbackArgs, ToolFallbackContent, ToolFallbackError, ToolFallbackResult, ToolFallbackRoot, ToolFallbackTrigger, formatUnknownValue, offersInterruptAction, tool_fallback_aui_exports };

package/dist/components/assistant-ui/elements/tool-group.aui.d.ts

@@ -0,0 +1,37 @@
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "../../ui/collapsible.js";
+import { FC, PropsWithChildren } from "react";
+import { VariantProps } from "class-variance-authority";
+declare namespace tool_group_aui_d_exports {
+  export { ToolGroup, ToolGroupContent, ToolGroupRoot, ToolGroupRootProps, ToolGroupTrigger, toolGroupVariants };
+}
+declare const toolGroupVariants: (props?: ({
+  variant?: "ghost" | "muted" | "outline" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ToolGroupRootProps = Omit<React.ComponentProps<typeof Collapsible>, "open" | "onOpenChange"> & VariantProps<typeof toolGroupVariants> & {
+  open?: boolean;
+  onOpenChange?: (open: boolean) => void;
+  defaultOpen?: boolean;
+};
+declare function ToolGroupRoot({ className, variant, open: controlledOpen, onOpenChange: controlledOnOpenChange, defaultOpen, children, ...props }: ToolGroupRootProps): import("react").JSX.Element;
+declare function ToolGroupTrigger({ count, active, className, ...props }: React.ComponentProps<typeof CollapsibleTrigger> & {
+  count: number;
+  active?: boolean;
+}): import("react").JSX.Element;
+declare function ToolGroupContent({ className, children, ...props }: React.ComponentProps<typeof CollapsibleContent>): import("react").JSX.Element;
+type ToolGroupComponent = FC<PropsWithChildren<{
+  startIndex: number;
+  endIndex: number;
+}>> & {
+  Root: typeof ToolGroupRoot;
+  Trigger: typeof ToolGroupTrigger;
+  Content: typeof ToolGroupContent;
+};
+/**
+ * @deprecated This wrapper targets the legacy `components.ToolGroup` prop
+ * on `<MessagePrimitive.Parts>`. Use `<MessagePrimitive.GroupedParts>` with
+ * a `groupBy` returning `"group-tool"` and compose `ToolGroupRoot` /
+ * `ToolGroupTrigger` / `ToolGroupContent` directly. See `thread.tsx`.
+ */
+declare const ToolGroup: ToolGroupComponent;
+//#endregion
+export { ToolGroup, ToolGroupContent, ToolGroupRoot, ToolGroupTrigger, toolGroupVariants, tool_group_aui_d_exports };