@ulearning/ai-sdk 0.0.0-stage → 1.0.0-next.0

package/src/primitives/composer.ts

@@ -0,0 +1,88 @@
+import type { TriggerMatch, TriggerMatcher } from "./composer/trigger";
+
+export { ComposerPrimitiveRoot as Root } from "./composer/ComposerRoot";
+export { ComposerPrimitiveInput as Input } from "./composer/ComposerInput";
+export { ComposerPrimitiveSend as Send } from "./composer/ComposerSend";
+export { ComposerPrimitiveResume as Resume } from "./composer/ComposerResume";
+export { ComposerPrimitiveCancel as Cancel } from "./composer/ComposerCancel";
+export { ComposerPrimitiveAddAttachment as AddAttachment } from "./composer/ComposerAddAttachment";
+export { ComposerPrimitiveAttachments as Attachments } from "./composer/ComposerAttachments";
+export { ComposerPrimitiveAttachmentByIndex as AttachmentByIndex } from "./composer/ComposerAttachments";
+export { ComposerPrimitiveAttachmentDropzone as AttachmentDropzone } from "./composer/ComposerAttachmentDropzone";
+export { ComposerPrimitiveDictate as Dictate } from "./composer/ComposerDictate";
+export { ComposerPrimitiveStopDictation as StopDictation } from "./composer/ComposerStopDictation";
+export { ComposerPrimitiveDictationTranscript as DictationTranscript } from "./composer/ComposerDictationTranscript";
+export { ComposerPrimitiveIf as If } from "./composer/ComposerIf";
+export { ComposerPrimitiveQuote as Quote } from "./composer/ComposerQuote";
+export { ComposerPrimitiveQuoteText as QuoteText } from "./composer/ComposerQuote";
+export { ComposerPrimitiveQuoteDismiss as QuoteDismiss } from "./composer/ComposerQuote";
+export { ComposerPrimitiveQueue as Queue } from "./composer/ComposerQueue";
+
+export { ComposerPrimitiveTriggerPopover as TriggerPopover } from "./composer/trigger";
+export {
+  /** @deprecated Use `ComposerPrimitive.TriggerPopover` instead. */
+  ComposerPrimitiveTriggerPopover as Unstable_TriggerPopover,
+} from "./composer/trigger";
+export { ComposerPrimitiveTriggerPopoverRoot as TriggerPopoverRoot } from "./composer/trigger";
+export {
+  /** @deprecated Use `ComposerPrimitive.TriggerPopoverRoot` instead. */
+  ComposerPrimitiveTriggerPopoverRoot as Unstable_TriggerPopoverRoot,
+} from "./composer/trigger";
+export { ComposerPrimitiveTriggerPopoverCategories as TriggerPopoverCategories } from "./composer/trigger";
+export {
+  /** @deprecated Use `ComposerPrimitive.TriggerPopoverCategories` instead. */
+  ComposerPrimitiveTriggerPopoverCategories as Unstable_TriggerPopoverCategories,
+} from "./composer/trigger";
+export { ComposerPrimitiveTriggerPopoverCategoryItem as TriggerPopoverCategoryItem } from "./composer/trigger";
+export {
+  /** @deprecated Use `ComposerPrimitive.TriggerPopoverCategoryItem` instead. */
+  ComposerPrimitiveTriggerPopoverCategoryItem as Unstable_TriggerPopoverCategoryItem,
+} from "./composer/trigger";
+export { ComposerPrimitiveTriggerPopoverItems as TriggerPopoverItems } from "./composer/trigger";
+export {
+  /** @deprecated Use `ComposerPrimitive.TriggerPopoverItems` instead. */
+  ComposerPrimitiveTriggerPopoverItems as Unstable_TriggerPopoverItems,
+} from "./composer/trigger";
+export { ComposerPrimitiveTriggerPopoverItem as TriggerPopoverItem } from "./composer/trigger";
+export {
+  /** @deprecated Use `ComposerPrimitive.TriggerPopoverItem` instead. */
+  ComposerPrimitiveTriggerPopoverItem as Unstable_TriggerPopoverItem,
+} from "./composer/trigger";
+export { ComposerPrimitiveTriggerPopoverBack as TriggerPopoverBack } from "./composer/trigger";
+export {
+  /** @deprecated Use `ComposerPrimitive.TriggerPopoverBack` instead. */
+  ComposerPrimitiveTriggerPopoverBack as Unstable_TriggerPopoverBack,
+} from "./composer/trigger";
+export {
+  /** @deprecated Experimental since 2026-04-15. Not scheduled for removal; the API may change in any release. */
+  useTriggerPopoverRootContext as unstable_useTriggerPopoverRootContext,
+} from "./composer/trigger";
+export {
+  /** @deprecated Experimental since 2026-04-15. Not scheduled for removal; the API may change in any release. */
+  useTriggerPopoverRootContextOptional as unstable_useTriggerPopoverRootContextOptional,
+} from "./composer/trigger";
+export {
+  /** @deprecated Experimental since 2026-04-15. Not scheduled for removal; the API may change in any release. */
+  useTriggerPopoverScopeContext as unstable_useTriggerPopoverScopeContext,
+} from "./composer/trigger";
+export {
+  /** @deprecated Experimental since 2026-04-15. Not scheduled for removal; the API may change in any release. */
+  useTriggerPopoverScopeContextOptional as unstable_useTriggerPopoverScopeContextOptional,
+} from "./composer/trigger";
+export {
+  /** @deprecated Experimental since 2026-04-15. Not scheduled for removal; the API may change in any release. */
+  useTriggerPopoverTriggers as unstable_useTriggerPopoverTriggers,
+} from "./composer/trigger";
+export {
+  /** @deprecated Experimental since 2026-04-15. Not scheduled for removal; the API may change in any release. */
+  useTriggerPopoverTriggersOptional as unstable_useTriggerPopoverTriggersOptional,
+} from "./composer/trigger";
+export type {
+  /** @deprecated Experimental since 2026-04-15. Not scheduled for removal; the API may change in any release. */
+  RegisteredTrigger as Unstable_RegisteredTrigger,
+} from "./composer/trigger";
+export type { TriggerMatch, TriggerMatcher } from "./composer/trigger";
+/** @deprecated Use `TriggerMatcher` instead. */
+export type Unstable_TriggerMatcher = TriggerMatcher;
+/** @deprecated Use `TriggerMatch` instead. */
+export type Unstable_TriggerMatch = TriggerMatch;

