@assistant-ui/react 0.15.16 → 0.15.18

package/src/unstable/webmcp/useWebMcpProvider.ts

@@ -0,0 +1,150 @@
+"use client";
+
+import { useEffect, useState, useSyncExternalStore } from "react";
+import { useResources, useTapRoot, withKey } from "@assistant-ui/tap";
+import { useAui, type AssistantClient } from "@assistant-ui/store";
+import type { Tool } from "assistant-stream";
+import { getDefaultWebMcpHost, type WebMcpHost } from "./webmcp-host";
+import { defaultWebMcpFilter, toWebMcpInputSchema } from "./convertTools";
+import { WebMcpRegistrationResource } from "./WebMcpRegistrationResource";
+import {
+  useModelContextSnapshot,
+  type ModelContextSnapshotSource,
+} from "../useModelContextSnapshot";
+
+export type Unstable_WebMcpProviderOptions = {
+  filter?: (name: string, tool: Tool<any, any>) => boolean;
+};
+
+export type Unstable_WebMcpProviderResult = {
+  status: "unsupported" | "active";
+  registeredToolNames: readonly string[];
+};
+
+const EMPTY_NAMES: readonly string[] = Object.freeze([]);
+const EMPTY_TOOLS: Record<string, Tool<any, any>> = Object.freeze({});
+
+// The description is re-read on every sync so mutating it in place is
+// observed; the schema is converted only when the tool object itself changes.
+// Keyed on the tool so a schema or filter that throws warns once instead of
+// on every model-context notify.
+const warned = new WeakSet<Tool<any, any>>();
+
+const signatures = new WeakMap<
+  Tool<any, any>,
+  { description: string | undefined; signature: string }
+>();
+
+const signatureOf = (tool: Tool<any, any>) => {
+  const cached = signatures.get(tool);
+  if (cached && cached.description === tool.description)
+    return cached.signature;
+  const signature = `${tool.description ?? ""}\u0000${JSON.stringify(
+    toWebMcpInputSchema(tool),
+  )}`;
+  signatures.set(tool, { description: tool.description, signature });
+  return signature;
+};
+
+const NO_SUBSCRIPTION = () => {};
+
+// No `isEqual`: a caller republishing an unchanged tool set is how it asks for
+// a re-sync, which is what re-attempts a tool whose filter has stopped throwing
+// and what picks up a description edited in place on a stable tool object.
+const modelContextToolSource: ModelContextSnapshotSource<
+  Record<string, Tool<any, any>>
+> = {
+  empty: EMPTY_TOOLS,
+  read: (aui) => aui.modelContext.getModelContext().tools ?? EMPTY_TOOLS,
+  subscribe: (aui, onChange) =>
+    aui.modelContext.subscribe?.(onChange) ?? NO_SUBSCRIPTION,
+};
+
+const useStableNames = (names: readonly (string | null)[]) => {
+  const [cell] = useState(() => ({ names: EMPTY_NAMES }));
+  const next = names.filter((name): name is string => name !== null).sort();
+  const previous = cell.names;
+  if (
+    previous.length === next.length &&
+    previous.every((name, index) => name === next[index])
+  ) {
+    return previous;
+  }
+  cell.names = next;
+  return next;
+};
+
+const useWebMcpRegistry = ({
+  aui,
+  host,
+  filter,
+}: {
+  aui: AssistantClient;
+  host: WebMcpHost;
+  filter: (name: string, tool: Tool<any, any>) => boolean;
+}) => {
+  const tools = useModelContextSnapshot(
+    aui,
+    host.available,
+    modelContextToolSource,
+  );
+
+  const elements = [];
+  for (const [name, tool] of Object.entries(tools)) {
+    try {
+      if (!filter(name, tool)) continue;
+      const signature = signatureOf(tool);
+      elements.push(
+        withKey(
+          name,
+          WebMcpRegistrationResource({ host, name, signature, tool }),
+          [host, name, signature, tool],
+        ),
+      );
+    } catch (error) {
+      if (warned.has(tool)) continue;
+      warned.add(tool);
+      console.warn(
+        `[assistant-ui] Skipping WebMCP registration for tool "${name}": filter or schema conversion failed.`,
+        error,
+      );
+    }
+  }
+
+  return useStableNames(useResources(elements));
+};
+
+/**
+ * Publishes the frontend tools in the model context to a WebMCP-capable
+ * browser, so the user's own browser agent can call them.
+ *
+ * Returns `status: "unsupported"` when the page exposes no
+ * `document.modelContext` (or `navigator.modelContext`), and the sorted names
+ * of the tools currently registered with the host.
+ */
+export const unstable_useWebMcpProvider = (
+  options: Unstable_WebMcpProviderOptions = {},
+): Unstable_WebMcpProviderResult => {
+  const aui = useAui();
+  const [host] = useState(getDefaultWebMcpHost);
+  const filter = options.filter ?? defaultWebMcpFilter;
+
+  const root = useTapRoot(function WebMcpProviderRoot() {
+    return useWebMcpRegistry({ aui, host, filter });
+  });
+  const registeredToolNames = useSyncExternalStore(
+    root.subscribe,
+    root.getValue,
+    () => EMPTY_NAMES,
+  );
+
+  const [published, setPublished] = useState(false);
+  useEffect(() => {
+    if (host.available) setPublished(true);
+  }, [host]);
+
+  return {
+    status: published ? "active" : "unsupported",
+    registeredToolNames,
+  };
+};

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/src/utils/Primitive.tsx

