@humain/ui 2.1.63 → 2.1.65

package/dist/index185.js

@@ -1,387 +1,1087 @@
-"use client";
-import { assertNever, cn } from "./index2.js";
-import { Button } from "./index5.js";
-import { Progress } from "./index17.js";
-import { Card } from "./index48.js";
-import { AISource } from "./index173.js";
-import { WorkflowStepRenderer } from "./index174.js";
-import { validateAIToolRunSnapshot } from "./index184.js";
-import { AlertCircle, Check, ChevronDown, ChevronRight, CirclePause, Clock, Wrench } from "lucide-react";
-import * as React from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
-//#region src/components/organisms/ai/AIToolRun/AIToolRun.tsx
-var MAX_RUNTIME_EXPANDED_STEP_IDS = 1e4;
-var INVALID_RUNTIME_STRING_ARRAY = Symbol("invalid-runtime-string-array");
-var ARRAY_PROTOTYPE_MEMBER_KEYS = Reflect.ownKeys(Array.prototype).filter((key) => key !== "length");
-function cloneRuntimeStringArray(value) {
+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",
+	"durationMs"
+]);
+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",
+	"kind"
+]);
+var ACTION_KEYS = /* @__PURE__ */ new Set([
+	"id",
+	"kind",
+	"label",
+	"disabled",
+	"loading"
+]);
+var STEP_KEYS = /* @__PURE__ */ new Set([
+	"toolCall",
+	"title",
+	"description",
+	"progress",
+	"sourceIds",
+	"currentSourceId",
+	"durationMs",
+	"context",
+	"technicalDetails"
+]);
+var TOOL_CALL_KEYS = /* @__PURE__ */ new Set([
+	"toolCallId",
+	"toolName",
+	"status",
+	"error"
+]);
+var CONTEXT_KEYS = /* @__PURE__ */ new Set(["id", "label"]);
+var TECHNICAL_DETAILS_KEYS = /* @__PURE__ */ new Set(["label", "toolCalls"]);
+var TECHNICAL_TOOL_CALL_KEYS = /* @__PURE__ */ new Set([
+	"toolCallId",
+	"toolName",
+	"args",
+	"result",
+	"status",
+	"error"
+]);
+var REFERENCE_SOURCE_KEYS = /* @__PURE__ */ new Set([
+	"id",
+	"kind",
+	"title",
+	"description"
+]);
+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",
+		"context",
+		"technicalDetails"
+	]),
+	running: /* @__PURE__ */ new Set([
+		"toolCall",
+		"title",
+		"description",
+		"context",
+		"technicalDetails",
+		"progress",
+		"sourceIds",
+		"currentSourceId",
+		"durationMs"
+	]),
+	success: /* @__PURE__ */ new Set([
+		"toolCall",
+		"title",
+		"description",
+		"context",
+		"technicalDetails",
+		"durationMs",
+		"sourceIds"
+	]),
+	error: /* @__PURE__ */ new Set([
+		"toolCall",
+		"title",
+		"description",
+		"context",
+		"technicalDetails",
+		"sourceIds",
+		"durationMs"
+	])
+};
+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
+	});
+}
+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 {
-		if (!Array.isArray(value)) return INVALID_RUNTIME_STRING_ARRAY;
-		const lengthDescriptor = Reflect.getOwnPropertyDescriptor(value, "length");
-		if (lengthDescriptor === void 0 || lengthDescriptor.enumerable || !Object.hasOwn(lengthDescriptor, "value") || typeof lengthDescriptor.value !== "number" || !Number.isInteger(lengthDescriptor.value) || lengthDescriptor.value < 0 || lengthDescriptor.value > MAX_RUNTIME_EXPANDED_STEP_IDS || !Object.is(Reflect.get(value, "length"), lengthDescriptor.value)) return INVALID_RUNTIME_STRING_ARRAY;
-		for (const key of ARRAY_PROTOTYPE_MEMBER_KEYS) if (Reflect.getOwnPropertyDescriptor(value, key) !== void 0) return INVALID_RUNTIME_STRING_ARRAY;
-		const copy = [];
-		for (let index = 0; index < lengthDescriptor.value; index += 1) {
-			const key = String(index);
-			const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
-			if (descriptor === void 0 || descriptor.enumerable !== true || !Object.hasOwn(descriptor, "value") || typeof descriptor.value !== "string" || !Object.is(Reflect.get(value, key), descriptor.value)) return INVALID_RUNTIME_STRING_ARRAY;
-			copy.push(descriptor.value);
-		}
-		return copy;
+		const prototype = Reflect.getPrototypeOf(value);
+		if (Array.isArray(value)) return prototype === Array.prototype ? "array" : "other";
+		return prototype === Object.prototype || prototype === null ? "record" : "other";
 	} catch {
-		return INVALID_RUNTIME_STRING_ARRAY;
+		addInspectionIssue(issues, path);
+		return "uninspectable";
 	}
 }