package/src/primitives/dropdownMenuRenderPrimitives.test.tsx

@@ -0,0 +1,64 @@
+import { renderToString } from "@vue/server-renderer";
+import { describe, expect, it } from "vitest";
+import * as ActionBarMorePrimitive from "./actionBarMore";
+import * as ThreadListItemMorePrimitive from "./threadListItemMore";
+
+describe("dropdown menu primitive render props", () => {
+  it.each([
+    [
+      "ActionBarMorePrimitive.Trigger",
+      ActionBarMorePrimitive.Root,
+      ActionBarMorePrimitive.Trigger,
+    ],
+    [
+      "ThreadListItemMorePrimitive.Trigger",
+      ThreadListItemMorePrimitive.Root,
+      ThreadListItemMorePrimitive.Trigger,
+    ],
+  ])("%s render matches asChild", async (_name, Root, Trigger) => {
+    const renderHtml = await renderToString(
+      <Root open>
+        <Trigger render={<button type="button" class="trigger" />}>
+          More
+        </Trigger>
+      </Root>,
+    );
+
+    const asChildHtml = await renderToString(
+      <Root open>
+        <Trigger asChild>
+          <button type="button" class="trigger">
+            More
+          </button>
+        </Trigger>
+      </Root>,
+    );
+
+    expect(renderHtml).toBe(asChildHtml);
+  });
+
+  it("accepts render on all affected dropdown menu primitives", () => {
+    const actionBarTree = (
+      <ActionBarMorePrimitive.Root open>
+        <ActionBarMorePrimitive.Trigger render={<button type="button" />} />
+        <ActionBarMorePrimitive.Content render={<div />} />
+        <ActionBarMorePrimitive.Item render={<div />} />
+        <ActionBarMorePrimitive.Separator render={<div />} />
+      </ActionBarMorePrimitive.Root>
+    );
+
+    const threadListItemTree = (
+      <ThreadListItemMorePrimitive.Root open>
+        <ThreadListItemMorePrimitive.Trigger
+          render={<button type="button" />}
+        />
+        <ThreadListItemMorePrimitive.Content render={<div />} />
+        <ThreadListItemMorePrimitive.Item render={<div />} />
+        <ThreadListItemMorePrimitive.Separator render={<div />} />
+      </ThreadListItemMorePrimitive.Root>
+    );
+
+    expect(actionBarTree).toBeTruthy();
+    expect(threadListItemTree).toBeTruthy();
+  });
+});

