@assistant-ui/react 0.15.30 → 0.15.32

package/src/cloud-renderer/CloudRendererHost.tsx

@@ -17,10 +17,12 @@ import {
   type AssistantClient,
 } from "@assistant-ui/store";
 import { resource } from "@assistant-ui/tap";
-import { ReadonlyThreadProvider } from "@assistant-ui/core/react";
+import {
+  ReadonlyThreadProvider,
+  useExternalStoreRuntime,
+} from "@assistant-ui/core/react";
 import type { ThreadMessage } from "@assistant-ui/core";
 import { AssistantRuntimeProvider } from "../legacy-runtime/AssistantRuntimeProvider";
-import { useExternalStoreRuntime } from "../legacy-runtime/runtime-cores/external-store/useExternalStoreRuntime";
 
 const CHANNEL = "assistant-ui/cloud-renderer";
 

package/src/index.ts

@@ -60,7 +60,7 @@ export {
   SimpleTextAttachmentAdapter,
   CompositeAttachmentAdapter,
 } from "@assistant-ui/core";
-export { CloudFileAttachmentAdapter } from "./legacy-runtime/runtime-cores/adapters/attachment/CloudFileAttachmentAdapter";
+export { CloudFileAttachmentAdapter } from "@assistant-ui/core/react";
 
 // --- adapters/voice ---
 export type { RealtimeVoiceAdapter } from "@assistant-ui/core";
@@ -164,7 +164,7 @@ export {
   type ExternalThreadQueueAdapter,
   type ExternalThreadBranchAdapter,
 } from "@assistant-ui/core";
