@assistant-ui/react 0.15.17 → 0.15.19

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.test.tsx

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { renderToStaticMarkup } from "react-dom/server";
-import { Primitive, withRenderProp } from "./Primitive";
+import { Primitive, renderSlot, withRenderProp } from "./Primitive";
 
 const ALL_NODES = [
   "a",
@@ -103,3 +103,48 @@ describe("Primitive", () => {
     });
   });
 });
+
+describe("renderSlot", () => {
+  it("lets supplied children replace the render element's own", () => {
+    expect(
+      renderToStaticMarkup(renderSlot(<em>Original</em>, "Override", {})),
+    ).toBe("<em>Override</em>");
+  });
+
+  it("falls back to the render element's own children", () => {
+    expect(
+      renderToStaticMarkup(renderSlot(<em>Fallback</em>, undefined, {})),
+    ).toBe("<em>Fallback</em>");
+  });
+
+  it("treats null children as supplied rather than absent", () => {
+    expect(renderToStaticMarkup(renderSlot(<em>Fallback</em>, null, {}))).toBe(
+      "<em></em>",
+    );
+  });
+
+  it("merges call-site props into the render element", () => {
+    const html = renderToStaticMarkup(
+      renderSlot(<em className="child" id="kept" />, "text", {
+        className: "parent",
+        id: "dropped",
+      }),
+    );
+
+    expect(html).toContain('id="kept"');
+    expect(html).toContain("parent");
+    expect(html).toContain("child");
+  });
+
+  it("applies the same precedence as withRenderProp", () => {
+    expect(
+      renderToStaticMarkup(
+        renderSlot(<em>Fallback</em>, undefined, { className: "parent" }),
+      ),
+    ).toBe(
+      renderToStaticMarkup(
+        <Primitive.span className="parent" render={<em>Fallback</em>} />,
+      ),
+    );
+  });
+});

package/src/utils/Primitive.tsx

