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

package/src/primitives/actionBar/ActionBarStopSpeaking.tsx

@@ -0,0 +1,24 @@
+"use client";
+
+import { computed } from "vue";
+import {
+  createActionButton,
+  type ActionButtonElement,
+  type ActionButtonProps,
+} from "../../utils/createActionButton";
+import { useActionBarStopSpeaking as useActionBarStopSpeakingBehavior } from "@ulearning/ai-core/vue";
+
+const useActionBarStopSpeaking = () => {
+  const { disabled, stopSpeaking } = useActionBarStopSpeakingBehavior();
+  return computed(() => (disabled.value ? null : stopSpeaking));
+};
+
+export namespace ActionBarPrimitiveStopSpeaking {
+  export type Element = ActionButtonElement;
+  export type Props = ActionButtonProps<typeof useActionBarStopSpeaking>;
+}
+
+export const ActionBarPrimitiveStopSpeaking = createActionButton(
+  "ActionBarPrimitive.StopSpeaking",
+  useActionBarStopSpeaking,
+);

package/src/primitives/actionBar/useActionBarFloatStatus.ts

@@ -0,0 +1,48 @@
+"use client";
+
+import { toValue, type MaybeRefOrGetter } from "vue";
+import { useAuiState } from "@ulearning/ai-store";
+
+export const HideAndFloatStatus = {
+  Hidden: "hidden",
+  Floating: "floating",
+  Normal: "normal",
+} as const;
+export type HideAndFloatStatus =
+  (typeof HideAndFloatStatus)[keyof typeof HideAndFloatStatus];
+
+export type UseActionBarFloatStatusProps = {
+  hideWhenRunning?: boolean | undefined;
+  autohide?: "always" | "not-last" | "never" | undefined;
+  autohideFloat?: "always" | "single-branch" | "never" | undefined;
+  forceVisible?: boolean | undefined;
+};
+
+export const useActionBarFloatStatus = (
+  options: MaybeRefOrGetter<UseActionBarFloatStatusProps>,
+) => {
+  return useAuiState((s) => {
+    const { hideWhenRunning, autohide, autohideFloat, forceVisible } =
+      toValue(options);
+    if (hideWhenRunning && s.thread.isRunning) return HideAndFloatStatus.Hidden;
+
+    const autohideEnabled =
+      autohide === "always" || (autohide === "not-last" && !s.message.isLast);
+    const isVisibleByInteraction = forceVisible || s.message.isHovering;
+
+    // normal status
+    if (!autohideEnabled) return HideAndFloatStatus.Normal;
+
+    // hidden status
+    if (!isVisibleByInteraction) return HideAndFloatStatus.Hidden;
+
+    // floating status
+    if (
+      autohideFloat === "always" ||
+      (autohideFloat === "single-branch" && s.message.branchCount <= 1)
+    )
+      return HideAndFloatStatus.Floating;
+
+    return HideAndFloatStatus.Normal;
+  });
+};

package/src/primitives/actionBar.ts

@@ -0,0 +1,9 @@
+export { ActionBarPrimitiveRoot as Root } from "./actionBar/ActionBarRoot";
+export { ActionBarPrimitiveCopy as Copy } from "./actionBar/ActionBarCopy";
+export { ActionBarPrimitiveReload as Reload } from "./actionBar/ActionBarReload";
+export { ActionBarPrimitiveEdit as Edit } from "./actionBar/ActionBarEdit";
+export { ActionBarPrimitiveSpeak as Speak } from "./actionBar/ActionBarSpeak";
+export { ActionBarPrimitiveStopSpeaking as StopSpeaking } from "./actionBar/ActionBarStopSpeaking";
+export { ActionBarPrimitiveFeedbackPositive as FeedbackPositive } from "./actionBar/ActionBarFeedbackPositive";
+export { ActionBarPrimitiveFeedbackNegative as FeedbackNegative } from "./actionBar/ActionBarFeedbackNegative";
+export { ActionBarPrimitiveExportMarkdown as ExportMarkdown } from "./actionBar/ActionBarExportMarkdown";

package/src/primitives/actionBarMore/ActionBarMoreContent.tsx