-function validateRuntimeViewProps({ headingLevel, open, defaultOpen, expandedStepIds, defaultExpandedStepIds }) {
-	const issues = [];
-	let validatedExpandedStepIds;
-	let validatedDefaultExpandedStepIds;
-	if (headingLevel !== void 0 && (typeof headingLevel !== "number" || !Number.isInteger(headingLevel) || headingLevel < 2 || headingLevel > 6)) issues.push("headingLevel must be an integer from 2 through 6");
-	if (open !== void 0 && typeof open !== "boolean") issues.push("open must be a boolean");
-	if (defaultOpen !== void 0 && typeof defaultOpen !== "boolean") issues.push("defaultOpen must be a boolean");
-	if (expandedStepIds !== void 0) {
-		const cloned = cloneRuntimeStringArray(expandedStepIds);
-		if (cloned === INVALID_RUNTIME_STRING_ARRAY) issues.push("expandedStepIds must be an array of strings");
-		else validatedExpandedStepIds = cloned;
-	}
-	if (defaultExpandedStepIds !== void 0) {
-		const cloned = cloneRuntimeStringArray(defaultExpandedStepIds);
-		if (cloned === INVALID_RUNTIME_STRING_ARRAY) issues.push("defaultExpandedStepIds must be an array of strings");
-		else validatedDefaultExpandedStepIds = cloned;
-	}
-	if (issues.length > 0) return {
-		valid: false,
-		issues
-	};
+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: {
-			...headingLevel === void 0 ? {} : { headingLevel },
-			...open === void 0 ? {} : { open },
-			...defaultOpen === void 0 ? {} : { defaultOpen },
-			...expandedStepIds === void 0 ? {} : { expandedStepIds: validatedExpandedStepIds },
-			...defaultExpandedStepIds === void 0 ? {} : { defaultExpandedStepIds: validatedDefaultExpandedStepIds }
+		value: descriptor.value
+	};
+}
+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;
+	}
+}
+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
 	};
+	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" };
 }
-var InvalidAIToolRun = React.forwardRef(({ className, ...sectionProps }, ref) => /* @__PURE__ */ jsx("section", {
-	...sectionProps,
-	ref,
-	"data-slot": "ai-tool-run",
-	role: "alert",
-	"aria-label": "Tool run",
-	className: cn("w-full min-w-0", className),
-	children: "Unable to display tool run."
-}));
-InvalidAIToolRun.displayName = "InvalidAIToolRun";
-var RUN_STATUS_LABELS = {
-	ready: "Ready",
-	running: "Running",
-	paused: "Paused",
-	completed: "Completed",
-	error: "Failed"
-};
-var STANDARD_ACTION_LABELS = {
-	start: "Start",
-	pause: "Pause",
-	resume: "Resume",
-	retry: "Retry",
-	dismiss: "Dismiss"
-};
-var PAUSED_PROGRESS_CLASS_NAME = "[&_[data-slot=progress-indicator]]:!transition-none [&_[data-slot=progress-indicator]]:!animate-none";
-function RunStatusIcon({ status }) {
-	switch (status) {
-		case "ready": return /* @__PURE__ */ jsx(Wrench, {
-			"aria-hidden": "true",
-			className: "size-4 text-muted-foreground"
-		});
-		case "running": return /* @__PURE__ */ jsx(Clock, {
-			"aria-hidden": "true",
-			className: "size-4 text-primary animate-pulse motion-reduce:animate-none"
-		});
-		case "paused": return /* @__PURE__ */ jsx(CirclePause, {
-			"aria-hidden": "true",
-			className: "size-4 text-warning"
-		});
-		case "completed": return /* @__PURE__ */ jsx(Check, {
-			"aria-hidden": "true",
-			className: "size-4 text-success"
+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
 		});
-		case "error": return /* @__PURE__ */ jsx(AlertCircle, {
-			"aria-hidden": "true",
-			className: "size-4 text-destructive"
+	}
+	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;
+}
+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
 		});
