@assistant-ui/react 0.15.17 → 0.15.18

package/src/unstable/webmcp/webmcp-host.test.ts

@@ -0,0 +1,142 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  getDefaultWebMcpHost,
+  type WebMcpModelContext,
+  type WebMcpToolDescriptor,
+} from "./webmcp-host";
+
+type Host = { modelContext?: WebMcpModelContext };
+
+const descriptor: WebMcpToolDescriptor = {
+  name: "get_weather",
+  description: "",
+  inputSchema: {},
+  execute: async () => ({ content: [] }),
+};
+
+const install = (
+  context: Partial<WebMcpModelContext>,
+  on: "document" | "navigator" = "document",
+) => {
+  const host = (on === "document" ? document : navigator) as Host;
+  host.modelContext = context as WebMcpModelContext;
+  return context;
+};
+
+afterEach(() => {
+  delete (document as Host).modelContext;
+  delete (navigator as Host).modelContext;
+});
+
+describe("getDefaultWebMcpHost", () => {
+  it("reports unavailable when the page exposes no model context", () => {
+    const host = getDefaultWebMcpHost();
+    expect(host.available).toBe(false);
+    expect(() => host.registerTool(descriptor)()).not.toThrow();
+  });
+
+  it("reports unavailable and warns when the platform property has no registerTool", () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      install({} as Partial<WebMcpModelContext>);
+      const host = getDefaultWebMcpHost();
+      expect(host.available).toBe(false);
+      expect(() => host.registerTool(descriptor)()).not.toThrow();
+      expect(warn).toHaveBeenCalledWith(
+        expect.stringContaining("no callable registerTool"),
+      );
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  it("falls back to navigator.modelContext, preferring document when both exist", () => {
+    const fromNavigator = vi.fn();
+    install({ registerTool: fromNavigator }, "navigator");
+    expect(getDefaultWebMcpHost().available).toBe(true);
+    getDefaultWebMcpHost().registerTool(descriptor);
+    expect(fromNavigator).toHaveBeenCalledOnce();
+
+    const fromDocument = vi.fn();
+    install({ registerTool: fromDocument });
+    getDefaultWebMcpHost().registerTool(descriptor);
+    expect(fromDocument).toHaveBeenCalledOnce();
+    expect(fromNavigator).toHaveBeenCalledOnce();
+  });
+
+  it("registers with an abort signal and aborts it on dispose", () => {
+    const registerTool = vi.fn();
+    install({ registerTool });
+
+    const dispose = getDefaultWebMcpHost().registerTool(descriptor);
+    const options = registerTool.mock.calls[0]![1];
+    expect(registerTool).toHaveBeenCalledWith(descriptor, expect.anything());
+    expect(options.signal.aborted).toBe(false);
+
+    dispose();
+    expect(options.signal.aborted).toBe(true);
+    expect(() => dispose()).not.toThrow();
+  });
+
+  it("reports a rejected registration to the caller", async () => {
+    install({
+      registerTool: () => Promise.reject(new Error("already registered")),
+    });
+
+    const onError = vi.fn();
+    getDefaultWebMcpHost().registerTool(descriptor, onError);
+    await vi.waitFor(() => expect(onError).toHaveBeenCalledOnce());
+    expect(onError.mock.calls[0]![0]).toBeInstanceOf(Error);
+  });
+
+  it("aborts the signal even when the registration was rejected", async () => {
+    let options: { signal?: AbortSignal } | undefined;
+    install({
+      registerTool: (_def, registerOptions) => {
+        options = registerOptions;
+        return Promise.reject(new Error("already registered"));
+      },
+    });
+
+    const onError = vi.fn();
+    const dispose = getDefaultWebMcpHost().registerTool(descriptor, onError);
+    await vi.waitFor(() => expect(onError).toHaveBeenCalledOnce());
+
+    dispose();
+    expect(options?.signal?.aborted).toBe(true);
+  });
+
+  it("lets a synchronous registration failure propagate", () => {
+    install({
+      registerTool: () => {
+        throw new Error("already registered");
+      },
+    });
+
+    expect(() => getDefaultWebMcpHost().registerTool(descriptor)).toThrow(
+      "already registered",
+    );
+  });
+
+  it("survives a registration that returns a bare thenable", () => {
+    install({
+      registerTool: () =>
+        ({
+          then: (resolve: () => void) => resolve(),
+        }) as unknown as Promise<void>,
+    });
+
+    const dispose = getDefaultWebMcpHost().registerTool(descriptor);
+    expect(() => dispose()).not.toThrow();
+  });
+
+  it("survives a registration that returns nothing", () => {
+    const registerTool = vi.fn();
+    install({ registerTool });
+
+    const dispose = getDefaultWebMcpHost().registerTool(descriptor);
+    dispose();
+    expect(registerTool.mock.calls[0]![1].signal.aborted).toBe(true);
+  });
+});

package/src/unstable/webmcp/webmcp-host.ts

@@ -0,0 +1,83 @@
+export type WebMcpContent =
+  | { type: "text"; text: string }
+  | { type: "image"; data: string; mimeType: string };
+
+export type WebMcpCallToolResult = {
+  content: WebMcpContent[];
+  isError?: boolean;
+};
+
+export type WebMcpToolDescriptor = {
+  name: string;
+  description: string;
+  inputSchema: unknown;
+  execute: (
+    args: unknown,
+    context?: { signal?: AbortSignal },
+  ) => Promise<WebMcpCallToolResult>;
+};
+
+export type WebMcpModelContext = {
+  /**
+   * Aborting `options.signal` is what unregisters the tool. The explainer
+   * defines no other removal method, and a name-keyed one could not be used
+   * safely: a later registration may already hold the name.
+   */
+  registerTool(
+    tool: WebMcpToolDescriptor,
+    options?: { signal?: AbortSignal },
+  ): Promise<void> | void;
+};
+
+export type WebMcpHost = {
+  available: boolean;
+  registerTool(
+    def: WebMcpToolDescriptor,
+    onError?: (error: unknown) => void,
+  ): () => void;
+};
+
+type ModelContextHost = { modelContext?: WebMcpModelContext } | undefined;
+
+const isThenable = (value: unknown): value is Promise<unknown> =>
+  typeof (value as { then?: unknown } | null | undefined)?.then === "function";
+
+// The explainer puts modelContext on document; navigator is tolerated for
+// older drafts and extensions that still inject it there.
+const resolveModelContext = (): WebMcpModelContext | undefined => {
+  const context =
+    (globalThis.document as ModelContextHost)?.modelContext ??
+    (globalThis.navigator as ModelContextHost)?.modelContext;
+  if (!context) return undefined;
+  if (typeof context.registerTool === "function") return context;
+  console.warn(
+    "[assistant-ui] Ignoring a modelContext with no callable registerTool; WebMCP reports unsupported.",
+  );
+  return undefined;
+};
+
+const createHost = (context: WebMcpModelContext): WebMcpHost => ({
+  available: true,
+  registerTool: (def, onError) => {
+    const controller = new AbortController();
+    const handle = context.registerTool(def, { signal: controller.signal });
+    if (isThenable(handle)) {
+      handle.then(
+        () => {},
+        (error) => onError?.(error),
+      );
+    }
+    return () => controller.abort();
+  },
+});
+
+export const getDefaultWebMcpHost = (): WebMcpHost => {
+  const context = resolveModelContext();
+  if (!context) {
+    return {
+      available: false,
+      registerTool: () => () => {},
+    };
+  }
+  return createHost(context);
+};

package/dist/utils/invokeCallbackSafely.d.ts

@@ -1,5 +0,0 @@
-//#region src/utils/invokeCallbackSafely.d.ts
-declare const invokeCallbackSafely: (invoke: () => unknown, name: string) => void;
-//#endregion
-export { invokeCallbackSafely };
-//# sourceMappingURL=invokeCallbackSafely.d.ts.map

package/dist/utils/invokeCallbackSafely.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"invokeCallbackSafely.d.ts","names":[],"sources":["../../src/utils/invokeCallbackSafely.ts"],"mappings":";cAAa,uBAAwB,uBAAuB"}

