@copilotkit/web-inspector 1.69.0 → 1.69.1

package/dist/lib/event-snippets.d.cts

@@ -0,0 +1,61 @@
+//#region src/lib/event-snippets.d.ts
+declare const SNIPPET_RECIPES: readonly ["tool-call", "reasoning", "text", "activity", "raw"];
+type SnippetRecipe = (typeof SNIPPET_RECIPES)[number];
+type SnippetEvent = {
+  type: string;
+  [key: string]: unknown;
+};
+type EventSnippet = {
+  id: string;
+  name: string;
+  recipe: SnippetRecipe;
+  events: SnippetEvent[];
+  createdAt: string;
+  updatedAt: string;
+};
+type ActivitySnippetMessage = {
+  id: string;
+  activityType: string;
+  content: unknown;
+};
+type ChatSnippetCapture = {
+  kind: "text";
+  messageId: string;
+  content: string;
+} | {
+  kind: "reasoning";
+  messageId: string;
+  content: string;
+} | {
+  kind: "tool-call";
+  messageId: string;
+  toolCallId: string;
+  toolName: string;
+  argsJson: string | Record<string, unknown>;
+} | {
+  kind: "activity";
+  messageId: string;
+  activityType: string;
+  content: unknown;
+};
+declare function compileChatSnippet(input: ChatSnippetCapture & {
+  threadId: string;
+  runId: string;
+}): {
+  recipe: SnippetRecipe;
+  events: SnippetEvent[];
+  name: string;
+};
+declare function compileFromActivityMessage(input: {
+  message: ActivitySnippetMessage;
+  threadId: string;
+  runId: string;
+}): {
+  recipe: SnippetRecipe;
+  events: SnippetEvent[];
+  name: string;
+};
+declare function upsertEventSnippet(snippet: EventSnippet, storage?: Pick<Storage, "getItem" | "setItem"> | null): EventSnippet[];
+//#endregion
+export { ActivitySnippetMessage, ChatSnippetCapture, EventSnippet, compileChatSnippet, compileFromActivityMessage, upsertEventSnippet };
+//# sourceMappingURL=event-snippets.d.cts.map

package/dist/lib/event-snippets.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-snippets.d.cts","names":[],"sources":["../../src/lib/event-snippets.ts"],"mappings":";cAEa,eAAA;AAAA,KAQD,aAAA,WAAwB,eAAA;AAAA,KAExB,YAAA;EACV,IAAA;EAAA,CACC,GAAA;AAAA;AAAA,KAGS,YAAA;EACV,EAAA;EACA,IAAA;EACA,MAAA,EAAQ,aAAA;EACR,MAAA,EAAQ,YAAA;EACR,SAAA;EACA,SAAA;AAAA;AAAA,KAmBU,sBAAA;EACV,EAAA;EACA,YAAA;EACA,OAAA;AAAA;AAAA,KA8bU,kBAAA;EAEN,IAAA;EACA,SAAA;EACA,OAAA;AAAA;EAGA,IAAA;EACA,SAAA;EACA,OAAA;AAAA;EAGA,IAAA;EACA,SAAA;EACA,UAAA;EACA,QAAA;EACA,QAAA,WAAmB,MAAA;AAAA;EAGnB,IAAA;EACA,SAAA;EACA,YAAA;EACA,OAAA;AAAA;AAAA,iBAuBU,kBAAA,CACd,KAAA,EAAO,kBAAA;EAAuB,QAAA;EAAkB,KAAA;AAAA;EAC7C,MAAA,EAAQ,aAAA;EAAe,MAAA,EAAQ,YAAA;EAAgB,IAAA;AAAA;AAAA,iBAmHpC,0BAAA,CAA2B,KAAA;EACzC,OAAA,EAAS,sBAAA;EACT,QAAA;EACA,KAAA;AAAA;EACI,MAAA,EAAQ,aAAA;EAAe,MAAA,EAAQ,YAAA;EAAgB,IAAA;AAAA;AAAA,iBAqErC,kBAAA,CACd,OAAA,EAAS,YAAA,EACT,OAAA,GAAS,IAAA,CAAK,OAAA,kCACb,YAAA"}

