@humain/ui 2.1.63 → 2.1.65

package/dist/index184.js

@@ -1,995 +1,207 @@
-import { assertNever } from "./index2.js";
-//#region src/components/organisms/ai/AIToolRun/validation.ts
-var ROOT_KEYS = /* @__PURE__ */ new Set([
-	"runId",
-	"status",
-	"header",
-	"steps",
-	"sources",
-	"actions",
-	"progress",
-	"activeStepId",
-	"error"
-]);
-var HEADER_KEYS = /* @__PURE__ */ new Set([
-	"title",
-	"description",
-	"metadata"
-]);
-var METADATA_KEYS = /* @__PURE__ */ new Set(["label", "value"]);
-var PROGRESS_KEYS = /* @__PURE__ */ new Set([
-	"value",
-	"label",
-	"meta"
-]);
-var ROOT_ERROR_KEYS = /* @__PURE__ */ new Set(["message"]);
-var SOURCE_KEYS = /* @__PURE__ */ new Set([
-	"id",
-	"url",
-	"title",
-	"description",
-	"favicon",
-	"siteName"
-]);
-var ACTION_KEYS = /* @__PURE__ */ new Set([
-	"id",
-	"kind",
-	"label",
-	"disabled",
-	"loading"
-]);
-var STEP_KEYS = /* @__PURE__ */ new Set([
-	"toolCall",
-	"title",
-	"description",
-	"progress",
-	"sourceIds",
-	"currentSourceId",
-	"durationMs"
-]);
-var TOOL_CALL_KEYS = /* @__PURE__ */ new Set([
-	"toolCallId",
-	"toolName",
-	"status",
-	"error"
-]);
-var TOOL_STATUSES = {
-	error: true,
-	pending: true,
-	running: true,
-	success: true
-};
-var RUN_STATUSES = {
-	completed: true,
-	error: true,
-	paused: true,
-	ready: true,
-	running: true
-};
-var ACTION_KINDS = {
-	custom: true,
-	dismiss: true,
-	pause: true,
-	resume: true,
-	retry: true,
-	start: true
-};
-var ACTIONS_BY_STATUS = {
-	ready: [
-		"start",
-		"dismiss",
-		"custom"
-	],
-	running: [
-		"pause",
-		"dismiss",
-		"custom"
-	],
-	paused: [
-		"resume",
-		"dismiss",
-		"custom"
-	],
-	completed: ["dismiss", "custom"],
-	error: [
-		"retry",
-		"dismiss",
-		"custom"
-	]
-};
-var STEP_KEYS_BY_STATUS = {
-	pending: /* @__PURE__ */ new Set([
-		"toolCall",
-		"title",
-		"description"
-	]),
-	running: /* @__PURE__ */ new Set([
-		"toolCall",
-		"title",
-		"description",
-		"progress",
-		"sourceIds",
-		"currentSourceId"
-	]),
-	success: /* @__PURE__ */ new Set([
-		"toolCall",
-		"title",
-		"description",
-		"durationMs",
-		"sourceIds"
-	]),
-	error: /* @__PURE__ */ new Set([
-		"toolCall",
-		"title",
-		"description",
-		"sourceIds"
-	])
-};
-var TOOL_CALL_KEYS_BY_STATUS = {
-	pending: /* @__PURE__ */ new Set([
-		"toolCallId",
-		"toolName",
-		"status"
-	]),
-	running: /* @__PURE__ */ new Set([
-		"toolCallId",
-		"toolName",
-		"status"
-	]),
-	success: /* @__PURE__ */ new Set([
-		"toolCallId",
-		"toolName",
-		"status"
-	]),
-	error: /* @__PURE__ */ new Set([
-		"toolCallId",
-		"toolName",
-		"status",
-		"error"
-	])
-};
-var MAX_JSON_DEPTH = 100;
-var MAX_JSON_NODES = 1e4;
-var MAX_VALIDATION_ISSUES = 100;
-var INSPECTION_FAILURE_MESSAGE = "Value could not be inspected safely";
-var INVALID_FIELD = Symbol("invalid-shape-field");
-function addIssue(issues, path, message) {
-	if (issues.length < MAX_VALIDATION_ISSUES) issues.push({
-		path,
-		message
+import { cn } from "./index2.js";
+import { useControllableState } from "./index12.js";
+import { AICodeBlock } from "./index146.js";
+import { cva } from "class-variance-authority";
+import { AlertCircle, Check, ChevronDown, ChevronRight, Clock, Code, Wrench } from "lucide-react";
+import * as React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { AnimatePresence, motion } from "motion/react";
+//#region src/components/organisms/ai/AIToolCall/AIToolCall.tsx
+var toolCallVariants = cva("overflow-hidden rounded-xl border transition-colors", {
+	variants: { status: {
+		pending: "border-border bg-muted",
+		running: "border-primary bg-primary/10",
+		success: "border-success/50 bg-success/10",
+		error: "border-destructive/50 bg-destructive/10"
+	} },
+	defaultVariants: { status: "pending" }
+});
+var statusIconVariants = cva("size-4", {
+	variants: { status: {
+		pending: "text-muted-foreground",
+		running: "text-primary animate-spin motion-reduce:animate-none",
+		success: "text-success",
+		error: "text-destructive"
+	} },
+	defaultVariants: { status: "pending" }
+});
+function StatusIcon({ status, className }) {
+	const iconClass = cn(statusIconVariants({ status }), className);
+	switch (status) {
+		case "running": return /* @__PURE__ */ jsx(Clock, { className: iconClass });
+		case "success": return /* @__PURE__ */ jsx(Check, { className: cn(iconClass, "delight-check-bounce motion-reduce:!animate-none") });
+		case "error": return /* @__PURE__ */ jsx(AlertCircle, { className: cn(iconClass, "delight-shake motion-reduce:!animate-none") });
+		default: return /* @__PURE__ */ jsx(Wrench, { className: iconClass });
+	}
+}
+StatusIcon.displayName = "StatusIcon";
+function AIToolCallHeader({ toolName, status, isOpen, onToggle, className }) {
+	return /* @__PURE__ */ jsxs("button", {
+		type: "button",
+		onClick: onToggle,
+		"aria-expanded": isOpen,
+		className: cn("flex items-center justify-between w-full px-4 py-3 transition-colors hover:bg-foreground/5 focus-visible:outline-2 focus-visible:outline-offset-[-2px] focus-visible:outline-ring", className),
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: "flex items-center gap-3",
+			children: [/* @__PURE__ */ jsx(StatusIcon, {
+				status,
+				"aria-hidden": "true"
+			}), /* @__PURE__ */ jsxs("div", {
+				className: "flex flex-col items-start",
+				children: [/* @__PURE__ */ jsx("span", {
+					className: "text-sm font-medium text-foreground",
+					children: toolName
+				}), /* @__PURE__ */ jsx("span", {
+					className: "text-xs text-text-quaternary",
+					children: {
+						pending: "Pending",
+						running: "Running...",
+						success: "Completed",
+						error: "Failed"
+					}[status]
+				})]
+			})]
+		}), isOpen ? /* @__PURE__ */ jsx(ChevronDown, {
+			className: "size-4 text-muted-foreground",
+			"aria-hidden": "true"
+		}) : /* @__PURE__ */ jsx(ChevronRight, {
+			className: "size-4 text-muted-foreground rtl:rotate-180",
+			"aria-hidden": "true"
+		})]
 	});
 }
