@assistant-ui/core 0.3.16 → 0.3.18

package/dist/utils/record.d.ts

@@ -0,0 +1,11 @@
+//#region src/utils/record.d.ts
+/**
+ * Builds a dictionary with no prototype from the own entries of its arguments.
+ * Bracket assignment on a plain object routes a `__proto__` key through the
+ * `Object.prototype` setter instead of defining an own property, so a record
+ * assigned into by a key the app does not control is built this way.
+ */
+declare const nullProtoRecord: <T>(base?: Readonly<Record<string, T>>, ...rest: readonly (Readonly<Record<string, NoInfer<T>>> | undefined)[]) => Record<string, T>;
+//#endregion
+export { nullProtoRecord };
+//# sourceMappingURL=record.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"record.d.ts","names":[],"sources":["../../src/utils/record.ts"],"mappings":";;;;;;;cAMa,kBAAmB,GAC9B,OAAO,SAAS,eAAe,QAC5B,gBAAgB,SAAS,eAAe,QAAQ,wBAClD,eAAe"}

package/dist/utils/record.js

@@ -0,0 +1,12 @@
+//#region src/utils/record.ts
+/**
+* Builds a dictionary with no prototype from the own entries of its arguments.
+* Bracket assignment on a plain object routes a `__proto__` key through the
+* `Object.prototype` setter instead of defining an own property, so a record
+* assigned into by a key the app does not control is built this way.
+*/
+const nullProtoRecord = (base, ...rest) => Object.assign(Object.create(null), base, ...rest);
+//#endregion
+export { nullProtoRecord };
+
+//# sourceMappingURL=record.js.map

package/dist/utils/record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.js","names":["nullProtoRecord","base","Readonly","Record","T","rest","NoInfer","Object","assign","create"],"sources":["../../src/utils/record.ts"],"sourcesContent":["/**\n * Builds a dictionary with no prototype from the own entries of its arguments.\n * Bracket assignment on a plain object routes a `__proto__` key through the\n * `Object.prototype` setter instead of defining an own property, so a record\n * assigned into by a key the app does not control is built this way.\n */\nexport const nullProtoRecord = <T>(\n  base?: Readonly<Record<string, T>>,\n  ...rest: readonly (Readonly<Record<string, NoInfer<T>>> | undefined)[]\n): Record<string, T> =>\n  Object.assign(Object.create(null) as Record<string, T>, base, ...rest);\n"],"mappings":";;;;;;;AAMA,MAAaA,mBACXC,MACA,GAAGI,SAEHE,OAAOC,OAAOD,OAAOE,OAAO,IAAI,GAAwBR,MAAM,GAAGI,IAAI"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/core",
-  "version": "0.3.16",
+  "version": "0.3.18",
   "description": "Framework-agnostic core runtime for assistant-ui",
   "keywords": [
     "assistant",
@@ -59,19 +59,18 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "assistant-stream": "^0.3.40",
+    "assistant-stream": "^0.3.42",
     "nanoid": "^6.0.1"
   },
   "optionalDevDependencies": {
     "@assistant-ui/x-generative-compiler": ">=0.0.3"
   },
   "peerDependencies": {
-    "@assistant-ui/store": "^0.3.0",
-    "@assistant-ui/tap": "^0.9.0",
+    "@assistant-ui/store": "^0.3.13",
+    "@assistant-ui/tap": "^0.9.17",
     "@types/react": "*",
     "react": "^18 || ^19",
-    "assistant-cloud": "^0.1.42",
-    "zustand": "^5.0.11"
+    "assistant-cloud": "^0.2.0"
   },
   "peerDependenciesMeta": {
     "@types/react": {
@@ -82,24 +81,20 @@
     },
     "react": {
       "optional": true
-    },
-    "zustand": {
-      "optional": true
     }
   },
   "devDependencies": {
-    "@assistant-ui/store": "0.3.11",
-    "@assistant-ui/tap": "0.9.15",
-    "@assistant-ui/vite": "0.0.15",
-    "@assistant-ui/x-buildutils": "0.0.24",
-    "@testing-library/react": "^16.3.2",
+    "@assistant-ui/store": "0.3.13",
+    "@assistant-ui/tap": "0.9.17",
+    "@assistant-ui/vite": "0.0.17",
+    "@assistant-ui/x-buildutils": "0.0.26",
+    "@testing-library/react": "^16.3.3",
     "@types/react": "^19.2.18",
-    "assistant-cloud": "0.1.42",
+    "assistant-cloud": "0.2.0",
     "jsdom": "^30.0.1",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
-    "vitest": "^4.1.11",
-    "zustand": "^5.0.15"
+    "vitest": "^4.1.11"
   },
   "publishConfig": {
     "access": "public",

package/src/adapters/attachment.test.ts

@@ -1,5 +1,10 @@
 import { afterEach, describe, expect, it } from "vitest";
-import { getFileDataURL, SimpleImageAttachmentAdapter } from "./attachment";
+import {
+  type AttachmentAdapter,
+  CompositeAttachmentAdapter,
+  getFileDataURL,
+  SimpleImageAttachmentAdapter,
+} from "./attachment";
 
 const originalFileReader = globalThis.FileReader;
 const originalBuffer = globalThis.Buffer;
@@ -105,3 +110,47 @@ describe("SimpleImageAttachmentAdapter", () => {
     );
   });
 });