-		default: return assertNever(status);
-	}
-}
-RunStatusIcon.displayName = "RunStatusIcon";
-function getActionLabel(action) {
-	if (action.kind === "custom") return action.label;
-	return action.label ?? STANDARD_ACTION_LABELS[action.kind];
-}
-function getPoliteAnnouncement(run) {
-	if (run.status === "error") return "";
-	const activeStep = run.activeStepId === void 0 ? void 0 : run.steps.find((step) => step.toolCall.toolCallId === run.activeStepId);
-	const statusLabel = RUN_STATUS_LABELS[run.status];
-	return activeStep ? `${statusLabel}. Current step: ${activeStep.title ?? activeStep.toolCall.toolName}.` : `${statusLabel}.`;
-}
-function getWorkflowStepStatus(runStatus, step) {
-	const toolStatus = step.toolCall.status;
-	switch (toolStatus) {
-		case "pending": return "pending";
-		case "running": return runStatus === "paused" ? "suspended" : "running";
-		case "success": return "completed";
-		case "error": return "error";
-		default: return assertNever(toolStatus);
-	}
-}
-function AIToolRunStepContent({ progress, sources, title, paused }) {
-	return /* @__PURE__ */ jsxs("div", {
-		className: "grid min-w-0 gap-3",
-		children: [progress && /* @__PURE__ */ jsx(Progress, {
-			value: progress.value,
-			label: progress.label,
-			subLabel: progress.meta,
-			className: paused ? PAUSED_PROGRESS_CLASS_NAME : void 0
-		}), sources.length > 0 && /* @__PURE__ */ jsx("ul", {
-			"aria-label": `Sources for ${title}`,
-			className: "grid min-w-0 gap-2",
-			children: sources.map((item, index) => /* @__PURE__ */ jsx("li", {
-				className: "flex min-w-0 items-center gap-2",
-				children: /* @__PURE__ */ jsx(AISource, {
-					source: item,
-					variant: "minimal",
-					showTooltip: false,
-					className: "min-w-0 max-w-none"
-				})
-			}, `${item.id}-${index}`))
-		})]
-	});
+		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
+			});
+		}
+	}
 }
-AIToolRunStepContent.displayName = "AIToolRunStepContent";
-function toWorkflowStep(runStatus, step, sourcesById) {
-	const title = step.title ?? step.toolCall.toolName;
-	const stepSources = (step.sourceIds ?? []).flatMap((sourceId) => {
-		const source = sourcesById.get(sourceId);
-		return source === void 0 ? [] : [source];
-	});
-	const hasContent = step.progress !== void 0 || stepSources.length > 0;
+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 {
-		id: step.toolCall.toolCallId,
-		title,
-		description: step.description,
-		status: getWorkflowStepStatus(runStatus, step),
-		content: hasContent ? /* @__PURE__ */ jsx(AIToolRunStepContent, {
-			progress: step.progress,
-			sources: stepSources,
-			title,
-			paused: runStatus === "paused"
-		}) : void 0,
-		durationMs: step.durationMs,
-		error: step.toolCall.status === "error" ? step.toolCall.error : void 0
+		toolCallId,
+		status
 	};
 }