-function hasIssuesSince(issues, issueCount) {
-	return issues.length > issueCount || issues.length >= MAX_VALIDATION_ISSUES;
-}
-function addInspectionIssue(issues, path) {
-	addIssue(issues, path, INSPECTION_FAILURE_MESSAGE);
-}
-function getContainerKind(value, path, issues) {
-	if (value === null || typeof value !== "object") return "other";
-	try {
-		const prototype = Reflect.getPrototypeOf(value);
-		if (Array.isArray(value)) return prototype === Array.prototype ? "array" : "other";
-		return prototype === Object.prototype || prototype === null ? "record" : "other";
-	} catch {
-		addInspectionIssue(issues, path);
-		return "uninspectable";
-	}
-}
-function getOwnKeys(value, path, issues) {
-	try {
-		return Reflect.ownKeys(value);
-	} catch {
-		addInspectionIssue(issues, path);
-		return;
-	}
-}
-function getOwnPropertyDescriptor(value, key, path, issues) {
-	try {
-		return Reflect.getOwnPropertyDescriptor(value, key);
-	} catch {
-		addInspectionIssue(issues, path);
-		return null;
-	}
-}
-function readEnumerableDataDescriptor(_value, _key, descriptor, path, issues) {
-	if (!descriptor.enumerable || !Object.hasOwn(descriptor, "value")) {
-		addIssue(issues, path, "Value must be an own enumerable data property");
-		return { valid: false };
-	}
-	return {
-		valid: true,
-		value: descriptor.value
-	};
+AIToolCallHeader.displayName = "AIToolCallHeader";
+function ToolCallSection({ title, icon, children, className }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("space-y-2", className),
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: "flex items-center gap-2 text-xs font-medium text-text-quaternary uppercase tracking-wide",
+			children: [icon, title]
+		}), children]
+	});
 }