package/dist/utils/invokeCallbackSafely.js

@@ -1,15 +0,0 @@
-//#region src/utils/invokeCallbackSafely.ts
-const invokeCallbackSafely = (invoke, name) => {
-	const reportFailure = (error) => {
-		console.error(`[assistant-ui] ${name} callback threw an error`, error);
-	};
-	try {
-		Promise.resolve(invoke()).catch(reportFailure);
-	} catch (error) {
-		reportFailure(error);
-	}
-};
-//#endregion
-export { invokeCallbackSafely };
-
-//# sourceMappingURL=invokeCallbackSafely.js.map

package/dist/utils/invokeCallbackSafely.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"invokeCallbackSafely.js","names":["invokeCallbackSafely","invoke","name","reportFailure","error","console","Promise","resolve","catch"],"sources":["../../src/utils/invokeCallbackSafely.ts"],"sourcesContent":["export const invokeCallbackSafely = (invoke: () => unknown, name: string) => {\n  const reportFailure = (error: unknown) => {\n    console.error(`[assistant-ui] ${name} callback threw an error`, error);\n  };\n\n  try {\n    void Promise.resolve(invoke()).catch(reportFailure);\n  } catch (error) {\n    reportFailure(error);\n  }\n};\n"],"mappings":";AAAA,MAAaA,wBAAwBC,QAAuBC,SAAiB;CAC3E,MAAMC,iBAAiBC,UAAmB;EACxCC,QAAQD,MAAM,kBAAkBF,KAAI,2BAA4BE,KAAK;CACvE;CAEA,IAAI;EACF,QAAaG,QAAQN,OAAO,CAAC,CAAC,CAACO,MAAML,aAAa;CACpD,SAASC,OAAO;EACdD,cAAcC,KAAK;CACrB;AACF"}