@@ -0,0 +1,45 @@
+"use client";
+
+import { defineComponent, h, type ComponentPublicInstance } from "vue";
+import {
+  DropdownMenuContent,
+  DropdownMenuPortal,
+  type DropdownMenuPortalProps,
+  useForwardExpose,
+} from "reka-ui";
+import type { WithRenderPropProps } from "../../utils/Primitive";
+import { DropdownMenuRenderContent } from "../dropdownMenuRenderPrimitives";
+export namespace ActionBarMorePrimitiveContent {
+  export type Element = ComponentPublicInstance;
+  export type Props = WithRenderPropProps<typeof DropdownMenuContent> & {
+    portalProps?: DropdownMenuPortalProps;
+  };
+}
+export const ActionBarMorePrimitiveContent = defineComponent(
+  (props: ActionBarMorePrimitiveContent.Props, { attrs, slots }) => {
+    const { forwardRef } = useForwardExpose();
+    return () =>
+      h(DropdownMenuPortal, props.portalProps, {
+        default: () =>
+          h(
+            DropdownMenuRenderContent,
+            {
+              ...attrs,
+              ...(props.render === undefined ? {} : { render: props.render }),
+              ...(props.asChild === undefined
+                ? {}
+                : { asChild: props.asChild }),
+              children: props.children,
+              sideOffset: props.sideOffset ?? 4,
+              ref: forwardRef,
+            },
+            slots,
+          ),
+      });
+  },
+  {
+    name: "ActionBarMorePrimitive.Content",
+    inheritAttrs: false,
+    props: ["render", "asChild", "children", "portalProps", "sideOffset"],
+  },
+);

package/src/primitives/actionBarMore/ActionBarMoreItem.tsx

@@ -0,0 +1,22 @@
+"use client";
+
+import { defineComponent, h, type ComponentPublicInstance } from "vue";
+import { DropdownMenuItem, useForwardExpose } from "reka-ui";
+import type { WithRenderPropProps } from "../../utils/Primitive";
+import { DropdownMenuRenderItem } from "../dropdownMenuRenderPrimitives";
+export namespace ActionBarMorePrimitiveItem {
+  export type Element = ComponentPublicInstance;
+  export type Props = WithRenderPropProps<typeof DropdownMenuItem>;
+}
+export const ActionBarMorePrimitiveItem = defineComponent(
+  (props: ActionBarMorePrimitiveItem.Props, { attrs, slots }) => {
+    const { forwardRef } = useForwardExpose();
+    return () =>
+      h(DropdownMenuRenderItem, { ...attrs, ...props, ref: forwardRef }, slots);
+  },
+  {
+    name: "ActionBarMorePrimitive.Item",
+    inheritAttrs: false,
+    props: ["render", "asChild", "children"],
+  },
+);

package/src/primitives/actionBarMore/ActionBarMoreRoot.test.ts

@@ -0,0 +1,70 @@
+// @vitest-environment jsdom
+import {
+  defineComponent,
+  h,
+  KeepAlive,
+  nextTick,
+  provide,
+  shallowRef,
+} from "vue";
+import { afterEach, expect, it, vi } from "vitest";
+import { cleanup, render } from "../../tests/vue";
+import { ActionBarInteractionContext } from "../actionBar/ActionBarInteractionContext";
+import { ActionBarMorePrimitiveRoot } from "./ActionBarMoreRoot";
+import { ActionBarMorePrimitiveTrigger } from "./ActionBarMoreTrigger";
+
+afterEach(cleanup);
+
+it("holds exactly one interaction lock for an accepted open and releases cached owners", async () => {
+  const release = vi.fn();
+  const acquire = vi.fn(() => release);
+  const open = shallowRef(false);
+  const visible = shallowRef(true);
+  const onOpenChange = vi.fn();
+  const Owner = defineComponent({
+    setup: () => () =>
+      h(
+        ActionBarMorePrimitiveRoot,
+        { open: open.value, onOpenChange },
+        {
+          default: () =>
+            h(ActionBarMorePrimitiveTrigger, null, { default: () => "More" }),
+        },
+      ),
+  });
+  const view = render(
+    h(
+      defineComponent({
+        setup() {
+          provide(ActionBarInteractionContext, {
+            acquireInteractionLock: acquire,
+          });
+          return () =>
+            h(KeepAlive, null, {
+              default: () => (visible.value ? h(Owner) : null),
+            });
+        },
+      }),
+    ),
+  );
+  view.container
+    .querySelector("button")!
+    .dispatchEvent(new MouseEvent("click", { button: 0, bubbles: true }));
+  await nextTick();
+  expect(onOpenChange).toHaveBeenCalledExactlyOnceWith(true);
+  expect(acquire).not.toHaveBeenCalled();
+  open.value = true;
+  await nextTick();
+  expect(acquire).toHaveBeenCalledOnce();
+  visible.value = false;
+  await nextTick();
+  expect(release).toHaveBeenCalledOnce();
+  visible.value = true;
+  await nextTick();
+  expect(acquire).toHaveBeenCalledTimes(2);
+  open.value = false;
+  await nextTick();
+  expect(release).toHaveBeenCalledTimes(2);
+  view.unmount();
+  expect(release).toHaveBeenCalledTimes(2);
+});