-function findReflectedPropertyDescriptor(value, key, path, issues) {
-	const visited = /* @__PURE__ */ new Set();
-	let current = value;
-	let isOwn = true;
-	while (current !== null) {
-		if (visited.has(current)) {
-			addInspectionIssue(issues, path);
-			return null;
-		}
-		visited.add(current);
-		const descriptor = getOwnPropertyDescriptor(current, key, path, issues);
-		if (descriptor === null) return null;
-		if (descriptor !== void 0) {
-			if (isOwn) {
-				const ownKeys = getOwnKeys(value, path, issues);
-				if (!ownKeys) return null;
-				if (!ownKeys.includes(key)) {
-					addIssue(issues, path, "Own property must be exposed by Reflect.ownKeys");
-					return null;
-				}
-			}
-			return {
-				descriptor,
-				isOwn
-			};
-		}
-		try {
-			current = Reflect.getPrototypeOf(current);
-		} catch {
-			addInspectionIssue(issues, path);
-			return null;
-		}
-		isOwn = false;
-	}
+ToolCallSection.displayName = "ToolCallSection";
+function formatValue(value) {
+	if (typeof value === "string") return value;
+	return JSON.stringify(value, null, 2);
 }
-function inspectProperty(value, key, path, issues) {
-	const descriptor = findReflectedPropertyDescriptor(value, key, path, issues);
-	if (descriptor === null) return void 0;
-	if (descriptor !== void 0) return {
-		kind: "descriptor",
-		...descriptor
+function AIToolCall({ toolPart, defaultOpen = false, open: controlledOpen, onOpenChange, className }) {
+	const [isOpen, setIsOpen] = useControllableState({
+		value: controlledOpen,
+		defaultValue: defaultOpen,
+		onChange: onOpenChange
+	});
+	const status = toolPart.status || "pending";
+	const handleToggle = () => {
+		setIsOpen(!isOpen);
 	};
-	let present;
-	try {
-		present = Reflect.has(value, key);
-	} catch {
-		addInspectionIssue(issues, path);
-		return;
-	}
-	if (present) return { kind: "synthetic" };
-	let visibleValue;
-	try {
-		visibleValue = Reflect.get(value, key);
-	} catch {
-		addInspectionIssue(issues, path);
-		return;
-	}
-	return present || visibleValue !== void 0 ? { kind: "synthetic" } : { kind: "absent" };
-}
-function readShapeField(value, key, path, issues) {
-	const inspection = inspectProperty(value, key, path, issues);
-	if (!inspection) return INVALID_FIELD;
-	if (inspection.kind === "absent") return;
-	if (inspection.kind === "synthetic" || !inspection.isOwn) {
-		addIssue(issues, path, "Value must be an own enumerable data property");
-		return INVALID_FIELD;
-	}
-	const field = readEnumerableDataDescriptor(value, key, inspection.descriptor, path, issues);
-	return field.valid ? field.value : INVALID_FIELD;
-}
-function readRequiredField(value, key, path, issues) {
-	return readShapeField(value, key, path, issues);
-}
-function readOptionalField(value, key, path, issues) {
-	return readShapeField(value, key, path, issues);
-}
-function isInvalidField(value) {
-	return value === INVALID_FIELD;
-}
-function getOwnEnumerableDataKeys(value, path, issues) {
-	const keys = getOwnKeys(value, path, issues);
-	if (!keys) return void 0;
-	if (keys.length > MAX_JSON_NODES) {
-		addIssue(issues, path, "Value exceeds the maximum JSON node limit");
-		return;
-	}
-	const stringKeys = [];
-	for (const key of keys) {
-		const keyPath = typeof key === "string" ? `${path}.${key}` : path;
-		const descriptor = getOwnPropertyDescriptor(value, key, keyPath, issues);
-		if (descriptor === null) return void 0;
-		if (descriptor === void 0) {
-			addInspectionIssue(issues, keyPath);
-			return;
-		}
-		if (typeof key !== "string") {
-			addIssue(issues, path, "Symbol keys are not JSON-safe");
-			continue;
-		}
-		if (!readEnumerableDataDescriptor(value, key, descriptor, keyPath, issues).valid) continue;
-		stringKeys.push(key);
-	}
-	return stringKeys;
-}
-function isArrayIndexKey(key) {
-	const index = Number(key);
-	if (!Number.isInteger(index) || index < 0 || index >= 2 ** 32 - 1 || String(index) !== key) return;
-	return index;
-}
-function readArrayLength(_value, descriptor, path, issues) {
-	if (descriptor.enumerable || !Object.hasOwn(descriptor, "value") || typeof descriptor.value !== "number" || !Number.isInteger(descriptor.value) || descriptor.value < 0 || descriptor.value > 2 ** 32 - 1) {
-		addIssue(issues, path, "Array length must be a valid data property");
-		return;
-	}
-	return descriptor.value;
-}
-function readArrayItems(value, path, issues) {
-	const issueCount = issues.length;
-	const keys = getOwnKeys(value, path, issues);
-	if (!keys) return void 0;
-	if (keys.length > 10001) {
-		addIssue(issues, path, "Value exceeds the maximum JSON node limit");
-		return;
-	}
-	let length;
-	const items = /* @__PURE__ */ new Map();
-	for (const key of keys) {
-		const keyPath = typeof key === "string" ? `${path}.${key}` : path;
-		const descriptor = getOwnPropertyDescriptor(value, key, keyPath, issues);
-		if (descriptor === null) return void 0;
-		if (descriptor === void 0) {
-			addInspectionIssue(issues, keyPath);
-			return;
-		}
-		if (typeof key !== "string") {
-			addIssue(issues, path, "Symbol keys are not JSON-safe");
-			continue;
-		}
-		if (key === "length") {
-			length = readArrayLength(value, descriptor, path, issues);
-			continue;
-		}
-		const index = isArrayIndexKey(key);
-		if (index === void 0) {
-			addIssue(issues, keyPath, "Arrays must not contain custom properties");
-			continue;
-		}
-		const item = readEnumerableDataDescriptor(value, key, descriptor, `${path}[${index}]`, issues);
-		if (item.valid) items.set(index, item.value);
-	}
-	if (length === void 0) {
-		if (!hasIssuesSince(issues, issueCount)) addInspectionIssue(issues, path);
-		return;
-	}
-	if (length > MAX_JSON_NODES) {
-		addIssue(issues, path, "Array length exceeds the maximum JSON node limit");
-		return;
-	}
-	const orderedItems = [...items.entries()].sort(([left], [right]) => left - right);
-	let expectedIndex = 0;
-	for (const [index] of orderedItems) {
-		if (index !== expectedIndex) {
-			addIssue(issues, `${path}[${expectedIndex}]`, "Array holes are not JSON-safe");
-			return;
-		}
-		expectedIndex += 1;
-	}
-	if (expectedIndex !== length) {
-		addIssue(issues, `${path}[${expectedIndex}]`, "Array holes are not JSON-safe");
-		return;
-	}
-	if (hasIssuesSince(issues, issueCount)) return void 0;
-	return orderedItems.map(([index, item]) => ({
-		index,
-		value: item
-	}));
-}
-function readObjectChildren(value, path, issues) {
-	const issueCount = issues.length;
-	const keys = getOwnKeys(value, path, issues);
-	if (!keys) return void 0;
-	if (keys.length > MAX_JSON_NODES) {
-		addIssue(issues, path, "Value exceeds the maximum JSON node limit");
-		return;
-	}
-	const children = [];
-	for (const key of keys) {
-		const keyPath = typeof key === "string" ? `${path}.${key}` : path;
-		const descriptor = getOwnPropertyDescriptor(value, key, keyPath, issues);
-		if (descriptor === null) return void 0;
-		if (descriptor === void 0) {
-			addInspectionIssue(issues, keyPath);
-			return;
-		}
-		if (typeof key !== "string") {
-			addIssue(issues, path, "Symbol keys are not JSON-safe");
-			continue;
-		}
-		const child = readEnumerableDataDescriptor(value, key, descriptor, keyPath, issues);
-		if (child.valid) children.push({
-			path: keyPath,
-			value: child.value
-		});
-	}
-	return hasIssuesSince(issues, issueCount) ? void 0 : children;
-}
-function rejectUnknownKeys(value, allowed, path, issues) {
-	const keys = getOwnEnumerableDataKeys(value, path, issues);
-	if (!keys) return;
-	for (const key of keys) if (!allowed.has(key)) addIssue(issues, `${path}.${key}`, `Unknown key "${key}"`);
-}
-function rejectDisallowedKeys(value, known, allowed, path, issues) {
-	for (const key of known) if (!allowed.has(key)) {
-		const inspection = inspectProperty(value, key, `${path}.${key}`, issues);
-		if (!inspection) return;
-		if (inspection.kind === "absent") continue;
-		addIssue(issues, `${path}.${key}`, "Field is not allowed for this status");
-	}
-}
-function rejectPresentKeys(value, keys, path, issues) {
-	for (const key of keys) {
-		const inspection = inspectProperty(value, key, `${path}.${key}`, issues);
-		if (!inspection) return;
-		if (inspection.kind === "absent") continue;
-		addIssue(issues, `${path}.${key}`, "Field is not allowed for this status");
-	}
-}
-function isFiniteNumber(value) {
-	return typeof value === "number" && Number.isFinite(value);
-}
-function hasSafeToJSON(value, path, issues) {
-	const descriptor = findReflectedPropertyDescriptor(value, "toJSON", path, issues);
-	if (descriptor === null) return false;
-	if (descriptor !== void 0) {
-		addIssue(issues, path, "Value must not define toJSON");
-		return false;
-	}
-	return true;
+	return /* @__PURE__ */ jsxs("div", {
+		"data-slot": "ai-tool-call",
+		className: cn(toolCallVariants({ status }), className),
+		children: [/* @__PURE__ */ jsx(AIToolCallHeader, {
+			toolName: toolPart.toolName,
+			status,
+			isOpen,
+			onToggle: handleToggle
+		}), /* @__PURE__ */ jsx(AnimatePresence, { children: isOpen && /* @__PURE__ */ jsx(motion.div, {
+			initial: {
+				height: 0,
+				opacity: 0
+			},
+			animate: {
+				height: "auto",
+				opacity: 1
+			},
+			exit: {
+				height: 0,
+				opacity: 0
+			},
+			transition: { duration: .2 },
+			className: "overflow-hidden",
+			children: /* @__PURE__ */ jsxs("div", {
+				className: "px-4 pb-4 space-y-4",
+				children: [
+					/* @__PURE__ */ jsxs("div", {
+						className: "text-xs text-muted-foreground font-mono",
+						children: ["ID: ", toolPart.toolCallId]
+					}),
+					toolPart.args && Object.keys(toolPart.args).length > 0 && /* @__PURE__ */ jsx(ToolCallSection, {
+						title: "Input",
+						icon: /* @__PURE__ */ jsx(Code, { className: "size-3" }),
+						children: /* @__PURE__ */ jsx(AICodeBlock, {
+							code: formatValue(toolPart.args),
+							language: "json",
+							showHeader: false,
+							showCopyButton: true,
+							size: "sm"
+						})
+					}),
+					toolPart.result !== void 0 && /* @__PURE__ */ jsx(ToolCallSection, {
+						title: "Output",
+						icon: /* @__PURE__ */ jsx(Code, { className: "size-3" }),
+						children: /* @__PURE__ */ jsx(AICodeBlock, {
+							code: formatValue(toolPart.result),
+							language: "json",
+							showHeader: false,
+							showCopyButton: true,
+							size: "sm"
+						})
+					}),
+					toolPart.error && /* @__PURE__ */ jsx("div", {
+						className: "p-3 rounded-lg bg-destructive/20 border border-destructive/50",
+						children: /* @__PURE__ */ jsxs("div", {
+							className: "flex items-start gap-2",
+							children: [/* @__PURE__ */ jsx(AlertCircle, { className: "size-4 text-destructive mt-0.5 shrink-0" }), /* @__PURE__ */ jsx("p", {
+								className: "text-sm text-destructive",
+								children: toolPart.error
+							})]
+						})
+					})
+				]
+			})
+		}) })]
+	});
 }
-function validateJsonSafe(value, path, issues) {
-	const ancestors = /* @__PURE__ */ new Set();
-	const stack = [{
-		kind: "visit",
-		value,
-		path,
-		depth: 0
-	}];
-	let nodeCount = 0;
-	while (stack.length > 0 && issues.length < MAX_VALIDATION_ISSUES) {
-		const frame = stack.pop();
-		if (!frame) break;
-		if (frame.kind === "leave") {
-			ancestors.delete(frame.value);
-			continue;
-		}
-		if (frame.depth > MAX_JSON_DEPTH) {
-			addIssue(issues, frame.path, "Value exceeds the maximum JSON depth limit");
-			continue;
-		}
-		nodeCount += 1;
-		if (nodeCount > MAX_JSON_NODES) {
-			addIssue(issues, frame.path, "Value exceeds the maximum JSON node limit");
-			break;
-		}
-		const currentValue = frame.value;
-		if (currentValue === void 0 || typeof currentValue === "function" || typeof currentValue === "symbol" || typeof currentValue === "bigint") {
-			addIssue(issues, frame.path, "Value must be JSON-safe");
-			continue;
-		}
-		if (typeof currentValue === "number" && !isFiniteNumber(currentValue)) {
-			addIssue(issues, frame.path, "Number must be finite");
-			continue;
-		}
-		if (currentValue === null || typeof currentValue !== "object") continue;
-		if (ancestors.has(currentValue)) {
-			addIssue(issues, frame.path, "Value must not contain cycles");
-			continue;
-		}
-		const containerKind = getContainerKind(currentValue, frame.path, issues);
-		if (containerKind === "uninspectable") continue;
-		if (containerKind === "other") {
-			addIssue(issues, frame.path, "Value must contain only plain objects and arrays");
-			continue;
-		}
-		if (!hasSafeToJSON(currentValue, frame.path, issues)) continue;
-		ancestors.add(currentValue);
-		stack.push({
-			kind: "leave",
-			value: currentValue
+AIToolCall.displayName = "AIToolCall";
+function normalizeOpenToolCallIds(ids, toolCalls) {
+	const requested = new Set(ids);
+	return toolCalls.flatMap((toolCall) => requested.has(toolCall.toolCallId) ? [toolCall.toolCallId] : []);
+}
+function areToolCallIdsEqual(left, right) {
+	return left.length === right.length && left.every((id, index) => id === right[index]);
+}
+function AIToolCallList({ toolCalls, defaultAllOpen = false, defaultOpenToolCallIds = [], openToolCallIds: controlledOpenToolCallIds, onOpenToolCallIdsChange, className }) {
+	const isControlled = controlledOpenToolCallIds !== void 0;
+	const [uncontrolledOpenToolCallIds, setUncontrolledOpenToolCallIds] = React.useState(() => normalizeOpenToolCallIds(defaultAllOpen ? toolCalls.map((toolCall) => toolCall.toolCallId) : defaultOpenToolCallIds, toolCalls));
+	const visibleOpenToolCallIds = normalizeOpenToolCallIds(isControlled ? controlledOpenToolCallIds : uncontrolledOpenToolCallIds, toolCalls);
+	const openSet = new Set(visibleOpenToolCallIds);
+	React.useLayoutEffect(() => {
+		if (isControlled) return;
+		setUncontrolledOpenToolCallIds((current) => {
+			const normalized = normalizeOpenToolCallIds(current, toolCalls);
+			return areToolCallIdsEqual(current, normalized) ? current : normalized;
 		});
-		if (containerKind === "array") {
-			const children = readArrayItems(currentValue, frame.path, issues);
-			if (!children) continue;
-			for (let index = children.length - 1; index >= 0; index -= 1) {
-				const child = children[index];
-				stack.push({
-					kind: "visit",
-					value: child.value,
-					path: `${frame.path}[${child.index}]`,
-					depth: frame.depth + 1
-				});
-			}
-			continue;
-		}
-		const children = readObjectChildren(currentValue, frame.path, issues);
-		if (!children) continue;
-		for (let index = children.length - 1; index >= 0; index -= 1) {
-			const child = children[index];
-			stack.push({
-				kind: "visit",
-				value: child.value,
-				path: child.path,
-				depth: frame.depth + 1
-			});
-		}
-	}
-}
-var INVALID_JSON_SNAPSHOT = Symbol("invalid-json-snapshot");
-function captureJsonSnapshot(value, path, issues) {
-	const ancestors = /* @__PURE__ */ new Set();
-	const snapshots = /* @__PURE__ */ new Map();
-	let nodeCount = 0;
-	function capture(currentValue, currentPath, depth) {
-		if (issues.length >= MAX_VALIDATION_ISSUES) return INVALID_JSON_SNAPSHOT;
-		if (depth > MAX_JSON_DEPTH) {
-			addIssue(issues, currentPath, "Value exceeds the maximum JSON depth limit");
-			return INVALID_JSON_SNAPSHOT;
-		}
-		nodeCount += 1;
-		if (nodeCount > MAX_JSON_NODES) {
-			addIssue(issues, currentPath, "Value exceeds the maximum JSON node limit");
-			return INVALID_JSON_SNAPSHOT;
-		}
-		if (currentValue === void 0 || typeof currentValue === "function" || typeof currentValue === "symbol" || typeof currentValue === "bigint") {
-			addIssue(issues, currentPath, "Value must be JSON-safe");
-			return INVALID_JSON_SNAPSHOT;
-		}
-		if (typeof currentValue === "number" && !isFiniteNumber(currentValue)) {
-			addIssue(issues, currentPath, "Number must be finite");
-			return INVALID_JSON_SNAPSHOT;
-		}
-		if (currentValue === null || typeof currentValue !== "object") return currentValue;
-		if (ancestors.has(currentValue)) {
-			addIssue(issues, currentPath, "Value must not contain cycles");
-			return INVALID_JSON_SNAPSHOT;
-		}
-		const containerKind = getContainerKind(currentValue, currentPath, issues);
-		if (containerKind === "uninspectable") return INVALID_JSON_SNAPSHOT;
-		if (containerKind === "other") {
-			addIssue(issues, currentPath, "Value must contain only plain objects and arrays");
-			return INVALID_JSON_SNAPSHOT;
-		}
-		if (!hasSafeToJSON(currentValue, currentPath, issues)) return INVALID_JSON_SNAPSHOT;
-		const existingSnapshot = snapshots.get(currentValue);
-		if (existingSnapshot !== void 0) return existingSnapshot;
-		ancestors.add(currentValue);
-		try {
-			if (containerKind === "array") {
-				const items = readArrayItems(currentValue, currentPath, issues);
-				if (!items) return INVALID_JSON_SNAPSHOT;
-				const snapshot = new Array(items.length);
-				snapshots.set(currentValue, snapshot);
-				for (const item of items) {
-					const capturedItem = capture(item.value, `${currentPath}[${item.index}]`, depth + 1);
-					if (capturedItem === INVALID_JSON_SNAPSHOT) return INVALID_JSON_SNAPSHOT;
-					snapshot[item.index] = capturedItem;
-				}
-				return snapshot;
-			}
-			const children = readObjectChildren(currentValue, currentPath, issues);
-			if (!children) return INVALID_JSON_SNAPSHOT;
-			const snapshot = Object.create(null);
-			snapshots.set(currentValue, snapshot);
-			for (const child of children) {
-				const key = child.path.slice(currentPath.length + 1);
-				const capturedChild = capture(child.value, child.path, depth + 1);
-				if (capturedChild === INVALID_JSON_SNAPSHOT) return INVALID_JSON_SNAPSHOT;
-				Object.defineProperty(snapshot, key, {
-					configurable: true,
-					enumerable: true,
-					value: capturedChild,
-					writable: true
-				});
-			}
-			return snapshot;
-		} finally {
-			ancestors.delete(currentValue);
-		}
-	}
-	return capture(value, path, 0);
-}
-function requireRecord(value, path, issues) {
-	if (isInvalidField(value)) return void 0;
-	const containerKind = getContainerKind(value, path, issues);
-	if (containerKind !== "record") {
-		if (containerKind !== "uninspectable") addIssue(issues, path, "Value must be a plain object");
-		return;
-	}
-	return value;
-}
-function requireString(value, path, issues) {
-	if (isInvalidField(value)) return void 0;
-	if (typeof value !== "string") {
-		addIssue(issues, path, "Value must be a string");
-		return;
-	}
-	return value;
-}
-function requireNonEmptyString(value, path, issues) {
-	const stringValue = requireString(value, path, issues);
-	if (stringValue !== void 0 && stringValue.length === 0) {
-		addIssue(issues, path, "Value must not be empty");
-		return;
-	}
-	return stringValue;
-}
-function requireNonWhitespaceString(value, path, issues) {
-	const stringValue = requireString(value, path, issues);
-	if (stringValue !== void 0 && stringValue.trim().length === 0) {
-		addIssue(issues, path, "Value must be non-whitespace");
-		return;
-	}
-	return stringValue;
-}
-function requireBoolean(value, path, issues) {
-	if (isInvalidField(value)) return void 0;
-	if (typeof value !== "boolean") {
-		addIssue(issues, path, "Value must be a boolean");
-		return;
-	}
-	return value;
-}
-function requireNumber(value, path, issues) {
-	if (isInvalidField(value)) return void 0;
-	if (typeof value !== "number") {
-		addIssue(issues, path, "Value must be a number");
-		return;
-	}
-	return value;
-}
-function requireArray(value, path, issues) {
-	if (isInvalidField(value)) return void 0;
-	try {
-		if (Array.isArray(value)) return value;
-	} catch {
-		addInspectionIssue(issues, path);
-		return;
-	}
-	addIssue(issues, path, "Value must be an array");
-}
-function requireRunStatus(value, path, issues) {
-	if (isInvalidField(value)) return void 0;
-	if (typeof value !== "string" || !Object.hasOwn(RUN_STATUSES, value)) {
-		addIssue(issues, path, "Value must be a supported run status");
-		return;
-	}
-	return value;
-}
-function requireToolStatus(value, path, issues) {
-	if (isInvalidField(value)) return void 0;
-	if (typeof value !== "string" || !Object.hasOwn(TOOL_STATUSES, value)) {
-		addIssue(issues, path, "Value is not allowed as a tool status");
-		return;
-	}
-	return value;
-}
-function requireActionKind(value, path, issues) {
-	if (isInvalidField(value)) return void 0;
-	if (typeof value !== "string" || !Object.hasOwn(ACTION_KINDS, value)) {
-		addIssue(issues, path, "Value must be an allowed action kind");
-		return;
-	}
-	return value;
-}
-function validateProgress(value, path, issues) {
-	const progress = requireRecord(value, path, issues);
-	if (!progress) return;
-	rejectUnknownKeys(progress, PROGRESS_KEYS, path, issues);
-	const progressValue = requireNumber(readRequiredField(progress, "value", `${path}.value`, issues), `${path}.value`, issues);
-	if (progressValue !== void 0 && (progressValue < 0 || progressValue > 100)) addIssue(issues, `${path}.value`, "Value must be between 0 and 100");
-	const label = readOptionalField(progress, "label", `${path}.label`, issues);
-	if (label !== void 0 && !isInvalidField(label)) requireNonWhitespaceString(label, `${path}.label`, issues);
-	const meta = readOptionalField(progress, "meta", `${path}.meta`, issues);
-	if (meta !== void 0 && !isInvalidField(meta)) requireString(meta, `${path}.meta`, issues);
-}
-function validateStringArray(value, path, issues) {
-	const issueCount = issues.length;
-	const values = requireArray(value, path, issues);
-	if (!values) return void 0;
-	const items = readArrayItems(values, path, issues);
-	if (!items) return void 0;
-	const strings = [];
-	for (const item of items) {
-		const stringValue = requireString(item.value, `${path}[${item.index}]`, issues);
-		if (stringValue !== void 0) strings.push(stringValue);
-	}
-	return hasIssuesSince(issues, issueCount) ? void 0 : strings;
-}
-function validateToolCall(value, path, issues) {
-	const issueCount = issues.length;
-	const toolCall = requireRecord(value, path, issues);
-	if (!toolCall) return void 0;
-	rejectUnknownKeys(toolCall, TOOL_CALL_KEYS, path, issues);
-	const toolCallId = requireNonEmptyString(readRequiredField(toolCall, "toolCallId", `${path}.toolCallId`, issues), `${path}.toolCallId`, issues);
-	requireNonWhitespaceString(readRequiredField(toolCall, "toolName", `${path}.toolName`, issues), `${path}.toolName`, issues);
-	const status = requireToolStatus(readRequiredField(toolCall, "status", `${path}.status`, issues), `${path}.status`, issues);
-	if (!status) return void 0;
-	rejectDisallowedKeys(toolCall, TOOL_CALL_KEYS, TOOL_CALL_KEYS_BY_STATUS[status], path, issues);
-	if (status === "error") {
-		const error = readRequiredField(toolCall, "error", `${path}.error`, issues);
-		if (error === void 0) addIssue(issues, `${path}.error`, "Value is required for error tool calls");
-		else if (!isInvalidField(error)) requireNonWhitespaceString(error, `${path}.error`, issues);
-	}
-	if (hasIssuesSince(issues, issueCount) || !toolCallId) return void 0;
-	return {
-		toolCallId,
-		status
-	};
-}
-function validateStep(value, path, issues) {
-	const issueCount = issues.length;
-	const step = requireRecord(value, path, issues);
-	if (!step) return void 0;
-	rejectUnknownKeys(step, STEP_KEYS, path, issues);
-	const title = readOptionalField(step, "title", `${path}.title`, issues);
-	if (title !== void 0 && !isInvalidField(title)) requireString(title, `${path}.title`, issues);
-	const description = readOptionalField(step, "description", `${path}.description`, issues);
-	if (description !== void 0 && !isInvalidField(description)) requireString(description, `${path}.description`, issues);
-	const toolCall = validateToolCall(readRequiredField(step, "toolCall", `${path}.toolCall`, issues), `${path}.toolCall`, issues);
-	if (!toolCall) return void 0;
-	const { status } = toolCall;
-	rejectDisallowedKeys(step, STEP_KEYS, STEP_KEYS_BY_STATUS[status], path, issues);
-	const progress = readOptionalField(step, "progress", `${path}.progress`, issues);
-	if (progress !== void 0 && !isInvalidField(progress)) validateProgress(progress, `${path}.progress`, issues);
-	const sourceIdsField = readOptionalField(step, "sourceIds", `${path}.sourceIds`, issues);
-	const sourceIds = sourceIdsField === void 0 || isInvalidField(sourceIdsField) ? void 0 : validateStringArray(sourceIdsField, `${path}.sourceIds`, issues);
-	const currentSourceIdField = readOptionalField(step, "currentSourceId", `${path}.currentSourceId`, issues);
-	const currentSourceId = currentSourceIdField === void 0 || isInvalidField(currentSourceIdField) ? void 0 : requireString(currentSourceIdField, `${path}.currentSourceId`, issues);
-	const durationMsField = readOptionalField(step, "durationMs", `${path}.durationMs`, issues);
-	if (durationMsField !== void 0 && !isInvalidField(durationMsField)) {
-		const durationMs = requireNumber(durationMsField, `${path}.durationMs`, issues);
-		if (durationMs !== void 0 && durationMs < 0) addIssue(issues, `${path}.durationMs`, "Value must be non-negative");
-	}
-	if (hasIssuesSince(issues, issueCount)) return void 0;
-	return {
-		toolCall,
-		...sourceIds === void 0 ? {} : { sourceIds },
-		...currentSourceId === void 0 ? {} : { currentSourceId }
+	}, [isControlled, toolCalls]);
+	const setToolCallOpen = (toolCallId, open) => {
+		const next = new Set(visibleOpenToolCallIds);
+		if (open) next.add(toolCallId);
+		else next.delete(toolCallId);
+		const normalized = normalizeOpenToolCallIds([...next], toolCalls);
+		if (!isControlled) setUncontrolledOpenToolCallIds(normalized);
+		onOpenToolCallIdsChange?.([...normalized]);
 	};
+	return /* @__PURE__ */ jsx("div", {
+		"data-slot": "ai-tool-call-list",
+		className: cn("space-y-2", className),
+		children: toolCalls.map((toolCall) => /* @__PURE__ */ jsx(AIToolCall, {
+			toolPart: toolCall,
+			open: openSet.has(toolCall.toolCallId),
+			onOpenChange: (open) => setToolCallOpen(toolCall.toolCallId, open)
+		}, toolCall.toolCallId))
+	});
 }
-function validateSource(value, path, issues) {
-	const issueCount = issues.length;
-	const source = requireRecord(value, path, issues);
-	if (!source) return void 0;
-	rejectUnknownKeys(source, SOURCE_KEYS, path, issues);
-	const id = requireNonEmptyString(readRequiredField(source, "id", `${path}.id`, issues), `${path}.id`, issues);
-	requireNonWhitespaceString(readRequiredField(source, "url", `${path}.url`, issues), `${path}.url`, issues);
-	for (const key of [
-		"title",
-		"description",
-		"favicon",
-		"siteName"
-	]) {
-		const field = readOptionalField(source, key, `${path}.${key}`, issues);
-		if (field !== void 0 && !isInvalidField(field)) requireString(field, `${path}.${key}`, issues);
-	}
-	return hasIssuesSince(issues, issueCount) || !id ? void 0 : id;
-}
-function validateSources(value, path, issues) {
-	const sourceIds = /* @__PURE__ */ new Set();
-	const sources = requireArray(value, path, issues);
-	if (!sources) return sourceIds;
-	const sourceItems = readArrayItems(sources, path, issues);
-	if (!sourceItems) return sourceIds;
-	for (const item of sourceItems) {
-		const sourcePath = `${path}[${item.index}]`;
-		const sourceId = validateSource(item.value, sourcePath, issues);
-		if (!sourceId) continue;
-		if (sourceIds.has(sourceId)) {
-			addIssue(issues, `${sourcePath}.id`, "duplicate source ID");
-			continue;
-		}
-		sourceIds.add(sourceId);
-	}
-	return sourceIds;
-}
-function validateAction(value, path, issues) {
-	const issueCount = issues.length;
-	const action = requireRecord(value, path, issues);
-	if (!action) return void 0;
-	rejectUnknownKeys(action, ACTION_KEYS, path, issues);
-	const id = requireNonEmptyString(readRequiredField(action, "id", `${path}.id`, issues), `${path}.id`, issues);
-	const kind = requireActionKind(readRequiredField(action, "kind", `${path}.kind`, issues), `${path}.kind`, issues);
-	if (!kind) return void 0;
-	const label = kind === "custom" ? readRequiredField(action, "label", `${path}.label`, issues) : readOptionalField(action, "label", `${path}.label`, issues);
-	if (kind === "custom" && label === void 0) addIssue(issues, `${path}.label`, "Value is required for custom actions");
-	else if (label !== void 0 && !isInvalidField(label)) requireNonWhitespaceString(label, `${path}.label`, issues);
-	const disabled = readOptionalField(action, "disabled", `${path}.disabled`, issues);
-	if (disabled !== void 0 && !isInvalidField(disabled)) requireBoolean(disabled, `${path}.disabled`, issues);
-	const loading = readOptionalField(action, "loading", `${path}.loading`, issues);
-	if (loading !== void 0 && !isInvalidField(loading)) requireBoolean(loading, `${path}.loading`, issues);
-	return hasIssuesSince(issues, issueCount) || !id ? void 0 : {
-		id,
-		kind
-	};
-}
-function validateActions(value, path, status, issues) {
-	const actions = requireArray(value, path, issues);
-	if (!actions) return;
-	const actionItems = readArrayItems(actions, path, issues);
-	if (!actionItems) return;
-	const actionIds = /* @__PURE__ */ new Set();
-	for (const item of actionItems) {
-		const actionPath = `${path}[${item.index}]`;
-		const action = validateAction(item.value, actionPath, issues);
-		if (!action) continue;
-		if (actionIds.has(action.id)) addIssue(issues, `${actionPath}.id`, "duplicate action ID");
-		else actionIds.add(action.id);
-		if (status && !ACTIONS_BY_STATUS[status].includes(action.kind)) addIssue(issues, `${actionPath}.kind`, `Action kind "${action.kind}" is not allowed for ${status} runs`);
-	}
-}
-function validateLifecycle(status, steps, issues) {
-	const statuses = steps.map((step) => step.toolCall.status);
-	switch (status) {
-		case "ready":
-			if (statuses.some((stepStatus) => stepStatus !== "pending")) addIssue(issues, "$.steps", "Ready runs allow pending steps only");
-			return;
-		case "running":
-		case "paused":
-			if (statuses.some((stepStatus) => stepStatus !== "pending" && stepStatus !== "running" && stepStatus !== "success") || !statuses.includes("running")) addIssue(issues, "$.steps", `${status} runs require at least one running step and allow pending, running, or success only`);
-			return;
-		case "completed":
-			if (steps.length === 0 || statuses.some((stepStatus) => stepStatus !== "success")) addIssue(issues, "$.steps", "Completed runs require a non-empty all-success step list");
-			return;
-		case "error":
-			if (statuses.some((stepStatus) => stepStatus !== "pending" && stepStatus !== "success" && stepStatus !== "error")) addIssue(issues, "$.steps", "Error runs allow pending, success, or error steps only");
-			return;
-		default: assertNever(status);
-	}
-}
-function validateSourceReferences(steps, sourceIds, issues) {
-	for (const [stepIndex, step] of steps.entries()) {
-		const sourceIdPath = `$.steps[${stepIndex}].sourceIds`;
-		const stepSourceIds = step.sourceIds;
-		if (stepSourceIds) {
-			for (const [sourceIndex, sourceId] of stepSourceIds.entries()) if (!sourceIds.has(sourceId)) addIssue(issues, `${sourceIdPath}[${sourceIndex}]`, "Unknown source reference");
-		}
-		const currentSourceId = step.currentSourceId;
-		if (currentSourceId === void 0) continue;
-		const currentSourcePath = `$.steps[${stepIndex}].currentSourceId`;
-		if (!sourceIds.has(currentSourceId)) addIssue(issues, currentSourcePath, "Unknown current source reference");
-		else if (!stepSourceIds?.includes(currentSourceId)) addIssue(issues, currentSourcePath, "Current source ID must be included in sourceIds");
-	}
-}
-function validateActiveStepReference(status, activeStepId, steps, issues) {
-	if (status !== "running" && status !== "paused" || activeStepId === void 0) return;
-	if (!steps.some((step) => step.toolCall.status === "running" && step.toolCall.toolCallId === activeStepId)) addIssue(issues, "$.activeStepId", "Active step ID must reference a running step");
-}
-function validateMetadata(value, path, issues) {
-	const metadata = requireArray(value, path, issues);
-	if (!metadata) return;
-	const metadataItems = readArrayItems(metadata, path, issues);
-	if (!metadataItems) return;
-	for (const item of metadataItems) {
-		const itemPath = `${path}[${item.index}]`;
-		const record = requireRecord(item.value, itemPath, issues);
-		if (!record) continue;
-		rejectUnknownKeys(record, METADATA_KEYS, itemPath, issues);
-		requireNonWhitespaceString(readRequiredField(record, "label", `${itemPath}.label`, issues), `${itemPath}.label`, issues);
-		requireString(readRequiredField(record, "value", `${itemPath}.value`, issues), `${itemPath}.value`, issues);
-	}
-}
-function validateHeader(value, path, issues) {
-	const header = requireRecord(value, path, issues);
-	if (!header) return;
-	rejectUnknownKeys(header, HEADER_KEYS, path, issues);
-	requireNonWhitespaceString(readRequiredField(header, "title", `${path}.title`, issues), `${path}.title`, issues);
-	const description = readOptionalField(header, "description", `${path}.description`, issues);
-	if (description !== void 0 && !isInvalidField(description)) requireString(description, `${path}.description`, issues);
-	const metadata = readOptionalField(header, "metadata", `${path}.metadata`, issues);
-	if (metadata !== void 0 && !isInvalidField(metadata)) validateMetadata(metadata, `${path}.metadata`, issues);
-}
-function validateStateFields(status, snapshot, issues) {
-	switch (status) {
-		case "ready":
-		case "completed":
-			rejectPresentKeys(snapshot, [
-				"progress",
-				"activeStepId",
-				"error"
-			], "$", issues);
-			return;
-		case "running":
-		case "paused": {
-			rejectPresentKeys(snapshot, ["error"], "$", issues);
-			const progress = readOptionalField(snapshot, "progress", "$.progress", issues);
-			if (progress !== void 0 && !isInvalidField(progress)) validateProgress(progress, "$.progress", issues);
-			const activeStepId = readOptionalField(snapshot, "activeStepId", "$.activeStepId", issues);
-			return activeStepId === void 0 || isInvalidField(activeStepId) ? void 0 : requireString(activeStepId, "$.activeStepId", issues);
-		}
-		case "error": {
-			rejectPresentKeys(snapshot, ["activeStepId"], "$", issues);
-			const progress = readOptionalField(snapshot, "progress", "$.progress", issues);
-			if (progress !== void 0 && !isInvalidField(progress)) validateProgress(progress, "$.progress", issues);
-			const error = requireRecord(readRequiredField(snapshot, "error", "$.error", issues), "$.error", issues);
-			if (!error) return void 0;
-			rejectUnknownKeys(error, ROOT_ERROR_KEYS, "$.error", issues);
-			requireNonWhitespaceString(readRequiredField(error, "message", "$.error.message", issues), "$.error.message", issues);
-			return;
-		}
-		default: assertNever(status);
-	}
-}
-function validateAIToolRunSnapshot(value) {
-	const issues = [];
-	try {
-		const capturedValue = captureJsonSnapshot(value, "$", issues);
-		if (issues.length > 0) return {
-			valid: false,
-			issues
-		};
-		if (capturedValue === INVALID_JSON_SNAPSHOT) return {
-			valid: false,
-			issues: [{
-				path: "$",
-				message: INSPECTION_FAILURE_MESSAGE
-			}]
-		};
-		validateJsonSafe(capturedValue, "$", issues);
-		if (issues.length > 0) return {
-			valid: false,
-			issues
-		};
-		const snapshot = requireRecord(capturedValue, "$", issues);
-		if (!snapshot) return {
-			valid: false,
-			issues
-		};
-		rejectUnknownKeys(snapshot, ROOT_KEYS, "$", issues);
-		const status = requireRunStatus(readRequiredField(snapshot, "status", "$.status", issues), "$.status", issues);
-		const activeStepId = status ? validateStateFields(status, snapshot, issues) : void 0;
-		requireNonEmptyString(readRequiredField(snapshot, "runId", "$.runId", issues), "$.runId", issues);
-		validateHeader(readRequiredField(snapshot, "header", "$.header", issues), "$.header", issues);
-		const steps = requireArray(readRequiredField(snapshot, "steps", "$.steps", issues), "$.steps", issues);
-		const validatedSteps = [];
-		let stepsAreValid = false;
-		if (steps) {
-			const stepItems = readArrayItems(steps, "$.steps", issues);
-			if (stepItems) {
-				const toolCallIds = /* @__PURE__ */ new Set();
-				for (const item of stepItems) {
-					const validatedStep = validateStep(item.value, `$.steps[${item.index}]`, issues);
-					if (!validatedStep) continue;
-					if (toolCallIds.has(validatedStep.toolCall.toolCallId)) addIssue(issues, `$.steps[${item.index}].toolCall.toolCallId`, "duplicate tool-call ID");
-					else toolCallIds.add(validatedStep.toolCall.toolCallId);
-					validatedSteps.push(validatedStep);
-				}
-				stepsAreValid = validatedSteps.length === stepItems.length;
-				if (status && stepsAreValid) validateLifecycle(status, validatedSteps, issues);
-			}
-		}
-		const sources = readOptionalField(snapshot, "sources", "$.sources", issues);
-		const sourceIds = sources === void 0 || isInvalidField(sources) ? /* @__PURE__ */ new Set() : validateSources(sources, "$.sources", issues);
-		if (stepsAreValid) {
-			validateSourceReferences(validatedSteps, sourceIds, issues);
-			validateActiveStepReference(status, activeStepId, validatedSteps, issues);
-		}
-		const actions = readOptionalField(snapshot, "actions", "$.actions", issues);
-		if (actions !== void 0 && !isInvalidField(actions)) validateActions(actions, "$.actions", status, issues);
-		if (issues.length > 0) return {
-			valid: false,
-			issues
-		};
-		return {
-			valid: true,
-			value: capturedValue
-		};
-	} catch {
-		return {
-			valid: false,
-			issues: [{
-				path: "$",
-				message: INSPECTION_FAILURE_MESSAGE
-			}]
-		};
-	}
-}
+AIToolCallList.displayName = "AIToolCallList";
 //#endregion
-export { validateAIToolRunSnapshot };
+export { AIToolCall, AIToolCallHeader, AIToolCallList, StatusIcon, ToolCallSection, statusIconVariants, toolCallVariants };
 
 //# sourceMappingURL=index184.js.map