+
+describe("CompositeAttachmentAdapter", () => {
+  it.each(["pending", "complete"])(
+    "removes a %s attachment through its matching adapter",
+    async (status) => {
+      const removed: string[] = [];
+      const imageAdapter = {
+        accept: "image/*",
+        async add({ file }) {
+          return {
+            id: "image-1",
+            type: "image",
+            name: file.name,
+            file,
+            status: { type: "requires-action", reason: "composer-send" },
+          };
+        },
+        async send(attachment) {
+          return {
+            id: attachment.id,
+            type: attachment.type,
+            name: attachment.name,
+            contentType: attachment.file.type,
+            status: { type: "complete" },
+            content: [],
+          };
+        },
+        async remove(attachment) {
+          removed.push(attachment.id);
+        },
+      } satisfies AttachmentAdapter;
+      const composite = new CompositeAttachmentAdapter([imageAdapter]);
+      const pending = await imageAdapter.add({
+        file: new File(["image bytes"], "photo.png", { type: "image/png" }),
+      });
+      const attachment =
+        status === "pending" ? pending : await composite.send(pending);
+
+      await composite.remove(attachment);
+
+      expect(removed).toEqual(["image-1"]);
+    },
+  );
+});

package/src/adapters/attachment.ts

@@ -142,11 +142,11 @@ export function fileMatchesAccept(
     .split(",")
     .map((type) => type.trim().toLowerCase());
 
-  const fileExtension = `.${file.name.split(".").pop()!.toLowerCase()}`;
+  const fileName = file.name.toLowerCase();
   const fileMimeType = file.type.split(";", 1)[0]!.trim().toLowerCase();
 
   for (const type of allowedTypes) {
-    if (type.startsWith(".") && type === fileExtension) {
+    if (type.startsWith(".") && fileName.endsWith(type)) {
       return true;
     }
 
@@ -170,7 +170,10 @@ export function attachmentsEqual(
   b: readonly CompleteAttachment[],
 ): boolean {
   if (a.length !== b.length) return false;
-  return a.every((att, i) => att.id === b[i]!.id);
+  for (let i = 0; i < a.length; i++) {
+    if (a[i]?.id !== b[i]?.id) return false;
+  }
+  return true;
 }
 
 export function partToCompleteAttachment(
@@ -276,7 +279,7 @@ export class CompositeAttachmentAdapter implements AttachmentAdapter {
     for (const adapter of adapters) {
       if (
         fileMatchesAccept(
-          {
+          attachment.file ?? {
             name: attachment.name,
             type: attachment.contentType ?? "",
           },

package/src/index.ts

@@ -22,6 +22,7 @@ export type {
   GenerativeUINode,
   GenerativeUISpec,
   Unstable_AudioMessagePart,
+  ToolApprovalDisplay,
   ToolApprovalOption,
   ToolApprovalOptionKind,
   ToolApprovalResponse,
@@ -50,7 +51,11 @@ export type {
   AppendMessage,
 } from "./types/message";
 
-export { MCP_APP_URI_SCHEME, isMcpAppUri } from "./types/message";
+export {
+  MCP_APP_URI_SCHEME,
+  isMcpAppUri,
+  toolApprovalAcceptsText,
+} from "./types/message";
 
 export type {
   Attachment,
@@ -256,6 +261,7 @@ export type {
   ThreadListItemEventCallback,
   ThreadListItemEventPayload,
   ThreadListItemEventType,
+  ThreadListItemGenerateTitleOptions,
   ThreadListItemRuntime,
 } from "./runtime/api/thread-list-item-runtime";
 

package/src/internal.ts

@@ -67,6 +67,10 @@ export {
   resolveFilePartSource,
 } from "./utils/data-url";
 export { invokeUserCallback } from "./utils/invoke-user-callback";
+export {
+  abortableIterable,
+  openAbortableIterable,
+} from "./utils/abortable-iterable";
 export { detectImageMediaType } from "./utils/image-media-type";
 export {
   resolveFileMediaType,
@@ -77,6 +81,14 @@ export {
   createToolCallCancellationStub,
   scanPendingToolCalls,
 } from "./runtime/utils/pending-tool-calls";
+// Nested tool-call traversal, reused by framework adapters so the
+// ToolCallMessagePart.messages tree is walked one way.
+export {
+  iterateToolCallParts,
+  mapToolCallPartsDeep,
+  type ToolCallTreeEntry,
+  walkToolCallTree,
+} from "./runtime/utils/tool-call-tree";
 export {
   createAbortableThreadLoad,
   type AbortableThreadLoadPurpose,

package/src/model-context/frame/host.test.ts

@@ -133,6 +133,30 @@ describe("AssistantFrameHost", () => {
     host.dispose();
   });
 
+  it("cleans up tool calls when posting the request fails", async () => {
+    const { execute, host, postMessage } = createHost();
+    const error = new Error("postMessage failed");
+    const abortController = new AbortController();
+    const removeEventListener = vi.spyOn(
+      abortController.signal,
+      "removeEventListener",
+    );
+    postMessage.mockImplementation((data) => {
+      if (data.message.type === "tool-call") throw error;
+    });
+
+    await expect(
+      execute({}, { ...executionContext, abortSignal: abortController.signal }),
+    ).rejects.toBe(error);
+
+    expect(vi.getTimerCount()).toBe(0);
+    expect(removeEventListener).toHaveBeenCalledWith(
+      "abort",
+      expect.any(Function),
+    );
+    host.dispose();
+  });
+
   it("rejects tool results that carry an empty error message", async () => {
     const { dispatchMessage, execute, getToolCallId, host } = createHost();
     const result = Promise.resolve(

package/src/model-context/frame/host.ts

@@ -195,10 +195,16 @@ export class AssistantFrameHost implements ModelContextProvider {
       }, timeout);
       abortSignal?.addEventListener("abort", onAbort, { once: true });
 
-      this._iframeWindow.postMessage(
-        { channel: FRAME_MESSAGE_CHANNEL, message },
-        this._targetOrigin,
-      );
+      try {
+        this._iframeWindow.postMessage(
+          { channel: FRAME_MESSAGE_CHANNEL, message },
+          this._targetOrigin,
+        );
+      } catch (error) {
+        const pending = this._pendingRequests.get(message.id);
+        this._pendingRequests.delete(message.id);
+        pending?.reject(error);
+      }
     });
   }
 

package/src/model-context/frame/provider.test.ts

@@ -13,6 +13,7 @@ describe("AssistantFrameProvider", () => {
     origin: string,
     source: Window = parentWindow,
     id = "tool-call-1",
+    toolName = "sensitiveTool",
   ) => {
     messageHandler?.(
       new MessageEvent("message", {
@@ -21,7 +22,7 @@ describe("AssistantFrameProvider", () => {
           message: {
             type: "tool-call",
             id,
-            toolName: "sensitiveTool",
+            toolName,
             args: {},
           },
         },
@@ -119,6 +120,42 @@ describe("AssistantFrameProvider", () => {
     await vi.waitFor(() => expect(execute).toHaveBeenCalledOnce());
   });
 
+  it("does not broadcast from a disposed provider", async () => {
+    vi.useFakeTimers();
+
+    try {
+      AssistantFrameProvider.addModelContextProvider({
+        getModelContext: () => ({ system: "disposed context" }),
+      });
+      AssistantFrameProvider.dispose();
+
+      AssistantFrameProvider.addModelContextProvider({
+        getModelContext: () => ({ system: "current context" }),
+      });
+      vi.mocked(parentWindow.postMessage).mockClear();
+
+      await vi.runAllTimersAsync();
+
+      expect(parentWindow.postMessage).toHaveBeenCalledOnce();
+      expect(parentWindow.postMessage).toHaveBeenCalledWith(
+        {
+          channel: FRAME_MESSAGE_CHANNEL,
+          message: {
+            type: "model-context-update",
+            context: {
+              system: "current context",
+              tools: {},
+            },
+          },
+        },
+        window.location.origin,
+      );
+    } finally {
+      AssistantFrameProvider.dispose();
+      vi.useRealTimers();
+    }
+  });
+
   it("reports a failure even when the thrown error has an empty message", async () => {
     const execute = vi.fn(async () => {
       throw new Error();
@@ -145,6 +182,41 @@ describe("AssistantFrameProvider", () => {
     });
   });
 
+  it("reports tool results that cannot cross the frame boundary", async () => {
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => undefined);
+    const execute = vi.fn(async () => () => undefined);
+    vi.mocked(parentWindow.postMessage).mockImplementation((data) => {
+      structuredClone(data);
+    });
+    AssistantFrameProvider.addModelContextProvider({
+      getModelContext: () => ({
+        tools: { sensitiveTool: { execute } },
+      }),
+    });
+
+    dispatchToolCall(window.location.origin);
+
+    await vi.waitFor(() => {
+      expect(consoleError).toHaveBeenCalledWith(
+        "[assistant-ui] AssistantFrame tool result could not be sent.",
+        expect.objectContaining({ name: "DataCloneError" }),
+      );
+      expect(parentWindow.postMessage).toHaveBeenCalledWith(
+        {
+          channel: FRAME_MESSAGE_CHANNEL,
+          message: {
+            type: "tool-result",
+            id: "tool-call-1",
+            error: "Tool result could not be sent across the frame boundary",
+          },
+        },
+        { targetOrigin: window.location.origin },
+      );
+    });
+  });
+
   it("aborts in-flight tool calls when the parent cancels them", async () => {
     let toolSignal: AbortSignal | undefined;
     const execute = vi.fn(
@@ -284,6 +356,179 @@ describe("AssistantFrameProvider", () => {
     expect(toolResults).toHaveLength(1);
   });
 
+  it("aborts in-flight tool calls when their provider is removed", async () => {
+    let toolSignal: AbortSignal | undefined;
+    const execute = vi.fn(
+      async (_args: unknown, context: { abortSignal: AbortSignal }) => {
+        toolSignal = context.abortSignal;
+        await new Promise<never>((_resolve, reject) => {
+          context.abortSignal.addEventListener(
+            "abort",
+            () => reject(context.abortSignal.reason),
+            { once: true },
+          );
+        });
+      },
+    );
+    const removeProvider = AssistantFrameProvider.addModelContextProvider({
+      getModelContext: () => ({ tools: { sensitiveTool: { execute } } }),
+    });
+
+    dispatchToolCall(window.location.origin);
+    await vi.waitFor(() => expect(toolSignal).toBeDefined());
+
+    removeProvider();
+
+    expect(toolSignal?.aborted).toBe(true);
+    expect(parentWindow.postMessage).toHaveBeenCalledWith(
+      {
+        channel: FRAME_MESSAGE_CHANNEL,
+        message: {
+          type: "tool-result",
+          id: "tool-call-1",
+          error: "AssistantFrame tool provider has been removed",
+        },
+      },
+      { targetOrigin: window.location.origin },
+    );
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    const toolResults = vi
+      .mocked(parentWindow.postMessage)
+      .mock.calls.filter(
+        ([data]) =>
+          (data as { message?: { type?: string } }).message?.type ===
+          "tool-result",
+      );
+    expect(toolResults).toHaveLength(1);
+  });
+
+  it("keeps tool calls active while the same provider remains registered", async () => {
+    let toolSignal: AbortSignal | undefined;
+    const execute = vi.fn(
+      async (_args: unknown, context: { abortSignal: AbortSignal }) => {
+        toolSignal = context.abortSignal;
+        await new Promise<never>((_resolve, reject) => {
+          context.abortSignal.addEventListener(
+            "abort",
+            () => reject(context.abortSignal.reason),
+            { once: true },
+          );
+        });
+      },
+    );
+    const provider = {
+      getModelContext: () => ({ tools: { sensitiveTool: { execute } } }),
+    };
+    const removeFirst =
+      AssistantFrameProvider.addModelContextProvider(provider);
+    const removeSecond =
+      AssistantFrameProvider.addModelContextProvider(provider);
+
+    dispatchToolCall(window.location.origin);
+    await vi.waitFor(() => expect(toolSignal).toBeDefined());
+
+    removeFirst();
+    expect(toolSignal?.aborted).toBe(false);
+
+    removeSecond();
+    expect(toolSignal?.aborted).toBe(true);
+  });
+
+  it("cancels only calls owned by the removed provider", async () => {
+    const shadowedExecute = vi.fn(async () => "shadowed");
+    const removeShadowed = AssistantFrameProvider.addModelContextProvider({
+      getModelContext: () => ({
+        tools: { sensitiveTool: { execute: shadowedExecute } },
+      }),
+    });
+
+    let toolSignal: AbortSignal | undefined;
+    const execute = vi.fn(
+      async (_args: unknown, context: { abortSignal: AbortSignal }) => {
+        toolSignal = context.abortSignal;
+        await new Promise<never>((_resolve, reject) => {
+          context.abortSignal.addEventListener(
+            "abort",
+            () => reject(context.abortSignal.reason),
+            { once: true },
+          );
+        });
+      },
+    );
+    const removeOwner = AssistantFrameProvider.addModelContextProvider({
+      getModelContext: () => ({
+        tools: { sensitiveTool: { execute } },
+      }),
+    });
+
+    dispatchToolCall(window.location.origin);
+    await vi.waitFor(() => expect(toolSignal).toBeDefined());
+    expect(shadowedExecute).not.toHaveBeenCalled();
+
+    removeShadowed();
+    expect(toolSignal?.aborted).toBe(false);
+
+    removeOwner();
+    expect(toolSignal?.aborted).toBe(true);
+  });
+
+  it("keeps other providers' tool calls active when one is removed", async () => {
+    const signals = new Map<string, AbortSignal>();
+    const execute = vi.fn(
+      async (
+        _args: unknown,
+        context: { toolCallId: string; abortSignal: AbortSignal },
+      ) => {
+        signals.set(context.toolCallId, context.abortSignal);
+        await new Promise<never>((_resolve, reject) => {
+          context.abortSignal.addEventListener(
+            "abort",
+            () => reject(context.abortSignal.reason),
+            { once: true },
+          );
+        });
+      },
+    );
+    const removeFirst = AssistantFrameProvider.addModelContextProvider({
+      getModelContext: () => ({ tools: { firstTool: { execute } } }),
+    });
+    const removeSecond = AssistantFrameProvider.addModelContextProvider({
+      getModelContext: () => ({ tools: { secondTool: { execute } } }),
+    });
+
+    dispatchToolCall(
+      window.location.origin,
+      parentWindow,
+      "first-call",
+      "firstTool",
+    );
+    dispatchToolCall(
+      window.location.origin,
+      parentWindow,
+      "second-call",
+      "secondTool",
+    );
+    await vi.waitFor(() => expect(signals.size).toBe(2));
+
+    removeFirst();
+
+    expect(signals.get("first-call")?.aborted).toBe(true);
+    expect(signals.get("second-call")?.aborted).toBe(false);
+    const toolResults = vi
+      .mocked(parentWindow.postMessage)
+      .mock.calls.filter(
+        ([data]) =>
+          (data as { message?: { type?: string } }).message?.type ===
+          "tool-result",
+      );
+    expect(toolResults).toHaveLength(1);
+    expect(toolResults[0]?.[0]).toMatchObject({
+      message: { id: "first-call" },
+    });
+
+    removeSecond();
+  });
+
   it("upgrades a wildcard origin policy when a strict provider registers", async () => {
     AssistantFrameProvider.addModelContextProvider(
       { getModelContext: () => ({}) },
@@ -385,6 +630,48 @@ describe("AssistantFrameProvider", () => {
     ).not.toThrow();
   });
 
+  it("cancels reentrant tool calls when registration rolls back", async () => {
+    let toolSignal: AbortSignal | undefined;
+    const execute = vi.fn(
+      async (_args: unknown, context: { abortSignal: AbortSignal }) => {
+        toolSignal = context.abortSignal;
+        await new Promise<never>((_resolve, reject) => {
+          context.abortSignal.addEventListener(
+            "abort",
+            () => reject(context.abortSignal.reason),
+            { once: true },
+          );
+        });
+      },
+    );
+
+    expect(() =>
+      AssistantFrameProvider.addModelContextProvider({
+        getModelContext: () => ({
+          tools: { sensitiveTool: { execute } },
+        }),
+        subscribe: () => {
+          dispatchToolCall(window.location.origin);
+          throw new Error("subscribe failed");
+        },
+      }),
+    ).toThrow("subscribe failed");
+
+    expect(toolSignal?.aborted).toBe(true);
+    expect(parentWindow.postMessage).toHaveBeenCalledWith(
+      {
+        channel: FRAME_MESSAGE_CHANNEL,
+        message: {
+          type: "tool-result",
+          id: "tool-call-1",
+          error: "AssistantFrame tool provider has been removed",
+        },
+      },
+      { targetOrigin: window.location.origin },
+    );
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  });
+
   it("keeps an existing registration when the same provider fails to register again", async () => {
     const execute = vi.fn(async () => "result");
     const firstUnsubscribe = vi.fn();