package/src/primitives/actionBarMore/ActionBarMoreRoot.tsx

@@ -0,0 +1,46 @@
+"use client";
+
+import { defineComponent, h, computed, shallowRef } from "vue";
+import { DropdownMenuRoot, type DropdownMenuRootProps } from "reka-ui";
+import { useIsomorphicLayoutEffect } from "@ulearning/ai-store/internal";
+import { useActionBarInteractionContext } from "../actionBar/ActionBarInteractionContext";
+export namespace ActionBarMorePrimitiveRoot {
+  export type Props = DropdownMenuRootProps & {
+    onOpenChange?: (open: boolean) => void;
+  };
+}
+export const ActionBarMorePrimitiveRoot = defineComponent(
+  (props: ActionBarMorePrimitiveRoot.Props, { attrs, slots }) => {
+    const interaction = useActionBarInteractionContext();
+    const localOpen = shallowRef(props.defaultOpen ?? false);
+    const open = computed(() => props.open ?? localOpen.value);
+    const updateOpen = (next: boolean) => {
+      if (props.open === undefined) localOpen.value = next;
+      props.onOpenChange?.(next);
+    };
+    useIsomorphicLayoutEffect(
+      () => {
+        if (!open.value) return;
+        return interaction?.acquireInteractionLock();
+      },
+      () => [open.value],
+    );
+    return () =>
+      h(
+        DropdownMenuRoot,
+        {
+          ...attrs,
+          ...(props.dir === undefined ? {} : { dir: props.dir }),
+          ...(props.modal === undefined ? {} : { modal: props.modal }),
+          open: open.value,
+          "onUpdate:open": updateOpen,
+        },
+        slots,
+      );
+  },
+  {
+    name: "ActionBarMorePrimitive.Root",
+    inheritAttrs: false,
+    props: ["open", "defaultOpen", "onOpenChange", "dir", "modal"],
+  },
+);

package/src/primitives/actionBarMore/ActionBarMoreSeparator.tsx

@@ -0,0 +1,26 @@
+"use client";
+
+import { defineComponent, h, type ComponentPublicInstance } from "vue";
+import { DropdownMenuSeparator, useForwardExpose } from "reka-ui";
+import type { WithRenderPropProps } from "../../utils/Primitive";
+import { DropdownMenuRenderSeparator } from "../dropdownMenuRenderPrimitives";
+export namespace ActionBarMorePrimitiveSeparator {
+  export type Element = ComponentPublicInstance;
+  export type Props = WithRenderPropProps<typeof DropdownMenuSeparator>;
+}
+export const ActionBarMorePrimitiveSeparator = defineComponent(
+  (props: ActionBarMorePrimitiveSeparator.Props, { attrs, slots }) => {
+    const { forwardRef } = useForwardExpose();
+    return () =>
+      h(
+        DropdownMenuRenderSeparator,
+        { ...attrs, ...props, ref: forwardRef },
+        slots,
+      );
+  },
+  {
+    name: "ActionBarMorePrimitive.Separator",
+    inheritAttrs: false,
+    props: ["render", "asChild", "children"],
+  },
+);

package/src/primitives/actionBarMore/ActionBarMoreTrigger.tsx

@@ -0,0 +1,26 @@
+"use client";
+
+import { defineComponent, h, type ComponentPublicInstance } from "vue";
+import { DropdownMenuTrigger, useForwardExpose } from "reka-ui";
+import type { WithRenderPropProps } from "../../utils/Primitive";
+import { DropdownMenuRenderTrigger } from "../dropdownMenuRenderPrimitives";
+export namespace ActionBarMorePrimitiveTrigger {
+  export type Element = ComponentPublicInstance;
+  export type Props = WithRenderPropProps<typeof DropdownMenuTrigger>;
+}
+export const ActionBarMorePrimitiveTrigger = defineComponent(
+  (props: ActionBarMorePrimitiveTrigger.Props, { attrs, slots }) => {
+    const { forwardRef } = useForwardExpose();
+    return () =>
+      h(
+        DropdownMenuRenderTrigger,
+        { ...attrs, ...props, ref: forwardRef },
+        slots,
+      );
+  },
+  {
+    name: "ActionBarMorePrimitive.Trigger",
+    inheritAttrs: false,
+    props: ["render", "asChild", "children"],
+  },
+);