package/src/primitives/dropdownMenuRenderPrimitives.ts

@@ -0,0 +1,14 @@
+import {
+  DropdownMenuTrigger,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuSeparator,
+} from "reka-ui";
+import { withRenderProp } from "../utils/Primitive";
+
+export const DropdownMenuRenderTrigger = withRenderProp(DropdownMenuTrigger);
+export const DropdownMenuRenderContent = withRenderProp(DropdownMenuContent);
+export const DropdownMenuRenderItem = withRenderProp(DropdownMenuItem);
+export const DropdownMenuRenderSeparator = withRenderProp(
+  DropdownMenuSeparator,
+);

package/src/primitives/error/ErrorMessage.tsx

@@ -0,0 +1,39 @@
+"use client";
+
+import { defineComponent, h, type ComponentPublicInstance } from "vue";
+import { useForwardExpose } from "reka-ui";
+import { useMessageError } from "@ulearning/ai-core/vue";
+import { Primitive, type PrimitiveProps } from "../../utils/Primitive";
+
+export namespace ErrorPrimitiveMessage {
+  export type Element = ComponentPublicInstance;
+  export type Props = PrimitiveProps<"span">;
+}
+
+export const ErrorPrimitiveMessage = defineComponent(
+  (props: ErrorPrimitiveMessage.Props, { attrs, slots }) => {
+    const { forwardRef } = useForwardExpose();
+    const error = useMessageError();
+    return () =>
+      error.value === undefined
+        ? null
+        : h(
+            Primitive.span,
+            {
+              ...attrs,
+              render: props.render,
+              asChild: props.asChild,
+              ref: forwardRef,
+            },
+            {
+              default: () =>
+                slots.default?.() ?? props.children ?? String(error.value),
+            },
+          );
+  },
+  {
+    name: "ErrorPrimitive.Message",
+    inheritAttrs: false,
+    props: ["render", "asChild", "children"],
+  },
+);

package/src/primitives/error/ErrorRoot.tsx

@@ -0,0 +1,34 @@
+"use client";
+
+import { defineComponent, h, type ComponentPublicInstance } from "vue";
+import { useForwardExpose } from "reka-ui";
+import { Primitive, type PrimitiveProps } from "../../utils/Primitive";
+
+export namespace ErrorPrimitiveRoot {
+  export type Element = ComponentPublicInstance;
+  export type Props = PrimitiveProps<"div">;
+}
+
+export const ErrorPrimitiveRoot = defineComponent(
+  (props: ErrorPrimitiveRoot.Props, { attrs, slots }) => {
+    const { forwardRef } = useForwardExpose();
+    return () =>
+      h(
+        Primitive.div,
+        {
+          role: "alert",
+          ...attrs,
+          render: props.render,
+          asChild: props.asChild,
+          children: props.children,
+          ref: forwardRef,
+        },
+        slots,
+      );
+  },
+  {
+    name: "ErrorPrimitive.Root",
+    inheritAttrs: false,
+    props: ["render", "asChild", "children"],
+  },
+);

package/src/primitives/error.ts

@@ -0,0 +1,2 @@
+export { ErrorPrimitiveRoot as Root } from "./error/ErrorRoot";
+export { ErrorPrimitiveMessage as Message } from "./error/ErrorMessage";

package/src/primitives/message/MessageAttachments.tsx

@@ -0,0 +1,6 @@
+"use client";
+
+export {
+  MessagePrimitiveAttachments,
+  MessagePrimitiveAttachmentByIndex,
+} from "@ulearning/ai-core/vue";

package/src/primitives/message/MessageError.ts

@@ -0,0 +1,13 @@
+"use client";
+
+import { defineComponent, type VNodeChild } from "vue";
+import { useMessageError } from "@ulearning/ai-core/vue";
+
+export const MessagePrimitiveError = defineComponent(
+  (props: { children?: VNodeChild }, { slots }) => {
+    const error = useMessageError();
+    return () =>
+      error.value !== undefined ? (slots.default?.() ?? props.children) : null;
+  },
+  { name: "MessagePrimitive.Error", props: ["children"] },
+);

package/src/primitives/message/MessageIf.test.tsx

