@assistant-ui/react 0.15.20 → 0.15.21

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

@@ -498,6 +498,101 @@ describe("useThreadViewportAutoScroll", () => {
     expect(screen.getByTestId("is-at-bottom").textContent).toBe("false");
   });
 
+  it("starts following when auto-scroll is enabled at the bottom", async () => {
+    const view = render(
+      <SyncRuntimeProvider>
+        <Thread autoScroll={false} scrollToBottomOnInitialize={false} />
+      </SyncRuntimeProvider>,
+    );
+
+    const viewport = getViewport();
+    await waitFor(() => {
+      expect(screen.getAllByTestId("thread-message")).toHaveLength(
+        messages.length,
+      );
+    });
+
+    act(() => {
+      viewport.scrollTop = getMaxScrollTop(viewport);
+      viewport.dispatchEvent(new Event("scroll"));
+    });
+
+    view.rerender(
+      <SyncRuntimeProvider>
+        <Thread autoScroll scrollToBottomOnInitialize={false} />
+      </SyncRuntimeProvider>,
+    );
+
+    viewportMeasurementOffset += 200;
+    act(notifyResizeObservers);
+
+    expect(viewport.scrollTop).toBe(getMaxScrollTop(viewport));
+  });
+
+  it("preserves bottom follow on initial mount when initialize scrolling is disabled", async () => {
+    render(
+      <SyncRuntimeProvider>
+        <ThreadPrimitiveRoot>
+          <ThreadPrimitiveViewport
+            autoScroll
+            data-testid="viewport"
+            scrollToBottomOnInitialize={false}
+            turnAnchor="top"
+          >
+            {messages.map((_, index) => (
+              <div key={index} data-testid="thread-message" />
+            ))}
+          </ThreadPrimitiveViewport>
+        </ThreadPrimitiveRoot>
+      </SyncRuntimeProvider>,
+    );
+
+    const viewport = getViewport();
+    await waitFor(() => {
+      expect(screen.getAllByTestId("thread-message")).toHaveLength(
+        messages.length,
+      );
+    });
+
+    viewportMeasurementOffset += 200;
+    act(notifyResizeObservers);
+
+    expect(viewport.scrollTop).toBe(getMaxScrollTop(viewport));
+  });
+
+  it("does not jump down when auto-scroll is enabled away from the bottom", async () => {
+    const view = render(
+      <SyncRuntimeProvider>
+        <Thread autoScroll={false} scrollToBottomOnInitialize={false} />
+      </SyncRuntimeProvider>,
+    );
+
+    const viewport = getViewport();
+    await waitFor(() => {
+      expect(screen.getAllByTestId("thread-message")).toHaveLength(
+        messages.length,
+      );
+    });
+
+    act(() => {
+      viewport.scrollTop = getMaxScrollTop(viewport) - 80;
+      viewport.dispatchEvent(new Event("scroll"));
+    });
+    const scrollTopBeforeEnable = viewport.scrollTop;
+
+    view.rerender(
+      <SyncRuntimeProvider>
+        <Thread autoScroll scrollToBottomOnInitialize={false} />
+      </SyncRuntimeProvider>,
+    );
+
+    viewportMeasurementOffset += 200;
+    act(notifyResizeObservers);
+
+    expect(viewport.scrollTop).toBe(scrollTopBeforeEnable);
+    expect(viewport.scrollTop).toBeLessThan(getMaxScrollTop(viewport));
+  });
+
   it("defers auto-scroll to an active top anchor only while the run is active", async () => {
     let releaseRun!: () => void;
     const runGate = new Promise<void>((resolve) => {

package/src/primitives/thread/useThreadViewportAutoScroll.ts

@@ -74,6 +74,16 @@ export const useThreadViewportAutoScroll = <TElement extends HTMLElement>({
   // user actively scrolls up while content size is stable.
   const scrollingToBottomBehaviorRef = useRef<ScrollBehavior | null>(null);
   const followBottomRef = useRef(autoScroll);
+  const previousAutoScrollRef = useRef(autoScroll);
+
+  useLayoutEffect(() => {
+    const previousAutoScroll = previousAutoScrollRef.current;
+    previousAutoScrollRef.current = autoScroll;
+    if (previousAutoScroll || !autoScroll) return;
+
+    const div = divRef.current;
+    followBottomRef.current = div !== null && isViewportAtBottom(div);
+  }, [autoScroll]);
 
   const scrollToBottom = useCallback((behavior: ScrollBehavior) => {
     const div = divRef.current;

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

@@ -3,10 +3,8 @@
 import { act, render, waitFor } from "@testing-library/react";
 import { type FC, useEffect } from "react";
 import { describe, expect, it } from "vitest";
-import {
-  useRemoteThreadListRuntime,
-  type AssistantRuntime,
-} from "@assistant-ui/core/react";
+import type { AssistantRuntime } from "@assistant-ui/core";
+import { useRemoteThreadListRuntime } 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";

package/src/tests/threadListItemIsRunning.test.tsx

@@ -3,6 +3,7 @@
 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 { makeAdapter } from "./remote-thread-list-test-helpers";
 import { AssistantRuntimeProvider } from "../context";
@@ -79,7 +80,7 @@ describe("threadListItem.isRunning", () => {
 
   it("reports the run of a single-thread runtime that cannot observe background threads", async () => {
     const Inner: FC<{ isRunning: boolean }> = ({ isRunning }) => {
-      const runtime = useExternalStoreRuntime({
+      const runtime = useExternalStoreRuntime<ThreadMessage>({
         messages: [],
         isRunning,
         onNew: async () => {},
@@ -126,7 +127,7 @@ describe("threadListItem.isRunning", () => {
         };
       }, []);
 
-      return useExternalStoreRuntime({
+      return useExternalStoreRuntime<ThreadMessage>({
         messages: [],
         isRunning: running.get(threadId) ?? false,
         onNew: async () => {},

package/src/unstable/useMentionAdapter.test.tsx

@@ -82,20 +82,21 @@ describe("unstable_useMentionAdapter", () => {
 
   it("does not expose flat items when the last category is removed", () => {
     const items = [{ id: "alice", type: "person", label: "Alice" }];
+    const initialOptions: Unstable_UseMentionAdapterOptions = {
+      items,
+      categories: [
+        {
+          id: "people",
+          label: "People",
+          items: [{ id: "bob", type: "person", label: "Bob" }],
+        },
+      ],
+    };
     const { result, rerender } = renderHook(
       (options: Unstable_UseMentionAdapterOptions) =>
         unstable_useMentionAdapter(options),
       {
-        initialProps: {
-          items,
-          categories: [
-            {
-              id: "people",
-              label: "People",
-              items: [{ id: "bob", type: "person", label: "Bob" }],
-            },
-          ],
-        },
+        initialProps: initialOptions,
       },
     );
 
@@ -334,23 +335,16 @@ describe("unstable_useMentionAdapter", () => {
       createIssue: { description: "Create an issue" },
     };
 
+    const initialOptions: Unstable_UseMentionAdapterOptions = { items: [] };
     const { result, rerender } = renderHook(
-      ({
-        items,
-      }: {
-        items: readonly {
-          id: string;
-          type: string;
-          label: string;
-        }[];
-      }) =>
+      ({ items }: Unstable_UseMentionAdapterOptions) =>
         unstable_useMentionAdapter({
-          items,
+          ...(items === undefined ? {} : { items }),
           includeModelContextTools: {
             category: { id: "actions", label: "Actions" },
           },
         }),
-      { initialProps: { items: [] } },
+      { initialProps: initialOptions },
     );
 
     expect(result.current.adapter.categories()).toEqual([]);

package/src/unstable/useModelContextSnapshot.test.tsx

@@ -15,6 +15,7 @@ const createSource = (
   overrides: Partial<
     ModelContextSnapshotSource<Readonly<Record<string, string>>>
   > = {},
+  includeIsEqual = true,
 ) => {
   const listeners = new Set<() => void>();
   const state = { tools: EMPTY as Record<string, string> };
@@ -29,7 +30,7 @@ const createSource = (
         unsubscribe();
       };
     }),
-    isEqual: shallowEqualRecords,
+    ...(includeIsEqual ? { isEqual: shallowEqualRecords } : {}),
     ...overrides,
   };
   return {
@@ -90,7 +91,7 @@ describe("useModelContextSnapshot", () => {
   });
 
   it("takes every notification when the source omits isEqual", () => {
-    const { source, state, notify } = createSource({ isEqual: undefined });
+    const { source, state, notify } = createSource({}, false);
     state.tools = { a: "1" };
 
     const { result } = renderHook(() =>

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

@@ -7,25 +7,41 @@ import {
   toWebMcpTool,
 } from "./convertTools";
 
-const jsonSchema = {
+type WeatherArgs = { city: string };
+type FrontendTool = Extract<Tool<WeatherArgs, unknown>, { type: "frontend" }>;
+
+const jsonSchema: FrontendTool["parameters"] = {
   type: "object",
   properties: { city: { type: "string" } },
   required: ["city"],
-} as const;
-
-const frontendTool = (
-  overrides: Partial<Tool<any, any>> = {},
-): Tool<any, any> =>
-  ({
-    type: "frontend",
-    description: "Get the weather for a city.",
-    parameters: jsonSchema,
-    execute: async ({ city }: { city: string }) => `Sunny in ${city}`,
-    ...overrides,
-  }) as Tool<any, any>;
+};
+
+const frontendTool = (overrides: Partial<FrontendTool> = {}): FrontendTool => ({
+  type: "frontend",
+  description: "Get the weather for a city.",
+  parameters: jsonSchema,
+  execute: async ({ city }) => `Sunny in ${city}`,
+  ...overrides,
+});
+
+const frontendToolWithoutExecute = (): FrontendTool => ({
+  type: "frontend",
+  description: "Get the weather for a city.",
+  parameters: jsonSchema,
+});
+
+const typeLessTool = (): Tool<WeatherArgs, unknown> => ({
+  description: "Get the weather for a city.",
+  parameters: jsonSchema,
+  execute: async ({ city }) => `Sunny in ${city}`,
+});
+
+const typeLessToolWithoutExecute = (): Tool<WeatherArgs, unknown> => ({
+  type: undefined,
+});
 
 const descriptorFor = (
-  overrides: Partial<Tool<any, any>> = {},
+  overrides: Partial<FrontendTool> = {},
   lifecycleSignal?: AbortSignal,
 ) => toWebMcpTool("t", () => frontendTool(overrides), lifecycleSignal);
 
@@ -33,20 +49,29 @@ const text = (value: string) => ({ type: "text", text: value });
 
 describe("defaultWebMcpFilter", () => {
   it.for([
-    ["exposes an enabled frontend tool", {}, true],
-    ["hides a backend tool", { type: "backend" }, false],
-    ["hides a frontend tool with no execute", { execute: undefined }, false],
-    ["hides a disabled frontend tool", { disabled: true }, false],
-    ["exposes a tool authored without a type", { type: undefined }, true],
+    ["exposes an enabled frontend tool", frontendTool(), true],
+    [
+      "hides a backend tool",
+      { ...frontendTool(), type: "backend" } as unknown as Tool<
+        WeatherArgs,
+        unknown
+      >,
+      false,
+    ],
+    [
+      "hides a frontend tool with no execute",
+      frontendToolWithoutExecute(),
+      false,
+    ],
+    ["hides a disabled frontend tool", frontendTool({ disabled: true }), false],
+    ["exposes a tool authored without a type", typeLessTool(), true],
     [
       "hides a type-less tool with no execute",
-      { type: undefined, execute: undefined },
+      typeLessToolWithoutExecute(),
       false,
     ],
-  ] as const)("%s", ([, overrides, expected]) => {
-    expect(defaultWebMcpFilter("t", frontendTool(overrides as any))).toBe(
-      expected,
-    );
+  ] as const)("%s", ([, tool, expected]) => {
+    expect(defaultWebMcpFilter("t", tool)).toBe(expected);
   });
 });
 
@@ -61,10 +86,7 @@ describe("toWebMcpTool descriptor", () => {
       descriptorFor({ parameters: z.object({ city: z.string() }) }).inputSchema,
     ).toMatchObject(jsonSchema);
 
-    const bare = descriptorFor({
-      description: undefined,
-      parameters: undefined,
-    });
+    const bare = toWebMcpTool("bare", () => ({ type: "backend" }));
     expect(bare.description).toBe("");
     expect(bare.inputSchema).toEqual({ type: "object", properties: {} });
   });
@@ -80,7 +102,7 @@ describe("toWebMcpTool descriptor", () => {
 describe("toWebMcpTool execute", () => {
   it("passes the arguments through, defaulting missing arguments to {}", async () => {
     const execute = vi.fn(async () => "Sunny in Paris");
-    const descriptor = descriptorFor({ execute, parameters: undefined });
+    const descriptor = descriptorFor({ execute });
 
     const result = await descriptor.execute({ city: "Paris" });
     expect(execute).toHaveBeenCalledWith(
@@ -137,7 +159,7 @@ describe("toWebMcpTool execute", () => {
 
   it("reports an error when a published tool has no client-side execute", async () => {
     await expect(
-      descriptorFor({ execute: undefined }).execute({}),
+      toWebMcpTool("t", frontendToolWithoutExecute).execute({}),
     ).resolves.toEqual({
       isError: true,
       content: [text('Tool "t" has no client-side implementation.')],
@@ -155,7 +177,7 @@ describe("toWebMcpTool execute", () => {
 
   it("rejects human input requests", async () => {
     const result = await descriptorFor({
-      execute: async (_args: unknown, context: any) => await context.human(),
+      execute: async (_args, context) => await context.human(undefined),
     }).execute({});
     expect(result).toEqual({
       isError: true,
@@ -165,7 +187,7 @@ describe("toWebMcpTool execute", () => {
 });
 
 describe("toWebMcpTool schema validation", () => {
-  const zodTool = (overrides: Partial<Tool<any, any>> = {}) =>
+  const zodTool = (overrides: Omit<Partial<FrontendTool>, "parameters"> = {}) =>
     descriptorFor({
       parameters: z.object({ city: z.string() }),
       ...overrides,
@@ -521,12 +543,12 @@ describe("toMcpContent", () => {
   });
 
   it("projects a successful result through toModelOutput", async () => {
-    const toModelOutput = vi.fn(async () => [
-      { type: "text", text: "projected" },
-    ]);
+    const toModelOutput = vi.fn<NonNullable<FrontendTool["toModelOutput"]>>(
+      async () => [{ type: "text", text: "projected" }],
+    );
     const response = await toMcpContent("raw", {
       ...options,
-      tool: frontendTool({ toModelOutput } as any),
+      tool: frontendTool({ toModelOutput }),
     });
     expect(toModelOutput).toHaveBeenCalledWith({
       toolCallId: "1",
@@ -544,7 +566,7 @@ describe("toMcpContent", () => {
         toModelOutput: () => {
           throw new Error("bad projection");
         },
-      } as any),
+      }),
     });
     expect(response).toEqual({ content: [text("raw")] });
     expect(warn).toHaveBeenCalled();

package/src/unstable/webmcp/useWebMcpProvider.test.tsx

@@ -445,7 +445,11 @@ describe("unstable_useWebMcpProvider", () => {
       available: true,
       registerTool: (def, onError) => {
         const dispose = vi.fn();
-        calls.push({ def, onError, dispose });
+        calls.push({
+          def,
+          ...(onError === undefined ? {} : { onError }),
+          dispose,
+        });
         return dispose;
       },
     });
@@ -457,10 +461,15 @@ describe("unstable_useWebMcpProvider", () => {
     provider.setTools({ search: frontendTool({ description: "renamed" }) });
     await vi.waitFor(() => expect(calls).toHaveLength(2));
 
-    calls[0]!.onError?.(new Error("late failure"));
+    const initialCall = calls.at(0);
+    const replacementCall = calls.at(1);
+    if (!initialCall?.onError || !replacementCall) {
+      throw new Error("Expected both tool registrations");
+    }
+    initialCall.onError(new Error("late failure"));
 
     expect(providerResult().registeredToolNames).toEqual(["search"]);
-    expect(calls[1]!.dispose).not.toHaveBeenCalled();
+    expect(replacementCall.dispose).not.toHaveBeenCalled();
     expect(warn).not.toHaveBeenCalled();
   });
 });