package/dist/lib/event-snippets.d.mts

@@ -0,0 +1,61 @@
+//#region src/lib/event-snippets.d.ts
+declare const SNIPPET_RECIPES: readonly ["tool-call", "reasoning", "text", "activity", "raw"];
+type SnippetRecipe = (typeof SNIPPET_RECIPES)[number];
+type SnippetEvent = {
+  type: string;
+  [key: string]: unknown;
+};
+type EventSnippet = {
+  id: string;
+  name: string;
+  recipe: SnippetRecipe;
+  events: SnippetEvent[];
+  createdAt: string;
+  updatedAt: string;
+};
+type ActivitySnippetMessage = {
+  id: string;
+  activityType: string;
+  content: unknown;
+};
+type ChatSnippetCapture = {
+  kind: "text";
+  messageId: string;
+  content: string;
+} | {
+  kind: "reasoning";
+  messageId: string;
+  content: string;
+} | {
+  kind: "tool-call";
+  messageId: string;
+  toolCallId: string;
+  toolName: string;
+  argsJson: string | Record<string, unknown>;
+} | {
+  kind: "activity";
+  messageId: string;
+  activityType: string;
+  content: unknown;
+};
+declare function compileChatSnippet(input: ChatSnippetCapture & {
+  threadId: string;
+  runId: string;
+}): {
+  recipe: SnippetRecipe;
+  events: SnippetEvent[];
+  name: string;
+};
+declare function compileFromActivityMessage(input: {
+  message: ActivitySnippetMessage;
+  threadId: string;
+  runId: string;
+}): {
+  recipe: SnippetRecipe;
+  events: SnippetEvent[];
+  name: string;
+};
+declare function upsertEventSnippet(snippet: EventSnippet, storage?: Pick<Storage, "getItem" | "setItem"> | null): EventSnippet[];
+//#endregion
+export { ActivitySnippetMessage, ChatSnippetCapture, EventSnippet, compileChatSnippet, compileFromActivityMessage, upsertEventSnippet };
+//# sourceMappingURL=event-snippets.d.mts.map

package/dist/lib/event-snippets.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-snippets.d.mts","names":[],"sources":["../../src/lib/event-snippets.ts"],"mappings":";cAEa,eAAA;AAAA,KAQD,aAAA,WAAwB,eAAA;AAAA,KAExB,YAAA;EACV,IAAA;EAAA,CACC,GAAA;AAAA;AAAA,KAGS,YAAA;EACV,EAAA;EACA,IAAA;EACA,MAAA,EAAQ,aAAA;EACR,MAAA,EAAQ,YAAA;EACR,SAAA;EACA,SAAA;AAAA;AAAA,KAmBU,sBAAA;EACV,EAAA;EACA,YAAA;EACA,OAAA;AAAA;AAAA,KA8bU,kBAAA;EAEN,IAAA;EACA,SAAA;EACA,OAAA;AAAA;EAGA,IAAA;EACA,SAAA;EACA,OAAA;AAAA;EAGA,IAAA;EACA,SAAA;EACA,UAAA;EACA,QAAA;EACA,QAAA,WAAmB,MAAA;AAAA;EAGnB,IAAA;EACA,SAAA;EACA,YAAA;EACA,OAAA;AAAA;AAAA,iBAuBU,kBAAA,CACd,KAAA,EAAO,kBAAA;EAAuB,QAAA;EAAkB,KAAA;AAAA;EAC7C,MAAA,EAAQ,aAAA;EAAe,MAAA,EAAQ,YAAA;EAAgB,IAAA;AAAA;AAAA,iBAmHpC,0BAAA,CAA2B,KAAA;EACzC,OAAA,EAAS,sBAAA;EACT,QAAA;EACA,KAAA;AAAA;EACI,MAAA,EAAQ,aAAA;EAAe,MAAA,EAAQ,YAAA;EAAgB,IAAA;AAAA;AAAA,iBAqErC,kBAAA,CACd,OAAA,EAAS,YAAA,EACT,OAAA,GAAS,IAAA,CAAK,OAAA,kCACb,YAAA"}

