@assistant-ui/react 0.15.20 → 0.15.22

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

@@ -7,25 +7,41 @@ import {
   toWebMcpTool,
 } from "./convertTools";
 
-const jsonSchema = {
+type WeatherArgs = { city: string; unit?: "c" | "f" | undefined };
+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,
@@ -178,6 +200,25 @@ describe("toWebMcpTool schema validation", () => {
     expect(result).toEqual({ content: [text("ok")] });
   });
 
+  it("uses schema output for execution and model content", async () => {
+    const args = { city: " Paris ", extra: true };
+    const result = await descriptorFor({
+      parameters: z.object({
+        city: z.string().trim(),
+        unit: z.enum(["c", "f"]).default("c"),
+      }),
+      execute: ({ city, unit }) => `Weather in ${city} (${unit})`,
+      toModelOutput: ({ input, output }) => [
+        { type: "text", text: `${JSON.stringify(input)}: ${output}` },
+      ],
+    }).execute(args);
+
+    expect(result).toEqual({
+      content: [text('{"city":"Paris","unit":"c"}: Weather in Paris (c)')],
+    });
+    expect(args).toEqual({ city: " Paris ", extra: true });
+  });
+
   it("returns a validation error when the arguments do not validate", async () => {
     const execute = vi.fn(async () => "ok");
     const result = await zodTool({ execute }).execute({ city: 42 });
@@ -192,10 +233,11 @@ describe("toWebMcpTool schema validation", () => {
     const execute = vi.fn(async () => "ok");
     const result = await zodTool({
       execute,
-      experimental_onSchemaValidationError: async () => "recovered",
+      experimental_onSchemaValidationError: async (args) =>
+        `Invalid: ${JSON.stringify(args)}`,
     }).execute({ city: 42 });
     expect(execute).not.toHaveBeenCalled();
-    expect(result).toEqual({ content: [text("recovered")] });
+    expect(result).toEqual({ content: [text('Invalid: {"city":42}')] });
   });
 
   it("awaits a validator that returns a non-Promise thenable", async () => {
@@ -521,12 +563,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 +586,7 @@ describe("toMcpContent", () => {
         toModelOutput: () => {
           throw new Error("bad projection");
         },
-      } as any),
+      }),
     });
     expect(response).toEqual({ content: [text("raw")] });
     expect(warn).toHaveBeenCalled();

package/src/unstable/webmcp/convertTools.ts

@@ -101,16 +101,10 @@ export const toMcpContent = async (
   return response.isError ? { isError: true, content } : { content };
 };
 
-type StandardSchemaLike = {
-  "~standard": {
-    version: number;
-    validate: (
-      value: unknown,
-    ) =>
-      | { issues?: readonly unknown[] | undefined }
-      | Promise<{ issues?: readonly unknown[] | undefined }>;
-  };
-};
+type StandardSchemaLike = Extract<
+  NonNullable<Tool["parameters"]>,
+  { readonly "~standard": unknown }
+>;
 
 const isStandardSchema = (schema: unknown): schema is StandardSchemaLike =>
   typeof schema === "object" &&
@@ -193,7 +187,7 @@ export const toWebMcpTool = (
       return errorResult(`Tool "${name}" is no longer registered`);
     }
     const tool = getTool();
-    const args = (rawArgs ?? {}) as Record<string, unknown>;
+    let args = (rawArgs ?? {}) as Record<string, unknown>;
     const toolCallId = generateId();
     let cleanup: (() => void) | undefined;
     try {
@@ -231,6 +225,8 @@ export const toWebMcpTool = (
                 `Function parameter validation failed. ${JSON.stringify(issues)}`,
               );
             });
+        } else {
+          args = validation.value;
         }
       }
 

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

package/src/utils/getSelectionMessageId.test.ts