@@ -1,4 +1,5 @@
 import {
+  type ComponentProps,
   type ComponentPropsWithoutRef,
   type ComponentRef,
   type ElementType,
@@ -12,6 +13,7 @@ import {
   isValidElement,
 } from "react";
 import { Primitive as RadixPrimitive } from "radix-ui/internal";
+import { Slot } from "radix-ui";
 
 /**
  * Thin wrapper around Radix `Primitive` that adds `render` prop support.
@@ -64,6 +66,39 @@ type PrimitiveRef<E extends PrimitiveNode> = ComponentRef<
   (typeof RadixPrimitive)[E]
 >;
 
+/**
+ * Composes the children of a `render` element. Outer children win when supplied;
+ * the render element's own children are the fallback.
+ */
+function composeRenderElement(
+  render: ReactElement,
+  children: ReactNode,
+): ReactElement {
+  return cloneElement(
+    render,
+    undefined,
+    children !== undefined
+      ? children
+      : (render.props as { children?: ReactNode }).children,
+  );
+}
+
+/**
+ * Composes a `render` element at a call site that has already computed its props.
+ *
+ * `withRenderProp` wraps a component; this covers the case where the props are
+ * already in hand and the composition happens inline.
+ */
+function renderSlot(
+  render: ReactElement,
+  children: ReactNode,
+  props: ComponentProps<typeof Slot.Root>,
+): ReactElement {
+  return (
+    <Slot.Root {...props}>{composeRenderElement(render, children)}</Slot.Root>
+  );
+}
+
 function withRenderProp<T extends ElementType>(Component: T) {
   const Wrapped = forwardRef<ComponentRef<T>, WithRenderPropRuntimeProps<T>>(
     (
@@ -78,14 +113,9 @@ function withRenderProp<T extends ElementType>(Component: T) {
       const Comp = Component as any;
 
       if (render && isValidElement(render)) {
-        const renderChildren =
-          children !== undefined
-            ? children
-            : ((render.props as Record<string, unknown>).children as ReactNode);
-
         return (
           <Comp {...(rest as any)} asChild ref={ref}>
-            {cloneElement(render, undefined, renderChildren)}
+            {composeRenderElement(render, children)}
           </Comp>
         );
       }
@@ -129,5 +159,5 @@ const Primitive = NODES.reduce(
   },
 );
 
-export { Primitive, withRenderProp };
+export { Primitive, renderSlot, withRenderProp };
 export type { PrimitiveProps, WithRenderPropProps };

package/src/utils/getSelectionMessageId.test.ts

@@ -1,7 +1,7 @@
 /**
  * @vitest-environment jsdom
  */
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, assert, describe, expect, it, vi } from "vitest";
 import { getSelectionMessageId } from "./getSelectionMessageId";
 
 const selectText = (start: Text, end = start) => {
@@ -24,6 +24,7 @@ const textNode = (selector: string) => {
 };
 
 afterEach(() => {
+  vi.restoreAllMocks();
   window.getSelection()?.removeAllRanges();
   document.body.replaceChildren();
 });
@@ -116,6 +117,180 @@ describe("getSelectionMessageId", () => {
     ).toBeNull();
   });
 
+  it.each(["", "data-aui-quote-selectable"])(
+    "rejects selections spanning an excluded subtree with root %s",
+    (marker) => {
+      document.body.innerHTML = `
+        <div data-message-id="message-1" ${marker}>
+          <span id="before">before</span>
+          <span data-aui-quote-selectable="false">excluded</span>
+          <span id="after">after</span>
+        </div>
+      `;
+
+      expect(getSelectionMessageId(selectText(textNode("#before")))).toBe(
+        "message-1",
+      );
+      expect(
+        getSelectionMessageId(
+          selectText(textNode("#before"), textNode("#after")),
+        ),
+      ).toBeNull();
+    },
+  );
+
+  it("rejects a paragraph selection that spans an inline exclusion", () => {
+    document.body.innerHTML = `
+      <div data-message-id="message-1">
+        <p id="text" data-aui-quote-selectable>before <span data-aui-quote-selectable="false">[1]</span> after</p>
+      </div>
+    `;
+
+    const paragraph = document.querySelector("#text");
+    assert(paragraph);
+    const selection = selectText(textNode("#text"));
+    selection.getRangeAt(0).selectNodeContents(paragraph);
+
+    expect(getSelectionMessageId(selection)).toBeNull();
+  });
+
+  it("accepts selections that stop or start at an excluded node boundary", () => {
+    document.body.innerHTML = `
+      <div data-message-id="message-1" data-aui-quote-selectable>
+        <span id="before">before</span><span id="chip" data-aui-quote-selectable="false">[1]</span><span id="after">after</span>
+      </div>
+    `;
+
+    const chip = document.querySelector("#chip");
+    assert(chip);
+    const before = selectText(textNode("#before"));
+    before.getRangeAt(0).setEndBefore(chip);
+    expect(getSelectionMessageId(before)).toBe("message-1");
+
+    const after = selectText(textNode("#after"));
+    after.getRangeAt(0).setStartAfter(chip);
+    expect(getSelectionMessageId(after)).toBe("message-1");
+  });
+
+  it("preserves a nested quote region inside an excluded subtree", () => {
+    document.body.innerHTML = `
+      <div data-message-id="message-1">
+        <div data-aui-quote-selectable="false">
+          <p data-aui-quote-selectable>
+            <span id="before">before</span>
+            <span data-aui-quote-selectable="false">[1]</span>
+            <span id="after">after</span>
+          </p>
+        </div>
+      </div>
+    `;
+
+    expect(getSelectionMessageId(selectText(textNode("#before")))).toBe(
+      "message-1",
+    );
+    expect(
+      getSelectionMessageId(
+        selectText(textNode("#before"), textNode("#after")),
+      ),
+    ).toBeNull();
+  });
+
+  it("checks another range outside the active quote region, including its excluded ancestor", () => {
+    document.body.innerHTML = `
+      <div data-message-id="message-1">
+        <p id="other">before <span id="chip" data-aui-quote-selectable="false">[1]</span> after</p>
+        <p id="active" data-aui-quote-selectable>active text</p>
+      </div>
+    `;
+
+    const other = document.querySelector("#other");
+    assert(other);
+    const range = document.createRange();
+    range.selectNodeContents(other);
+    const selection = selectText(textNode("#active"));
+    const active = selection.getRangeAt(0);
+    vi.spyOn(selection, "rangeCount", "get").mockReturnValue(2);
+    vi.spyOn(selection, "getRangeAt").mockImplementation((index) => {
+      if (index === 0) return range;
+      if (index === 1) return active;
+      throw new DOMException("Range index out of bounds", "IndexSizeError");
+    });
+
+    expect(getSelectionMessageId(selection)).toBeNull();
+
+    range.selectNodeContents(textNode("#chip"));
+    expect(getSelectionMessageId(selection)).toBeNull();
+  });
+
+  it("rejects another range inside the excluded ancestor of the active quote region", () => {
+    document.body.innerHTML = `
+      <div data-message-id="message-1">
+        <div data-aui-quote-selectable="false">
+          <span id="sibling">excluded prose</span>
+          <p id="active" data-aui-quote-selectable>active text</p>
+        </div>
+      </div>
+    `;
+
+    const range = document.createRange();
+    range.selectNodeContents(textNode("#sibling"));
+    const selection = selectText(textNode("#active"));
+    const active = selection.getRangeAt(0);
+    vi.spyOn(selection, "rangeCount", "get").mockReturnValue(2);
+    vi.spyOn(selection, "getRangeAt").mockImplementation((index) => {
+      if (index === 0) return range;
+      if (index === 1) return active;
+      throw new DOMException("Range index out of bounds", "IndexSizeError");
+    });
+
+    expect(getSelectionMessageId(selection)).toBeNull();
+  });
+
+  it("rejects another range in a different message", () => {
+    document.body.innerHTML = `
+      <div data-message-id="message-1"><p id="active">active text</p></div>
+      <div data-message-id="message-2">
+        <p id="other" data-aui-quote-selectable="false">excluded prose</p>
+      </div>
+    `;
+
+    const range = document.createRange();
+    range.selectNodeContents(textNode("#other"));
+    const selection = selectText(textNode("#active"));
+    const active = selection.getRangeAt(0);
+    vi.spyOn(selection, "rangeCount", "get").mockReturnValue(2);
+    vi.spyOn(selection, "getRangeAt").mockImplementation((index) => {
+      if (index === 0) return range;
+      if (index === 1) return active;
+      throw new DOMException("Range index out of bounds", "IndexSizeError");
+    });
+
+    expect(getSelectionMessageId(selection)).toBeNull();
+  });
+
+  it("accepts disjoint ranges on either side of an excluded gap", () => {
+    document.body.innerHTML = `
+      <div data-message-id="message-1" data-aui-quote-selectable>
+        <p id="before">before</p>
+        <p data-aui-quote-selectable="false">excluded</p>
+        <p id="after">after</p>
+      </div>
+    `;
+
+    const before = document.createRange();
+    before.selectNodeContents(textNode("#before"));
+    const selection = selectText(textNode("#after"));
+    const after = selection.getRangeAt(0);
+    vi.spyOn(selection, "rangeCount", "get").mockReturnValue(2);
+    vi.spyOn(selection, "getRangeAt").mockImplementation((index) => {
+      if (index === 0) return before;
+      if (index === 1) return after;
+      throw new DOMException("Range index out of bounds", "IndexSizeError");
+    });
+
+    expect(getSelectionMessageId(selection)).toBe("message-1");
+  });
+
   it("rejects selections outside quote-selectable regions when a message opts in", () => {
     document.body.innerHTML = `
       <div data-message-id="message-1">

package/src/utils/getSelectionMessageId.ts

@@ -43,6 +43,17 @@ const findQuoteMarker = (
   return marker;
 };
 
+const intersectsExcluded = (scope: Element, selection: Selection): boolean => {
+  const ranges = Array.from({ length: selection.rangeCount }, (_, i) =>
+    selection.getRangeAt(i),
+  );
+  for (const marker of scope.querySelectorAll(QUOTE_SELECTABLE_SELECTOR)) {
+    if (!isExcluded(marker)) continue;
+    if (ranges.some((range) => range.intersectsNode(marker))) return true;
+  }
+  return false;
+};
+
 export const getSelectionMessageId = (selection: Selection): string | null => {
   const { anchorNode, focusNode } = selection;
   if (!anchorNode || !focusNode) return null;
@@ -63,9 +74,16 @@ export const getSelectionMessageId = (selection: Selection): string | null => {
   if (anchorMarker && isExcluded(anchorMarker)) return null;
   if (focusMarker && isExcluded(focusMarker)) return null;
 
-  if (!hasQuoteSelectableRegion(anchorMessageElement)) return messageId;
+  if (hasQuoteSelectableRegion(anchorMessageElement)) {
+    if (!anchorMarker || anchorMarker !== focusMarker) return null;
+  }
+
+  const scope = anchorMarker ?? anchorMessageElement;
 
-  if (!anchorMarker || anchorMarker !== focusMarker) return null;
+  for (let i = 0; i < selection.rangeCount; i++) {
+    const { commonAncestorContainer } = selection.getRangeAt(i);
+    if (!scope.contains(commonAncestorContainer)) return null;
+  }
 
-  return messageId;
+  return intersectsExcluded(scope, selection) ? null : messageId;
 };

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"}