package/src/primitives/actionBarMore/scope.ts

@@ -0,0 +1,6 @@
+import { injectDropdownMenuRootContext } from "reka-ui";
+
+/** Vue injection replaces React's opaque context scope objects. */
+export const useDropdownMenuScope: typeof injectDropdownMenuRootContext =
+  injectDropdownMenuRootContext;
+export type ScopedProps<P> = P;

package/src/primitives/actionBarMore.ts

@@ -0,0 +1,5 @@
+export { ActionBarMorePrimitiveRoot as Root } from "./actionBarMore/ActionBarMoreRoot";
+export { ActionBarMorePrimitiveTrigger as Trigger } from "./actionBarMore/ActionBarMoreTrigger";
+export { ActionBarMorePrimitiveContent as Content } from "./actionBarMore/ActionBarMoreContent";
+export { ActionBarMorePrimitiveItem as Item } from "./actionBarMore/ActionBarMoreItem";
+export { ActionBarMorePrimitiveSeparator as Separator } from "./actionBarMore/ActionBarMoreSeparator";

package/src/primitives/assistantModal/AssistantModalAnchor.tsx

@@ -0,0 +1,22 @@
+"use client";
+
+import { defineComponent, h, type ComponentPublicInstance } from "vue";
+import { PopoverAnchor, useForwardExpose } from "reka-ui";
+import type { WithRenderPropProps } from "../../utils/Primitive";
+import { PopoverRenderAnchor } from "./popoverRenderPrimitives";
+export namespace AssistantModalPrimitiveAnchor {
+  export type Element = ComponentPublicInstance;
+  export type Props = WithRenderPropProps<typeof PopoverAnchor>;
+}
+export const AssistantModalPrimitiveAnchor = defineComponent(
+  (props: AssistantModalPrimitiveAnchor.Props, { attrs, slots }) => {
+    const { forwardRef } = useForwardExpose();
+    return () =>
+      h(PopoverRenderAnchor, { ...attrs, ...props, ref: forwardRef }, slots);
+  },
+  {
+    name: "AssistantModalPrimitive.Anchor",
+    inheritAttrs: false,
+    props: ["render", "asChild", "children"],
+  },
+);

package/src/primitives/assistantModal/AssistantModalContent.tsx

@@ -0,0 +1,85 @@
+"use client";
+
+import {
+  cloneVNode,
+  defineComponent,
+  h,
+  mergeProps,
+  type ComponentPublicInstance,
+} from "vue";
+import {
+  PopoverContent,
+  PopoverPortal,
+  Slot,
+  type PopoverPortalProps,
+  useForwardExpose,
+} from "reka-ui";
+import type { WithRenderPropProps } from "../../utils/Primitive";
+import { PopoverRenderContent } from "./popoverRenderPrimitives";
+export namespace AssistantModalPrimitiveContent {
+  export type Element = ComponentPublicInstance;
+  export type Props = WithRenderPropProps<typeof PopoverContent> & {
+    portalProps?: PopoverPortalProps;
+    dissmissOnInteractOutside?: boolean;
+  };
+}
+export const AssistantModalPrimitiveContent = defineComponent(
+  (props: AssistantModalPrimitiveContent.Props, { attrs, slots }) => {
+    const { forwardRef } = useForwardExpose();
+    const onInteractOutside = (event: Event) => {
+      if (!props.dissmissOnInteractOutside) event.preventDefault();
+    };
+    return () => {
+      const explicitName =
+        attrs["aria-label"] != null || attrs["aria-labelledby"] != null;
+      const labelledBy =
+        typeof attrs["aria-labelledby"] === "string"
+          ? attrs["aria-labelledby"]
+          : undefined;
+      // Reka's generated labelledby is an internal explicit prop. Put the
+      // caller's override on its asChild target so Slot precedence preserves it
+      // through the complete PopoverContent/FocusScope/DismissableLayer chain.
+      const render = explicitName
+        ? props.render
+          ? cloneVNode(props.render, { "aria-labelledby": labelledBy })
+          : h(props.asChild ? Slot : (props.as ?? "div"), {
+              "aria-labelledby": labelledBy,
+            })
+        : props.render;
+      return h(PopoverPortal, props.portalProps, {
+        default: () =>
+          h(
+            PopoverRenderContent,
+            mergeProps(
+              {
+                ...attrs,
+                as: props.as,
+                render,
+                asChild: props.asChild,
+                children: props.children,
+                side: props.side ?? "top",
+                align: props.align ?? "end",
+                ref: forwardRef,
+              },
+              { onInteractOutside },
+            ),
+            slots,
+          ),
+      });
+    };
+  },
+  {
+    name: "AssistantModalPrimitive.Content",
+    inheritAttrs: false,
+    props: [
+      "render",
+      "as",
+      "asChild",
+      "children",
+      "side",
+      "align",
+      "portalProps",
+      "dissmissOnInteractOutside",
+    ],
+  },
+);