package/dist/lib/event-snippets.mjs

@@ -0,0 +1,537 @@
+//#region src/lib/event-snippets.ts
+const EVENT_SNIPPETS_STORAGE_KEY = "cpk:inspector:event-snippets";
+const SNIPPET_RECIPES = [
+	"tool-call",
+	"reasoning",
+	"text",
+	"activity",
+	"raw"
+];
+const ACTIVITY_STARTERS = ["a2ui-surface", "open-generative-ui"];
+function isSnippetRecipe(value) {
+	return typeof value === "string" && SNIPPET_RECIPES.some((recipe) => recipe === value);
+}
+function createSnippetId() {
+	if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
+	return `cpk-snippet-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function autoSnippetName(recipe, label) {
+	const time = (/* @__PURE__ */ new Date()).toLocaleTimeString([], {
+		hour: "2-digit",
+		minute: "2-digit"
+	});
+	return `${label.trim() || recipeLabel(recipe)} - ${time}`;
+}
+function recipeLabel(recipe) {
+	switch (recipe) {
+		case "tool-call": return "Tool call";
+		case "reasoning": return "Reasoning";
+		case "text": return "Assistant text";
+		case "activity": return "Activity";
+		case "raw": return "Raw events";
+	}
+}
+const GENERATE_SANDBOXED_UI_TOOL_NAME = "generateSandboxedUi";
+const OPEN_GENERATIVE_UI_ACTIVITY_TYPE = "open-generative-ui";
+function recipeIconName(recipe) {
+	switch (recipe) {
+		case "tool-call": return "Hammer";
+		case "reasoning": return "Brain";
+		case "text": return "MessageSquare";
+		case "activity": return "LayoutDashboard";
+		case "raw": return "Code";
+	}
+}
+function recipeIconWrapClass(recipe) {
+	switch (recipe) {
+		case "tool-call": return "bg-amber-100 text-amber-700";
+		case "reasoning": return "bg-violet-100 text-violet-700";
+		case "text": return "bg-sky-100 text-sky-700";
+		case "activity": return "bg-emerald-100 text-emerald-700";
+		case "raw": return "bg-gray-200 text-gray-700";
+	}
+}
+function groupEventSnippets(snippets) {
+	return SNIPPET_RECIPES.flatMap((recipe) => {
+		const items = snippets.filter((snippet) => snippet.recipe === recipe);
+		if (items.length === 0) return [];
+		return [{
+			recipe,
+			label: recipeLabel(recipe),
+			snippets: items
+		}];
+	});
+}
+function snippetJsonIsRunnable(raw) {
+	try {
+		return parseSnippetEvents(raw).length > 0;
+	} catch {
+		return false;
+	}
+}
+function expandSnippetEventsForRun(events) {
+	const next = [...events];
+	const hasOpenGenUi = next.some((event) => event.type === "ACTIVITY_SNAPSHOT" && event.activityType === OPEN_GENERATIVE_UI_ACTIVITY_TYPE);
+	const toolCallIds = [];
+	for (const event of next) if (event.type === "TOOL_CALL_START" && event.toolCallName === GENERATE_SANDBOXED_UI_TOOL_NAME && typeof event.toolCallId === "string") toolCallIds.push(event.toolCallId);
+	if (toolCallIds.length === 0) return next;
+	const argParts = /* @__PURE__ */ new Map();
+	for (const event of next) if (event.type === "TOOL_CALL_ARGS" && typeof event.toolCallId === "string" && typeof event.delta === "string") {
+		const parts = argParts.get(event.toolCallId) ?? [];
+		parts.push(event.delta);
+		argParts.set(event.toolCallId, parts);
+	}
+	const extras = [];
+	for (const toolCallId of toolCallIds) {
+		let addedSnapshot = false;
+		if (!hasOpenGenUi) {
+			const snapshot = activitySnapshotFromSandboxedUiArgs(toolCallId, (argParts.get(toolCallId) ?? []).join(""));
+			if (snapshot) {
+				extras.push(snapshot);
+				addedSnapshot = true;
+			}
+		}
+		if (!hasOpenGenUi && !addedSnapshot) continue;
+		if (!next.some((event) => event.type === "TOOL_CALL_RESULT" && event.toolCallId === toolCallId)) extras.push({
+			type: "TOOL_CALL_RESULT",
+			toolCallId,
+			messageId: `${toolCallId}-result`,
+			role: "tool",
+			content: "UI generated"
+		});
+	}
+	if (extras.length === 0) return next;
+	const finishIndex = next.findIndex((event) => event.type === "RUN_FINISHED");
+	if (finishIndex === -1) return [...next, ...extras];
+	return [
+		...next.slice(0, finishIndex),
+		...extras,
+		...next.slice(finishIndex)
+	];
+}
+function activitySnapshotFromSandboxedUiArgs(toolCallId, rawArgs) {
+	let args;
+	try {
+		const parsed = JSON.parse(snippetArgsJson(rawArgs));
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+		args = parsed;
+	} catch {
+		return null;
+	}
+	const html = sandboxedUiHtmlChunks(args.html);
+	const css = typeof args.css === "string" ? args.css : void 0;
+	const jsFunctions = typeof args.jsFunctions === "string" ? args.jsFunctions : void 0;
+	const jsExpressions = Array.isArray(args.jsExpressions) ? args.jsExpressions.filter((item) => typeof item === "string") : void 0;
+	if (html.length === 0 && css === void 0 && jsFunctions === void 0 && (jsExpressions === void 0 || jsExpressions.length === 0)) return null;
+	return {
+		type: "ACTIVITY_SNAPSHOT",
+		messageId: `${toolCallId}-activity`,
+		activityType: OPEN_GENERATIVE_UI_ACTIVITY_TYPE,
+		content: {
+			initialHeight: typeof args.initialHeight === "number" ? args.initialHeight : void 0,
+			generating: false,
+			css,
+			cssComplete: true,
+			html,
+			htmlComplete: true,
+			jsFunctions,
+			jsFunctionsComplete: true,
+			jsExpressions,
+			jsExpressionsComplete: true
+		},
+		replace: true
+	};
+}
+function sandboxedUiHtmlChunks(html) {
+	if (typeof html === "string" && html.length > 0) return [html];
+	if (Array.isArray(html)) return html.filter((item) => typeof item === "string");
+	return [];
+}
+function snippetContainsToolCall(events) {
+	return events.some((event) => typeof event.type === "string" && event.type.startsWith("TOOL_CALL"));
+}
+function ensureRunEnvelope(events, ids) {
+	const next = [...events];
+	const hasStart = next.some((event) => event.type === "RUN_STARTED");
+	const hasFinish = next.some((event) => event.type === "RUN_FINISHED");
+	if (!hasStart) next.unshift({
+		type: "RUN_STARTED",
+		threadId: ids.threadId,
+		runId: ids.runId
+	});
+	if (!hasFinish) next.push({
+		type: "RUN_FINISHED",
+		threadId: ids.threadId,
+		runId: ids.runId
+	});
+	return next;
+}
+function snippetArgsJson(value) {
+	if (value && typeof value === "object") return JSON.stringify(value);
+	if (typeof value !== "string") return "{}";
+	const trimmed = value.trim() || "{}";
+	try {
+		return JSON.stringify(JSON.parse(trimmed));
+	} catch {
+		const recovered = firstJsonValue(trimmed);
+		if (recovered !== void 0) return JSON.stringify(recovered);
+		throw new Error("Tool args JSON is invalid.");
+	}
+}
+function firstJsonValue(raw) {
+	const start = raw.indexOf("{");
+	if (start === -1) return;
+	let depth = 0;
+	let inString = false;
+	let escaped = false;
+	for (let index = start; index < raw.length; index += 1) {
+		const char = raw[index];
+		if (inString) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === "\"") inString = false;
+			continue;
+		}
+		if (char === "\"") inString = true;
+		else if (char === "{") depth += 1;
+		else if (char === "}") {
+			depth -= 1;
+			if (depth === 0) try {
+				return JSON.parse(raw.slice(start, index + 1));
+			} catch {
+				return;
+			}
+		}
+	}
+}
+function compileToolCallRecipe(input) {
+	const toolName = input.toolName.trim();
+	if (!toolName) throw new Error("Tool name is required.");
+	const argsJson = snippetArgsJson(input.argsJson);
+	parseObjectJson(argsJson, "Tool args");
+	const parentMessageId = input.parentMessageId ?? createSnippetId();
+	const toolCallId = input.toolCallId ?? createSnippetId();
+	return ensureRunEnvelope([
+		{
+			type: "TOOL_CALL_START",
+			toolCallId,
+			toolCallName: toolName,
+			parentMessageId
+		},
+		{
+			type: "TOOL_CALL_ARGS",
+			toolCallId,
+			delta: argsJson
+		},
+		{
+			type: "TOOL_CALL_END",
+			toolCallId
+		}
+	], input);
+}
+function compileReasoningRecipe(input) {
+	const text = input.text.trim();
+	if (!text) throw new Error("Reasoning text is required.");
+	const messageId = createSnippetId();
+	return ensureRunEnvelope([
+		{
+			type: "REASONING_START",
+			messageId
+		},
+		{
+			type: "REASONING_MESSAGE_START",
+			messageId,
+			role: "reasoning"
+		},
+		{
+			type: "REASONING_MESSAGE_CONTENT",
+			messageId,
+			delta: text
+		},
+		{
+			type: "REASONING_MESSAGE_END",
+			messageId
+		},
+		{
+			type: "REASONING_END",
+			messageId
+		}
+	], input);
+}
+function compileTextRecipe(input) {
+	const text = input.text.trim();
+	if (!text) throw new Error("Assistant text is required.");
+	const messageId = input.messageId ?? createSnippetId();
+	return ensureRunEnvelope([
+		{
+			type: "TEXT_MESSAGE_START",
+			messageId,
+			role: "assistant"
+		},
+		{
+			type: "TEXT_MESSAGE_CONTENT",
+			messageId,
+			delta: text
+		},
+		{
+			type: "TEXT_MESSAGE_END",
+			messageId
+		}
+	], input);
+}
+function compileActivityRecipe(input) {
+	const activityType = input.activityType.trim();
+	if (!activityType) throw new Error("Activity type is required.");
+	const content = parseObjectJson(input.contentJson, "Activity content");
+	return ensureRunEnvelope([{
+		type: "ACTIVITY_SNAPSHOT",
+		messageId: input.messageId ?? createSnippetId(),
+		activityType,
+		content,
+		replace: true
+	}], input);
+}
+function emptyRecipeDraft() {
+	return {
+		toolName: "",
+		toolArgs: "{}",
+		reasoningText: "",
+		textContent: "",
+		activityType: "a2ui-surface",
+		activityContent: "{}"
+	};
+}
+function compileChatSnippet(input) {
+	switch (input.kind) {
+		case "text": return {
+			recipe: "text",
+			events: compileTextRecipe({
+				text: input.content,
+				threadId: input.threadId,
+				runId: input.runId,
+				messageId: input.messageId
+			}),
+			name: autoSnippetName("text", snippetLabelFromText(input.content))
+		};
+		case "reasoning": return {
+			recipe: "reasoning",
+			events: compileReasoningRecipe({
+				text: input.content,
+				threadId: input.threadId,
+				runId: input.runId
+			}),
+			name: autoSnippetName("reasoning", snippetLabelFromText(input.content))
+		};
+		case "tool-call": return {
+			recipe: "tool-call",
+			events: compileToolCallRecipe({
+				toolName: input.toolName,
+				argsJson: snippetArgsJson(input.argsJson),
+				threadId: input.threadId,
+				runId: input.runId,
+				parentMessageId: input.messageId,
+				toolCallId: input.toolCallId
+			}),
+			name: autoSnippetName("tool-call", input.toolName)
+		};
+		case "activity": return {
+			recipe: "activity",
+			events: compileActivityRecipe({
+				activityType: input.activityType,
+				contentJson: JSON.stringify(input.content ?? {}),
+				threadId: input.threadId,
+				runId: input.runId,
+				messageId: input.messageId
+			}),
+			name: autoSnippetName("activity", input.activityType)
+		};
+	}
+}
+function editorStateFromSnippet(snippet) {
+	return {
+		recipe: snippet.recipe,
+		name: snippet.name,
+		json: JSON.stringify(snippet.events, null, 2),
+		draft: recipeDraftFromEvents(snippet.events)
+	};
+}
+function recipeDraftFromEvents(events) {
+	const draft = emptyRecipeDraft();
+	const textParts = [];
+	const reasoningParts = [];
+	const argParts = [];
+	for (const event of events) {
+		if (event.type === "TEXT_MESSAGE_CONTENT") {
+			const delta = readEventString(event, "delta");
+			if (delta) textParts.push(delta);
+		}
+		if (event.type === "REASONING_MESSAGE_CONTENT") {
+			const delta = readEventString(event, "delta");
+			if (delta) reasoningParts.push(delta);
+		}
+		if (event.type === "TOOL_CALL_START") {
+			const toolName = readEventString(event, "toolCallName");
+			if (toolName) draft.toolName = toolName;
+		}
+		if (event.type === "TOOL_CALL_ARGS") {
+			const delta = readEventString(event, "delta");
+			if (delta) argParts.push(delta);
+		}
+		if (event.type === "ACTIVITY_SNAPSHOT") {
+			const activityType = readEventString(event, "activityType");
+			if (activityType) draft.activityType = activityType;
+			draft.activityContent = prettyJson(event.content ?? {});
+		}
+	}
+	draft.textContent = textParts.join("");
+	draft.reasoningText = reasoningParts.join("");
+	if (argParts.length > 0) draft.toolArgs = prettyJson(argParts.join(""));
+	return draft;
+}
+function compileFromActivityMessage(input) {
+	return compileChatSnippet({
+		kind: "activity",
+		messageId: input.message.id,
+		activityType: input.message.activityType,
+		content: input.message.content,
+		threadId: input.threadId,
+		runId: input.runId
+	});
+}
+function parseSnippetEvents(raw) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error("Snippet JSON is invalid.");
+	}
+	if (!Array.isArray(parsed)) throw new Error("Snippet JSON must be an array of events.");
+	const events = [];
+	for (const item of parsed) {
+		if (!item || typeof item !== "object" || Array.isArray(item)) throw new Error("Each event must be an object with a string type.");
+		const record = item;
+		if (typeof record.type !== "string" || record.type.length === 0) throw new Error("Each event must have a string type.");
+		events.push(item);
+	}
+	return events;
+}
+function loadEventSnippets(storage = defaultStorage()) {
+	if (!storage) return [];
+	try {
+		const raw = storage.getItem(EVENT_SNIPPETS_STORAGE_KEY);
+		if (!raw) return [];
+		const parsed = JSON.parse(raw);
+		if (!Array.isArray(parsed)) return [];
+		return parsed.flatMap((item) => {
+			const snippet = parseStoredSnippet(item);
+			return snippet ? [snippet] : [];
+		});
+	} catch {
+		return [];
+	}
+}
+function saveEventSnippets(snippets, storage = defaultStorage()) {
+	if (!storage) throw new Error("Snippet storage is not available.");
+	storage.setItem(EVENT_SNIPPETS_STORAGE_KEY, JSON.stringify(snippets));
+}
+function upsertEventSnippet(snippet, storage = defaultStorage()) {
+	const current = loadEventSnippets(storage);
+	const index = current.findIndex((item) => item.id === snippet.id);
+	const next = index === -1 ? [...current, snippet] : current.map((item, itemIndex) => itemIndex === index ? snippet : item);
+	saveEventSnippets(next, storage);
+	return next;
+}
+function deleteEventSnippet(id, storage = defaultStorage()) {
+	const next = loadEventSnippets(storage).filter((item) => item.id !== id);
+	saveEventSnippets(next, storage);
+	return next;
+}
+function exportEventSnippetsJson(snippets) {
+	return JSON.stringify(snippets, null, 2);
+}
+function importEventSnippets(raw, storage = defaultStorage()) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error("Import JSON is invalid.");
+	}
+	const incoming = Array.isArray(parsed) ? parsed : [parsed];
+	const imported = [];
+	for (const item of incoming) {
+		const snippet = parseStoredSnippet(item);
+		if (!snippet) throw new Error("Import JSON is not a valid snippet list.");
+		imported.push({
+			...snippet,
+			id: createSnippetId(),
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	}
+	if (imported.length === 0) throw new Error("Import JSON is not a valid snippet list.");
+	const next = [...loadEventSnippets(storage), ...imported];
+	saveEventSnippets(next, storage);
+	return next;
+}
+function snippetLabelFromText(text) {
+	const compact = text.trim().replace(/\s+/g, " ");
+	if (compact.length <= 40) return compact;
+	return `${compact.slice(0, 37)}...`;
+}
+function parseObjectJson(raw, label) {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		throw new Error(`${label} JSON is invalid.`);
+	}
+}
+function readEventString(event, key) {
+	const value = event[key];
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function prettyJson(value) {
+	if (typeof value === "string") try {
+		return JSON.stringify(JSON.parse(value), null, 2);
+	} catch {
+		return value;
+	}
+	try {
+		return JSON.stringify(value ?? {}, null, 2);
+	} catch {
+		return "{}";
+	}
+}
+function parseStoredSnippet(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	if (typeof record.id !== "string" || record.id.length === 0) return null;
+	if (typeof record.name !== "string") return null;
+	if (!isSnippetRecipe(record.recipe)) return null;
+	if (!Array.isArray(record.events)) return null;
+	const events = [];
+	for (const event of record.events) {
+		if (!event || typeof event !== "object" || Array.isArray(event)) return null;
+		if (typeof event.type !== "string") return null;
+		events.push(event);
+	}
+	return {
+		id: record.id,
+		name: record.name,
+		recipe: record.recipe,
+		events,
+		createdAt: typeof record.createdAt === "string" ? record.createdAt : (/* @__PURE__ */ new Date()).toISOString(),
+		updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+function defaultStorage() {
+	if (typeof window === "undefined") return null;
+	try {
+		return window.localStorage;
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+export { ACTIVITY_STARTERS, compileActivityRecipe, compileChatSnippet, compileFromActivityMessage, compileReasoningRecipe, compileTextRecipe, compileToolCallRecipe, createSnippetId, deleteEventSnippet, editorStateFromSnippet, expandSnippetEventsForRun, exportEventSnippetsJson, groupEventSnippets, importEventSnippets, loadEventSnippets, parseSnippetEvents, recipeIconName, recipeIconWrapClass, recipeLabel, snippetContainsToolCall, snippetJsonIsRunnable, upsertEventSnippet };
+//# sourceMappingURL=event-snippets.mjs.map