@@ -11,10 +11,10 @@ import {
   forwardRef,
   isValidElement,
 } from "react";
-import { Primitive as RadixPrimitive } from "@radix-ui/react-primitive";
+import { Primitive as RadixPrimitive } from "radix-ui/internal";
 
 /**
- * Thin wrapper around `@radix-ui/react-primitive` that adds `render` prop support.
+ * Thin wrapper around Radix `Primitive` that adds `render` prop support.
  *
  * When `render` is provided, it is converted to the equivalent `asChild` pattern:
  *   render={<Comp props />} + children  →  asChild + <Comp props>{children}</Comp>

package/src/utils/createActionButton.tsx

@@ -5,7 +5,7 @@ import {
   type MouseEventHandler,
 } from "react";
 import { Primitive } from "./Primitive";
-import { composeEventHandlers } from "@radix-ui/primitive";
+import { composeEventHandlers } from "radix-ui/internal";
 
 type ActionButtonCallback<TProps> = (
   props: TProps,

package/src/utils/hooks/useOnResizeContent.ts

@@ -1,4 +1,4 @@
-import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
+import { useCallbackRef } from "radix-ui/internal";
 import { useCallback } from "react";
 import { useManagedRef } from "./useManagedRef";
 

package/src/utils/hooks/useOnScrollToBottom.ts

@@ -1,6 +1,6 @@
 "use client";
 
-import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
+import { useCallbackRef } from "radix-ui/internal";
 import { useEffect } from "react";
 import { useThreadViewport } from "../../context/react/ThreadViewportContext";
 

package/src/utils/smooth/useSmooth.ts

@@ -8,7 +8,7 @@ import type {
   TextMessagePart,
   MessagePartState,
 } from "@assistant-ui/core";
-import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
+import { useCallbackRef } from "radix-ui/internal";
 import { useMediaQuery } from "../hooks/useMediaQuery";
 import { useSmoothStatusStore } from "./SmoothContext";
 import { writableStore } from "../../context/ReadonlyStore";

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

@@ -1,3 +0,0 @@
-import { MessagePartRuntime, MessagePartState } from "@assistant-ui/core";
-import { MessagePartRuntimeImpl } from "@assistant-ui/core/internal";
-export { type MessagePartRuntime, MessagePartRuntimeImpl, type MessagePartState };

package/dist/legacy-runtime/runtime/MessagePartRuntime.js

@@ -1,2 +0,0 @@
-import { MessagePartRuntimeImpl } from "@assistant-ui/core/internal";
-export { MessagePartRuntimeImpl };

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

@@ -1,3 +0,0 @@
-import { MessageRuntime, MessageState } from "@assistant-ui/core";
-import { MessageRuntimeImpl, MessageStateBinding } from "@assistant-ui/core/internal";
-export { type MessageRuntime, MessageRuntimeImpl, type MessageState, type MessageStateBinding };

package/dist/legacy-runtime/runtime/MessageRuntime.js

@@ -1,2 +0,0 @@
-import { MessageRuntimeImpl } from "@assistant-ui/core/internal";
-export { MessageRuntimeImpl };

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

@@ -1,3 +0,0 @@
-import { ThreadListRuntime, ThreadListState } from "@assistant-ui/core";
-import { ThreadListRuntimeCoreBinding, ThreadListRuntimeImpl } from "@assistant-ui/core/internal";
-export { type ThreadListRuntime, type ThreadListRuntimeCoreBinding, ThreadListRuntimeImpl, type ThreadListState };

package/dist/legacy-runtime/runtime/ThreadListRuntime.js

@@ -1,2 +0,0 @@
-import { ThreadListRuntimeImpl } from "@assistant-ui/core/internal";
-export { ThreadListRuntimeImpl };

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,15 +0,0 @@
-//#region src/utils/useToolArgsFieldStatus.d.ts
-declare const useToolArgsFieldStatus: (fieldPath: (string | number)[]) => {
-  readonly type: "running";
-} | {
-  readonly type: "complete";
-} | {
-  readonly type: "incomplete";
-  readonly reason: "cancelled" | "length" | "content-filter" | "other" | "error";
-  readonly error?: unknown;
-} | {
-  type: string;
-};
-//#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/legacy-runtime/runtime/MessagePartRuntime.ts

@@ -1,2 +0,0 @@
-export type { MessagePartState, MessagePartRuntime } from "@assistant-ui/core";
-export { MessagePartRuntimeImpl } from "@assistant-ui/core/internal";

package/src/legacy-runtime/runtime/MessageRuntime.ts

@@ -1,3 +0,0 @@
-export type { MessageState, MessageRuntime } from "@assistant-ui/core";
-export type { MessageStateBinding } from "@assistant-ui/core/internal";
-export { MessageRuntimeImpl } from "@assistant-ui/core/internal";

package/src/legacy-runtime/runtime/ThreadListRuntime.ts

@@ -1,4 +0,0 @@
-export type { ThreadListState, ThreadListRuntime } from "@assistant-ui/core";
-
-export type { ThreadListRuntimeCoreBinding } from "@assistant-ui/core/internal";
-export { ThreadListRuntimeImpl } from "@assistant-ui/core/internal";

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