package/src/primitives/assistantModal/AssistantModalRoot.test.tsx

@@ -0,0 +1,153 @@
+// @vitest-environment jsdom
+
+import { fireEvent, screen, waitFor } from "@testing-library/dom";
+import { actAsync as act, cleanup, render } from "../../tests/vue";
+import { defineComponent, shallowRef } from "vue";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { AssistantRuntimeProvider } from "../../context";
+import { useLocalRuntime } from "@ulearning/ai-core/vue";
+import { useAuiState } from "@ulearning/ai-store";
+import { AssistantModalPrimitiveContent } from "./AssistantModalContent";
+import { AssistantModalPrimitiveRoot } from "./AssistantModalRoot";
+import { AssistantModalPrimitiveTrigger } from "./AssistantModalTrigger";
+
+const adapter = {
+  async *run() {
+    yield { content: [{ type: "text" as const, text: "Hello" }] };
+  },
+};
+
+const RuntimeReady = defineComponent(() => {
+  const loading = useAuiState((state) => state.thread.isLoading);
+  return () => (
+    <output data-testid="runtime-ready">{String(!loading.value)}</output>
+  );
+});
+
+const Modal = defineComponent(
+  (props: AssistantModalPrimitiveRoot.Props & { controlled?: boolean }) => {
+    const runtime = useLocalRuntime(adapter);
+    const open = shallowRef(false);
+    return () => (
+      <AssistantRuntimeProvider runtime={runtime}>
+        <button onClick={() => runtime.thread.append("Hello")}>
+          Start run
+        </button>
+        <AssistantModalPrimitiveRoot
+          {...(props.open !== undefined
+            ? { open: props.open }
+            : (props.controlled ?? true)
+              ? { open: open.value }
+              : {})}
+          onOpenChange={(value) => {
+            open.value = value;
+            props.onOpenChange?.(value);
+          }}
+          {...(props.defaultOpen === undefined
+            ? {}
+            : { defaultOpen: props.defaultOpen })}
+          {...(props.modal === undefined ? {} : { modal: props.modal })}
+          {...(props.unstable_openOnRunStart === undefined
+            ? {}
+            : { unstable_openOnRunStart: props.unstable_openOnRunStart })}
+        >
+          <AssistantModalPrimitiveTrigger>
+            Toggle chat
+          </AssistantModalPrimitiveTrigger>
+          <AssistantModalPrimitiveContent aria-label="Chat">
+            Response
+          </AssistantModalPrimitiveContent>
+        </AssistantModalPrimitiveRoot>
+        <RuntimeReady />
+      </AssistantRuntimeProvider>
+    );
+  },
+  {
+    props: [
+      "controlled",
+      "open",
+      "defaultOpen",
+      "modal",
+      "unstable_openOnRunStart",
+      "onOpenChange",
+    ],
+  },
+);
+
+afterEach(cleanup);
+
+describe("AssistantModalPrimitiveRoot run start", () => {
+  it.each([true, false])(
+    "opens on run start and closes through the trigger (controlled: %s)",
+    async (controlled) => {
+      const onOpenChange = vi.fn();
+      render(<Modal controlled={controlled} onOpenChange={onOpenChange} />);
+      expect(screen.queryByRole("dialog")).toBeNull();
+
+      await act(async () => {
+        fireEvent.click(screen.getByRole("button", { name: "Start run" }));
+      });
+      expect(await screen.findByRole("dialog", { name: "Chat" })).toBeDefined();
+      expect(onOpenChange).toHaveBeenCalledExactlyOnceWith(true);
+
+      await act(async () => {
+        fireEvent.click(screen.getByRole("button", { name: "Start run" }));
+      });
+      expect(onOpenChange).toHaveBeenCalledExactlyOnceWith(true);
+
+      await act(() =>
+        fireEvent.click(screen.getByRole("button", { name: "Toggle chat" })),
+      );
+      expect(screen.queryByRole("dialog")).toBeNull();
+    },
+  );
+
+  it.each([{ open: true }, { controlled: false, defaultOpen: true }])(
+    "does not request opening when already open (%o)",
+    async (props) => {
+      const onOpenChange = vi.fn();
+      render(<Modal {...props} onOpenChange={onOpenChange} />);
+      expect(await screen.findByRole("dialog", { name: "Chat" })).toBeDefined();
+
+      await act(async () => {
+        fireEvent.click(screen.getByRole("button", { name: "Start run" }));
+      });
+
+      expect(onOpenChange).not.toHaveBeenCalled();
+      expect(screen.getByRole("dialog", { name: "Chat" })).toBeDefined();
+    },
+  );
+
+  it("notifies the current owner without overriding its controlled value", async () => {
+    const previous = vi.fn();
+    const current = vi.fn();
+    const view = render(<Modal open={false} onOpenChange={previous} />);
+    await view.rerender(<Modal open={false} onOpenChange={current} />);
+
+    await waitFor(() =>
+      expect(screen.getByTestId("runtime-ready").textContent).toBe("true"),
+    );
+
+    await act(async () => {
+      fireEvent.click(screen.getByRole("button", { name: "Start run" }));
+    });
+
+    await waitFor(() => expect(current).toHaveBeenCalledExactlyOnceWith(true));
+    expect(previous).not.toHaveBeenCalled();
+    expect(screen.queryByRole("dialog")).toBeNull();
+  });
+
+  it("does not request opening when auto-open is disabled", async () => {
+    const onOpenChange = vi.fn();
+    render(
+      <Modal unstable_openOnRunStart={false} onOpenChange={onOpenChange} />,
+    );
+
+    await act(async () => {
+      fireEvent.click(screen.getByRole("button", { name: "Start run" }));
+    });
+
+    expect(onOpenChange).not.toHaveBeenCalled();
+    expect(screen.queryByRole("dialog")).toBeNull();
+  });
+});