@@ -0,0 +1,83 @@
+// @vitest-environment jsdom
+
+import { defineComponent, h } from "vue";
+import { cleanup, render } from "../../tests/vue";
+import { afterEach, describe, expect, it } from "vitest";
+import type { ThreadMessageLike } from "@ulearning/ai-core";
+import {
+  AssistantRuntimeProvider,
+  useExternalStoreRuntime,
+} from "@ulearning/ai-core/vue";
+import { useAuiState } from "@ulearning/ai-store";
+import { ThreadPrimitiveMessages } from "../thread/ThreadMessages";
+import { ThreadPrimitiveRoot } from "../thread/ThreadRoot";
+import { MessagePrimitiveIf } from "./MessageIf";
+
+afterEach(cleanup);
+
+const messages: ThreadMessageLike[] = [
+  { id: "u", role: "user", content: [{ type: "text", text: "u" }] },
+  { id: "a", role: "assistant", content: [{ type: "text", text: "a" }] },
+  { id: "s", role: "system", content: [{ type: "text", text: "s" }] },
+];
+
+const roles = ["user", "assistant", "system"] as const;
+type Role = (typeof roles)[number];
+
+const roleFilter = (role: Role, value: boolean | undefined) =>
+  ({ [role]: value }) as MessagePrimitiveIf.Props;
+
+const renderRoles = (filter: MessagePrimitiveIf.Props) => {
+  const Message = defineComponent({
+    setup() {
+      const role = useAuiState((s) => s.message.role);
+      return () =>
+        h(MessagePrimitiveIf, filter, {
+          default: () => h("span", { "data-testid": `shown-${role.value}` }),
+        });
+    },
+  });
+  const Example = defineComponent({
+    setup() {
+      const runtime = useExternalStoreRuntime({
+        messages,
+        convertMessage: (message) => message,
+        onNew: async () => {},
+      });
+      return () =>
+        h(
+          AssistantRuntimeProvider,
+          { runtime },
+          {
+            default: () =>
+              h(ThreadPrimitiveRoot, null, {
+                default: () =>
+                  h(ThreadPrimitiveMessages, { components: { Message } }),
+              }),
+          },
+        );
+    },
+  });
+  const { queryByTestId } = render(h(Example));
+  return roles.filter((role) => queryByTestId(`shown-${role}`) !== null);
+};
+
+describe("MessagePrimitive.If role filters", () => {
+  it.each(roles)("%s={true} renders only that role", (role) => {
+    expect(renderRoles(roleFilter(role, true))).toEqual([role]);
+  });
+
+  it.each(roles)("%s={false} renders every other role", (role) => {
+    expect(renderRoles(roleFilter(role, false))).toEqual(
+      roles.filter((r) => r !== role),
+    );
+  });
+
+  it.each(roles)("%s={undefined} renders every role", (role) => {
+    expect(renderRoles(roleFilter(role, undefined))).toEqual([...roles]);
+  });
+
+  it("combines a true filter with a false filter", () => {
+    expect(renderRoles({ assistant: false, system: false })).toEqual(["user"]);
+  });
+});

package/src/primitives/message/MessageIf.ts

