@assistant-ui/react 0.15.19 → 0.15.21

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();
   });
 });