@assistant-ui/react 0.15.30 → 0.15.31

package/src/primitives/threadListItem/ThreadListItemUnarchive.test.tsx

@@ -0,0 +1,52 @@
+// @vitest-environment jsdom
+
+import { cleanup, fireEvent, render } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  AssistantRuntimeProvider,
+  ThreadListItemByIndexProvider,
+} from "@assistant-ui/core/react";
+import {
+  AssistantRuntimeImpl,
+  ExternalStoreRuntimeCore,
+} from "@assistant-ui/core/internal";
+import { ThreadListItemPrimitiveUnarchive } from "./ThreadListItemUnarchive";
+
+afterEach(cleanup);
+
+describe("ThreadListItemPrimitive.Unarchive", () => {
+  it.each([true, false])(
+    "renders an actionable button only when unarchive is supported (%s)",
+    (supported) => {
+      const onUnarchive = vi.fn();
+      const runtime = new AssistantRuntimeImpl(
+        new ExternalStoreRuntimeCore({
+          messages: [],
+          onNew: async () => {},
+          adapters: {
+            threadList: {
+              archivedThreads: [{ id: "archived", status: "archived" }],
+              onUnarchive: supported ? onUnarchive : undefined,
+            },
+          },
+        }),
+      );
+      const { getByRole } = render(
+        <AssistantRuntimeProvider runtime={runtime}>
+          <ThreadListItemByIndexProvider index={0} archived>
+            <ThreadListItemPrimitiveUnarchive disabled={false}>
+              Restore
+            </ThreadListItemPrimitiveUnarchive>
+          </ThreadListItemByIndexProvider>
+        </AssistantRuntimeProvider>,
+      );
+      const button = getByRole("button", {
+        name: "Restore",
+      }) as HTMLButtonElement;
+      expect(button.disabled).toBe(!supported);
+      fireEvent.click(button);
+      if (supported) expect(onUnarchive).toHaveBeenCalledWith("archived");
+      else expect(onUnarchive).not.toHaveBeenCalled();
+    },
+  );
+});

package/src/primitives/threadListItem/ThreadListItemUnarchive.ts