@@ -0,0 +1,110 @@
+"use client";
+
+import { defineComponent, type VNodeChild } from "vue";
+import { useAuiState } from "@ulearning/ai-store";
+import type { RequireAtLeastOne } from "../../utils/RequireAtLeastOne";
+
+type MessageIfFilters = {
+  user: boolean | undefined;
+  assistant: boolean | undefined;
+  system: boolean | undefined;
+  hasBranches: boolean | undefined;
+  copied: boolean | undefined;
+  lastOrHover: boolean | undefined;
+  last: boolean | undefined;
+  speaking: boolean | undefined;
+  hasAttachments: boolean | undefined;
+  hasContent: boolean | undefined;
+  submittedFeedback: "positive" | "negative" | null | undefined;
+};
+type UseMessageIfProps = RequireAtLeastOne<MessageIfFilters>;
+
+const useMessageIf = (props: UseMessageIfProps) => {
+  return useAuiState((s) => {
+    const {
+      role,
+      attachments,
+      parts,
+      branchCount,
+      isLast,
+      speech,
+      isCopied,
+      isHovering,
+    } = s.message;
+
+    if (props.hasBranches === true && branchCount < 2) return false;
+
+    if (props.user === true && role !== "user") return false;
+    if (props.user === false && role === "user") return false;
+
+    if (props.assistant === true && role !== "assistant") return false;
+    if (props.assistant === false && role === "assistant") return false;
+
+    if (props.system === true && role !== "system") return false;
+    if (props.system === false && role === "system") return false;
+
+    if (props.lastOrHover === true && !isHovering && !isLast) return false;
+    if (props.last !== undefined && props.last !== isLast) return false;
+
+    if (props.copied === true && !isCopied) return false;
+    if (props.copied === false && isCopied) return false;
+
+    if (props.speaking === true && speech == null) return false;
+    if (props.speaking === false && speech != null) return false;
+
+    if (
+      props.hasAttachments === true &&
+      (role !== "user" || !attachments?.length)
+    )
+      return false;
+    if (
+      props.hasAttachments === false &&
+      role === "user" &&
+      attachments?.length
+    )
+      return false;
+
+    if (props.hasContent === true && parts.length === 0) return false;
+    if (props.hasContent === false && parts.length > 0) return false;
+
+    if (
+      props.submittedFeedback !== undefined &&
+      (s.message.metadata.submittedFeedback?.type ?? null) !==
+        props.submittedFeedback
+    )
+      return false;
+
+    return true;
+  });
+};
+
+export namespace MessagePrimitiveIf {
+  export type Props = UseMessageIfProps & { children?: VNodeChild };
+}
+
+/**
+ * @deprecated Use `<AuiIf condition={(s) => s.message...} />` instead.
+ */
+export const MessagePrimitiveIf = defineComponent<MessagePrimitiveIf.Props>(
+  (props, { slots }) => {
+    const result = useMessageIf(props);
+    return () => (result.value ? (slots.default?.() ?? props.children) : null);
+  },
+  {
+    name: "Message.If",
+    props: [
+      "user",
+      "assistant",
+      "system",
+      "hasBranches",
+      "copied",
+      "lastOrHover",
+      "last",
+      "speaking",
+      "hasAttachments",
+      "hasContent",
+      "submittedFeedback",
+      "children",
+    ],
+  },
+);

package/src/primitives/message/MessageParts.test.tsx

@@ -0,0 +1,119 @@
+// @vitest-environment jsdom
+import { defineComponent, h, nextTick, shallowRef } from "vue";
+import { afterEach, expect, it } from "vitest";
+import { flushTapSync } from "@ulearning/ai-tap";
+import {
+  AssistantRuntimeProvider,
+  ThreadPrimitiveMessages,
+  useExternalStoreRuntime,
+} from "@ulearning/ai-core/vue";
+import type { ThreadMessageLike } from "@ulearning/ai-core";
+import { cleanup, render } from "../../tests/vue";
+import { MessagePrimitiveParts } from "./MessageParts";
+import { MessagePartPrimitiveImage } from "../messagePart/MessagePartImage";
+
+afterEach(cleanup);
+const mountParts = (
+  content: ThreadMessageLike["content"],
+  Message = defineComponent({ setup: () => () => h(MessagePrimitiveParts) }),
+) => {
+  const source = shallowRef(content);
+  const fixture = render(
+    h(
+      defineComponent({
+        setup() {
+          const runtime = useExternalStoreRuntime(() => ({
+            messages: [
+              {
+                id: "message",
+                role: "assistant" as const,
+                content: source.value,
+              },
+            ],
+            convertMessage: (message: ThreadMessageLike) => message,
+            onNew: async () => {},
+          }));
+          return () =>
+            h(
+              AssistantRuntimeProvider,
+              { runtime },
+              {
+                default: () =>
+                  h(ThreadPrimitiveMessages, { components: { Message } }),
+              },
+            );
+        },
+      }),
+    ),
+  );
+  return {
+    ...fixture,
+    async update(content: ThreadMessageLike["content"]) {
+      flushTapSync(() => {
+        source.value = content;
+      });
+      await nextTick();
+    },
+  };
+};
+it("renders Web text and image defaults and follows real part replacements", async () => {
+  const fixture = mountParts([
+    { type: "text", text: "line one\nline two" },
+    { type: "image", image: "https://example.com/one.png" },
+  ]);
+  expect(fixture.container.querySelector("p")!.style.whiteSpace).toBe(
+    "pre-line",
+  );
+  expect(fixture.container.querySelector("span")!.textContent).toBe(
+    "line one\nline two",
+  );
+  expect(fixture.container.querySelector("img")!.getAttribute("src")).toBe(
+    "https://example.com/one.png",
+  );
+  await fixture.update([
+    { type: "text", text: "replacement" },
+    { type: "image", image: "https://example.com/two.png" },
+  ]);
+  expect(fixture.container.querySelector("span")!.textContent).toBe(
+    "replacement",
+  );
+  expect(fixture.container.querySelector("img")!.getAttribute("src")).toBe(
+    "https://example.com/two.png",
+  );
+});
+it("retains explicit image src overrides", () => {
+  const Image = defineComponent({
+    setup: () => () =>
+      h(MessagePartPrimitiveImage, { src: "override.png", alt: "preview" }),
+  });
+  const Message = defineComponent({
+    setup: () => () => h(MessagePrimitiveParts, { components: { Image } }),
+  });
+  const fixture = mountParts(
+    [{ type: "image", image: "https://example.com/original.png" }],
+    Message,
+  );
+  expect(fixture.container.querySelector("img")!.getAttribute("src")).toBe(
+    "override.png",
+  );
+  expect(fixture.container.querySelector("img")!.alt).toBe("preview");
+});
+it("uses Web defaults for undefined slots and supports native scoped rendering", () => {
+  const Default = defineComponent({
+    setup: () => () =>
+      h(MessagePrimitiveParts, {
+        components: { Text: undefined, Image: undefined },
+      }),
+  });
+  const fixture = mountParts([{ type: "text", text: "fallback" }], Default);
+  expect(fixture.container.querySelector("span")!.textContent).toBe("fallback");
+  const Scoped = defineComponent({
+    setup: () => () =>
+      h(MessagePrimitiveParts, null, {
+        default: ({ part }: { part: { type: string; text?: string } }) =>
+          h("b", `${part.type}:${part.text}`),
+      }),
+  });
+  const scoped = mountParts([{ type: "text", text: "slot" }], Scoped);
+  expect(scoped.container.querySelector("b")!.textContent).toBe("text:slot");
+});