package/src/primitives/assistantModal/AssistantModalRoot.tsx

@@ -0,0 +1,48 @@
+"use client";
+
+import { computed, defineComponent, h, shallowRef } from "vue";
+import { PopoverRoot, type PopoverRootProps } from "reka-ui";
+import { useAuiEvent } from "@ulearning/ai-store";
+export namespace AssistantModalPrimitiveRoot {
+  export type Props = PopoverRootProps & {
+    onOpenChange?: (open: boolean) => void;
+    /** @deprecated Experimental since 2024-10-12. Not scheduled for removal; the API may change in any release. */
+    unstable_openOnRunStart?: boolean;
+  };
+}
+export const AssistantModalPrimitiveRoot = defineComponent(
+  (props: AssistantModalPrimitiveRoot.Props, { attrs, slots }) => {
+    const localOpen = shallowRef(props.defaultOpen ?? false);
+    const open = computed(() => props.open ?? localOpen.value);
+    const updateOpen = (next: boolean) => {
+      props.onOpenChange?.(next);
+      localOpen.value = next;
+    };
+    useAuiEvent("thread.runStart", () => {
+      if ((props.unstable_openOnRunStart ?? true) && !open.value)
+        updateOpen(true);
+    });
+    return () =>
+      h(
+        PopoverRoot,
+        {
+          ...attrs,
+          ...(props.modal === undefined ? {} : { modal: props.modal }),
+          open: open.value,
+          "onUpdate:open": updateOpen,
+        },
+        slots,
+      );
+  },
+  {
+    name: "AssistantModalPrimitive.Root",
+    inheritAttrs: false,
+    props: [
+      "open",
+      "defaultOpen",
+      "onOpenChange",
+      "modal",
+      "unstable_openOnRunStart",
+    ],
+  },
+);