@@ -8,8 +8,8 @@ import {
 import { useThreadListItemUnarchive as useThreadListItemUnarchiveBehavior } from "@assistant-ui/core/react";
 
 const useThreadListItemUnarchive = () => {
-  const { unarchive } = useThreadListItemUnarchiveBehavior();
-  return unarchive;
+  const { unarchive, disabled } = useThreadListItemUnarchiveBehavior();
+  return disabled ? null : unarchive;
 };
 
 export namespace ThreadListItemPrimitiveUnarchive {

package/src/tests/DataRenderers.test.tsx

@@ -15,7 +15,7 @@ import { useAui } from "@assistant-ui/store";
 import { AssistantRuntimeProvider } from "../context";
 import * as MessagePrimitive from "../primitives/message";
 import * as ThreadPrimitive from "../primitives/thread";
-import { useLocalRuntime } from "../legacy-runtime/runtime-cores/local/useLocalRuntime";
+import { useLocalRuntime } from "@assistant-ui/core/react";
 import {
   useAssistantDataUI,
   type ChatModelAdapter,

package/src/tests/MessageParts.loading.test.tsx

@@ -7,7 +7,7 @@ import { AssistantRuntimeProvider } from "../context";
 import * as MessagePartPrimitive from "../primitives/messagePart";
 import * as MessagePrimitive from "../primitives/message";
 import * as ThreadPrimitive from "../primitives/thread";
-import { useLocalRuntime } from "../legacy-runtime/runtime-cores/local/useLocalRuntime";
+import { useLocalRuntime } from "@assistant-ui/core/react";
 import type { ChatModelAdapter, ThreadMessageLike } from "../index";
 
 const noOpAdapter: ChatModelAdapter = {

package/src/tests/RemoteThreadListRuntime.adapterProvider.test.tsx

@@ -8,9 +8,9 @@ import {
   useRemoteThreadListRuntime,
   useRuntimeAdapters,
   type RuntimeAdapters as RuntimeAdaptersShape,
+  useLocalRuntime,
 } from "@assistant-ui/core/react";
 import { makeAdapter } from "./remote-thread-list-test-helpers";
-import { useLocalRuntime } from "../legacy-runtime/runtime-cores/local/useLocalRuntime";
 import { AssistantRuntimeProvider } from "../context";
 import type { ChatModelAdapter, RemoteThreadListAdapter } from "../index";
 import type { ThreadHistoryAdapter } from "@assistant-ui/core";

package/src/tests/RemoteThreadListRuntime.deferredProvider.test.tsx

@@ -3,12 +3,14 @@
 import { act, render } from "@testing-library/react";
 import { type FC, type PropsWithChildren, useState } from "react";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { useRemoteThreadListRuntime } from "@assistant-ui/core/react";
+import {
+  useRemoteThreadListRuntime,
+  useLocalRuntime,
+} from "@assistant-ui/core/react";
 import { makeAdapter } from "./remote-thread-list-test-helpers";
 import type { AssistantRuntime } from "@assistant-ui/core";
 import { useAui } from "@assistant-ui/store";
 import { AssistantRuntimeProvider } from "../context";
-import { useLocalRuntime } from "../legacy-runtime/runtime-cores/local/useLocalRuntime";
 import type { ChatModelAdapter, RemoteThreadListAdapter } from "../index";
 
 const noOpAdapter: ChatModelAdapter = {

package/src/tests/RemoteThreadListRuntime.reloadMainThread.test.tsx

@@ -4,12 +4,14 @@ import { act, render, waitFor } from "@testing-library/react";
 import { type FC, useEffect } from "react";
 import { describe, expect, it } from "vitest";
 import type { AssistantRuntime } from "@assistant-ui/core";
-import { useRemoteThreadListRuntime } from "@assistant-ui/core/react";
+import {
+  useRemoteThreadListRuntime,
+  useLocalRuntime,
+} from "@assistant-ui/core/react";
 import {
   makeAdapter,
   settleOutsideAct,
 } from "./remote-thread-list-test-helpers";
-import { useLocalRuntime } from "../legacy-runtime/runtime-cores/local/useLocalRuntime";
 import { AssistantRuntimeProvider } from "../context";
 import type { ChatModelAdapter } from "../index";
 

package/src/tests/generative-ui.primitive.test.tsx

@@ -6,7 +6,7 @@ import { describe, expect, it, vi } from "vitest";
 import { AssistantRuntimeProvider } from "../context";
 import * as MessagePrimitive from "../primitives/message";
 import * as ThreadPrimitive from "../primitives/thread";
-import { useLocalRuntime } from "../legacy-runtime/runtime-cores/local/useLocalRuntime";
+import { useLocalRuntime } from "@assistant-ui/core/react";
 import type {
   ChatModelAdapter,
   GenerativeUISpec,

package/src/tests/local-runtime-queue.test.tsx

@@ -5,8 +5,8 @@ import type { FC } from "react";
 import { describe, it, expect } from "vitest";
 import { useAui } from "@assistant-ui/store";
 import { AssistantRuntimeProvider } from "../context";
-import { useLocalRuntime } from "../legacy-runtime/runtime-cores/local/useLocalRuntime";
-import type { ChatModelAdapter } from "../legacy-runtime/runtime-cores/local/ChatModelAdapter";
+import { useLocalRuntime } from "@assistant-ui/core/react";
+import type { ChatModelAdapter } from "@assistant-ui/core";
 
 const flush = () => new Promise<void>((resolve) => setTimeout(resolve, 0));
 

package/src/tests/messagePartSwitchRace.test.tsx

@@ -6,8 +6,8 @@ import { Component, useEffect, useState, type FC, type ReactNode } from "react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { useAui, useAuiState } from "@assistant-ui/store";
 import { AssistantRuntimeProvider, PartByIndexProvider } from "../context";
-import { useLocalRuntime } from "../legacy-runtime/runtime-cores/local/useLocalRuntime";
-import type { ChatModelAdapter } from "../legacy-runtime/runtime-cores/local/ChatModelAdapter";
+import { useLocalRuntime } from "@assistant-ui/core/react";
+import type { ChatModelAdapter } from "@assistant-ui/core";
 import * as ThreadPrimitive from "../primitives/thread";
 import * as MessagePrimitive from "../primitives/message";
 import { useMessagePartText } from "../primitives/messagePart/useMessagePartText";

package/src/tests/messagePartTypeMismatch.test.tsx

@@ -7,7 +7,7 @@ import { AssistantRuntimeProvider } from "../context";
 import * as MessagePartPrimitive from "../primitives/messagePart";
 import * as MessagePrimitive from "../primitives/message";
 import * as ThreadPrimitive from "../primitives/thread";
-import { useLocalRuntime } from "../legacy-runtime/runtime-cores/local/useLocalRuntime";
+import { useLocalRuntime } from "@assistant-ui/core/react";
 import {
   useMessagePartReasoning,
   useMessagePartSource,

package/src/tests/threadListItemIsRunning.test.tsx

@@ -4,7 +4,11 @@ import { act, render, screen, waitFor } from "@testing-library/react";
 import { type FC, useEffect, useReducer } from "react";
 import { describe, expect, it } from "vitest";
 import type { ThreadMessage } from "@assistant-ui/core";
-import { useRemoteThreadListRuntime } from "@assistant-ui/core/react";
+import {
+  useRemoteThreadListRuntime,
+  useLocalRuntime,
+  useExternalStoreRuntime,
+} from "@assistant-ui/core/react";
 import {
   makeAdapter,
   settleOutsideAct,
@@ -17,8 +21,6 @@ import {
   type AssistantRuntime,
   type ChatModelAdapter,
 } from "../index";
-import { useExternalStoreRuntime } from "../legacy-runtime/runtime-cores/external-store/useExternalStoreRuntime";
-import { useLocalRuntime } from "../legacy-runtime/runtime-cores/local/useLocalRuntime";
 
 const Probe: FC = () => {
   const id = useAuiState((s) => s.threadListItem.id);

package/src/tests/toolCallTiming.test.tsx

@@ -6,7 +6,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { AssistantRuntimeProvider } from "../context";
 import * as MessagePrimitive from "../primitives/message";
 import * as ThreadPrimitive from "../primitives/thread";
-import { useLocalRuntime } from "../legacy-runtime/runtime-cores/local/useLocalRuntime";
+import { useLocalRuntime } from "@assistant-ui/core/react";
 import {
   type ChatModelAdapter,
   type ThreadMessageLike,

package/src/unstable/useComposerInput.test.tsx

@@ -100,7 +100,7 @@ describe("unstable_useComposerInput", () => {
   it("writes text via flushTapSync when editing", () => {
     renderInput()().setText("world");
     expect(flushTapSync).toHaveBeenCalledTimes(1);
-    expect(composerSetText).toHaveBeenCalledWith("world");
+    expect(composerSetText).toHaveBeenCalledWith("world", { origin: "user" });
   });
 
   it("ignores setText when the composer is not editing (editing guard)", () => {

package/src/unstable/useComposerInput.ts

@@ -89,7 +89,7 @@ export function unstable_useComposerInput(
     (text: string) => {
       if (!aui.composer.getState().isEditing) return;
       flushTapSync(() => {
-        aui.composer.setText(text);
+        aui.composer.setText(text, { origin: "user" });
       });
     },
     [aui],

package/src/unstable/useComposerInputHistory.test.tsx

@@ -12,6 +12,7 @@ const setText = vi.fn();
 
 vi.mock("@assistant-ui/store", () => ({
   useAui: () => ({
+    optional: { threads: {} },
     composer: {
       getState: () => ({ type: fixture.composerType }),
       setText,
@@ -81,7 +82,7 @@ describe("unstable_useComposerInputHistory", () => {
     const { textarea } = setup("");
     const notPrevented = arrow(textarea, "ArrowUp");
     expect(notPrevented).toBe(false);
-    expect(setText).toHaveBeenCalledWith("second");
+    expect(setText).toHaveBeenCalledWith("second", { origin: "recall" });
   });
 
   it("steps to older entries and consumes the key at the oldest", () => {
@@ -89,7 +90,7 @@ describe("unstable_useComposerInputHistory", () => {
     arrow(textarea, "ArrowUp");
     textarea.value = "second";
     arrow(textarea, "ArrowUp");
-    expect(setText).toHaveBeenLastCalledWith("first");
+    expect(setText).toHaveBeenLastCalledWith("first", { origin: "recall" });
 
     textarea.value = "first";
     const notPrevented = arrow(textarea, "ArrowUp");
@@ -102,7 +103,7 @@ describe("unstable_useComposerInputHistory", () => {
     arrow(textarea, "ArrowUp");
     textarea.value = "second";
     arrow(textarea, "ArrowDown");
-    expect(setText).toHaveBeenLastCalledWith("  ");
+    expect(setText).toHaveBeenLastCalledWith("  ", { origin: "recall" });
 
     textarea.value = "  ";
     const notPrevented = arrow(textarea, "ArrowDown");
@@ -121,7 +122,9 @@ describe("unstable_useComposerInputHistory", () => {
     fixture.messages = [user("other"), user("line1\nline2")];
     const { textarea } = setup("");
     arrow(textarea, "ArrowUp");
-    expect(setText).toHaveBeenLastCalledWith("line1\nline2");
+    expect(setText).toHaveBeenLastCalledWith("line1\nline2", {
+      origin: "recall",
+    });
     textarea.value = "line1\nline2";
     textarea.setSelectionRange(8, 8);
     const notPrevented = arrow(textarea, "ArrowUp");
@@ -164,10 +167,10 @@ describe("unstable_useComposerInputHistory", () => {
     ];
     const { textarea } = setup("");
     arrow(textarea, "ArrowUp");
-    expect(setText).toHaveBeenLastCalledWith("second");
+    expect(setText).toHaveBeenLastCalledWith("second", { origin: "recall" });
     textarea.value = "second";
     arrow(textarea, "ArrowUp");
-    expect(setText).toHaveBeenLastCalledWith("first");
+    expect(setText).toHaveBeenLastCalledWith("first", { origin: "recall" });
     textarea.value = "first";
     arrow(textarea, "ArrowUp");
     expect(setText).toHaveBeenCalledTimes(2);
@@ -179,7 +182,7 @@ describe("unstable_useComposerInputHistory", () => {
     fixture.messages = [...fixture.messages, user("third")];
     textarea.value = "";
     arrow(textarea, "ArrowUp");
-    expect(setText).toHaveBeenLastCalledWith("third");
+    expect(setText).toHaveBeenLastCalledWith("third", { origin: "recall" });
   });
 
   it("is inert on edit composers", () => {

package/src/unstable/useComposerInputHistory.thread-scope.test.tsx

@@ -0,0 +1,123 @@
+// @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,
+  useAuiState,
+} from "@assistant-ui/store";
+import { ExternalThread, InMemoryThreadList } from "@assistant-ui/core/store";
+import { resource, useResource } from "@assistant-ui/tap";
+import type { ThreadMessage } from "@assistant-ui/core";
+import { unstable_useComposerInputHistory } from "./useComposerInputHistory";
+
+const messages: ThreadMessage[] = [
+  {
+    id: "user-1",
+    role: "user",
+    createdAt: new Date(0),
+    content: [{ type: "text", text: "Previous question" }],
+    attachments: [],
+    metadata: { custom: {} },
+  },
+];
+const StandaloneThread = resource(function useStandaloneThread() {
+  return useResource(ExternalThread({ messages }));
+});
+const Input = () => {
+  const aui = useAui();
+  const value = useAuiState((s) => s.composer.text);
+  const history = unstable_useComposerInputHistory();
+  return (
+    <textarea
+      aria-label="Composer"
+      value={value}
+      onChange={(e) => aui.composer.setText(e.target.value)}
+      {...history}
+    />
+  );
+};
+const StandaloneApp = () => {
+  const config = AuiConfig({
+    thread: StandaloneThread(),
+    composer: Derived({
+      source: "thread",
+      query: {},
+      get: (aui) => aui.thread.composer(),
+    }),
+  });
+  return (
+    <AuiProvider config={config}>
+      <Input />
+    </AuiProvider>
+  );
+};
+
+afterEach(cleanup);
+
+it("recalls history without a thread-list scope", async () => {
+  render(<StandaloneApp />);
+  const input = screen.getByRole("textbox", {
+    name: "Composer",
+  }) as HTMLTextAreaElement;
+  await act(async () => {
+    fireEvent.keyDown(input, { key: "ArrowUp" });
+  });
+  expect(input.value).toBe("Previous question");
+  await act(async () => {
+    fireEvent.keyDown(input, { key: "ArrowDown" });
+  });
+  expect(input.value).toBe("");
+});
+
+it("resets browsing when the thread switches without remounting the input", async () => {
+  let captured!: ReturnType<typeof useAui>;
+  const App = () => {
+    const aui = useAui({
+      threads: InMemoryThreadList({
+        thread: () => ExternalThread({ messages }),
+      }),
+    });
+    captured = aui;
+    return (
+      <AuiProvider value={aui}>
+        <Input />
+      </AuiProvider>
+    );
+  };
+  render(<App />);
+  const input = screen.getByRole("textbox", {
+    name: "Composer",
+  }) as HTMLTextAreaElement;
+  await act(async () => {
+    fireEvent.keyDown(input, { key: "ArrowUp" });
+  });
+  expect(input.value).toBe("Previous question");
+
+  const oldId = captured.threads.getState().mainThreadId;
+  await act(async () => {
+    captured.threads.switchToNewThread();
+  });
+  await waitFor(() =>
+    expect(captured.threads.getState().mainThreadId).not.toBe(oldId),
+  );
+  await act(async () => {
+    fireEvent.change(input, { target: { value: "Previous question" } });
+  });
+  input.setSelectionRange(input.value.length, input.value.length);
+  await act(async () => {
+    fireEvent.keyDown(input, { key: "ArrowDown" });
+  });
+  expect(screen.getByRole("textbox", { name: "Composer" })).toBe(input);
+  expect(input.value).toBe("Previous question");
+});

package/src/unstable/useComposerInputHistory.ts

@@ -71,7 +71,8 @@ export function unstable_useComposerInputHistory(): Unstable_ComposerInputHistor
   const browseRef = useRef<BrowseState | null>(null);
 
   useEffect(() => {
-    if (aui.composer.getState().type !== "thread") return undefined;
+    if (aui.composer.getState().type !== "thread" || !aui.optional.threads)
+      return undefined;
 
     return aui.on("threads.selectionChanged", () => {
       browseRef.current = null;
@@ -97,7 +98,7 @@ export function unstable_useComposerInputHistory(): Unstable_ComposerInputHistor
       const browse = browseRef.current;
 
       const commitText = (text: string): void => {
-        flushTapSync(() => aui.composer.setText(text));
+        flushTapSync(() => aui.composer.setText(text, { origin: "recall" }));
         // React's controlled-value commit restores the pre-recall caret;
         // reposition after the commit, before paint.
         requestAnimationFrame(() => {

package/src/unstable/useLiveCompletionAdapter.test.tsx

@@ -243,6 +243,50 @@ describe("unstable_useLiveCompletionAdapter", () => {
     expect(result.current.isLoading).toBe(false);
   });
 
+  it.each(["queued", "debounced"] as const)(
+    "cancels a %s search when disabled and allows searching after re-enabling",
+    async (phase) => {
+      const fetcher = vi.fn(async () => [item("alice")]);
+      const { result, rerender } = renderHook(
+        ({ enabled }) =>
+          unstable_useLiveCompletionAdapter({
+            fetcher,
+            enabled,
+            debounceMs: 50,
+          }),
+        { initialProps: { enabled: true } },
+      );
+
+      if (phase === "debounced") {
+        await act(async () => {
+          result.current.adapter.search!("alice");
+        });
+        rerender({ enabled: false });
+      } else {
+        act(() => {
+          result.current.adapter.search!("alice");
+          rerender({ enabled: false });
+        });
+      }
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(50);
+      });
+
+      expect(fetcher).not.toHaveBeenCalled();
+      expect(result.current.adapter.search!("alice")).toEqual([]);
+      expect(result.current.isLoading).toBe(false);
+
+      rerender({ enabled: true });
+      await act(async () => {
+        result.current.adapter.search!("alice");
+        await vi.advanceTimersByTimeAsync(50);
+      });
+      expect(fetcher).toHaveBeenCalledExactlyOnceWith("alice");
+      expect(result.current.adapter.search!("alice")).toEqual([item("alice")]);
+      expect(result.current.isLoading).toBe(false);
+    },
+  );
+
   it("drops a stale in-flight result when the query changes", async () => {
     const resolvers: Record<
       string,

package/src/unstable/useLiveCompletionAdapter.ts

@@ -192,10 +192,11 @@ export function unstable_useLiveCompletionAdapter(
       categories: () => [],
       categoryItems: () => [],
       search: (query: string) => {
+        if (!enabled) return [];
         // search() runs inside the popover's render; defer state updates with
         // queueMicrotask so they are not dispatched while another component renders.
         if (query !== state.query || retryableQueryRef.current === query) {
-          queueMicrotask(() => scheduleFetch(query));
+          queueMicrotask(() => scheduleFetchRef.current(query));
         } else {
           queueMicrotask(() => {
             if (
@@ -215,7 +216,7 @@ export function unstable_useLiveCompletionAdapter(
         return state.items;
       },
     }),
-    [state, scheduleFetch, invalidatePending],
+    [enabled, state, invalidatePending],
   );
 
   return { adapter, isLoading };

package/src/unstable/webmcp/convertTools.test.ts

@@ -466,15 +466,25 @@ describe("toWebMcpTool cancellation", () => {
     const caller = new AbortController();
     const callerRemove = vi.spyOn(caller.signal, "removeEventListener");
     const lifecycleRemove = vi.spyOn(lifecycle.signal, "removeEventListener");
+    const onAbort = vi.fn();
 
     const result = await descriptorFor(
-      { execute: async () => "ok" },
+      {
+        execute: async (_args, context) => {
+          context.abortSignal.addEventListener("abort", onAbort);
+          return "ok";
+        },
+      },
       lifecycle.signal,
     ).execute({}, { signal: caller.signal });
 
     expect(result).toEqual({ content: [text("ok")] });
     expect(callerRemove).toHaveBeenCalledTimes(1);
     expect(lifecycleRemove).toHaveBeenCalledTimes(1);
+
+    caller.abort();
+    lifecycle.abort();
+    expect(onAbort).not.toHaveBeenCalled();
   });
 
   it("merges a caller signal that is not a native AbortSignal", async () => {

package/src/utils/hooks/useMediaQuery.test.tsx

@@ -0,0 +1,35 @@
+// @vitest-environment jsdom
+
+import { act, cleanup, renderHook } from "@testing-library/react";
+import { afterEach, expect, it, vi } from "vitest";
+import { useMediaQuery } from "./useMediaQuery";
+
+afterEach(() => {
+  cleanup();
+  vi.unstubAllGlobals();
+});
+
+it("updates when a media query changes after mounting", () => {
+  const media = Object.assign(new EventTarget(), {
+    matches: false,
+    media: "(prefers-reduced-motion: reduce)",
+  });
+  vi.stubGlobal(
+    "matchMedia",
+    vi.fn(() => media),
+  );
+  const { result } = renderHook(() => useMediaQuery(media.media));
+  expect(result.current).toBe(false);
+
+  act(() => {
+    media.matches = true;
+    media.dispatchEvent(new Event("change"));
+  });
+  expect(result.current).toBe(true);
+
+  act(() => {
+    media.matches = false;
+    media.dispatchEvent(new Event("change"));
+  });
+  expect(result.current).toBe(false);
+});

package/src/utils/smooth/useSmooth.test.tsx

@@ -163,17 +163,44 @@ describe("useSmooth", () => {
     expect(result.current.status.type).toBe("running");
   });
 
-  it("falls back to defaults for non-positive or NaN options", () => {
-    const state = textState("hello");
-    const { result } = renderHook(() =>
-      useSmooth(state, {
-        drainMs: -1,
-        maxCharIntervalMs: NaN,
-        maxCharsPerFrame: 0,
-      }),
+  it.each([
+    { name: "negative drain time", options: { drainMs: -1 } },
+    { name: "NaN character interval", options: { maxCharIntervalMs: NaN } },
+    { name: "zero frame cap", options: { maxCharsPerFrame: 0 } },
+  ])("uses default animation timing for $name", ({ options }) => {
+    const frames = new Map<number, FrameRequestCallback>();
+    let nextFrame = 0;
+    vi.spyOn(globalThis, "requestAnimationFrame").mockImplementation(
+      (callback) => {
+        const id = ++nextFrame;
+        frames.set(id, callback);
+        return id;
+      },
     );
-    expect(result.current.text).toBe("hello");
-    expect(result.current.status).toBe(state.status);
+    vi.spyOn(globalThis, "cancelAnimationFrame").mockImplementation((id) => {
+      frames.delete(id);
+    });
+    let now = 0;
+    vi.spyOn(performance, "now").mockImplementation(() => now);
+    const frame = (time: number) => {
+      now = time;
+      const queued = [...frames.values()];
+      frames.clear();
+      act(() => queued.forEach((callback) => callback(now)));
+    };
+
+    const { result, unmount } = renderHook(() =>
+      useSmooth(runningState("hello"), options),
+    );
+    try {
+      expect(result.current.text).toBe("");
+      frame(16);
+      expect(result.current.text).toBe("hel");
+      frame(32);
+      expect(result.current.text).toBe("hello");
+    } finally {
+      unmount();
+    }
   });
 
   it("accepts a SmoothOptions object as the enabled form", () => {

package/dist/context/providers/ChainOfThoughtPartByIndexProvider.d.ts

@@ -1,2 +0,0 @@
-export { ChainOfThoughtPartByIndexProvider } from "@assistant-ui/core/react";
-//# sourceMappingURL=ChainOfThoughtPartByIndexProvider.d.ts.map

package/dist/context/providers/ChainOfThoughtPartByIndexProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ChainOfThoughtPartByIndexProvider.d.ts","sourceRoot":"","sources":["../../../src/context/providers/ChainOfThoughtPartByIndexProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,iCAAiC,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/context/providers/ChainOfThoughtPartByIndexProvider.js

@@ -1,3 +0,0 @@
-"use client";
-import { ChainOfThoughtPartByIndexProvider } from "@assistant-ui/core/react";
-export { ChainOfThoughtPartByIndexProvider };

package/dist/legacy-runtime/RuntimeAdapter.d.ts

@@ -1,2 +0,0 @@
-export { RuntimeAdapter } from "@assistant-ui/core/react";
-//# sourceMappingURL=RuntimeAdapter.d.ts.map

package/dist/legacy-runtime/RuntimeAdapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RuntimeAdapter.d.ts","sourceRoot":"","sources":["../../src/legacy-runtime/RuntimeAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC"}