package/src/primitives/message/MessageParts.tsx

@@ -0,0 +1,64 @@
+"use client";
+
+import { computed, defineComponent, h } from "vue";
+import {
+  MessagePrimitiveParts as MessagePrimitivePartsBase,
+  MessagePartComponent as MessagePartComponentBase,
+  MessagePrimitivePartByIndex as MessagePrimitivePartByIndexBase,
+  messagePartsDefaultComponents,
+} from "@ulearning/ai-core/vue";
+import { MessagePartPrimitiveText } from "../messagePart/MessagePartText";
+import { MessagePartPrimitiveImage } from "../messagePart/MessagePartImage";
+import { MessagePartPrimitiveInProgress } from "../messagePart/MessagePartInProgress";
+
+const webDefaultComponents = {
+  ...messagePartsDefaultComponents,
+  Text: defineComponent({
+    name: "MessagePrimitiveDefaultText",
+    setup: () => () =>
+      h("p", { style: { whiteSpace: "pre-line" } }, [
+        h(MessagePartPrimitiveText),
+        h(MessagePartPrimitiveInProgress, null, {
+          default: () =>
+            h("span", { style: { fontFamily: "revert" } }, " \u25CF"),
+        }),
+      ]),
+  }),
+  Image: defineComponent({ setup: () => () => h(MessagePartPrimitiveImage) }),
+} satisfies MessagePrimitiveParts.Props["components"];
+
+export namespace MessagePrimitiveParts {
+  export type Props = MessagePrimitivePartsBase.Props;
+}
+
+export const MessagePrimitiveParts = defineComponent(
+  (props: MessagePrimitiveParts.Props, { slots }) => {
+    const components = computed(() =>
+      props.components
+        ? {
+            ...props.components,
+            Text: props.components.Text ?? webDefaultComponents.Text,
+            Image: props.components.Image ?? webDefaultComponents.Image,
+          }
+        : webDefaultComponents,
+    );
+    return () => {
+      if (props.children)
+        return h(MessagePrimitivePartsBase, { children: props.children });
+      if (slots.default) return h(MessagePrimitivePartsBase, null, slots);
+      return h(MessagePrimitivePartsBase, {
+        components: components.value,
+        unstable_showEmptyOnNonTextEnd: props.unstable_showEmptyOnNonTextEnd,
+      });
+    };
+  },
+  {
+    name: "MessagePrimitive.Parts",
+    props: ["components", "children", "unstable_showEmptyOnNonTextEnd"],
+  },
+);
+
+export {
+  MessagePartComponentBase as MessagePartComponent,
+  MessagePrimitivePartByIndexBase as MessagePrimitivePartByIndex,
+};