@@ -30,6 +30,34 @@ afterEach(() => {
 });
 
 describe("getSelectionMessageId", () => {
+  it("rejects a message outside the supplied thread root", () => {
+    document.body.innerHTML = `
+      <div id="first-thread">
+        <div data-message-id="message-1"><p id="first">first</p></div>
+      </div>
+      <div id="second-thread">
+        <div data-message-id="message-1"><p>second</p></div>
+      </div>
+    `;
+    const firstThread = document.querySelector("#first-thread");
+    const secondThread = document.querySelector("#second-thread");
+    assert(firstThread);
+    assert(secondThread);
+    const selection = selectText(textNode("#first"));
+
+    expect(getSelectionMessageId(selection, firstThread)).toBe("message-1");
+    expect(getSelectionMessageId(selection, secondThread)).toBeNull();
+  });
+
+  it("falls back to an unscoped selection when a declared root has no element", () => {
+    document.body.innerHTML = `
+      <div data-message-id="message-1"><p id="text">text</p></div>
+    `;
+    const selection = selectText(textNode("#text"));
+
+    expect(getSelectionMessageId(selection, null)).toBe("message-1");
+  });
+
   it("accepts selections anywhere in a message without quote regions", () => {
     document.body.innerHTML = `
       <div data-message-id="message-1">

package/src/utils/getSelectionMessageId.ts

@@ -54,7 +54,10 @@ const intersectsExcluded = (scope: Element, selection: Selection): boolean => {
   return false;
 };
 
-export const getSelectionMessageId = (selection: Selection): string | null => {
+export const getSelectionMessageId = (
+  selection: Selection,
+  root?: Element | null,
+): string | null => {
   const { anchorNode, focusNode } = selection;
   if (!anchorNode || !focusNode) return null;
 
@@ -64,6 +67,9 @@ export const getSelectionMessageId = (selection: Selection): string | null => {
   if (!anchorMessageElement || anchorMessageElement !== focusMessageElement) {
     return null;
   }
+  if (root && !root.contains(anchorMessageElement)) {
+    return null;
+  }
 
   const messageId = anchorMessageElement.getAttribute("data-message-id");
   if (!messageId) return null;

package/dist/tests/remote-thread-list-test-helpers.d.ts

@@ -1,6 +0,0 @@
-import { RemoteThreadListAdapter } from "../index.js";
-//#region src/tests/remote-thread-list-test-helpers.d.ts
-declare function makeAdapter(overrides?: Partial<RemoteThreadListAdapter>): RemoteThreadListAdapter;
-//#endregion
-export { makeAdapter };
-//# sourceMappingURL=remote-thread-list-test-helpers.d.ts.map

package/dist/tests/remote-thread-list-test-helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"remote-thread-list-test-helpers.d.ts","names":[],"sources":["../../src/tests/remote-thread-list-test-helpers.ts"],"mappings":";;iBAGgB,YACd,YAAW,QAAQ,2BAClB"}

package/dist/tests/remote-thread-list-test-helpers.js

@@ -1,29 +0,0 @@
-import { vi } from "vitest";
-//#region src/tests/remote-thread-list-test-helpers.ts
-function makeAdapter(overrides = {}) {
-	return {
-		list: vi.fn(async () => ({ threads: [] })),
-		initialize: vi.fn(async (threadId) => ({
-			remoteId: threadId,
-			externalId: threadId
-		})),
-		rename: vi.fn(async () => {}),
-		archive: vi.fn(async () => {}),
-		unarchive: vi.fn(async () => {}),
-		delete: vi.fn(async () => {}),
-		generateTitle: vi.fn(async () => new ReadableStream({ start(c) {
-			c.close();
-		} })),
-		fetch: vi.fn(async (id) => ({
-			status: "regular",
-			remoteId: id,
-			externalId: id,
-			title: "Test"
-		})),
-		...overrides
-	};
-}
-//#endregion
-export { makeAdapter };
-
-//# sourceMappingURL=remote-thread-list-test-helpers.js.map

package/dist/tests/remote-thread-list-test-helpers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"remote-thread-list-test-helpers.js","names":["vi","RemoteThreadListAdapter","makeAdapter","overrides","Partial","list","fn","threads","initialize","threadId","remoteId","externalId","rename","archive","unarchive","delete","generateTitle","ReadableStream","start","c","close","fetch","id","status","const","title"],"sources":["../../src/tests/remote-thread-list-test-helpers.ts"],"sourcesContent":["import { vi } from \"vitest\";\nimport type { RemoteThreadListAdapter } from \"../index\";\n\nexport function makeAdapter(\n  overrides: Partial<RemoteThreadListAdapter> = {},\n): RemoteThreadListAdapter {\n  return {\n    list: vi.fn(async () => ({ threads: [] })),\n    initialize: vi.fn(async (threadId: string) => ({\n      remoteId: threadId,\n      externalId: threadId,\n    })),\n    rename: vi.fn(async () => {}),\n    archive: vi.fn(async () => {}),\n    unarchive: vi.fn(async () => {}),\n    delete: vi.fn(async () => {}),\n    generateTitle: vi.fn(\n      async () =>\n        new ReadableStream({\n          start(c) {\n            c.close();\n          },\n        }) as never,\n    ),\n    fetch: vi.fn(async (id: string) => ({\n      status: \"regular\" as const,\n      remoteId: id,\n      externalId: id,\n      title: \"Test\",\n    })),\n    ...overrides,\n  };\n}\n"],"mappings":";;AAGA,SAAgBE,YACdC,YAA8C,CAAC,GACtB;CACzB,OAAO;EACLE,MAAML,GAAGM,GAAG,aAAa,EAAEC,SAAS,CAAA,EAAG,EAAE;EACzCC,YAAYR,GAAGM,GAAG,OAAOG,cAAsB;GAC7CC,UAAUD;GACVE,YAAYF;EACd,EAAE;EACFG,QAAQZ,GAAGM,GAAG,YAAY,CAAC,CAAC;EAC5BO,SAASb,GAAGM,GAAG,YAAY,CAAC,CAAC;EAC7BQ,WAAWd,GAAGM,GAAG,YAAY,CAAC,CAAC;EAC/BS,QAAQf,GAAGM,GAAG,YAAY,CAAC,CAAC;EAC5BU,eAAehB,GAAGM,GAChB,YACE,IAAIW,eAAe,EACjBC,MAAMC,GAAG;GACPA,EAAEC,MAAM;EACV,EACF,CAAC,CACL;EACAC,OAAOrB,GAAGM,GAAG,OAAOgB,QAAgB;GAClCC,QAAQ;GACRb,UAAUY;GACVX,YAAYW;GACZG,OAAO;EACT,EAAE;EACF,GAAGtB;CACL;AACF"}

package/dist/tests/setup.d.ts

@@ -1 +0,0 @@
-export {}

package/dist/tests/setup.js

@@ -1,6 +0,0 @@
-import { vi } from "vitest";
-//#region src/tests/setup.ts
-vi.setSystemTime(/* @__PURE__ */ new Date("2023-01-01"));
-//#endregion
-
-//# sourceMappingURL=setup.js.map

package/dist/tests/setup.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"setup.js","names":["vi","setSystemTime","Date"],"sources":["../../src/tests/setup.ts"],"sourcesContent":["// This file contains setup code for tests\nimport { vi } from \"vitest\";\n\n// Use Vitest's built-in to mock Date\nvi.setSystemTime(new Date(\"2023-01-01\"));\n"],"mappings":";;AAIAA,GAAGC,8BAAc,IAAIC,KAAK,YAAY,CAAC"}