@assistant-ui/react 0.15.29 → 0.15.31

package/src/model-context/makeAssistantVisible.test.tsx

@@ -136,6 +136,21 @@ const runEditTool = async (
   await task;
 };
 
+const expectDefaultSettleDelay = async (start: () => Promise<unknown>) => {
+  await act(async () => {
+    const settled = vi.fn();
+    const task = start();
+    void task.then(settled);
+
+    await vi.advanceTimersByTimeAsync(1999);
+    expect(settled).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(settled).toHaveBeenCalledOnce();
+    await task;
+  });
+};
+
 describe("makeAssistantVisible", () => {
   beforeEach(() => {
     registerMock.mockClear();
@@ -191,21 +206,14 @@ describe("makeAssistantVisible", () => {
     });
     const input = render(<EditableInput />).getByRole("textbox");
     const editId = (input as HTMLInputElement).dataset.editId!;
-    const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
 
     expect(
       (input as HTMLInputElement).dataset.actionSettleDelay,
     ).toBeUndefined();
 
-    const task = getRegisteredTools().edit!.execute({
-      editId,
-      value: "updated",
-    });
-
-    expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 2000);
-    await vi.runAllTimersAsync();
-    await task;
-    setTimeoutSpy.mockRestore();
+    await expectDefaultSettleDelay(() =>
+      getRegisteredTools().edit!.execute({ editId, value: "updated" }),
+    );
   });
 
   it("uses the default when the rendered settle delay is invalid", async () => {
@@ -218,14 +226,9 @@ describe("makeAssistantVisible", () => {
     );
     const clickId = (button as HTMLButtonElement).dataset.clickId!;
     (button as HTMLButtonElement).dataset.actionSettleDelay = "invalid";
-    const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
-
-    const task = getRegisteredTools().click!.execute({ clickId });
-
-    expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 2000);
-    await vi.runAllTimersAsync();
-    await task;
-    setTimeoutSpy.mockRestore();
+    await expectDefaultSettleDelay(() =>
+      getRegisteredTools().click!.execute({ clickId }),
+    );
   });
 
   it.each(["", "   "])(
@@ -239,29 +242,14 @@ describe("makeAssistantVisible", () => {
       const input = render(<VisibleInput />).getByRole("textbox");
       const clickId = (input as HTMLInputElement).dataset.clickId!;
       const editId = (input as HTMLInputElement).dataset.editId!;
-      const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
       input.dataset.actionSettleDelay = renderedDelay;
 
-      const clickTask = getRegisteredTools().click!.execute({ clickId });
-      expect(setTimeoutSpy).toHaveBeenLastCalledWith(
-        expect.any(Function),
-        2000,
+      await expectDefaultSettleDelay(() =>
+        getRegisteredTools().click!.execute({ clickId }),
       );
-      await vi.runAllTimersAsync();
-      await clickTask;
-
-      setTimeoutSpy.mockClear();
-      const editTask = getRegisteredTools().edit!.execute({
-        editId,
-        value: "updated",
-      });
-      expect(setTimeoutSpy).toHaveBeenLastCalledWith(
-        expect.any(Function),
-        2000,
+      await expectDefaultSettleDelay(() =>
+        getRegisteredTools().edit!.execute({ editId, value: "updated" }),
       );
-      await vi.runAllTimersAsync();
-      await editTask;
-      setTimeoutSpy.mockRestore();
     },
   );
 

package/src/primitives/actionBar/ActionBarCopy.test.tsx

@@ -0,0 +1,57 @@
+// @vitest-environment jsdom
+
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from "@testing-library/react";
+import { afterEach, expect, it, vi } from "vitest";
+import type { ChatModelAdapter, ThreadMessageLike } from "@assistant-ui/core";
+import {
+  AssistantRuntimeProvider,
+  useLocalRuntime,
+} from "@assistant-ui/core/react";
+import { ThreadPrimitiveMessages } from "../thread/ThreadMessages";
+import { ActionBarPrimitiveCopy } from "./ActionBarCopy";
+
+const model: ChatModelAdapter = { async *run() {} };
+const initialMessages: ThreadMessageLike[] = [
+  {
+    role: "assistant",
+    content: [{ type: "text", text: "Message to copy." }],
+    status: { type: "complete", reason: "stop" },
+  },
+];
+const Message = () => (
+  <ActionBarPrimitiveCopy>Copy message</ActionBarPrimitiveCopy>
+);
+const Example = () => {
+  const runtime = useLocalRuntime(model, { initialMessages });
+  return (
+    <AssistantRuntimeProvider runtime={runtime}>
+      <ThreadPrimitiveMessages components={{ Message }} />
+    </AssistantRuntimeProvider>
+  );
+};
+
+afterEach(() => {
+  cleanup();
+  vi.unstubAllGlobals();
+});
+
+it("copies the scoped message through the browser clipboard", async () => {
+  const writeText = vi.fn().mockResolvedValue(undefined);
+  vi.stubGlobal("navigator", { ...navigator, clipboard: { writeText } });
+  render(<Example />);
+  const button = screen.getByRole("button", { name: "Copy message" });
+
+  await act(async () => {
+    fireEvent.click(button);
+  });
+
+  expect(writeText).toHaveBeenCalledExactlyOnceWith("Message to copy.");
+  await waitFor(() => expect(button.getAttribute("data-copied")).toBe("true"));
+});

package/src/primitives/actionBar/ActionBarExportMarkdown.test.tsx

@@ -41,16 +41,24 @@ describe("ActionBarPrimitiveExportMarkdown", () => {
     vi.restoreAllMocks();
   });
 
-  it("clicks a download anchor that is attached to the document", async () => {
+  it("downloads the message as Markdown through an attached anchor", async () => {
     const createObjectURL = vi
       .spyOn(URL, "createObjectURL")
       .mockReturnValue("blob:export");
     vi.spyOn(URL, "revokeObjectURL").mockImplementation(() => {});
-    const connectedAtClick: boolean[] = [];
+    const downloads: {
+      isConnected: boolean;
+      href: string;
+      download: string;
+    }[] = [];
     vi.spyOn(HTMLAnchorElement.prototype, "click").mockImplementation(function (
       this: HTMLAnchorElement,
     ) {
-      connectedAtClick.push(this.isConnected);
+      downloads.push({
+        isConnected: this.isConnected,
+        href: this.href,
+        download: this.download,
+      });
     });
 
     await act(async () => {
@@ -65,9 +73,20 @@ describe("ActionBarPrimitiveExportMarkdown", () => {
       container.querySelector("button")!.click();
     });
 
-    expect(createObjectURL).toHaveBeenCalled();
+    expect(createObjectURL).toHaveBeenCalledOnce();
+    const blob = createObjectURL.mock.calls[0]![0] as Blob;
+    expect(blob.type).toBe("text/markdown");
+    const content = await new Promise<string>((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(reader.result as string);
+      reader.onerror = () => reject(reader.error);
+      reader.readAsText(blob);
+    });
+    expect(content).toBe("# Exported message");
     // Firefox ignores a programmatic click on a detached anchor.
-    expect(connectedAtClick).toEqual([true]);
+    expect(downloads).toEqual([
+      { isConnected: true, href: "blob:export", download: "message.md" },
+    ]);
     expect(document.querySelector('a[download="message.md"]')).toBeNull();
   });
 

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

@@ -10,7 +10,7 @@ import {
 import { useState } from "react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { AssistantRuntimeProvider } from "../../context";
-import { useLocalRuntime } from "../../legacy-runtime/runtime-cores/local/useLocalRuntime";
+import { useLocalRuntime } from "@assistant-ui/core/react";
 import { AssistantModalPrimitiveContent } from "./AssistantModalContent";
 import { AssistantModalPrimitiveRoot } from "./AssistantModalRoot";
 import { AssistantModalPrimitiveTrigger } from "./AssistantModalTrigger";

package/src/primitives/composer/ComposerInput.focus-on-run-start.test.tsx

@@ -3,7 +3,7 @@
 import { act, fireEvent, render, screen } from "@testing-library/react";
 import { describe, expect, it } from "vitest";
 import { AssistantRuntimeProvider } from "../../context";
-import { useLocalRuntime } from "../../legacy-runtime/runtime-cores/local/useLocalRuntime";
+import { useLocalRuntime } from "@assistant-ui/core/react";
 import { ThreadPrimitiveRoot } from "../thread/ThreadRoot";
 import { ComposerPrimitiveInput } from "./ComposerInput";
 import { ComposerPrimitiveRoot } from "./ComposerRoot";

package/src/primitives/composer/ComposerInput.test.tsx

@@ -40,6 +40,7 @@ let pluginRegistry: { getPlugins: () => (typeof plugin)[] } | null = null;
 
 vi.mock("@assistant-ui/store", () => {
   const aui = {
+    optional: { threads: {} },
     composer: {
       setText: (text: string) => setText(text),
       getState: () => composerState,

package/src/primitives/composer/ComposerInput.text-change.test.tsx

@@ -0,0 +1,68 @@
+// @vitest-environment jsdom
+
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+} from "@testing-library/react";
+import type { FC } from "react";
+import { afterEach, expect, it } from "vitest";
+import { useAui } from "@assistant-ui/store";
+import { useLocalRuntime } from "@assistant-ui/core/react";
+import type { ChatModelAdapter } from "@assistant-ui/core";
+import { AssistantRuntimeProvider } from "../../context";
+import { ThreadPrimitiveViewportProvider } from "../../context/providers/ThreadViewportProvider";
+import { ComposerPrimitiveInput } from "./ComposerInput";
+
+const adapter: ChatModelAdapter = {
+  async *run() {
+    yield { content: [{ type: "text", text: "done" }] };
+  },
+};
+
+afterEach(cleanup);
+
+it("emits composer.textChange with the user origin for typing and the send origin for the clear", async () => {
+  let aui!: ReturnType<typeof useAui>;
+  const Capture: FC = () => {
+    aui = useAui();
+    return null;
+  };
+  const App: FC = () => (
+    <AssistantRuntimeProvider runtime={useLocalRuntime(adapter)}>
+      <Capture />
+      <ThreadPrimitiveViewportProvider>
+        <ComposerPrimitiveInput aria-label="Composer" />
+      </ThreadPrimitiveViewportProvider>
+    </AssistantRuntimeProvider>
+  );
+  render(<App />);
+  const changes: unknown[] = [];
+  aui.on({ scope: "*", event: "composer.textChange" }, (change) =>
+    changes.push(change),
+  );
+  const input = screen.getByRole("textbox", { name: "Composer" });
+
+  await act(async () => {
+    fireEvent.change(input, { target: { value: "hi" } });
+  });
+  await act(async () => {
+    fireEvent.change(input, { target: { value: "" } });
+  });
+  await act(async () => {
+    fireEvent.change(input, { target: { value: "hello" } });
+  });
+  await act(async () => {
+    aui.composer().send();
+  });
+
+  const threadId = aui.threads().getState().mainThreadId;
+  expect(changes).toEqual([
+    { threadId, text: "hi", origin: "user" },
+    { threadId, text: "", origin: "user" },
+    { threadId, text: "hello", origin: "user" },
+    { threadId, text: "", origin: "send" },
+  ]);
+});

package/src/primitives/composer/ComposerInput.thread-scope.test.tsx

@@ -0,0 +1,82 @@
+// @vitest-environment jsdom
+
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from "@testing-library/react";
+import { afterEach, expect, it } from "vitest";
+import { AuiConfig, AuiProvider, Derived, useAui } from "@assistant-ui/store";
+import { ExternalThread, InMemoryThreadList } from "@assistant-ui/core/store";
+import { resource, useResource } from "@assistant-ui/tap";
+import { ThreadPrimitiveViewportProvider } from "../../context/providers/ThreadViewportProvider";
+import { ComposerPrimitiveInput } from "./ComposerInput";
+
+const StandaloneThread = resource(function useStandaloneThread() {
+  return useResource(ExternalThread({ messages: [] }));
+});
+const StandaloneApp = () => {
+  const config = AuiConfig({
+    thread: StandaloneThread(),
+    composer: Derived({
+      source: "thread",
+      query: {},
+      get: (aui) => aui.thread.composer(),
+    }),
+  });
+  return (
+    <AuiProvider config={config}>
+      <ThreadPrimitiveViewportProvider>
+        <ComposerPrimitiveInput aria-label="Composer" />
+      </ThreadPrimitiveViewportProvider>
+    </AuiProvider>
+  );
+};
+
+afterEach(cleanup);
+
+it("edits a draft without a thread-list scope", async () => {
+  render(<StandaloneApp />);
+  const input = screen.getByRole("textbox", {
+    name: "Composer",
+  }) as HTMLTextAreaElement;
+  await act(async () => {
+    fireEvent.change(input, { target: { value: "New question" } });
+  });
+  expect(input.value).toBe("New question");
+});
+
+it("restores composer focus when the thread switches", async () => {
+  let captured!: ReturnType<typeof useAui>;
+  const App = () => {
+    const aui = useAui({
+      threads: InMemoryThreadList({
+        thread: () => ExternalThread({ messages: [] }),
+      }),
+    });
+    captured = aui;
+    return (
+      <AuiProvider value={aui}>
+        <ThreadPrimitiveViewportProvider>
+          <button>Outside</button>
+          <ComposerPrimitiveInput aria-label="Composer" autoFocus />
+        </ThreadPrimitiveViewportProvider>
+      </AuiProvider>
+    );
+  };
+  render(<App />);
+  const input = screen.getByRole("textbox", { name: "Composer" });
+  expect(document.activeElement).toBe(input);
+  act(() => screen.getByRole("button", { name: "Outside" }).focus());
+  const oldId = captured.threads.getState().mainThreadId;
+  await act(async () => {
+    captured.threads.switchToNewThread();
+  });
+  await waitFor(() =>
+    expect(captured.threads.getState().mainThreadId).not.toBe(oldId),
+  );
+  expect(document.activeElement).toBe(input);
+});

package/src/primitives/composer/ComposerInput.tsx

@@ -393,7 +393,8 @@ export const ComposerPrimitiveInput = forwardRef<
     useEffect(() => {
       if (
         aui.composer.getState().type !== "thread" ||
-        !unstable_focusOnThreadSwitched
+        !unstable_focusOnThreadSwitched ||
+        !aui.optional.threads
       )
         return undefined;
 
@@ -424,9 +425,9 @@ export const ComposerPrimitiveInput = forwardRef<
             compositionRef.current = false;
           }
           const isComposing = nativeIsComposing || compositionRef.current;
-          // keep controlled value in sync mid-IME so react does not reset the textarea to a stale value
+          // Standalone tap roots need a synchronous flush while the input is composing.
           flushTapSync(() => {
-            aui.composer.setText(e.target.value);
+            aui.composer.setText(e.target.value, { origin: "user" });
           });
           if (isComposing) return;
           const pos = e.target.selectionStart ?? e.target.value.length;
@@ -453,7 +454,7 @@ export const ComposerPrimitiveInput = forwardRef<
           if (!aui.composer.getState().isEditing) return;
           const target = e.target as HTMLTextAreaElement;
           flushTapSync(() => {
-            aui.composer.setText(target.value);
+            aui.composer.setText(target.value, { origin: "user" });
           });
           const pos = target.selectionStart ?? target.value.length;
           if (pluginRegistry) {

package/src/primitives/composer/ComposerResume.ts

@@ -0,0 +1,36 @@
+"use client";
+
+import { useCallback } from "react";
+import { useComposerResume as useComposerResumeBehavior } from "@assistant-ui/core/react";
+import {
+  createActionButton,
+  type ActionButtonElement,
+  type ActionButtonProps,
+} from "../../utils/createActionButton";
+
+const useComposerResume = () => {
+  const { disabled, resume } = useComposerResumeBehavior();
+  const callback = useCallback(() => resume(), [resume]);
+  if (disabled) return null;
+  return callback;
+};
+
+export namespace ComposerPrimitiveResume {
+  export type Element = ActionButtonElement;
+  export type Props = ActionButtonProps<typeof useComposerResume>;
+}
+
+/**
+ * Resumes an interrupted run when its adapter explicitly reports a checkpoint.
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.Resume>
+ *   Resume
+ * </ComposerPrimitive.Resume>
+ * ```
+ */
+export const ComposerPrimitiveResume = createActionButton(
+  "ComposerPrimitive.Resume",
+  useComposerResume,
+);

package/src/primitives/composer/trigger/triggerSelectionResource.test.ts

@@ -77,11 +77,35 @@ describe("TriggerSelectionResource", () => {
 
     root.getValue().selectItem(item);
 
-    expect(setText).toHaveBeenCalledWith("@file.txt tail");
+    expect(setText).toHaveBeenCalledWith("@file.txt tail", { origin: "user" });
     expect(setCursorPosition).toHaveBeenCalledWith("@file.txt".length + 1);
     expect(onSelected).toHaveBeenCalledOnce();
   });
 
+  it("reports an inserted directive once a select override finishes the insertion", () => {
+    const onInserted = vi.fn();
+    const { root, setText, onSelected } = render({
+      behavior: { kind: "directive", formatter, onInserted },
+      text: "@file tail",
+      trigger: { offset: 0, query: "file", endOffset: 5 },
+    });
+    let finishInsertion: (() => void) | undefined;
+    root.getValue().registerSelectItemOverride((_, onOverrideInserted) => {
+      finishInsertion = onOverrideInserted;
+      return true;
+    });
+
+    root.getValue().selectItem(item);
+
+    expect(onInserted).not.toHaveBeenCalled();
+    expect(setText).not.toHaveBeenCalled();
+    expect(onSelected).toHaveBeenCalledOnce();
+
+    finishInsertion?.();
+
+    expect(onInserted).toHaveBeenCalledExactlyOnceWith(item);
+  });
+
   it("resynchronizes the cursor after removing an action", () => {
     const { root, setText, setCursorPosition } = render({
       behavior: {
@@ -96,7 +120,7 @@ describe("TriggerSelectionResource", () => {
 
     root.getValue().selectItem(item);
 
-    expect(setText).toHaveBeenCalledWith("before tail");
+    expect(setText).toHaveBeenCalledWith("before tail", { origin: "user" });
     expect(setCursorPosition).toHaveBeenCalledWith(7);
   });
 
@@ -129,7 +153,7 @@ describe("TriggerSelectionResource", () => {
     root.getValue().selectItem(item);
 
     expect(setText).toHaveBeenCalledOnce();
-    expect(setText).toHaveBeenCalledWith("@file.txt ");
+    expect(setText).toHaveBeenCalledWith("@file.txt ", { origin: "user" });
     expect(textRef.value).toBe("@file.txt ");
   });
 
@@ -142,6 +166,8 @@ describe("TriggerSelectionResource", () => {
 
     root.getValue().selectItem(item);
 
-    expect(setText).toHaveBeenCalledWith("hello @file.txt tail");
+    expect(setText).toHaveBeenCalledWith("hello @file.txt tail", {
+      origin: "user",
+    });
   });
 });

package/src/primitives/composer/trigger/triggerSelectionResource.ts

@@ -7,8 +7,15 @@ import type {
 import type { AssistantClient } from "@assistant-ui/store";
 import type { DetectedTrigger } from "./triggerDetectionResource";
 
-/** External override for selection (used by Lexical's DirectivePlugin). */
-export type SelectItemOverride = (item: Unstable_TriggerItem) => boolean;
+/**
+ * External override for selection (used by Lexical's DirectivePlugin).
+ * Returns whether it handled the item, and calls `onInserted` once the
+ * insertion has reached the composer.
+ */
+export type SelectItemOverride = (
+  item: Unstable_TriggerItem,
+  onInserted: () => void,
+) => boolean;
 
 export type TriggerBehavior =
   | {
@@ -66,7 +73,11 @@ const useTriggerSelectionResource = ({
   const selectItem = useEffectEvent((item: Unstable_TriggerItem) => {
     if (!trigger || !behavior) return;
 
-    if (selectItemOverrideRef.current?.(item)) {
+    const reportInserted = () => {
+      if (behavior.kind === "directive") behavior.onInserted?.(item);
+    };
+
+    if (selectItemOverrideRef.current?.(item, reportInserted)) {
       onSelected();
       return;
     }
@@ -79,6 +90,7 @@ const useTriggerSelectionResource = ({
       const directive = behavior.formatter.serialize(item);
       aui.composer.setText(
         before + directive + (after.startsWith(" ") ? after : ` ${after}`),
+        { origin: "user" },
       );
       setCursorPosition(before.length + directive.length + 1);
     };
@@ -90,6 +102,7 @@ const useTriggerSelectionResource = ({
       if (behavior.removeOnExecute) {
         aui.composer.setText(
           before + (after.startsWith(" ") ? after.slice(1) : after),
+          { origin: "user" },
         );
         setCursorPosition(before.length);
       } else {

package/src/primitives/composer/useAuiState.composer.test.tsx

@@ -0,0 +1,84 @@
+/** @vitest-environment jsdom */
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { useState } from "react";
+import { describe, expect, it } from "vitest";
+import {
+  AssistantRuntimeProvider,
+  useExternalStoreRuntime,
+} from "@assistant-ui/core/react";
+import type { ThreadMessage } from "@assistant-ui/core";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+function Input({
+  value,
+  onChange,
+  withOwnState,
+}: {
+  value: string;
+  onChange: (value: string) => void;
+  withOwnState: boolean;
+}) {
+  const [, setChangeCount] = useState(0);
+  return (
+    <textarea
+      aria-label="composer"
+      value={value}
+      onChange={(event) => {
+        if (withOwnState) setChangeCount((count) => count + 1);
+        onChange(event.target.value);
+      }}
+    />
+  );
+}
+
+function BoundInput({ withOwnState }: { withOwnState: boolean }) {
+  const aui = useAui();
+  const text = useAuiState((s) => s.composer.text);
+  return (
+    <>
+      <button onClick={() => aui.composer.setText("hello world")}>seed</button>
+      <Input
+        value={text}
+        onChange={(value) => aui.composer.setText(value)}
+        withOwnState={withOwnState}
+      />
+    </>
+  );
+}
+
+function App({ withOwnState }: { withOwnState: boolean }) {
+  const runtime = useExternalStoreRuntime<ThreadMessage>({
+    messages: [],
+    convertMessage: (message) => message,
+    onNew: async () => {},
+  });
+  return (
+    <AssistantRuntimeProvider runtime={runtime}>
+      <BoundInput withOwnState={withOwnState} />
+    </AssistantRuntimeProvider>
+  );
+}
+
+describe("composer state in controlled inputs", () => {
+  it.each([
+    ["mentions-like", true],
+    ["plain textarea", false],
+  ])(
+    "keeps the caret after typing in the middle: %s",
+    async (_, withOwnState) => {
+      render(<App withOwnState={withOwnState} />);
+      fireEvent.click(screen.getByRole("button", { name: "seed" }));
+      const input = screen.getByRole("textbox", {
+        name: "composer",
+      }) as HTMLTextAreaElement;
+      await waitFor(() => expect(input.value).toBe("hello world"));
+
+      input.setSelectionRange(5, 5);
+      fireEvent.change(input, {
+        target: { value: "helloX world", selectionStart: 6, selectionEnd: 6 },
+      });
+      await waitFor(() => expect(input.value).toBe("helloX world"));
+      expect(input.selectionStart).toBe(6);
+    },
+  );
+});

package/src/primitives/composer.ts

@@ -3,6 +3,7 @@ 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";

package/src/primitives/thread/ThreadRoot.test.tsx

@@ -4,7 +4,7 @@ import { act, render, screen, waitFor } from "@testing-library/react";
 import type { FC, PropsWithChildren } from "react";
 import { describe, expect, it, vi } from "vitest";
 import { AssistantRuntimeProvider } from "../../context";
-import { useLocalRuntime } from "../../legacy-runtime/runtime-cores/local/useLocalRuntime";
+import { useLocalRuntime } from "@assistant-ui/core/react";
 import type {
   ChatModelAdapter,
   SpeechSynthesisAdapter,