package/dist/utils/useToolArgsFieldStatus.d.ts

@@ -1,19 +0,0 @@
-//#region src/utils/useToolArgsFieldStatus.d.ts
-declare const useToolArgsFieldStatus: (fieldPath: (string | number)[]) => {
-  type: string;
-} | {
-  readonly type: "running";
-} | {
-  readonly type: "complete";
-} | {
-  readonly type: "incomplete";
-  readonly reason: "cancelled" | "length" | "content-filter" | "other" | "error";
-  readonly error?: unknown;
-} | {
-  readonly type: "incomplete";
-  readonly reason: "tool-calls";
-  readonly error?: import("assistant-stream/utils").ReadonlyJSONValue;
-};
-//#endregion
-export { useToolArgsFieldStatus };
-//# sourceMappingURL=useToolArgsFieldStatus.d.ts.map

package/dist/utils/useToolArgsFieldStatus.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useToolArgsFieldStatus.d.ts","names":[],"sources":["../../src/utils/useToolArgsFieldStatus.ts"],"mappings":";cAKa,yBAA0B"}

package/dist/utils/useToolArgsFieldStatus.js

@@ -1,23 +0,0 @@
-import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
-import { useAuiState } from "@assistant-ui/store";
-import { getPartialJsonObjectFieldState } from "assistant-stream/utils";
-//#region src/utils/useToolArgsFieldStatus.ts
-const COMPLETE_STATUS = { type: "complete" };
-const useToolArgsFieldStatus = (fieldPath) => {
-	const $ = c(2);
-	let t0;
-	if ($[0] !== fieldPath) {
-		t0 = (s) => {
-			if (s.part.type !== "tool-call") throw new Error("useToolArgsFieldStatus can only be used inside tool-call message parts");
-			if (getPartialJsonObjectFieldState(s.part.args, fieldPath) === "complete" || s.part.status?.type === "requires-action") return COMPLETE_STATUS;
-			return s.part.status;
-		};
-		$[0] = fieldPath;
-		$[1] = t0;
-	} else t0 = $[1];
-	return useAuiState(t0);
-};
-//#endregion
-export { useToolArgsFieldStatus };
-
-//# sourceMappingURL=useToolArgsFieldStatus.js.map

