@anvia/react-ui 0.4.3 → 0.5.1

package/dist/chunk-ZODMCETL.js

@@ -0,0 +1,996 @@
+import {
+  Attachment
+} from "./chunk-WUMACFYS.js";
+import {
+  renderPrimitive
+} from "./chunk-T3ZFZ3NP.js";
+import {
+  InternalAttachmentProvider,
+  InternalMessagePartProvider,
+  useChatContext,
+  useMessage,
+  useMessagePart,
+  useOptionalMessagePart
+} from "./chunk-YQJLVBQD.js";
+
+// src/message/actions.tsx
+import { forwardRef, useCallback, useEffect, useRef, useState } from "react";
+
+// src/format/message.ts
+function messageText(message) {
+  return message.parts.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+
+// src/format/value.ts
+function stringifyValue(value) {
+  if (value === void 0) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+
+// src/message/actions.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var MessageActions = forwardRef(
+  function MessageActions2(props, ref) {
+    return renderPrimitive(
+      "div",
+      {
+        ...props,
+        children: props.children ?? /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(MessageCopy, {}),
+          /* @__PURE__ */ jsx(MessageRegenerate, {})
+        ] }),
+        "data-anvia-message-actions": ""
+      },
+      ref
+    );
+  }
+);
+var MessageCopy = forwardRef(function MessageCopy2({ 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-anvia-copy": "",
+      "data-state": copyState
+    },
+    ref
+  );
+});
+var MessageRegenerate = forwardRef(
+  function MessageRegenerate2({ 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 === "streaming" || message.role !== "assistant" || latestAssistantMessage?.id !== message.id);
+    const handleClick = useCallback(
+      (event) => {
+        onClick?.(event);
+        if (event.defaultPrevented || disabled) {
+          return;
+        }
+        void chat.regenerate();
+      },
+      [chat, disabled, onClick]
+    );
+    return renderPrimitive(
+      "button",
+      {
+        ...props,
+        children: props.children ?? "Regenerate",
+        disabled,
+        onClick: handleClick,
+        type: props.type ?? "button",
+        "data-anvia-regenerate": "",
+        "data-state": disabled ? "disabled" : "idle"
+      },
+      ref
+    );
+  }
+);
+
+// src/message/entity.tsx
+import { forwardRef as forwardRef2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var MessageEntity = forwardRef2(function MessageEntity2({ children, entity, ...props }, ref) {
+  return /* @__PURE__ */ jsx2(
+    "span",
+    {
+      ...props,
+      "data-anvia-message-entity": "",
+      "data-entity-id": entity.id,
+      "data-trigger-id": entity.triggerId,
+      ref,
+      children: children ?? entity.text
+    }
+  );
+});
+
+// src/message/parts.tsx
+import {
+  useSmoothStreamText
+} from "@anvia/react";
+import { createElement, forwardRef as forwardRef3 } from "react";
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+
+// 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 candidates = composerEntityCandidates(metadata);
+  const individuallyValid = candidates.flatMap(
+    (entity, index) => isValidComposerEntity(entity, text) ? [{ 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 isValidComposerEntity(value, text) {
+  if (!isRecord(value) || !isRecord(value.range)) {
+    return false;
+  }
+  if (!isNonEmptyString(value.id) || !isNonEmptyString(value.triggerId) || !isNonEmptyString(value.trigger) || !isNonEmptyString(value.label) || !isNonEmptyString(value.text)) {
+    return false;
+  }
+  const { from, to } = value.range;
+  return 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;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/message/markdown-entities.ts
+var phrasingParentTypes = /* @__PURE__ */ new Set([
+  "paragraph",
+  "heading",
+  "emphasis",
+  "strong",
+  "delete",
+  "link",
+  "linkReference",
+  "tableCell"
+]);
+var literalNodeTypes = /* @__PURE__ */ new Set(["code", "inlineCode", "html", "yaml"]);
+function createMessageEntityRemarkPlugin(markdown, entities) {
+  return function messageEntityRemarkPlugin() {
+    return (tree) => {
+      const rendered = /* @__PURE__ */ new Set();
+      transformNode(tree, markdown, entities, rendered);
+    };
+  };
+}
+function messageEntityRehypeOptions() {
+  return {
+    handlers: {
+      messageEntity(_state, node) {
+        const entityIndex = node.entityIndex;
+        return {
+          type: "element",
+          tagName: "span",
+          properties: {
+            dataAnviaMessageEntity: "",
+            dataAnviaEntityIndex: 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 void 0;
+  }
+  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 void 0;
+    }
+    const childIndex = node.children.findIndex((child2) => containsStart(child2, entity.range.from));
+    const child = node.children[childIndex];
+    if (child === void 0) {
+      return void 0;
+    }
+    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 void 0;
+  }
+  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 void 0;
+  }
+  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 void 0;
+    }
+    const childIndex = findLastIndex(node.children, (child2) => containsEnd(child2, entity.range.to));
+    const child = node.children[childIndex];
+    if (child === void 0) {
+      return void 0;
+    }
+    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 void 0;
+  }
+  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 void 0;
+  }
+  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 void 0;
+    }
+    if (index === occurrence) {
+      return found;
+    }
+    offset = found + search.length;
+  }
+  return void 0;
+}
+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
+import { Fragment as Fragment2, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var MessageParts = forwardRef3(function MessageParts2({ children, filter, ...props }, ref) {
+  const { message } = useMessage();
+  const parts = filter === void 0 ? message.parts : message.parts.filter(filter);
+  return renderPrimitive(
+    "div",
+    {
+      ...props,
+      children: parts.map((part) => /* @__PURE__ */ jsx3(InternalMessagePartProvider, { part, children: typeof children === "function" ? children(part) : children ?? /* @__PURE__ */ jsx3(MessagePart, {}) }, part.id)),
+      "data-anvia-message-parts": ""
+    },
+    ref
+  );
+});
+var MessagePart = forwardRef3(function MessagePart2({ children, ...props }, ref) {
+  const { part } = useMessagePart();
+  const renderedChildren = typeof children === "function" ? children(part) : children ?? defaultPart(part);
+  return renderPrimitive(
+    "div",
+    {
+      ...props,
+      children: renderedChildren,
+      "data-anvia-part": "",
+      "data-part": part.type
+    },
+    ref
+  );
+});
+var MessageText = forwardRef3(function MessageText2(props, ref) {
+  const { part } = useMessagePart();
+  if (part.type !== "text") {
+    return null;
+  }
+  return /* @__PURE__ */ jsx3(MessageTextContent, { ...props, content: part.text, ref });
+});
+var MessageTextContent = forwardRef3(
+  function MessageTextContent2({
+    animate = false,
+    animationMode = "smooth",
+    isStreaming,
+    smoothingPreset,
+    reducedMotion,
+    content,
+    ...props
+  }, ref) {
+    const animationEnabled = animate && props.children === void 0;
+    const smooth = useSmoothStreamText(
+      content,
+      smoothStreamOptions(
+        animationEnabled,
+        animationMode,
+        isStreaming,
+        smoothingPreset,
+        reducedMotion
+      )
+    );
+    const animationActive = animationEnabled && animationMode !== "none" && isStreaming !== false && reducedMotion !== true;
+    return renderPrimitive(
+      "span",
+      {
+        ...props,
+        children: props.children ?? (animationEnabled ? smooth.text : content),
+        "data-anvia-text": "",
+        "data-anvia-stream-animation": animationEnabled ? animationMode : void 0,
+        "data-streaming": animationActive ? "" : void 0
+      },
+      ref
+    );
+  }
+);
+var MessageMarkdown = forwardRef3(function MessageMarkdown2({ 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);
+  return /* @__PURE__ */ jsx3(MessageMarkdownContent, { ...props, entities, markdown, ref });
+});
+var MessageMarkdownContent = forwardRef3(
+  function MessageMarkdownContent2({
+    animate = false,
+    animationMode = "smooth",
+    isStreaming,
+    smoothingPreset,
+    reducedMotion,
+    components,
+    renderEntity,
+    remarkPlugins,
+    entities,
+    markdown,
+    ...props
+  }, ref) {
+    const smooth = useSmoothStreamText(
+      markdown,
+      smoothStreamOptions(animate, animationMode, isStreaming, smoothingPreset, reducedMotion)
+    );
+    const animationActive = animate && animationMode !== "none" && isStreaming !== false && reducedMotion !== true;
+    const renderedMarkdown = animate ? smooth.text : markdown;
+    const renderedEntities = validComposerEntities(renderedMarkdown, {
+      composer: { entities }
+    });
+    return renderPrimitive(
+      "div",
+      {
+        ...props,
+        children: /* @__PURE__ */ jsx3(
+          ReactMarkdown,
+          {
+            components: markdownComponents(components, renderedEntities, renderEntity),
+            remarkPlugins: [
+              createMessageEntityRemarkPlugin(renderedMarkdown, renderedEntities),
+              ...remarkPlugins ?? [remarkGfm]
+            ],
+            remarkRehypeOptions: messageEntityRehypeOptions(),
+            children: renderedMarkdown
+          }
+        ),
+        "data-anvia-markdown": "",
+        "data-anvia-stream-animation": animate ? animationMode : void 0,
+        "data-streaming": animationActive ? "" : void 0
+      },
+      ref
+    );
+  }
+);
+function markdownComponents(components, entities, renderEntity) {
+  const consumerSpan = components?.span;
+  return {
+    code: defaultCodeComponent,
+    pre: defaultPreComponent,
+    ...components,
+    span(spanProps) {
+      const internalProps = spanProps;
+      const entityIndexValue = internalProps["data-anvia-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-anvia-entity-index"];
+      if (entity !== void 0) {
+        if (renderEntity !== void 0) {
+          return renderEntity(entity);
+        }
+        const entityProps = {
+          ...consumerProps,
+          "data-anvia-message-entity": "",
+          "data-entity-id": entity.id,
+          "data-trigger-id": entity.triggerId
+        };
+        if (consumerSpan !== void 0) {
+          return createElement(consumerSpan, entityProps);
+        }
+        const { node: _node2, ...elementProps2 } = entityProps;
+        return /* @__PURE__ */ jsx3(MessageEntity, { ...elementProps2, entity });
+      }
+      if (consumerSpan !== void 0) {
+        return createElement(consumerSpan, consumerProps);
+      }
+      const { node: _node, ...elementProps } = consumerProps;
+      return /* @__PURE__ */ jsx3("span", { ...elementProps });
+    }
+  };
+}
+function smoothStreamOptions(enabled, mode, isStreaming, preset, reducedMotion) {
+  const options = { enabled, mode };
+  if (isStreaming !== void 0) options.isStreaming = isStreaming;
+  if (preset !== void 0) options.preset = preset;
+  if (reducedMotion !== void 0) options.reducedMotion = reducedMotion;
+  return options;
+}
+var MessageCodeBlock = forwardRef3(
+  function MessageCodeBlock2({ children, code, language, ...props }, ref) {
+    return renderPrimitive(
+      "pre",
+      {
+        ...props,
+        children: children ?? /* @__PURE__ */ jsx3("code", { "data-anvia-code": "", "data-language": language, children: code ?? "" }),
+        "data-anvia-code-block": "",
+        "data-language": language
+      },
+      ref
+    );
+  }
+);
+var MessageReasoning = forwardRef3(
+  function MessageReasoning2(props, ref) {
+    const { part } = useMessagePart();
+    if (part.type !== "reasoning") {
+      return null;
+    }
+    return renderPrimitive(
+      "details",
+      {
+        ...props,
+        children: props.children ?? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+          /* @__PURE__ */ jsx3("summary", { children: "Reasoning" }),
+          /* @__PURE__ */ jsx3("pre", { children: part.text })
+        ] }),
+        "data-anvia-reasoning": ""
+      },
+      ref
+    );
+  }
+);
+var MessageTool = forwardRef3(function MessageTool2({ 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-anvia-tool": "",
+      "data-state": part.state
+    },
+    ref
+  );
+});
+var MessageToolName = forwardRef3(
+  function MessageToolName2(props, ref) {
+    const { part } = useMessagePart();
+    if (part.type !== "tool") {
+      return null;
+    }
+    return renderPrimitive(
+      "span",
+      {
+        ...props,
+        children: props.children ?? part.toolName,
+        "data-anvia-tool-name": ""
+      },
+      ref
+    );
+  }
+);
+var MessageToolStatus = forwardRef3(
+  function MessageToolStatus2(props, ref) {
+    const { part } = useMessagePart();
+    if (part.type !== "tool") {
+      return null;
+    }
+    return renderPrimitive(
+      "span",
+      {
+        ...props,
+        children: props.children ?? toolStateLabel(part.state),
+        "data-anvia-tool-status": "",
+        "data-state": part.state
+      },
+      ref
+    );
+  }
+);
+var MessageToolInput = forwardRef3(
+  function MessageToolInput2(props, ref) {
+    const { part } = useMessagePart();
+    if (part.type !== "tool" || part.input === void 0) {
+      return null;
+    }
+    return renderPrimitive(
+      "pre",
+      {
+        ...props,
+        children: props.children ?? stringifyValue(part.input),
+        "data-anvia-tool-input": ""
+      },
+      ref
+    );
+  }
+);
+var MessageToolOutput = forwardRef3(
+  function MessageToolOutput2(props, ref) {
+    const { part } = useMessagePart();
+    if (part.type !== "tool" || part.output === void 0) {
+      return null;
+    }
+    return renderPrimitive(
+      "pre",
+      {
+        ...props,
+        children: props.children ?? stringifyValue(part.output),
+        "data-anvia-tool-output": ""
+      },
+      ref
+    );
+  }
+);
+var MessageToolError = forwardRef3(
+  function MessageToolError2(props, ref) {
+    const { part } = useMessagePart();
+    if (part.type !== "tool" || part.error === void 0) {
+      return null;
+    }
+    return renderPrimitive(
+      "div",
+      {
+        ...props,
+        children: props.children ?? part.error.message,
+        "data-anvia-tool-error": "",
+        role: props.role ?? "alert"
+      },
+      ref
+    );
+  }
+);
+var MessageAttachment = forwardRef3(
+  function MessageAttachment2({ children, ...props }, ref) {
+    const { part } = useMessagePart();
+    if (part.type !== "attachment") {
+      return null;
+    }
+    const renderedChildren = typeof children === "function" ? children(part.attachment) : children ?? /* @__PURE__ */ jsx3(Attachment.Root, {});
+    return /* @__PURE__ */ jsx3(InternalAttachmentProvider, { value: { attachment: part.attachment }, children: renderPrimitive(
+      "div",
+      {
+        ...props,
+        children: renderedChildren,
+        "data-anvia-message-attachment": ""
+      },
+      ref
+    ) });
+  }
+);
+var MessageData = forwardRef3(
+  function MessageData2(props, ref) {
+    const { part } = useMessagePart();
+    if (part.type !== "data") {
+      return null;
+    }
+    return renderPrimitive(
+      "pre",
+      {
+        ...props,
+        children: props.children ?? stringifyValue(part.data),
+        "data-anvia-data": "",
+        "data-name": part.name
+      },
+      ref
+    );
+  }
+);
+var MessageError = forwardRef3(
+  function MessageError2(props, ref) {
+    const { part } = useMessagePart();
+    if (part.type !== "error") {
+      return null;
+    }
+    return renderPrimitive(
+      "div",
+      {
+        ...props,
+        children: props.children ?? part.error.message,
+        "data-anvia-error": "",
+        role: props.role ?? "alert"
+      },
+      ref
+    );
+  }
+);
+function defaultPart(part) {
+  if (part.type === "text") {
+    return /* @__PURE__ */ jsx3(MessageText, {});
+  }
+  if (part.type === "reasoning") {
+    return /* @__PURE__ */ jsx3(MessageReasoning, {});
+  }
+  if (part.type === "tool") {
+    return /* @__PURE__ */ jsx3(MessageTool, {});
+  }
+  if (part.type === "attachment") {
+    return /* @__PURE__ */ jsx3(MessageAttachment, {});
+  }
+  if (part.type === "data") {
+    return /* @__PURE__ */ jsx3(MessageData, {});
+  }
+  return /* @__PURE__ */ jsx3(MessageError, {});
+}
+function defaultToolContent() {
+  return /* @__PURE__ */ jsxs2(Fragment2, { children: [
+    /* @__PURE__ */ jsx3(MessageToolName, {}),
+    /* @__PURE__ */ jsx3(MessageToolStatus, {}),
+    /* @__PURE__ */ jsx3(MessageToolInput, {}),
+    /* @__PURE__ */ jsx3(MessageToolOutput, {}),
+    /* @__PURE__ */ jsx3(MessageToolError, {})
+  ] });
+}
+function defaultCodeComponent({
+  children,
+  className,
+  node: _node,
+  ...props
+}) {
+  const language = /language-(\S+)/.exec(className ?? "")?.[1];
+  return /* @__PURE__ */ jsx3(
+    "code",
+    {
+      className,
+      "data-anvia-code": "",
+      "data-anvia-inline-code": language === void 0 ? "" : void 0,
+      "data-language": language,
+      ...props,
+      children
+    }
+  );
+}
+function defaultPreComponent({
+  children,
+  node: _node,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx3(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/root.tsx
+import { forwardRef as forwardRef4 } from "react";
+var MessageRoot = forwardRef4(function MessageRoot2({ children, ...props }, ref) {
+  const { message } = useMessage();
+  const renderedChildren = typeof children === "function" ? children(message) : children;
+  return renderPrimitive(
+    "article",
+    {
+      ...props,
+      children: renderedChildren,
+      "data-anvia-message": "",
+      "data-anvia-message-id": message.id,
+      "data-role": message.role
+    },
+    ref
+  );
+});
+var MessageContent = forwardRef4(
+  function MessageContent2(props, ref) {
+    return renderPrimitive(
+      "div",
+      {
+        ...props,
+        "data-anvia-message-content": ""
+      },
+      ref
+    );
+  }
+);
+
+// src/message/index.ts
+var Message = {
+  Root: MessageRoot,
+  Content: MessageContent,
+  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,
+  Message
+};
+//# sourceMappingURL=chunk-ZODMCETL.js.map