@assistant-ui/core 0.3.18 → 0.3.19

package/dist/utils/wire-media.js.map

@@ -1 +1 @@
-{"version":3,"file":"wire-media.js","names":["dataUrlMediaType","isParsableUrl","parseDataUrl","detectImageMediaType","resolveImageMediaType","image","contentType","startsWith","declared","parsed","payload","data","undefined","sniffed","resolveFileMediaType","mimeType","toMediaWireUrl","mediaType"],"sources":["../../src/utils/wire-media.ts"],"sourcesContent":["import { dataUrlMediaType, isParsableUrl, parseDataUrl } from \"./data-url\";\nimport { detectImageMediaType } from \"./image-media-type\";\n\n/**\n * The media type to declare for an `ImageMessagePart`, which carries none of\n * its own: an attachment's content type, then the payload's data URL\n * declaration, then its leading bytes, then `image/png`.\n *\n * The floor cannot be a wildcard. `image/*` is rejected outright by the AI SDK\n * for a url source and whenever inline bytes fail to sniff, so it fails exactly\n * where a fallback is needed.\n */\nexport function resolveImageMediaType(\n  image: string,\n  contentType?: string | undefined,\n): string {\n  if (contentType?.startsWith(\"image/\")) return contentType;\n\n  const declared = dataUrlMediaType(image);\n  if (declared?.startsWith(\"image/\")) return declared;\n\n  // Read through a data URL envelope too, so a generic one such as\n  // `application/octet-stream` does not mask the format. A url of any other\n  // scheme has no local bytes to read.\n  const parsed = parseDataUrl(image);\n  const payload = parsed?.data ?? (isParsableUrl(image) ? undefined : image);\n  if (payload !== undefined) {\n    const sniffed = detectImageMediaType(payload);\n    if (sniffed) return sniffed;\n  }\n\n  return \"image/png\";\n}\n\n/**\n * The media type to declare for a `FileMessagePart`: its own `mimeType`, then\n * the payload's data URL declaration, then `application/octet-stream`.\n *\n * `mimeType` is a plain string, and an adapter reading `file.type` on a file\n * the OS cannot type yields `\"\"`, so the declared value is not always present.\n */\nexport function resolveFileMediaType(\n  data: string,\n  mimeType?: string | undefined,\n): string {\n  return mimeType || dataUrlMediaType(data) || \"application/octet-stream\";\n}\n\n/**\n * A payload placed into a wire field that is contractually a url.\n *\n * Two hazards drive this. A consumer may hand the value to an unguarded\n * `new URL()`, so a payload that is not a url has to be wrapped; and a data\n * URL's own media type wins over a separately declared one downstream, so a\n * base64 envelope that disagrees with `mediaType` is rebuilt around the same\n * bytes. Everything else passes through byte for byte: an envelope that agrees,\n * a url of any other scheme, and a percent-encoded data URL, whose declaration\n * cannot be corrected without transcoding the payload and is authoritative for\n * the bytes it carries anyway.\n */\nexport function toMediaWireUrl(payload: string, mediaType: string): string {\n  const parsed = parseDataUrl(payload);\n  if (parsed) {\n    return parsed.mimeType === mediaType\n      ? payload\n      : `data:${mediaType};base64,${parsed.data}`;\n  }\n  if (isParsableUrl(payload)) return payload;\n  return `data:${mediaType};base64,${payload}`;\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAgBI,sBACdC,OACAC,aACQ;CACR,IAAIA,aAAaC,WAAW,QAAQ,GAAG,OAAOD;CAE9C,MAAME,WAAWR,iBAAiBK,KAAK;CACvC,IAAIG,UAAUD,WAAW,QAAQ,GAAG,OAAOC;CAM3C,MAAME,UADSR,aAAaG,KACZI,CAAM,EAAEE,SAASV,cAAcI,KAAK,IAAIO,KAAAA,IAAYP;CACpE,IAAIK,YAAYE,KAAAA,GAAW;EACzB,MAAMC,UAAUV,qBAAqBO,OAAO;EAC5C,IAAIG,SAAS,OAAOA;CACtB;CAEA,OAAO;AACT;;;;;;;;AASA,SAAgBC,qBACdH,MACAI,UACQ;CACR,OAAOA,YAAYf,iBAAiBW,IAAI,KAAK;AAC/C;;;;;;;;;;;;;AAcA,SAAgBK,eAAeN,SAAiBO,WAA2B;CACzE,MAAMR,SAASP,aAAaQ,OAAO;CACnC,IAAID,QACF,OAAOA,OAAOM,aAAaE,YACvBP,UACA,QAAQO,UAAS,UAAWR,OAAOE;CAEzC,IAAIV,cAAcS,OAAO,GAAG,OAAOA;CACnC,OAAO,QAAQO,UAAS,UAAWP;AACrC"}
+{"version":3,"file":"wire-media.js","names":["dataUrlMediaType","isParsableUrl","parseDataUrl","detectImageMediaType","resolveImageMediaType","image","contentType","startsWith","includes","declared","parsed","payload","data","undefined","sniffed","resolveFileMediaType","mimeType","toMediaWireUrl","mediaType"],"sources":["../../src/utils/wire-media.ts"],"sourcesContent":["import { dataUrlMediaType, isParsableUrl, parseDataUrl } from \"./data-url\";\nimport { detectImageMediaType } from \"./image-media-type\";\n\n/**\n * The media type to declare for an `ImageMessagePart`, which carries none of\n * its own: an attachment's content type, then the payload's data URL\n * declaration, then its leading bytes, then `image/png`.\n *\n * The floor cannot be a wildcard. `image/*` is rejected outright by the AI SDK\n * for a url source and whenever inline bytes fail to sniff, so it fails exactly\n * where a fallback is needed.\n */\nexport function resolveImageMediaType(\n  image: string,\n  contentType?: string | undefined,\n): string {\n  if (contentType?.startsWith(\"image/\") && !contentType.includes(\"*\")) {\n    return contentType;\n  }\n\n  const declared = dataUrlMediaType(image);\n  if (declared?.startsWith(\"image/\") && !declared.includes(\"*\")) {\n    return declared;\n  }\n\n  // Read through a data URL envelope too, so a generic one such as\n  // `application/octet-stream` does not mask the format. A url of any other\n  // scheme has no local bytes to read.\n  const parsed = parseDataUrl(image);\n  const payload = parsed?.data ?? (isParsableUrl(image) ? undefined : image);\n  if (payload !== undefined) {\n    const sniffed = detectImageMediaType(payload);\n    if (sniffed) return sniffed;\n  }\n\n  return \"image/png\";\n}\n\n/**\n * The media type to declare for a `FileMessagePart`: its own `mimeType`, then\n * the payload's data URL declaration, then `application/octet-stream`.\n *\n * `mimeType` is a plain string, and an adapter reading `file.type` on a file\n * the OS cannot type yields `\"\"`, so the declared value is not always present.\n */\nexport function resolveFileMediaType(\n  data: string,\n  mimeType?: string | undefined,\n): string {\n  return mimeType || dataUrlMediaType(data) || \"application/octet-stream\";\n}\n\n/**\n * A payload placed into a wire field that is contractually a url.\n *\n * Two hazards drive this. A consumer may hand the value to an unguarded\n * `new URL()`, so a payload that is not a url has to be wrapped; and a data\n * URL's own media type wins over a separately declared one downstream, so a\n * base64 envelope that disagrees with `mediaType` is rebuilt around the same\n * bytes. Everything else passes through byte for byte: an envelope that agrees,\n * a url of any other scheme, and a percent-encoded data URL, whose declaration\n * cannot be corrected without transcoding the payload and is authoritative for\n * the bytes it carries anyway.\n */\nexport function toMediaWireUrl(payload: string, mediaType: string): string {\n  const parsed = parseDataUrl(payload);\n  if (parsed) {\n    return parsed.mimeType === mediaType\n      ? payload\n      : `data:${mediaType};base64,${parsed.data}`;\n  }\n  if (isParsableUrl(payload)) return payload;\n  return `data:${mediaType};base64,${payload}`;\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAgBI,sBACdC,OACAC,aACQ;CACR,IAAIA,aAAaC,WAAW,QAAQ,KAAK,CAACD,YAAYE,SAAS,GAAG,GAChE,OAAOF;CAGT,MAAMG,WAAWT,iBAAiBK,KAAK;CACvC,IAAII,UAAUF,WAAW,QAAQ,KAAK,CAACE,SAASD,SAAS,GAAG,GAC1D,OAAOC;CAOT,MAAME,UADST,aAAaG,KACZK,CAAM,EAAEE,SAASX,cAAcI,KAAK,IAAIQ,KAAAA,IAAYR;CACpE,IAAIM,YAAYE,KAAAA,GAAW;EACzB,MAAMC,UAAUX,qBAAqBQ,OAAO;EAC5C,IAAIG,SAAS,OAAOA;CACtB;CAEA,OAAO;AACT;;;;;;;;AASA,SAAgBC,qBACdH,MACAI,UACQ;CACR,OAAOA,YAAYhB,iBAAiBY,IAAI,KAAK;AAC/C;;;;;;;;;;;;;AAcA,SAAgBK,eAAeN,SAAiBO,WAA2B;CACzE,MAAMR,SAASR,aAAaS,OAAO;CACnC,IAAID,QACF,OAAOA,OAAOM,aAAaE,YACvBP,UACA,QAAQO,UAAS,UAAWR,OAAOE;CAEzC,IAAIX,cAAcU,OAAO,GAAG,OAAOA;CACnC,OAAO,QAAQO,UAAS,UAAWP;AACrC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/core",
-  "version": "0.3.18",
+  "version": "0.3.19",
   "description": "Framework-agnostic core runtime for assistant-ui",
   "keywords": [
     "assistant",
@@ -59,7 +59,7 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "assistant-stream": "^0.3.42",
+    "assistant-stream": "^0.3.43",
     "nanoid": "^6.0.1"
   },
   "optionalDevDependencies": {
@@ -70,7 +70,7 @@
     "@assistant-ui/tap": "^0.9.17",
     "@types/react": "*",
     "react": "^18 || ^19",
-    "assistant-cloud": "^0.2.0"
+    "assistant-cloud": "^0.2.1"
   },
   "peerDependenciesMeta": {
     "@types/react": {
@@ -87,14 +87,14 @@
     "@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",
+    "@assistant-ui/x-buildutils": "0.0.27",
     "@testing-library/react": "^16.3.3",
     "@types/react": "^19.2.18",
-    "assistant-cloud": "0.2.0",
+    "assistant-cloud": "0.2.1",
     "jsdom": "^30.0.1",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
-    "vitest": "^4.1.11"
+    "vitest": "^5.0.0"
   },
   "publishConfig": {
     "access": "public",

package/src/adapters/speech.test.ts

@@ -7,6 +7,62 @@ afterEach(() => {
 });
 
 describe("WebSpeechSynthesisAdapter", () => {
+  const stubSpeechSynthesis = () => {
+    const utterances: EventTarget[] = [];
+    class MockSpeechSynthesisUtterance extends EventTarget {
+      constructor() {
+        super();
+        utterances.push(this);
+      }
+    }
+    const cancel = vi.fn();
+    vi.stubGlobal("SpeechSynthesisUtterance", MockSpeechSynthesisUtterance);
+    vi.stubGlobal("window", { speechSynthesis: { speak: vi.fn(), cancel } });
+    return { utterances, cancel };
+  };
+
+  it.each(["end", "error"])(
+    "does not cancel newer playback through a handle that received %s",
+    (event) => {
+      const { utterances, cancel } = stubSpeechSynthesis();
+      const adapter = new WebSpeechSynthesisAdapter();
+      const old = adapter.speak("old");
+      utterances[0]!.dispatchEvent(new Event(event));
+      const endedStatus = old.status;
+      const current = adapter.speak("current");
+
+      old.cancel();
+      old.cancel();
+
+      expect(cancel).not.toHaveBeenCalled();
+      expect(old.status).toBe(endedStatus);
+      expect(current.status).toEqual({ type: "running" });
+    },
+  );
+
+  it("cancels active playback once and leaves later playback alone", () => {
+    const { cancel } = stubSpeechSynthesis();
+    const adapter = new WebSpeechSynthesisAdapter();
+    const old = adapter.speak("old");
+    const onChange = vi.fn();
+    old.subscribe(onChange);
+
+    old.cancel();
+
+    expect(cancel).toHaveBeenCalledOnce();
+    expect(old.status).toMatchObject({ type: "ended", reason: "cancelled" });
+    expect(onChange).toHaveBeenCalledOnce();
+
+    const current = adapter.speak("current");
+    old.cancel();
+
+    expect(cancel).toHaveBeenCalledOnce();
+    expect(onChange).toHaveBeenCalledOnce();
+    expect(current.status).toEqual({ type: "running" });
+    current.cancel();
+    expect(cancel).toHaveBeenCalledTimes(2);
+  });
+
   it("isolates a late subscriber that throws after the utterance ended", async () => {
     const listeners = new Map<string, EventListener>();
     class MockSpeechSynthesisUtterance {
@@ -109,6 +165,186 @@ describe("WebSpeechDictationAdapter", () => {
     return listeners;
   };
 
+  const emitResults = (
+    listeners: Map<string, EventListener>,
+    results: [transcript: string, isFinal: boolean][],
+    resultIndex = 0,
+  ) => {
+    listeners.get("result")!({
+      resultIndex,
+      results: results.map(([transcript, isFinal]) => ({
+        0: { transcript },
+        isFinal,
+      })),
+    } as unknown as Event);
+  };
+
+  it("publishes the entire interim suffix when only its last result changes", () => {
+    const listeners = stubSpeechRecognition();
+    const session = new WebSpeechDictationAdapter().listen();
+    const onSpeech = vi.fn();
+    session.onSpeech(onSpeech);
+
+    emitResults(listeners, [
+      ["hello ", false],
+      ["world", false],
+    ]);
+    emitResults(
+      listeners,
+      [
+        ["hello ", false],
+        ["there", false],
+      ],
+      1,
+    );
+
+    expect(onSpeech.mock.calls).toEqual([
+      [{ transcript: "hello world", isFinal: false }],
+      [{ transcript: "hello there", isFinal: false }],
+    ]);
+  });
+
+  it("publishes partial and complete retractions with no changed results", () => {
+    const listeners = stubSpeechRecognition();
+    const session = new WebSpeechDictationAdapter().listen();
+    const onSpeech = vi.fn();
+    session.onSpeech(onSpeech);
+
+    emitResults(listeners, [
+      ["hello ", false],
+      ["world", false],
+    ]);
+    emitResults(listeners, [["hello ", false]], 1);
+    emitResults(listeners, []);
+    emitResults(listeners, []);
+
+    expect(onSpeech.mock.calls).toEqual([
+      [{ transcript: "hello world", isFinal: false }],
+      [{ transcript: "hello ", isFinal: false }],
+      [{ transcript: "", isFinal: false }],
+    ]);
+  });
+
+  it("delivers changed final results once before the remaining interim suffix", () => {
+    const listeners = stubSpeechRecognition();
+    const session = new WebSpeechDictationAdapter().listen();
+    const onSpeech = vi.fn();
+    const onEnd = vi.fn();
+    session.onSpeech(onSpeech);
+    session.onSpeechEnd(onEnd);
+
+    emitResults(listeners, [
+      ["hello ", true],
+      ["wor", false],
+      ["ld", false],
+    ]);
+    emitResults(
+      listeners,
+      [
+        ["hello ", true],
+        ["world", true],
+      ],
+      1,
+    );
+    listeners.get("end")!(new Event("end"));
+
+    expect(onSpeech.mock.calls).toEqual([
+      [{ transcript: "hello ", isFinal: true }],
+      [{ transcript: "world", isFinal: false }],
+      [{ transcript: "world", isFinal: true }],
+    ]);
+    expect(onEnd).toHaveBeenCalledExactlyOnceWith({
+      transcript: "hello world",
+    });
+  });
+
+  it("clears an interim suffix while retaining earlier final results", () => {
+    const listeners = stubSpeechRecognition();
+    const session = new WebSpeechDictationAdapter().listen();
+    const onSpeech = vi.fn();
+    session.onSpeech(onSpeech);
+
+    emitResults(listeners, [
+      ["hello ", true],
+      ["world", false],
+    ]);
+    emitResults(listeners, [["hello ", true]], 1);
+
+    expect(onSpeech.mock.calls).toEqual([
+      [{ transcript: "hello ", isFinal: true }],
+      [{ transcript: "world", isFinal: false }],
+      [{ transcript: "", isFinal: false }],
+    ]);
+  });
+
+  it("keeps final-only delivery free of empty interim updates", () => {
+    const listeners = stubSpeechRecognition();
+    const session = new WebSpeechDictationAdapter().listen();
+    const onSpeech = vi.fn();
+    session.onSpeech(onSpeech);
+
+    emitResults(listeners, [["hello", true]]);
+    emitResults(listeners, [["hello", true]], 1);
+
+    expect(onSpeech).toHaveBeenCalledExactlyOnceWith({
+      transcript: "hello",
+      isFinal: true,
+    });
+  });
+
+  it("does not drop an unconsumed final when resultIndex skips it", () => {
+    const listeners = stubSpeechRecognition();
+    const session = new WebSpeechDictationAdapter().listen();
+    const onSpeech = vi.fn();
+    const onEnd = vi.fn();
+    session.onSpeech(onSpeech);
+    session.onSpeechEnd(onEnd);
+
+    emitResults(listeners, [["hello ", false]]);
+    emitResults(
+      listeners,
+      [
+        ["hello ", true],
+        ["world", false],
+      ],
+      1,
+    );
+    listeners.get("end")!(new Event("end"));
+
+    expect(onSpeech.mock.calls).toEqual([
+      [{ transcript: "hello ", isFinal: false }],
+      [{ transcript: "hello ", isFinal: true }],
+      [{ transcript: "world", isFinal: false }],
+    ]);
+    expect(onEnd).toHaveBeenCalledExactlyOnceWith({ transcript: "hello " });
+  });
+
+  it("does not reread historical finalized results during interim updates", () => {
+    const listeners = stubSpeechRecognition();
+    new WebSpeechDictationAdapter().listen();
+    const readFinal = vi.fn(() => ({ transcript: "word " }));
+    const finals = Array.from({ length: 1_000 }, () => ({
+      get 0() {
+        return readFinal();
+      },
+      isFinal: true,
+    }));
+    listeners.get("result")!({
+      resultIndex: 0,
+      results: finals,
+    } as unknown as Event);
+    expect(readFinal).toHaveBeenCalledTimes(1_000);
+
+    for (const transcript of ["hel", "hello", "hello world"]) {
+      listeners.get("result")!({
+        resultIndex: finals.length,
+        results: [...finals, { 0: { transcript }, isFinal: false }],
+      } as unknown as Event);
+    }
+
+    expect(readFinal).toHaveBeenCalledTimes(1_000);
+  });
+
   it("continues notifying dictation listeners when one throws", () => {
     const listeners = stubSpeechRecognition();
     const listenerError = new Error("listener failed");

package/src/adapters/speech.ts

@@ -76,6 +76,7 @@ export class WebSpeechSynthesisAdapter implements SpeechSynthesisAdapter {
     const res: SpeechSynthesisAdapter.Utterance = {
       status: { type: "running" },
       cancel: () => {
+        if (res.status.type === "ended") return;
         window.speechSynthesis.cancel();
         handleEnd("cancelled");
       },
@@ -205,6 +206,8 @@ export class WebSpeechDictationAdapter implements DictationAdapter {
     >();
 
     let finalTranscript = "";
+    let hasInterimTranscript = false;
+    let firstInterimIndex = 0;
 
     const session: DictationAdapter.Session = {
       status: { type: "starting" },
@@ -267,32 +270,36 @@ export class WebSpeechDictationAdapter implements DictationAdapter {
 
     recognition.addEventListener("result", (event) => {
       const speechEvent = event as unknown as SpeechRecognitionEvent;
+      let interimTranscript = "";
 
-      for (
-        let i = speechEvent.resultIndex;
-        i < speechEvent.results.length;
-        i++
-      ) {
+      for (let i = firstInterimIndex; i < speechEvent.results.length; i++) {
         const result = speechEvent.results[i];
         if (!result) continue;
 
         const transcript = result[0]?.transcript ?? "";
 
         if (result.isFinal) {
+          firstInterimIndex = i + 1;
           finalTranscript += transcript;
+          hasInterimTranscript = false;
           notifyEventListeners(
             speechCallbacks,
             () => ({ transcript, isFinal: true }),
             "Dictation",
           );
         } else {
-          notifyEventListeners(
-            speechCallbacks,
-            () => ({ transcript, isFinal: false }),
-            "Dictation",
-          );
+          interimTranscript += transcript;
         }
       }
+
+      if (interimTranscript || hasInterimTranscript) {
+        hasInterimTranscript = interimTranscript.length > 0;
+        notifyEventListeners(
+          speechCallbacks,
+          () => ({ transcript: interimTranscript, isFinal: false }),
+          "Dictation",
+        );
+      }
     });
 
     recognition.addEventListener("speechend", () => {

package/src/adapters/thread-history.ts

@@ -7,6 +7,7 @@ import type {
   ExportedMessageRepositoryItem,
 } from "../runtime/utils/message-repository";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
+import type { ThreadMessage } from "../types";
 
 export interface MessageStorageEntry<TPayload> {
   id: string;
@@ -52,6 +53,8 @@ export type GenericThreadHistoryAdapter<TMessage> = {
     options?: {
       durationMs?: number;
       stepTimestamps?: { start_ms: number; end_ms: number }[];
+      /** The thread message the items were persisted from; its status and timing complete a report the stored format cannot carry. */
+      message?: ThreadMessage;
     },
   ): void;
 };

package/src/index.ts

@@ -40,6 +40,7 @@ export type {
   MessageStatus,
   // Thread messages
   MessageTiming,
+  MessageModality,
   ThreadStep,
   ThreadSystemMessage,
   ThreadUserMessage,

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

@@ -74,9 +74,31 @@ beforeEach(() => {
 afterEach(() => {
   vi.useRealTimers();
   vi.unstubAllGlobals();
+  vi.restoreAllMocks();
 });
 
 describe("AssistantFrameHost", () => {
+  it("does not install its message listener when initialization fails", () => {
+    const addEventListener = vi.fn();
+    const removeEventListener = vi.fn();
+    vi.stubGlobal("window", {
+      addEventListener,
+      removeEventListener,
+      location: { origin: DEFAULT_ORIGIN },
+    });
+    const error = new Error("postMessage failed");
+    const iframeWindow = {
+      postMessage: vi.fn(() => {
+        throw error;
+      }),
+    } as unknown as Window;
+
+    expect(() => new AssistantFrameHost(iframeWindow)).toThrow(error);
+
+    expect(addEventListener).not.toHaveBeenCalled();
+    expect(removeEventListener).not.toHaveBeenCalled();
+  });
+
   it("defaults to the current origin", () => {
     const { host, postMessage } = createHost();
 
@@ -212,8 +234,83 @@ describe("AssistantFrameHost", () => {
     expect(vi.getTimerCount()).toBe(0);
   });
 
+  it("settles every pending tool call when cancellation posting fails", async () => {
+    const { execute, host, postMessage } = createHost();
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => undefined);
+    const firstAbortController = new AbortController();
+    const secondAbortController = new AbortController();
+    const firstRemoveEventListener = vi.spyOn(
+      firstAbortController.signal,
+      "removeEventListener",
+    );
+    const secondRemoveEventListener = vi.spyOn(
+      secondAbortController.signal,
+      "removeEventListener",
+    );
+    const firstRejected = vi.fn();
+    const secondRejected = vi.fn();
+
+    void execute(
+      {},
+      { ...executionContext, abortSignal: firstAbortController.signal },
+    ).catch(firstRejected);
+    void execute(
+      {},
+      { ...executionContext, abortSignal: secondAbortController.signal },
+    ).catch(secondRejected);
+
+    const firstTransportError = new Error("first tool cancellation failed");
+    const secondTransportError = new Error("second tool cancellation failed");
+    let cancellationCount = 0;
+    postMessage.mockImplementation((data) => {
+      if (data.message.type !== "tool-cancel") return;
+      cancellationCount += 1;
+      throw cancellationCount === 1
+        ? firstTransportError
+        : secondTransportError;
+    });
+
+    expect(() => host.dispose()).toThrow(firstTransportError);
+    await Promise.resolve();
+
+    expect(firstRejected).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: "AssistantFrameHost has been disposed",
+      }),
+    );
+    expect(secondRejected).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: "AssistantFrameHost has been disposed",
+      }),
+    );
+    expect(
+      postMessage.mock.calls.filter(
+        ([data]) => data.message.type === "tool-cancel",
+      ),
+    ).toHaveLength(2);
+    expect(firstRemoveEventListener).toHaveBeenCalledWith(
+      "abort",
+      expect.any(Function),
+    );
+    expect(secondRemoveEventListener).toHaveBeenCalledWith(
+      "abort",
+      expect.any(Function),
+    );
+    expect(vi.getTimerCount()).toBe(0);
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] AssistantFrameHost tool cancellation could not be sent.",
+      secondTransportError,
+    );
+    expect(() => host.dispose()).not.toThrow();
+  });
+
   it("rejects pending tool calls when execution is aborted", async () => {
     const { execute, getToolCallId, host, postMessage } = createHost();
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => undefined);
     const abortController = new AbortController();
     const abortError = new Error("Run cancelled");
     abortError.name = "AbortError";
@@ -229,8 +326,13 @@ describe("AssistantFrameHost", () => {
     const onRejected = vi.fn();
     void result.catch(onRejected);
     const toolCallId = getToolCallId();
+    postMessage.mockImplementation((data) => {
+      if (data.message.type === "tool-cancel") {
+        throw new Error("tool cancellation failed");
+      }
+    });
 
-    abortController.abort(abortError);
+    expect(() => abortController.abort(abortError)).not.toThrow();
     await Promise.resolve();
 
     expect(onRejected).toHaveBeenCalledWith(abortError);
@@ -241,17 +343,26 @@ describe("AssistantFrameHost", () => {
       },
       DEFAULT_ORIGIN,
     );
+    expect(consoleError).toHaveBeenCalledOnce();
     expect(vi.getTimerCount()).toBe(0);
     host.dispose();
   });
 
   it("cancels tool calls when they time out", async () => {
     const { execute, getToolCallId, host, postMessage } = createHost();
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => undefined);
     const result = Promise.resolve(execute({}, executionContext));
     const toolCallId = getToolCallId();
     const rejection = expect(result).rejects.toThrow(
       'Tool call "search" timed out',
     );
+    postMessage.mockImplementation((data) => {
+      if (data.message.type === "tool-cancel") {
+        throw new Error("tool cancellation failed");
+      }
+    });
 
     await vi.advanceTimersByTimeAsync(30000);
 
@@ -263,6 +374,7 @@ describe("AssistantFrameHost", () => {
       },
       DEFAULT_ORIGIN,
     );
+    expect(consoleError).toHaveBeenCalledOnce();
     expect(vi.getTimerCount()).toBe(0);
     host.dispose();
   });

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

@@ -12,6 +12,13 @@ import {
 
 const getDefaultTargetOrigin = () => window.location.origin;
 
+const logCancellationFailure = (error: unknown) => {
+  console.error(
+    "[assistant-ui] AssistantFrameHost tool cancellation could not be sent.",
+    error,
+  );
+};
+
 /**
  * Deserializes tools from JSON Schema format back to Tool objects
  */
@@ -73,9 +80,10 @@ export class AssistantFrameHost implements ModelContextProvider {
     this._targetOrigin = targetOrigin;
 
     this.handleMessage = this.handleMessage.bind(this);
-    window.addEventListener("message", this.handleMessage);
-
+    // A posted message cannot be delivered before this constructor returns, so
+    // requesting first means a failed request leaves no listener to clean up.
     this.requestContext();
+    window.addEventListener("message", this.handleMessage);
   }
 
   private handleMessage(event: MessageEvent) {
@@ -208,14 +216,21 @@ export class AssistantFrameHost implements ModelContextProvider {
     });
   }
 
-  private cancelToolCall(id: string) {
-    this._iframeWindow.postMessage(
-      {
-        channel: FRAME_MESSAGE_CHANNEL,
-        message: { type: "tool-cancel", id } satisfies FrameMessage,
-      },
-      this._targetOrigin,
-    );
+  private cancelToolCall(
+    id: string,
+    onError: (error: unknown) => void = logCancellationFailure,
+  ) {
+    try {
+      this._iframeWindow.postMessage(
+        {
+          channel: FRAME_MESSAGE_CHANNEL,
+          message: { type: "tool-cancel", id } satisfies FrameMessage,
+        },
+        this._targetOrigin,
+      );
+    } catch (error) {
+      onError(error);
+    }
   }
 
   private requestContext() {
@@ -248,10 +263,22 @@ export class AssistantFrameHost implements ModelContextProvider {
     window.removeEventListener("message", this.handleMessage);
     this._subscribers.clear();
     const error = new Error("AssistantFrameHost has been disposed");
+    let cancellationFailed = false;
+    let cancellationError: unknown;
+
     for (const [id, pending] of this._pendingRequests) {
-      this.cancelToolCall(id);
+      this._pendingRequests.delete(id);
+      this.cancelToolCall(id, (error) => {
+        if (!cancellationFailed) {
+          cancellationFailed = true;
+          cancellationError = error;
+        } else {
+          logCancellationFailure(error);
+        }
+      });
       pending.reject(error);
     }
-    this._pendingRequests.clear();
+
+    if (cancellationFailed) throw cancellationError;
   }
 }