@anvia/react-ui 1.3.0 → 1.3.2

package/dist/message-CElFEKgL.js

@@ -0,0 +1,783 @@
+import { I as useChatContext, R as InternalAttachmentProvider, d as InternalMessagePartProvider, h as useOptionalMessagePart, m as useMessagePart, p as useMessage } from "./contexts-B4ijG24z.js";
+import { t as composeRefs } from "./refs-Djj9rSvB.js";
+import { t as renderPrimitive } from "./primitives-xfE7zfwJ.js";
+import { t as AttachmentPrimitive } from "./attachment-By2pged3.js";
+import { t as stringifyValue } from "./value-BGGrx72L.js";
+import { t as StreamMarkdown } from "./stream-CAO0x8_1.js";
+import { n as registerMessageElement } from "./elements-D4vmkkF8.js";
+import { createElement, forwardRef, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { useSmoothStreamItems, useSmoothStreamText } from "@anvia/react";
+import remarkGfm from "remark-gfm";
+// src/strict-json.ts
+function isComposerEntityData(value) {
+	return isComposerEntityDataWithAncestors(value, /* @__PURE__ */ new WeakSet());
+}
+function isComposerEntityDataWithAncestors(value, ancestors) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (typeof value !== "object" || ancestors.has(value)) return false;
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) {
+			if (Object.getPrototypeOf(value) !== Array.prototype || !hasOnlyDenseArrayProperties(value)) return false;
+			for (let index = 0; index < value.length; index += 1) if (!isComposerEntityDataWithAncestors(value[index], ancestors)) return false;
+			return true;
+		}
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== Object.prototype && prototype !== null) return false;
+		for (const key of Reflect.ownKeys(value)) {
+			if (typeof key !== "string") return false;
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			if (descriptor === void 0 || !descriptor.enumerable || !("value" in descriptor) || !isComposerEntityDataWithAncestors(descriptor.value, ancestors)) return false;
+		}
+		return true;
+	} catch {
+		return false;
+	} finally {
+		ancestors.delete(value);
+	}
+}
+function hasOnlyDenseArrayProperties(value) {
+	const keys = Reflect.ownKeys(value);
+	if (keys.length !== value.length + 1 || keys.at(-1) !== "length") return false;
+	for (let index = 0; index < value.length; index += 1) {
+		const key = String(index);
+		if (keys[index] !== key) return false;
+		const descriptor = Object.getOwnPropertyDescriptor(value, key);
+		if (descriptor === void 0 || !descriptor.enumerable || !("value" in descriptor)) return false;
+	}
+	return true;
+}
+// src/entities.ts
+function messageTextLayout(parts) {
+	const textParts = parts.filter((part) => part.type === "text");
+	const segments = [];
+	let offset = 0;
+	for (const [index, part] of textParts.entries()) {
+		const from = offset;
+		const to = from + part.text.length;
+		segments.push({
+			part,
+			from,
+			to
+		});
+		offset = to + (index === textParts.length - 1 ? 0 : 2);
+	}
+	return {
+		text: textParts.map((part) => part.text).join("\n\n"),
+		segments
+	};
+}
+function validComposerEntities(text, metadata) {
+	const individuallyValid = composerEntityCandidates(metadata).flatMap((candidate, index) => {
+		const entity = parseComposerEntity(candidate, text);
+		return entity === void 0 ? [] : [{
+			entity,
+			index
+		}];
+	});
+	individuallyValid.sort((left, right) => left.entity.range.from - right.entity.range.from || left.entity.range.to - right.entity.range.to || left.index - right.index);
+	const overlapping = /* @__PURE__ */ new Set();
+	let groupStart = 0;
+	let groupEnd = individuallyValid[0]?.entity.range.to ?? 0;
+	let groupHasOverlap = false;
+	for (let index = 1; index <= individuallyValid.length; index += 1) {
+		const current = individuallyValid[index];
+		if (current !== void 0 && current.entity.range.from < groupEnd) {
+			groupHasOverlap = true;
+			groupEnd = Math.max(groupEnd, current.entity.range.to);
+			continue;
+		}
+		if (groupHasOverlap) for (let groupIndex = groupStart; groupIndex < index; groupIndex += 1) {
+			const candidate = individuallyValid[groupIndex];
+			if (candidate !== void 0) overlapping.add(candidate.index);
+		}
+		groupStart = index;
+		groupEnd = current?.entity.range.to ?? 0;
+		groupHasOverlap = false;
+	}
+	return individuallyValid.filter((candidate) => !overlapping.has(candidate.index)).map((candidate) => candidate.entity);
+}
+function entitiesForTextSegment(entities, segment) {
+	return entities.flatMap((entity) => {
+		if (entity.range.from < segment.from || entity.range.to > segment.to) return [];
+		return [{
+			...entity,
+			range: {
+				from: entity.range.from - segment.from,
+				to: entity.range.to - segment.from
+			}
+		}];
+	});
+}
+function shiftComposerEntityRanges(entities, offset) {
+	if (offset === 0) return entities;
+	return entities.map((entity) => ({
+		...entity,
+		range: {
+			from: entity.range.from + offset,
+			to: entity.range.to + offset
+		}
+	}));
+}
+function composerEntityCandidates(metadata) {
+	if (!isRecord(metadata) || !isRecord(metadata.composer)) return [];
+	return Array.isArray(metadata.composer.entities) ? metadata.composer.entities : [];
+}
+function parseComposerEntity(value, text) {
+	if (!isRecord(value) || !isRecord(value.range)) return;
+	if (!isNonEmptyString(value.id) || !isNonEmptyString(value.triggerId) || !isNonEmptyString(value.trigger) || !isNonEmptyString(value.label) || !isNonEmptyString(value.text)) return;
+	const { from, to } = value.range;
+	if (typeof from !== "number" || typeof to !== "number" || !Number.isInteger(from) || !Number.isInteger(to) || from < 0 || to <= from || to > text.length || text.slice(from, to) !== value.text) return;
+	if (value.data !== void 0 && !isComposerEntityData(value.data)) return void 0;
+	const entity = {
+		id: value.id,
+		triggerId: value.triggerId,
+		trigger: value.trigger,
+		label: value.label,
+		text: value.text,
+		range: {
+			from,
+			to
+		}
+	};
+	if (value.data !== void 0) entity.data = value.data;
+	return entity;
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.length > 0;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// src/format/message.ts
+function messageText(message) {
+	return message.parts.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+// src/message/actions.tsx
+const MessageActions = forwardRef(function MessageActions(props, ref) {
+	const chat = useChatContext();
+	const { message } = useMessage();
+	const index = chat.messages.findIndex((item) => item.id === message.id);
+	if (message.role !== "assistant" || index < 0 || (props.children == null || typeof props.children === "boolean") && messageText(message).trim().length === 0) return null;
+	const following = chat.messages.slice(index + 1);
+	const nextUserIndex = following.findIndex((item) => item.role === "user");
+	if ((nextUserIndex < 0 ? following : following.slice(0, nextUserIndex)).some((item) => item.role === "assistant") || nextUserIndex < 0 && (chat.status === "submitted" || chat.status === "streaming")) return null;
+	return renderPrimitive("div", {
+		...props,
+		children: props.children ?? /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(MessageCopy, {}), /* @__PURE__ */ jsx(MessageRegenerate, {})] })
+	}, ref);
+});
+const MessageCopy = forwardRef(function MessageCopy({ onClick, ...props }, ref) {
+	const { message } = useMessage();
+	const [copyState, setCopyState] = useState("idle");
+	const text = messageText(message);
+	const previousTextRef = useRef(text);
+	const disabled = props.disabled ?? text.length === 0;
+	useEffect(() => {
+		if (previousTextRef.current !== text) {
+			previousTextRef.current = text;
+			setCopyState("idle");
+		}
+	}, [text]);
+	const handleClick = useCallback(async (event) => {
+		onClick?.(event);
+		if (event.defaultPrevented || disabled) return;
+		const writeText = navigator.clipboard?.writeText;
+		if (writeText === void 0) {
+			setCopyState("error");
+			return;
+		}
+		try {
+			await writeText.call(navigator.clipboard, text);
+			setCopyState("copied");
+		} catch {
+			setCopyState("error");
+		}
+	}, [
+		disabled,
+		onClick,
+		text
+	]);
+	return renderPrimitive("button", {
+		...props,
+		children: props.children ?? "Copy",
+		disabled,
+		onClick: handleClick,
+		type: props.type ?? "button",
+		"data-state": copyState
+	}, ref);
+});
+const MessageRegenerate = forwardRef(function MessageRegenerate({ onClick, ...props }, ref) {
+	const chat = useChatContext();
+	const { message } = useMessage();
+	const latestAssistantMessage = [...chat.messages].reverse().find((item) => item.role === "assistant");
+	const disabled = props.disabled ?? (chat.status === "submitted" || chat.status === "streaming" || message.role !== "assistant" || latestAssistantMessage?.id !== message.id);
+	const handleClick = useCallback((event) => {
+		onClick?.(event);
+		if (event.defaultPrevented || disabled) return;
+		chat.regenerate();
+	}, [
+		chat,
+		disabled,
+		onClick
+	]);
+	return renderPrimitive("button", {
+		...props,
+		children: props.children ?? "Regenerate",
+		disabled,
+		onClick: handleClick,
+		type: props.type ?? "button",
+		"data-state": disabled ? "disabled" : "idle"
+	}, ref);
+});
+// src/message/entity.tsx
+const MessageEntity = forwardRef(function MessageEntity({ children, entity, ...props }, ref) {
+	return /* @__PURE__ */ jsx("span", {
+		...props,
+		"data-role": "entity",
+		ref,
+		children: children ?? entity.text
+	});
+});
+// src/message/markdown-entities.ts
+const phrasingParentTypes = /* @__PURE__ */ new Set([
+	"paragraph",
+	"heading",
+	"emphasis",
+	"strong",
+	"delete",
+	"link",
+	"linkReference",
+	"tableCell"
+]);
+const literalNodeTypes = /* @__PURE__ */ new Set([
+	"code",
+	"inlineCode",
+	"html",
+	"yaml"
+]);
+function createMessageEntityRemarkPlugin(markdown, entities) {
+	return function messageEntityRemarkPlugin() {
+		return (tree) => {
+			transformNode(tree, markdown, entities, /* @__PURE__ */ new Set());
+		};
+	};
+}
+function messageEntityRehypeOptions() {
+	return { handlers: { messageEntity(_state, node) {
+		const entityIndex = node.entityIndex;
+		return {
+			type: "element",
+			tagName: "span",
+			properties: { dataEntityIndex: entityIndex === void 0 ? "" : String(entityIndex) },
+			children: [{
+				type: "text",
+				value: node.value ?? ""
+			}]
+		};
+	} } };
+}
+function transformNode(node, markdown, entities, rendered) {
+	if (literalNodeTypes.has(node.type) || node.children === void 0) return;
+	for (const child of node.children) transformNode(child, markdown, entities, rendered);
+	if (!phrasingParentTypes.has(node.type)) return;
+	for (let entityIndex = entities.length - 1; entityIndex >= 0; entityIndex -= 1) {
+		if (rendered.has(entityIndex)) continue;
+		const entity = entities[entityIndex];
+		if (entity !== void 0 && replaceEntity(node, markdown, entity, entityIndex)) rendered.add(entityIndex);
+	}
+}
+function replaceEntity(parent, markdown, entity, entityIndex) {
+	const children = parent.children;
+	if (children === void 0) return false;
+	const firstIndex = children.findIndex((child) => containsStart(child, entity.range.from));
+	const lastIndex = findLastIndex(children, (child) => containsEnd(child, entity.range.to));
+	if (firstIndex < 0 || lastIndex < firstIndex) return false;
+	const first = children[firstIndex];
+	const last = children[lastIndex];
+	const firstPosition = offsets(first);
+	const lastPosition = offsets(last);
+	if (first === void 0 || last === void 0 || firstPosition === void 0 || lastPosition === void 0 || entity.range.from < firstPosition.from || entity.range.to > lastPosition.to) return false;
+	if (firstIndex === lastIndex && literalNodeTypes.has(first.type)) return false;
+	const before = contentBefore(first, markdown, entity);
+	const after = contentAfter(last, markdown, entity);
+	if (before === void 0 || after === void 0) return false;
+	const replacement = [];
+	replacement.push(...before);
+	replacement.push({
+		type: "messageEntity",
+		value: entity.text,
+		entityIndex,
+		position: {
+			start: { offset: entity.range.from },
+			end: { offset: entity.range.to }
+		}
+	});
+	replacement.push(...after);
+	children.splice(firstIndex, lastIndex - firstIndex + 1, ...replacement);
+	return true;
+}
+function contentBefore(node, markdown, entity) {
+	const position = offsets(node);
+	if (position === void 0) return;
+	if (entity.range.from === position.from) return [];
+	if (node.type !== "text" || node.value === void 0) {
+		if (node.children === void 0 || literalNodeTypes.has(node.type)) return;
+		const childIndex = node.children.findIndex((child) => containsStart(child, entity.range.from));
+		const child = node.children[childIndex];
+		if (child === void 0) return;
+		const childContent = contentBefore(child, markdown, entity);
+		return childContent === void 0 ? void 0 : [...node.children.slice(0, childIndex), ...childContent];
+	}
+	const split = textValueRange(node, markdown, entity);
+	if (split === void 0) return;
+	return [{
+		...node,
+		value: node.value.slice(0, split.from),
+		position: {
+			start: node.position?.start ?? {},
+			end: { offset: entity.range.from }
+		}
+	}];
+}
+function contentAfter(node, markdown, entity) {
+	const position = offsets(node);
+	if (position === void 0) return;
+	if (entity.range.to === position.to) return [];
+	if (node.type !== "text" || node.value === void 0) {
+		if (node.children === void 0 || literalNodeTypes.has(node.type)) return;
+		const childIndex = findLastIndex(node.children, (child) => containsEnd(child, entity.range.to));
+		const child = node.children[childIndex];
+		if (child === void 0) return;
+		const childContent = contentAfter(child, markdown, entity);
+		return childContent === void 0 ? void 0 : [...childContent, ...node.children.slice(childIndex + 1)];
+	}
+	const split = textValueRange(node, markdown, entity);
+	if (split === void 0) return;
+	return [{
+		...node,
+		value: node.value.slice(split.to),
+		position: {
+			start: { offset: entity.range.to },
+			end: node.position?.end ?? {}
+		}
+	}];
+}
+function textValueRange(node, markdown, entity) {
+	const position = offsets(node);
+	const value = node.value;
+	if (position === void 0 || value === void 0) return;
+	const raw = markdown.slice(position.from, position.to);
+	const relativeFrom = entity.range.from - position.from;
+	const relativeTo = entity.range.to - position.from;
+	if (raw === value) return {
+		from: relativeFrom,
+		to: relativeTo
+	};
+	const occurrence = countOccurrences(raw.slice(0, relativeFrom), entity.text);
+	const valueFrom = occurrenceIndex(value, entity.text, occurrence);
+	return valueFrom === void 0 ? void 0 : {
+		from: valueFrom,
+		to: valueFrom + entity.text.length
+	};
+}
+function countOccurrences(value, search) {
+	let count = 0;
+	let offset = 0;
+	while (offset <= value.length - search.length) {
+		const index = value.indexOf(search, offset);
+		if (index < 0) break;
+		count += 1;
+		offset = index + search.length;
+	}
+	return count;
+}
+function occurrenceIndex(value, search, occurrence) {
+	let offset = 0;
+	for (let index = 0; index <= occurrence; index += 1) {
+		const found = value.indexOf(search, offset);
+		if (found < 0) return;
+		if (index === occurrence) return found;
+		offset = found + search.length;
+	}
+}
+function containsStart(node, offset) {
+	const position = offsets(node);
+	return position !== void 0 && offset >= position.from && offset < position.to;
+}
+function containsEnd(node, offset) {
+	const position = offsets(node);
+	return position !== void 0 && offset > position.from && offset <= position.to;
+}
+function offsets(node) {
+	const from = node?.position?.start.offset;
+	const to = node?.position?.end.offset;
+	return typeof from === "number" && typeof to === "number" ? {
+		from,
+		to
+	} : void 0;
+}
+function findLastIndex(items, predicate) {
+	for (let index = items.length - 1; index >= 0; index -= 1) {
+		const item = items[index];
+		if (item !== void 0 && predicate(item)) return index;
+	}
+	return -1;
+}
+// src/message/parts.tsx
+const messagePartStreamAdapter = {
+	getKey: (part) => part.id,
+	getText: (part) => part.type === "text" || part.type === "reasoning" ? part.text : void 0,
+	withText: (part, text) => {
+		if (part.type === "text" || part.type === "reasoning") return part.text === text ? part : {
+			...part,
+			text
+		};
+		return part;
+	}
+};
+const MessageParts = forwardRef(function MessageParts({ children, filter, stream, ...props }, ref) {
+	const { message } = useMessage();
+	const parts = filter === void 0 ? message.parts : message.parts.filter(filter);
+	if (stream !== void 0) return /* @__PURE__ */ jsx(SmoothedMessageParts, {
+		...props,
+		parts,
+		ref,
+		stream,
+		children
+	});
+	return renderPrimitive("div", {
+		...props,
+		children: renderMessagePartNodes(parts, children),
+		"data-role": "parts"
+	}, ref);
+});
+const SmoothedMessageParts = forwardRef(function SmoothedMessageParts({ children, parts, stream, ...props }, ref) {
+	const streamOptions = {
+		adapter: messagePartStreamAdapter,
+		isStreaming: stream.isStreaming,
+		resetKey: stream.resetKey
+	};
+	if (stream.flushImmediately !== void 0) Object.assign(streamOptions, { flushImmediately: stream.flushImmediately });
+	const smooth = useSmoothStreamItems(parts, streamOptions);
+	return renderPrimitive("div", {
+		...props,
+		children: renderMessagePartNodes(smooth.items, children, smooth.liveItemKey),
+		"data-role": "parts",
+		"data-state": smooth.isDraining ? "draining" : stream.isStreaming ? "streaming" : "idle"
+	}, ref);
+});
+function renderMessagePartNodes(parts, children, liveItemKey) {
+	return parts.map((part) => /* @__PURE__ */ jsx(InternalMessagePartProvider, {
+		isLive: liveItemKey === part.id,
+		part,
+		streamControlled: liveItemKey !== void 0,
+		children: typeof children === "function" ? children(part) : children ?? /* @__PURE__ */ jsx(MessagePart, {})
+	}, part.id));
+}
+const MessagePart = forwardRef(function MessagePart({ children, ...props }, ref) {
+	const { part } = useMessagePart();
+	const renderedChildren = typeof children === "function" ? children(part) : children ?? defaultPart(part);
+	return renderPrimitive("div", {
+		...props,
+		children: renderedChildren,
+		"data-role": part.type
+	}, ref);
+});
+const MessageText = forwardRef(function MessageText(props, ref) {
+	const { part, streamControlled } = useMessagePart();
+	if (part.type !== "text") return null;
+	return /* @__PURE__ */ jsx(MessageTextContent, {
+		...props,
+		content: part.text,
+		partId: part.id,
+		ref,
+		streamControlled
+	});
+});
+const MessageTextContent = forwardRef(function MessageTextContent({ content, partId, stream, streamControlled, ...props }, ref) {
+	const ownsStream = stream !== void 0 && !streamControlled && props.children === void 0;
+	const streamOptions = {
+		isStreaming: ownsStream ? stream.isStreaming : false,
+		resetKey: ownsStream ? stream.resetKey : partId
+	};
+	if (ownsStream && stream.flushImmediately !== void 0) Object.assign(streamOptions, { flushImmediately: stream.flushImmediately });
+	const smooth = useSmoothStreamText(content, streamOptions);
+	return renderPrimitive("span", {
+		...props,
+		children: props.children ?? (ownsStream ? smooth.text : content),
+		"data-role": "text",
+		"data-state": ownsStream ? smooth.isDraining ? "draining" : stream.isStreaming ? "streaming" : "idle" : void 0
+	}, ref);
+});
+const MessageMarkdown = forwardRef(function MessageMarkdown({ children, ...props }, ref) {
+	const { message } = useMessage();
+	const partContext = useOptionalMessagePart();
+	const part = partContext?.part;
+	if (part !== void 0 && part.type !== "text") return null;
+	const layout = messageTextLayout(message.parts);
+	const markdown = children ?? (part?.type === "text" ? part.text : layout.text);
+	const expectedMarkdown = part?.type === "text" ? part.text : layout.text;
+	const validEntities = children === void 0 || children === expectedMarkdown ? validComposerEntities(layout.text, message.metadata) : [];
+	const segment = part?.type === "text" ? layout.segments.find((candidate) => candidate.part.id === part.id) : void 0;
+	const entities = segment === void 0 ? validEntities : entitiesForTextSegment(validEntities, segment);
+	const lastPart = message.parts.at(-1);
+	const liveEligible = part?.type === "text" ? lastPart?.id === part.id : lastPart?.type === "text";
+	return /* @__PURE__ */ jsx(MessageMarkdownContent, {
+		...props,
+		entities,
+		liveEligible,
+		markdown,
+		ref,
+		resetKey: message.id,
+		streamControlled: partContext?.streamControlled ?? false,
+		streamLive: partContext?.isLive ?? false
+	});
+});
+const MessageMarkdownContent = forwardRef(function MessageMarkdownContent({ components, renderEntity, remarkPlugins, entities, liveEligible, markdown, resetKey, stream, streamControlled, streamLive, ...props }, ref) {
+	const ownsStream = stream !== void 0 && !streamControlled;
+	const streamOptions = {
+		isStreaming: ownsStream ? stream.isStreaming : false,
+		resetKey: ownsStream ? stream.resetKey : resetKey
+	};
+	if (ownsStream && stream.flushImmediately !== void 0) Object.assign(streamOptions, { flushImmediately: stream.flushImmediately });
+	const smooth = useSmoothStreamText(markdown, streamOptions);
+	const renderedMarkdown = ownsStream ? smooth.text : markdown;
+	const renderedEntities = useMemo(() => entities.length === 0 ? entities : validComposerEntities(renderedMarkdown, { composer: { entities } }), [entities, renderedMarkdown]);
+	const renderedComponents = useMemo(() => markdownComponents(components, renderedEntities, renderEntity), [
+		components,
+		renderEntity,
+		renderedEntities
+	]);
+	const renderedRemarkPlugins = useMemo(() => renderedEntities.length === 0 ? remarkPlugins : [createMessageEntityRemarkPlugin(renderedMarkdown, renderedEntities), ...remarkPlugins ?? [remarkGfm]], [
+		remarkPlugins,
+		renderedEntities,
+		renderedMarkdown
+	]);
+	const live = streamControlled ? streamLive : ownsStream && liveEligible && (stream.isStreaming || smooth.isDraining);
+	return /* @__PURE__ */ jsx(StreamMarkdown, {
+		...props,
+		components: renderedComponents,
+		content: renderedMarkdown,
+		"data-state": ownsStream && smooth.isDraining ? "draining" : ownsStream && stream.isStreaming ? "streaming" : "idle",
+		live,
+		ref,
+		remarkPlugins: renderedRemarkPlugins,
+		remarkRehypeOptions: renderedEntities.length === 0 ? void 0 : messageEntityRehypeOptions()
+	});
+});
+function markdownComponents(components, entities, renderEntity) {
+	const consumerSpan = components?.span;
+	return {
+		code: defaultCodeComponent,
+		pre: defaultPreComponent,
+		...components,
+		span(spanProps) {
+			const internalProps = spanProps;
+			const entityIndexValue = internalProps["data-entity-index"];
+			const entityIndex = typeof entityIndexValue === "string" && /^\d+$/.test(entityIndexValue) ? Number(entityIndexValue) : void 0;
+			const entity = entityIndex === void 0 ? void 0 : entities[entityIndex];
+			const consumerProps = { ...internalProps };
+			delete consumerProps["data-entity-index"];
+			if (entity !== void 0) {
+				if (renderEntity !== void 0) return renderEntity(entity);
+				const entityProps = {
+					...consumerProps,
+					"data-role": "entity"
+				};
+				if (consumerSpan !== void 0) return createElement(consumerSpan, entityProps);
+				const { node: _node, ...elementProps } = entityProps;
+				return /* @__PURE__ */ jsx(MessageEntity, {
+					...elementProps,
+					entity
+				});
+			}
+			if (consumerSpan !== void 0) return createElement(consumerSpan, consumerProps);
+			const { node: _node, ...elementProps } = consumerProps;
+			return /* @__PURE__ */ jsx("span", { ...elementProps });
+		}
+	};
+}
+const MessageCodeBlock = forwardRef(function MessageCodeBlock({ children, code, language, ...props }, ref) {
+	return renderPrimitive("pre", {
+		...props,
+		"data-role": "code-block",
+		children: children ?? /* @__PURE__ */ jsx("code", {
+			className: language === void 0 ? void 0 : `language-${language}`,
+			children: code ?? ""
+		})
+	}, ref);
+});
+const MessageReasoning = forwardRef(function MessageReasoning(props, ref) {
+	const { part } = useMessagePart();
+	if (part.type !== "reasoning") return null;
+	return renderPrimitive("details", {
+		...props,
+		children: props.children ?? /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("summary", { children: "Reasoning" }), /* @__PURE__ */ jsx("pre", { children: part.text })] })
+	}, ref);
+});
+const MessageTool = forwardRef(function MessageTool({ children, renderWhen = "always", ...props }, ref) {
+	const { part } = useMessagePart();
+	if (part.type !== "tool" || !shouldRenderTool(part, renderWhen)) return null;
+	const renderedChildren = typeof children === "function" ? children(part) : children ?? defaultToolContent();
+	return renderPrimitive("div", {
+		...props,
+		children: renderedChildren,
+		"data-role": "tool",
+		"data-state": part.state
+	}, ref);
+});
+const MessageToolName = forwardRef(function MessageToolName(props, ref) {
+	const { part } = useMessagePart();
+	if (part.type !== "tool") return null;
+	return renderPrimitive("span", {
+		...props,
+		children: props.children ?? part.toolName
+	}, ref);
+});
+const MessageToolStatus = forwardRef(function MessageToolStatus(props, ref) {
+	const { part } = useMessagePart();
+	if (part.type !== "tool") return null;
+	return renderPrimitive("span", {
+		...props,
+		children: props.children ?? toolStateLabel(part.state),
+		"data-state": part.state
+	}, ref);
+});
+const MessageToolInput = forwardRef(function MessageToolInput(props, ref) {
+	const { part } = useMessagePart();
+	if (part.type !== "tool") return null;
+	return renderPrimitive("pre", {
+		...props,
+		children: props.children ?? stringifyValue(part.input)
+	}, ref);
+});
+const MessageToolOutput = forwardRef(function MessageToolOutput(props, ref) {
+	const { part } = useMessagePart();
+	if (part.type !== "tool" || part.state !== "output-available") return null;
+	return renderPrimitive("pre", {
+		...props,
+		children: props.children ?? stringifyValue(part.output)
+	}, ref);
+});
+const MessageToolError = forwardRef(function MessageToolError(props, ref) {
+	const { part } = useMessagePart();
+	if (part.type !== "tool" || part.state !== "error") return null;
+	return renderPrimitive("div", {
+		...props,
+		children: props.children ?? part.error.message,
+		role: props.role ?? "alert"
+	}, ref);
+});
+const MessageAttachment = forwardRef(function MessageAttachment({ children, ...props }, ref) {
+	const { part } = useMessagePart();
+	if (part.type !== "attachment") return null;
+	const renderedChildren = typeof children === "function" ? children(part.attachment) : children ?? /* @__PURE__ */ jsx(AttachmentPrimitive.Root, {});
+	return /* @__PURE__ */ jsx(InternalAttachmentProvider, {
+		value: { attachment: part.attachment },
+		children: renderPrimitive("div", {
+			...props,
+			children: renderedChildren
+		}, ref)
+	});
+});
+const MessageData = forwardRef(function MessageData(props, ref) {
+	const { part } = useMessagePart();
+	if (part.type !== "data") return null;
+	return renderPrimitive("pre", {
+		...props,
+		children: props.children ?? stringifyValue(part.data)
+	}, ref);
+});
+const MessageError = forwardRef(function MessageError(props, ref) {
+	const { part } = useMessagePart();
+	if (part.type !== "error") return null;
+	return renderPrimitive("div", {
+		...props,
+		children: props.children ?? part.error.message,
+		role: props.role ?? "alert"
+	}, ref);
+});
+function defaultPart(part) {
+	if (part.type === "text") return /* @__PURE__ */ jsx(MessageText, {});
+	if (part.type === "reasoning") return /* @__PURE__ */ jsx(MessageReasoning, {});
+	if (part.type === "tool") return /* @__PURE__ */ jsx(MessageTool, {});
+	if (part.type === "attachment") return /* @__PURE__ */ jsx(MessageAttachment, {});
+	if (part.type === "data") return /* @__PURE__ */ jsx(MessageData, {});
+	return /* @__PURE__ */ jsx(MessageError, {});
+}
+function defaultToolContent() {
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(MessageToolName, {}),
+		/* @__PURE__ */ jsx(MessageToolStatus, {}),
+		/* @__PURE__ */ jsx(MessageToolInput, {}),
+		/* @__PURE__ */ jsx(MessageToolOutput, {}),
+		/* @__PURE__ */ jsx(MessageToolError, {})
+	] });
+}
+function defaultCodeComponent({ children, className, node: _node, ...props }) {
+	return /* @__PURE__ */ jsx("code", {
+		className,
+		...props,
+		children
+	});
+}
+function defaultPreComponent({ children, node: _node, ...props }) {
+	return /* @__PURE__ */ jsx(MessageCodeBlock, {
+		...props,
+		children
+	});
+}
+function shouldRenderTool(part, renderWhen) {
+	if (renderWhen === "always") return true;
+	if (renderWhen === "pending") return part.state === "input-streaming" || part.state === "input-available";
+	return part.state === "output-available" || part.state === "error";
+}
+function toolStateLabel(state) {
+	if (state === "output-available") return "Done";
+	if (state === "error") return "Error";
+	return "Running";
+}
+// src/message/index.ts
+const MessagePrimitive = {
+	Root: forwardRef(function MessageRoot({ children, ...props }, ref) {
+		const { message } = useMessage();
+		const renderedChildren = typeof children === "function" ? children(message) : children;
+		const registerElement = useCallback((element) => {
+			if (element !== null) registerMessageElement(element, message.id);
+		}, [message.id]);
+		const composedRef = useMemo(() => composeRefs(ref, registerElement), [ref, registerElement]);
+		return renderPrimitive("article", {
+			...props,
+			children: renderedChildren,
+			"data-role": message.role
+		}, composedRef);
+	}),
+	Content: forwardRef(function MessageContent(props, ref) {
+		return renderPrimitive("div", { ...props }, ref);
+	}),
+	Parts: MessageParts,
+	Part: MessagePart,
+	Text: MessageText,
+	Markdown: MessageMarkdown,
+	Entity: MessageEntity,
+	CodeBlock: MessageCodeBlock,
+	Reasoning: MessageReasoning,
+	Tool: MessageTool,
+	ToolName: MessageToolName,
+	ToolInput: MessageToolInput,
+	ToolOutput: MessageToolOutput,
+	ToolError: MessageToolError,
+	ToolStatus: MessageToolStatus,
+	Attachment: MessageAttachment,
+	Data: MessageData,
+	Error: MessageError,
+	Actions: MessageActions,
+	Copy: MessageCopy,
+	Regenerate: MessageRegenerate
+};
+export { shiftComposerEntityRanges as n, isComposerEntityData as r, MessagePrimitive as t };
+
+//# sourceMappingURL=message-CElFEKgL.js.map