package/dist/utils/useToolArgsFieldStatus.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useToolArgsFieldStatus.js","names":["getPartialJsonObjectFieldState","useAuiState","COMPLETE_STATUS","type","useToolArgsFieldStatus","fieldPath","$","_c","t0","s","part","Error","state","args","status"],"sources":["../../src/utils/useToolArgsFieldStatus.ts"],"sourcesContent":["import { getPartialJsonObjectFieldState } from \"assistant-stream/utils\";\nimport { useAuiState } from \"@assistant-ui/store\";\n\nconst COMPLETE_STATUS = { type: \"complete\" };\n\nexport const useToolArgsFieldStatus = (fieldPath: (string | number)[]) => {\n  return useAuiState((s) => {\n    if (s.part.type !== \"tool-call\")\n      throw new Error(\n        \"useToolArgsFieldStatus can only be used inside tool-call message parts\",\n      );\n\n    const state = getPartialJsonObjectFieldState(s.part.args, fieldPath);\n    if (state === \"complete\" || s.part.status?.type === \"requires-action\")\n      return COMPLETE_STATUS;\n    return s.part.status;\n  });\n};\n"],"mappings":";;;;AAGA,MAAME,kBAAkB,EAAEC,MAAM,WAAW;AAE3C,MAAaC,0BAAyBC,cAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAAA,IAAAC;CAAA,IAAAF,EAAA,OAAAD,WAAA;EACjBG,MAAAC,MAAA;GACjB,IAAIA,EAACC,KAAKP,SAAU,aAClB,MAAM,IAAIQ,MACR,wEACF;GAGF,IADcX,+BAA+BS,EAACC,KAAKG,MAAOR,SACtDO,MAAU,cAAcH,EAACC,KAAKI,QAAaX,SAAK,mBAAiB,OAC5DD;GAAgB,OAClBO,EAACC,KAAKI;EAAO;EACrBR,EAAA,KAAAD;EAAAC,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CAAA,OAVML,YAAYO,EAUlB;AAAC"}

package/src/utils/invokeCallbackSafely.ts

@@ -1,11 +0,0 @@
-export const invokeCallbackSafely = (invoke: () => unknown, name: string) => {
-  const reportFailure = (error: unknown) => {
-    console.error(`[assistant-ui] ${name} callback threw an error`, error);
-  };
-
-  try {
-    void Promise.resolve(invoke()).catch(reportFailure);
-  } catch (error) {
-    reportFailure(error);
-  }
-};

package/src/utils/useToolArgsFieldStatus.ts

@@ -1,18 +0,0 @@
-import { getPartialJsonObjectFieldState } from "assistant-stream/utils";
-import { useAuiState } from "@assistant-ui/store";
-
-const COMPLETE_STATUS = { type: "complete" };
-
-export const useToolArgsFieldStatus = (fieldPath: (string | number)[]) => {
-  return useAuiState((s) => {
-    if (s.part.type !== "tool-call")
-      throw new Error(
-        "useToolArgsFieldStatus can only be used inside tool-call message parts",
-      );
-
-    const state = getPartialJsonObjectFieldState(s.part.args, fieldPath);
-    if (state === "complete" || s.part.status?.type === "requires-action")
-      return COMPLETE_STATUS;
-    return s.part.status;
-  });
-};