-export { useExternalStoreRuntime } from "./legacy-runtime/runtime-cores/external-store/useExternalStoreRuntime";
+export { useExternalStoreRuntime } from "@assistant-ui/core/react";
 export { useExternalStoreSharedOptions } from "@assistant-ui/core/react";
 export {
   useExternalMessageConverter,
@@ -174,11 +174,11 @@ export {
   createExternalMessageConversionCache as unstable_createExternalMessageConversionCache,
   /** @deprecated Experimental since 2026-09-15. Not scheduled for removal; the API may change in any release. */
   type ExternalMessageConversionCache as Unstable_ExternalMessageConversionCache,
-} from "./legacy-runtime/runtime-cores/external-store/external-message-converter";
+} from "@assistant-ui/core/react";
 export {
   /** @deprecated Experimental since 2025-02-02. Not scheduled for removal; the API may change in any release. */
   createMessageConverter as unstable_createMessageConverter,
-} from "./legacy-runtime/runtime-cores/external-store/createMessageConverter";
+} from "@assistant-ui/core/react";
 
 // --- local ---
 export type {
@@ -188,12 +188,12 @@ export type {
   ChatModelRunUpdate,
   LocalRuntimeOptionsBase,
 } from "@assistant-ui/core";
-export { useLocalRuntime } from "./legacy-runtime/runtime-cores/local/useLocalRuntime";
-export type { LocalRuntimeOptions } from "./legacy-runtime/runtime-cores/local/LocalRuntimeOptions";
+export { useLocalRuntime } from "@assistant-ui/core/react";
+export type { LocalRuntimeOptions } from "@assistant-ui/core/react";
 
 // --- remote-thread-list ---
-export { useRemoteThreadListRuntime } from "./legacy-runtime/runtime-cores/remote-thread-list/useRemoteThreadListRuntime";
-export { useCloudThreadListAdapter } from "./legacy-runtime/runtime-cores/remote-thread-list/adapter/cloud";
+export { useRemoteThreadListRuntime } from "@assistant-ui/core/react";
+export { useCloudThreadListAdapter } from "@assistant-ui/core/react";
 export type {
   RemoteThreadListAdapter,
   RemoteThreadListProviderComponent,
@@ -303,6 +303,7 @@ export type {
   QueueItemMethods,
 } from "@assistant-ui/core/store";
 export type { ComposerSendOptions } from "@assistant-ui/core/store";
+export type { ComposerTextOrigin } from "@assistant-ui/core";
 
 export { makeAssistantVisible } from "./model-context/makeAssistantVisible";
 

package/src/internal.ts

@@ -20,7 +20,7 @@ export type {
 } from "@assistant-ui/core/internal";
 
 // React-specific (stay in react)
-export { splitLocalRuntimeOptions } from "./legacy-runtime/runtime-cores/local/LocalRuntimeOptions";
+export { splitLocalRuntimeOptions } from "@assistant-ui/core/react";
 export type { ToolExecutionStatus } from "@assistant-ui/core";
 
 export { useSmooth } from "./utils/smooth/useSmooth";

package/src/legacy-runtime/AssistantRuntimeProvider.tsx

@@ -6,7 +6,7 @@ import {
   type AuiConfig,
   useAui,
 } from "@assistant-ui/store";
-import type { AssistantRuntime } from "./runtime/AssistantRuntime";
+import type { AssistantRuntime } from "@assistant-ui/core";
 import { AssistantProviderBase } from "@assistant-ui/core/react";
 import { ThreadPrimitiveViewportProvider } from "../context/providers/ThreadViewportProvider";
 import { DevToolsProviderApi } from "../devtools/DevToolsHooks";

package/src/mcp-apps/McpAppRenderer.composer.test.tsx

@@ -0,0 +1,111 @@
+// @vitest-environment jsdom
+import { act, render, waitFor } from "@testing-library/react";
+import { resource, useResource } from "@assistant-ui/tap";
+import {
+  AssistantRuntimeProvider,
+  MessageByIndexProvider,
+  useExternalStoreRuntime,
+  type ToolCallMessagePartProps,
+} from "@assistant-ui/core/react";
+import type { ThreadMessageLike } from "@assistant-ui/core";
+import { expect, it, vi } from "vitest";
+import type { AssistantRuntime } from "../index";
+import type { McpAppBridgeHandlers, McpAppsHost } from "./types";
+
+const { framePropsMock } = vi.hoisted(() => ({ framePropsMock: vi.fn() }));
+
+vi.mock("./app-frame", () => ({
+  McpAppFrame: (props: unknown) => {
+    framePropsMock(props);
+    return null;
+  },
+}));
+
+import { McpAppRenderer } from "./McpAppRenderer";
+
+const Host = resource(({ host }: { host: McpAppsHost }) => host);
+
+const host: McpAppsHost = {
+  loadResource: vi.fn(async ({ uri }) => ({
+    uri,
+    mimeType: "text/html;profile=mcp-app" as const,
+    html: "",
+  })),
+  callTool: vi.fn(),
+  readResource: vi.fn(),
+  listResources: vi.fn(),
+};
+
+const part: ToolCallMessagePartProps = {
+  type: "tool-call",
+  toolCallId: "call-1",
+  toolName: "search",
+  args: {},
+  argsText: "{}",
+  status: { type: "complete" },
+  mcp: { app: { resourceUri: "ui://example/search" } },
+  addResult: vi.fn(),
+  resume: vi.fn(),
+  respondToApproval: vi.fn(),
+};
+
+const messages: ThreadMessageLike[] = [
+  { role: "assistant", content: "Here is the app" },
+];
+
+const AppPart = () => {
+  const renderer = useResource(McpAppRenderer({ host: Host({ host }) }));
+  const Renderer = renderer.render;
+  return <Renderer {...part} />;
+};
+
+let runtime!: AssistantRuntime;
+
+const App = () => {
+  runtime = useExternalStoreRuntime({
+    messages,
+    convertMessage: (message: ThreadMessageLike) => message,
+    onNew: async () => {},
+  });
+  return (
+    <AssistantRuntimeProvider runtime={runtime}>
+      <MessageByIndexProvider index={0}>
+        <AppPart />
+      </MessageByIndexProvider>
+    </AssistantRuntimeProvider>
+  );
+};
+
+const renderApp = async () => {
+  framePropsMock.mockClear();
+  render(<App />);
+  await waitFor(() => expect(framePropsMock).toHaveBeenCalled());
+  const handlers = framePropsMock.mock.lastCall?.[0]
+    .handlers as McpAppBridgeHandlers;
+  return handlers;
+};
+
+it("fills the thread composer from an MCP App message inside a message", async () => {
+  const handlers = await renderApp();
+
+  let result: unknown;
+  act(() => {
+    result = handlers.sendMessage?.({ text: "Open Grade 5 Math" });
+  });
+
+  expect(result).toEqual({ ok: true });
+  expect(runtime.thread.composer.getState().text).toBe("Open Grade 5 Math");
+});
+
+it("keeps the user's draft when an MCP App message arrives", async () => {
+  const handlers = await renderApp();
+  act(() => runtime.thread.composer.setText("Show my classes"));
+
+  act(() => {
+    handlers.sendMessage?.({ text: "Open Grade 5 Math" });
+  });
+
+  expect(runtime.thread.composer.getState().text).toBe(
+    "Show my classes Open Grade 5 Math",
+  );
+});

package/src/mcp-apps/McpAppRenderer.test.tsx

@@ -16,15 +16,22 @@ import type {
   McpAppsRemoteHostOptions,
 } from "./types";
 
-const { appendMock, framePropsMock } = vi.hoisted(() => ({
+const { appendMock, setTextMock, framePropsMock } = vi.hoisted(() => ({
   appendMock: vi.fn(),
+  setTextMock: vi.fn(),
   framePropsMock: vi.fn(),
 }));
 
 vi.mock("@assistant-ui/store", async (importOriginal) => ({
   ...(await importOriginal()),
   useAui: () => ({
-    thread: { append: appendMock },
+    thread: {
+      append: appendMock,
+      composer: () => ({
+        setText: setTextMock,
+        getState: () => ({ text: "" }),
+      }),
+    },
   }),
 }));
 
@@ -190,6 +197,7 @@ function RemoteHarness({
 describe("McpAppRenderer", () => {
   beforeEach(() => {
     appendMock.mockReset();
+    setTextMock.mockReset();
     framePropsMock.mockReset();
   });
 
@@ -676,7 +684,7 @@ describe("McpAppRenderer", () => {
     expect(listResources).toHaveBeenCalledWith(params);
   });
 
-  it("appends MCP Apps message content in the default sendMessage handler", async () => {
+  it("puts MCP Apps text content in the composer without appending", async () => {
     render(<Harness host={loadingHost()} />);
     await waitFor(() => expect(framePropsMock).toHaveBeenCalled());
     const handlers = framePropsMock.mock.lastCall?.[0]
@@ -692,19 +700,13 @@ describe("McpAppRenderer", () => {
         ],
       }),
     ).toEqual({ ok: true });
-    expect(appendMock).toHaveBeenCalledWith({
-      content: [
-        { type: "text", text: "Open Grade 5 Math" },
-        { type: "text", text: "Period 4" },
-      ],
-    });
+    expect(setTextMock).toHaveBeenCalledWith("Open Grade 5 Math\nPeriod 4");
+    expect(appendMock).not.toHaveBeenCalled();
 
     expect(handlers.sendMessage?.({ text: "typed instead" })).toEqual({
       ok: true,
     });
-    expect(appendMock).toHaveBeenLastCalledWith({
-      content: [{ type: "text", text: "typed instead" }],
-    });
+    expect(setTextMock).toHaveBeenLastCalledWith("typed instead");
 
     expect(
       handlers.sendMessage?.({
@@ -722,7 +724,8 @@ describe("McpAppRenderer", () => {
       ok: false,
       reason: "unrecognised params shape",
     });
-    expect(appendMock).toHaveBeenCalledTimes(2);
+    expect(setTextMock).toHaveBeenCalledTimes(2);
+    expect(appendMock).not.toHaveBeenCalled();
   });
 
   it("extracts sparse message content without traversing holes", async () => {
@@ -755,9 +758,8 @@ describe("McpAppRenderer", () => {
     }
 
     expect(visitedHole).not.toHaveBeenCalled();
-    expect(appendMock).toHaveBeenCalledWith({
-      content: [{ type: "text", text: "sparse prompt" }],
-    });
+    expect(setTextMock).toHaveBeenCalledExactlyOnceWith("sparse prompt");
+    expect(appendMock).not.toHaveBeenCalled();
   });
 
   it("ignores non-index message content properties after structured clone", async () => {
@@ -781,13 +783,10 @@ describe("McpAppRenderer", () => {
       ).toEqual({ ok: true });
     }
 
-    expect(appendMock).toHaveBeenCalledTimes(2);
-    expect(appendMock).toHaveBeenNthCalledWith(1, {
-      content: [{ type: "text", text: "message text" }],
-    });
-    expect(appendMock).toHaveBeenNthCalledWith(2, {
-      content: [{ type: "text", text: "message text" }],
-    });
+    expect(setTextMock).toHaveBeenCalledTimes(2);
+    expect(setTextMock).toHaveBeenNthCalledWith(1, "message text");
+    expect(setTextMock).toHaveBeenNthCalledWith(2, "message text");
+    expect(appendMock).not.toHaveBeenCalled();
   });
 
   it("uses caller UI handlers and keeps data-plane handlers on the host", async () => {
@@ -838,6 +837,8 @@ describe("McpAppRenderer", () => {
     expect(updateModelContext).toHaveBeenCalledWith({ text: "context" });
     expect(openLink).toHaveBeenCalledWith({ url: "https://example.com" });
     expect(sendMessage).toHaveBeenCalledWith({ text: "hello" });
+    expect(setTextMock).not.toHaveBeenCalled();
+    expect(appendMock).not.toHaveBeenCalled();
     expect(onInitialized).toHaveBeenCalledOnce();
     expect(host.callTool).toHaveBeenCalledWith({ name: "search" });
     expect(host.readResource).toHaveBeenCalledWith({ uri: "ui://resource" });

package/src/mcp-apps/McpAppRenderer.tsx

@@ -277,7 +277,15 @@ function InlineRenderer({
           if ("reason" in result) {
             return { isError: true, ok: false, reason: result.reason };
           }
-          aui.thread.append({ content: result.content });
+          const composer = aui.thread.composer();
+          composer.setText(
+            [
+              composer.getState().text,
+              result.content.map((part) => part.text).join("\n"),
+            ]
+              .filter((part) => part.trim())
+              .join(" "),
+          );
           return { ok: true };
         }),
       callTool: (params) =>

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/chainOfThought/ChainOfThoughtAccordionTrigger.test.tsx

@@ -0,0 +1,91 @@
+// @vitest-environment jsdom
+import { createRef, type MouseEvent, type Ref } from "react";
+import { cleanup, fireEvent, render, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { AuiProvider, useAui, useAuiState } from "@assistant-ui/store";
+import { ChainOfThoughtClient } from "@assistant-ui/core/store";
+import { ChainOfThoughtPrimitiveAccordionTrigger } from "./ChainOfThoughtAccordionTrigger";
+
+afterEach(cleanup);
+
+const Content = () => {
+  const collapsed = useAuiState((s) => s.chainOfThought.collapsed);
+  return (
+    <div data-testid="reasoning" hidden={collapsed}>
+      Reasoning details
+    </div>
+  );
+};
+
+const App = ({
+  triggerRef,
+  ...props
+}: ChainOfThoughtPrimitiveAccordionTrigger.Props & {
+  triggerRef?: Ref<HTMLButtonElement>;
+}) => {
+  const aui = useAui({
+    chainOfThought: ChainOfThoughtClient({
+      parts: [
+        {
+          type: "reasoning",
+          text: "Reasoning details",
+          status: { type: "complete" },
+        },
+      ],
+      getMessagePart: () => {
+        throw new Error("Part lookup is not used by the toggle");
+      },
+    }),
+  });
+  return (
+    <AuiProvider value={aui}>
+      <ChainOfThoughtPrimitiveAccordionTrigger {...props} ref={triggerRef} />
+      <Content />
+    </AuiProvider>
+  );
+};
+
+describe("ChainOfThoughtPrimitiveAccordionTrigger", () => {
+  it.each(["button", "render", "asChild"] as const)(
+    "exposes expansion and forwards the ref with %s",
+    async (mode) => {
+      const ref = createRef<HTMLButtonElement>();
+      const { getByRole, getByTestId } = render(
+        <App
+          triggerRef={ref}
+          {...(mode === "render" ? { render: <button /> } : {})}
+          {...(mode === "asChild" ? { asChild: true } : {})}
+        >
+          {mode === "asChild" ? <button>Thinking</button> : "Thinking"}
+        </App>,
+      );
+      const button = getByRole("button", { name: "Thinking" });
+      const content = getByTestId("reasoning");
+      expect(ref.current).toBe(button);
+      expect(content.hidden).toBe(true);
+      expect(button.getAttribute("aria-expanded")).toBe("false");
+      fireEvent.click(button);
+      await waitFor(() => expect(content.hidden).toBe(false));
+      expect(button.getAttribute("aria-expanded")).toBe("true");
+      fireEvent.click(button);
+      await waitFor(() => expect(content.hidden).toBe(true));
+      expect(button.getAttribute("aria-expanded")).toBe("false");
+    },
+  );
+
+  it("lets the caller veto expansion", () => {
+    const onClick = vi.fn((event: MouseEvent) => event.preventDefault());
+    const { getByRole, getByTestId } = render(
+      <App onClick={onClick}>Thinking</App>,
+    );
+    fireEvent.click(getByRole("button"));
+    expect(onClick).toHaveBeenCalledOnce();
+    expect(getByTestId("reasoning").hidden).toBe(true);
+  });
+
+  it("does not expand a disabled trigger", () => {
+    const { getByRole, getByTestId } = render(<App disabled>Thinking</App>);
+    fireEvent.click(getByRole("button"));
+    expect(getByTestId("reasoning").hidden).toBe(true);
+  });
+});

package/src/primitives/chainOfThought/ChainOfThoughtAccordionTrigger.tsx

@@ -0,0 +1,54 @@
+"use client";
+
+import type { ActionButtonElement } from "../../utils/createActionButton";
+import { type ComponentPropsWithoutRef, forwardRef, useCallback } from "react";
+import { useAuiState, useAui } from "@assistant-ui/store";
+import { composeEventHandlers } from "radix-ui/internal";
+import { Primitive } from "../../utils/Primitive";
+
+export namespace ChainOfThoughtPrimitiveAccordionTrigger {
+  export type Element = ActionButtonElement;
+  /**
+   * Props for the ChainOfThoughtPrimitive.AccordionTrigger component.
+   * Inherits all button element props and action button functionality.
+   */
+  export type Props = ComponentPropsWithoutRef<typeof Primitive.button>;
+}
+
+/**
+ * A button component that toggles the collapsed state of the chain of thought accordion.
+ *
+ * This component automatically handles the toggle functionality, expanding or collapsing
+ * the chain of thought parts when clicked.
+ * Exposes the current disclosure state through `aria-expanded`.
+ *
+ * @example
+ * ```tsx
+ * <ChainOfThoughtPrimitive.AccordionTrigger>
+ *   Toggle Reasoning
+ * </ChainOfThoughtPrimitive.AccordionTrigger>
+ * ```
+ */
+export const ChainOfThoughtPrimitiveAccordionTrigger = forwardRef<
+  ChainOfThoughtPrimitiveAccordionTrigger.Element,
+  ChainOfThoughtPrimitiveAccordionTrigger.Props
+>(({ onClick, ...props }, ref) => {
+  const aui = useAui();
+  const collapsed = useAuiState((s) => s.chainOfThought.collapsed);
+  const toggle = useCallback(() => {
+    aui.chainOfThought.setCollapsed(!collapsed);
+  }, [aui, collapsed]);
+
+  return (
+    <Primitive.button
+      type="button"
+      {...props}
+      ref={ref}
+      aria-expanded={!collapsed}
+      onClick={composeEventHandlers(onClick, toggle)}
+    />
+  );
+});
+
+ChainOfThoughtPrimitiveAccordionTrigger.displayName =
+  "ChainOfThoughtPrimitive.AccordionTrigger";

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,