-function useAIToolRunOpenState({ open, defaultOpen, onOpenChange }) {
-	const isControlled = open !== void 0;
-	const [uncontrolledOpen, setUncontrolledOpen] = React.useState(defaultOpen ?? true);
-	const lastControlledOpenRef = React.useRef(open ?? uncontrolledOpen);
-	const wasControlledRef = React.useRef(isControlled);
-	React.useLayoutEffect(() => {
-		if (open !== void 0) lastControlledOpenRef.current = open;
-	}, [open]);
-	React.useLayoutEffect(() => {
-		const wasControlled = wasControlledRef.current;
-		wasControlledRef.current = isControlled;
-		if (isControlled || !wasControlled) return;
-		setUncontrolledOpen((currentOpen) => currentOpen === lastControlledOpenRef.current ? currentOpen : lastControlledOpenRef.current);
-	}, [isControlled]);
-	const setOpen = React.useCallback((nextOpen) => {
-		if (!isControlled) setUncontrolledOpen(nextOpen);
-		onOpenChange?.(nextOpen);
-	}, [isControlled, onOpenChange]);
-	return [isControlled ? open : uncontrolledOpen, setOpen];
-}
-var AIToolRunPresentation = React.forwardRef(({ run, headingLevel = 2, open, defaultOpen, onOpenChange, expandedStepIds, defaultExpandedStepIds, onExpandedStepIdsChange, onAction, className, ...sectionProps }, ref) => {
-	const headingId = React.useId();
-	const detailsId = React.useId();
-	const Heading = `h${headingLevel}`;
-	const [isOpen, setIsOpen] = useAIToolRunOpenState({
-		open,
-		defaultOpen,
-		onOpenChange
-	});
-	const sourcesById = React.useMemo(() => new Map((run.sources ?? []).map((source) => [source.id, source])), [run.sources]);
-	const workflowSteps = React.useMemo(() => run.steps.map((step) => toWorkflowStep(run.status, step, sourcesById)), [
-		run.status,
-		run.steps,
-		sourcesById
-	]);
-	const rootError = run.status === "error" ? run.error.message : void 0;
-	const politeAnnouncement = getPoliteAnnouncement(run);
-	const { "aria-busy": _ariaBusy, ...nativeSectionProps } = sectionProps;
-	return /* @__PURE__ */ jsxs("section", {
-		...nativeSectionProps,
-		ref,
-		"data-slot": "ai-tool-run",
-		"aria-labelledby": headingId,
-		className: cn("relative w-full min-w-0", className),
-		children: [/* @__PURE__ */ jsxs(Card, {
-			"aria-busy": run.status === "running" ? true : void 0,
-			className: "rounded-2xl",
-			children: [
-				/* @__PURE__ */ jsxs(Card.Header, { children: [/* @__PURE__ */ jsxs("div", {
-					className: "grid min-w-0 gap-1",
-					children: [
-						/* @__PURE__ */ jsxs("div", {
-							className: "flex min-w-0 items-center gap-2 text-xs font-medium text-secondary-foreground",
-							children: [/* @__PURE__ */ jsx(RunStatusIcon, { status: run.status }), /* @__PURE__ */ jsxs("span", { children: ["Status: ", RUN_STATUS_LABELS[run.status]] })]
-						}),
-						/* @__PURE__ */ jsx(Heading, {
-							id: headingId,
-							className: "min-w-0 truncate text-base font-semibold text-foreground",
-							children: run.header.title
-						}),
-						run.header.description && /* @__PURE__ */ jsx("p", {
-							className: "line-clamp-2 text-sm text-secondary-foreground",
-							children: run.header.description
-						}),
-						run.header.metadata && run.header.metadata.length > 0 && /* @__PURE__ */ jsx("dl", {
-							className: "flex flex-wrap gap-x-3 gap-y-1 text-xs text-secondary-foreground",
-							children: run.header.metadata.map((item, index) => /* @__PURE__ */ jsxs("div", {
-								className: "flex min-w-0 items-center gap-1",
-								children: [/* @__PURE__ */ jsxs("dt", {
-									className: "text-muted-foreground",
-									children: [item.label, ":"]
-								}), /* @__PURE__ */ jsx("dd", {
-									className: "min-w-0 truncate",
-									children: item.value
-								})]
-							}, `${item.label}-${index}`))
-						}),
-						!isOpen && run.progress && /* @__PURE__ */ jsx(Progress, {
-							value: run.progress.value,
-							label: run.progress.label,
-							subLabel: run.progress.meta,
-							className: run.status === "paused" ? PAUSED_PROGRESS_CLASS_NAME : void 0
-						})
-					]
-				}), /* @__PURE__ */ jsx(Card.Action, { children: /* @__PURE__ */ jsx(Button, {
-					appearance: "ghost",
-					variant: "secondary",
-					size: "icon-xl",
-					iconOnly: true,
-					"aria-label": isOpen ? "Collapse tool run" : "Expand tool run",
-					"aria-expanded": isOpen,
-					"aria-controls": detailsId,
-					onClick: () => setIsOpen(!isOpen),
-					children: isOpen ? /* @__PURE__ */ jsx(ChevronDown, { "aria-hidden": "true" }) : /* @__PURE__ */ jsx(ChevronRight, {
-						"aria-hidden": "true",
-						className: "rtl:rotate-180"
-					})
-				}) })] }),
-				/* @__PURE__ */ jsxs(Card.Content, {
-					id: detailsId,
-					hidden: !isOpen,
-					className: "grid min-w-0 gap-4",
-					children: [
-						run.progress && /* @__PURE__ */ jsx(Progress, {
-							value: run.progress.value,
-							label: run.progress.label,
-							subLabel: run.progress.meta,
-							className: run.status === "paused" ? PAUSED_PROGRESS_CLASS_NAME : void 0
-						}),
-						rootError && /* @__PURE__ */ jsxs("div", {
-							className: "flex min-w-0 items-start gap-2 rounded-lg border border-destructive/50 bg-destructive/10 p-3",
-							children: [/* @__PURE__ */ jsx(AlertCircle, {
-								"aria-hidden": "true",
-								className: "mt-0.5 size-4 shrink-0 text-destructive"
-							}), /* @__PURE__ */ jsx("p", {
-								className: "min-w-0 text-sm text-destructive",
-								children: rootError
-							})]
-						}),
-						/* @__PURE__ */ jsx(WorkflowStepRenderer, {
-							appearance: "timeline",
-							steps: workflowSteps,
-							activeStepId: run.activeStepId,
-							expandedStepIds,
-							defaultExpandedStepIds,
-							onExpandedStepIdsChange,
-							renderItems: isOpen
-						}, run.runId)
-					]
-				}),
-				run.actions && run.actions.length > 0 && /* @__PURE__ */ jsx(Card.Footer, {
-					className: "flex flex-wrap gap-2",
-					children: run.actions.map((action) => /* @__PURE__ */ jsx(Button, {
-						appearance: "outline",
-						variant: "secondary",
-						disabled: action.disabled,
-						loading: action.loading,
-						"aria-label": getActionLabel(action),
-						className: "min-w-0 w-full max-w-full min-[480px]:w-auto h-auto min-h-9 whitespace-normal break-words [overflow-wrap:anywhere] [&>span]:min-w-0",
-						onClick: () => {
-							if (action.disabled || action.loading) return;
-							onAction?.({
-								runId: run.runId,
-								actionId: action.id,
-								kind: action.kind
-							});
-						},
-						children: getActionLabel(action)
-					}, action.id))
-				})
-			]
-		}), rootError ? /* @__PURE__ */ jsx("div", {
-			role: "alert",
-			"aria-live": "assertive",
-			className: "sr-only left-0 top-0",
-			children: rootError
-		}) : /* @__PURE__ */ jsx("div", {
-			role: "status",
-			"aria-live": "polite",
-			className: "sr-only left-0 top-0",
-			children: politeAnnouncement
-		})]
-	});
-});
-AIToolRunPresentation.displayName = "AIToolRunPresentation";
-var AIToolRunRuntimeBoundary = React.forwardRef((props, ref) => {
-	const { run, headingLevel, open, defaultOpen, expandedStepIds, defaultExpandedStepIds, dangerouslySetInnerHTML: unsafeHtml, onOpenChange, onExpandedStepIdsChange, onAction, ...sectionProps } = props;
-	const snapshotResult = validateAIToolRunSnapshot(run);
-	const viewResult = validateRuntimeViewProps({
-		headingLevel,
-		open,
-		defaultOpen,
-		expandedStepIds,
-		defaultExpandedStepIds
-	});
-	if (!snapshotResult.valid || !viewResult.valid) return /* @__PURE__ */ jsx(InvalidAIToolRun, {
-		...sectionProps,
-		ref
-	});
-	return /* @__PURE__ */ jsx(AIToolRunPresentation, {
-		...sectionProps,
-		...viewResult.value,
-		onOpenChange,
-		onExpandedStepIdsChange,
-		onAction,
-		ref,
-		run: snapshotResult.value
-	});
-});
-/**
-* Displays one validated AI tool run with lifecycle, progress, sources,
-* disclosure, and action intents.
-*
-* @llms Validated AI tool-run timeline with lifecycle, progress, sources, disclosure, and actions
-*/
-var AIToolRun = React.forwardRef((props, ref) => /* @__PURE__ */ jsx(AIToolRunRuntimeBoundary, {
-	...props,
-	ref
-}));
-AIToolRunRuntimeBoundary.displayName = "AIToolRunRuntimeBoundary";
-AIToolRun.displayName = "AIToolRun";
+function validateContext(value, path, issues) {
+	const context = requireRecord(value, path, issues);
+	if (!context) return;
+	rejectUnknownKeys(context, CONTEXT_KEYS, path, issues);
+	requireNonWhitespaceString(readRequiredField(context, "id", `${path}.id`, issues), `${path}.id`, issues);
+	requireNonWhitespaceString(readRequiredField(context, "label", `${path}.label`, issues), `${path}.label`, issues);
+}
+function validateTechnicalToolCall(value, path, issues) {
+	const issueCount = issues.length;
+	const toolCall = requireRecord(value, path, issues);
+	if (!toolCall) return void 0;
+	rejectUnknownKeys(toolCall, TECHNICAL_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 statusField = readOptionalField(toolCall, "status", `${path}.status`, issues);
+	const status = statusField === void 0 || isInvalidField(statusField) ? void 0 : requireToolStatus(statusField, `${path}.status`, issues);
+	const args = readOptionalField(toolCall, "args", `${path}.args`, issues);
+	if (args !== void 0 && !isInvalidField(args)) requireRecord(args, `${path}.args`, issues);
+	readOptionalField(toolCall, "result", `${path}.result`, issues);
+	const error = readOptionalField(toolCall, "error", `${path}.error`, issues);
+	if (status === "error") {
+		if (error === void 0) addIssue(issues, `${path}.error`, "Value is required for error tool calls");
+		else if (!isInvalidField(error)) requireNonWhitespaceString(error, `${path}.error`, issues);
+	} else if (error !== void 0) addIssue(issues, `${path}.error`, "Field is allowed for error tool calls only");
+	return hasIssuesSince(issues, issueCount) ? void 0 : toolCallId;
+}
+function validateTechnicalDetails(value, path, issues) {
+	const details = requireRecord(value, path, issues);
+	if (!details) return;
+	rejectUnknownKeys(details, TECHNICAL_DETAILS_KEYS, path, issues);
+	const label = readOptionalField(details, "label", `${path}.label`, issues);
+	if (label !== void 0 && !isInvalidField(label)) requireNonWhitespaceString(label, `${path}.label`, issues);
+	const toolCalls = requireArray(readRequiredField(details, "toolCalls", `${path}.toolCalls`, issues), `${path}.toolCalls`, issues);
+	if (!toolCalls) return;
+	const items = readArrayItems(toolCalls, `${path}.toolCalls`, issues);
+	if (!items) return;
+	const ids = /* @__PURE__ */ new Set();
+	for (const item of items) {
+		const itemPath = `${path}.toolCalls[${item.index}]`;
+		const id = validateTechnicalToolCall(item.value, itemPath, issues);
+		if (!id) continue;
+		if (ids.has(id)) addIssue(issues, `${itemPath}.toolCallId`, "duplicate tool-call ID");
+		else ids.add(id);
+	}
+}
+function validateDuration(value, path, issues) {
+	const durationMs = requireNumber(value, path, issues);
+	if (durationMs !== void 0 && durationMs < 0) addIssue(issues, path, "Value must be non-negative");
+}
+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 context = readOptionalField(step, "context", `${path}.context`, issues);
+	if (context !== void 0 && !isInvalidField(context)) validateContext(context, `${path}.context`, issues);
+	const technicalDetails = readOptionalField(step, "technicalDetails", `${path}.technicalDetails`, issues);
+	if (technicalDetails !== void 0 && !isInvalidField(technicalDetails)) validateTechnicalDetails(technicalDetails, `${path}.technicalDetails`, 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)) validateDuration(durationMsField, `${path}.durationMs`, issues);
+	if (hasIssuesSince(issues, issueCount)) return void 0;
+	return {
+		toolCall,
+		...sourceIds === void 0 ? {} : { sourceIds },
+		...currentSourceId === void 0 ? {} : { currentSourceId }
+	};
+}
+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);
+	const kindField = readOptionalField(source, "kind", `${path}.kind`, issues);
+	const kind = kindField === void 0 || isInvalidField(kindField) ? void 0 : requireString(kindField, `${path}.kind`, issues);
+	if (kind !== void 0 && kind !== "link" && kind !== "reference") addIssue(issues, `${path}.kind`, "Value must be \"link\" or \"reference\"");
+	if (kind === "reference") {
+		rejectDisallowedKeys(source, SOURCE_KEYS, REFERENCE_SOURCE_KEYS, path, issues);
+		requireNonWhitespaceString(readRequiredField(source, "title", `${path}.title`, issues), `${path}.title`, issues);
+		const description = readOptionalField(source, "description", `${path}.description`, issues);
+		if (description !== void 0 && !isInvalidField(description)) requireString(description, `${path}.description`, issues);
+		return hasIssuesSince(issues, issueCount) || !id ? void 0 : id;
+	}
+	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 durationMs = readOptionalField(snapshot, "durationMs", "$.durationMs", issues);
+		if (durationMs !== void 0 && !isInvalidField(durationMs)) validateDuration(durationMs, "$.durationMs", 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
+			}]
+		};
+	}
+}
 //#endregion
-export { AIToolRun, AIToolRunRuntimeBoundary };
+export { validateAIToolRunSnapshot };
 
 //# sourceMappingURL=index185.js.map