@assistant-ui/core 0.3.14 → 0.3.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/core",
-  "version": "0.3.14",
+  "version": "0.3.15",
   "description": "Framework-agnostic core runtime for assistant-ui",
   "keywords": [
     "assistant",
@@ -59,7 +59,7 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "assistant-stream": "^0.3.38",
+    "assistant-stream": "^0.3.39",
     "nanoid": "^6.0.1"
   },
   "optionalDevDependencies": {
@@ -94,9 +94,9 @@
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "vitest": "^4.1.10",
-    "zustand": "^5.0.14",
+    "zustand": "^5.0.15",
     "@assistant-ui/store": "0.3.10",
-    "@assistant-ui/tap": "0.9.13",
+    "@assistant-ui/tap": "0.9.14",
     "@assistant-ui/vite": "0.0.14",
     "@assistant-ui/x-buildutils": "0.0.23",
     "assistant-cloud": "0.1.41"

package/src/adapters/voice.test.ts

@@ -73,6 +73,25 @@ describe("createVoiceSession", () => {
     expect(controls.mute).not.toHaveBeenCalled();
   });
 
+  it("disconnects immediately when created with an already-aborted signal", async () => {
+    const abortController = new AbortController();
+    abortController.abort();
+    const setup = vi.fn(async () => ({
+      disconnect: vi.fn(),
+      mute: vi.fn(),
+      unmute: vi.fn(),
+    }));
+
+    const session = createVoiceSession(
+      { abortSignal: abortController.signal },
+      setup,
+    );
+    await Promise.resolve();
+
+    expect(setup).not.toHaveBeenCalled();
+    expect(session.status).toEqual({ type: "ended", reason: "cancelled" });
+  });
+
   it("removes the abort listener after disconnecting", async () => {
     const abortController = new AbortController();
     const controls = {
@@ -85,11 +104,52 @@ describe("createVoiceSession", () => {
       async () => controls,
     );
     await Promise.resolve();
+    const statusListener = vi.fn();
+    session.onStatusChange(statusListener);
 
     session.disconnect();
     session.disconnect();
     abortController.abort();
 
+    expect(session.status).toEqual({ type: "ended", reason: "cancelled" });
+    expect(statusListener).toHaveBeenCalledOnce();
+    expect(statusListener).toHaveBeenCalledWith({
+      type: "ended",
+      reason: "cancelled",
+    });
+    expect(controls.disconnect).toHaveBeenCalledOnce();
+  });
+
+  it("ends a running session when the abort signal fires", async () => {
+    const abortController = new AbortController();
+    const controls = {
+      disconnect: vi.fn(),
+      mute: vi.fn(),
+      unmute: vi.fn(),
+    };
+    let helpers: VoiceSessionHelpers | undefined;
+    const session = createVoiceSession(
+      { abortSignal: abortController.signal },
+      async (sessionHelpers) => {
+        helpers = sessionHelpers;
+        return controls;
+      },
+    );
+    await Promise.resolve();
+    if (!helpers) throw new Error("Voice session setup did not start");
+
+    helpers.setStatus({ type: "running" });
+    const statusListener = vi.fn();
+    session.onStatusChange(statusListener);
+
+    abortController.abort();
+
+    expect(session.status).toEqual({ type: "ended", reason: "cancelled" });
+    expect(statusListener).toHaveBeenCalledOnce();
+    expect(statusListener).toHaveBeenCalledWith({
+      type: "ended",
+      reason: "cancelled",
+    });
     expect(controls.disconnect).toHaveBeenCalledOnce();
   });
 
@@ -101,7 +161,7 @@ describe("createVoiceSession", () => {
       unmute: vi.fn(),
     };
     let helpers: VoiceSessionHelpers | undefined;
-    createVoiceSession(
+    const session = createVoiceSession(
       { abortSignal: abortController.signal },
       async (sessionHelpers) => {
         helpers = sessionHelpers;
@@ -114,6 +174,11 @@ describe("createVoiceSession", () => {
     helpers.end("error");
     abortController.abort();
 
+    expect(session.status).toEqual({
+      type: "ended",
+      reason: "error",
+      error: undefined,
+    });
     expect(controls.disconnect).toHaveBeenCalledOnce();
   });
 

package/src/adapters/voice.ts

@@ -130,6 +130,10 @@ export function createVoiceSession(
       if (disconnected) return;
       disconnected = true;
       detachAbortHandler();
+      if (currentStatus.type !== "ended") {
+        currentStatus = { type: "ended", reason: "cancelled" };
+        notifyEventListeners(statusCbs, currentStatus, "Voice session");
+      }
       try {
         controls?.disconnect();
       } finally {
@@ -165,6 +169,10 @@ export function createVoiceSession(
   if (abortSignal) {
     abortHandler = () => session.disconnect();
     abortSignal.addEventListener("abort", abortHandler, { once: true });
+    if (abortSignal.aborted) {
+      session.disconnect();
+      return session;
+    }
   }
 
   const doSetup = async () => {

package/src/internal.ts

@@ -33,6 +33,7 @@ export {
 // Message utilities
 export { getThreadMessageText } from "./utils/text";
 export { toMessagePartStatus } from "./utils/normalizePartStatus";
+export { notifyEventListeners } from "./utils/notify-event-listeners";
 export { resolveToolApprovalResponse } from "./runtime/utils/resolveToolApprovalResponse";
 export { consumeSuggestionResult } from "./adapters/suggestion";
 

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

@@ -46,7 +46,15 @@ const createHost = () => {
   const execute = host.getModelContext().tools?.search?.execute;
   if (!execute) throw new Error("Expected the search tool to be available");
 
-  return { dispatchMessage, execute, host, postMessage };
+  const getToolCallId = () => {
+    const call = postMessage.mock.calls.find(
+      ([data]) => data.message.type === "tool-call",
+    );
+    if (!call) throw new Error("Expected a tool call to be posted");
+    return call[0].message.id as string;
+  };
+
+  return { dispatchMessage, execute, getToolCallId, host, postMessage };
 };
 
 beforeEach(() => {
@@ -60,14 +68,14 @@ afterEach(() => {
 
 describe("AssistantFrameHost", () => {
   it("resolves tool calls from frame results", async () => {
-    const { dispatchMessage, execute, host } = createHost();
+    const { dispatchMessage, execute, getToolCallId, host } = createHost();
     const result = Promise.resolve(
       execute({ query: "weather" }, executionContext),
     );
 
     dispatchMessage({
       type: "tool-result",
-      id: "tool-0",
+      id: getToolCallId(),
       result: "sunny",
     });
 
@@ -77,19 +85,27 @@ describe("AssistantFrameHost", () => {
   });
 
   it("rejects pending tool calls when disposed", async () => {
-    const { execute, host } = createHost();
+    const { execute, getToolCallId, host, postMessage } = createHost();
     const result = Promise.resolve(execute({}, executionContext));
+    const toolCallId = getToolCallId();
 
     host.dispose();
 
     await expect(result).rejects.toThrow(
       "AssistantFrameHost has been disposed",
     );
+    expect(postMessage).toHaveBeenLastCalledWith(
+      {
+        channel: FRAME_MESSAGE_CHANNEL,
+        message: { type: "tool-cancel", id: toolCallId },
+      },
+      "*",
+    );
     expect(vi.getTimerCount()).toBe(0);
   });
 
   it("rejects pending tool calls when execution is aborted", async () => {
-    const { execute, host } = createHost();
+    const { execute, getToolCallId, host, postMessage } = createHost();
     const abortController = new AbortController();
     const abortError = new Error("Run cancelled");
     abortError.name = "AbortError";
@@ -104,15 +120,58 @@ describe("AssistantFrameHost", () => {
     );
     const onRejected = vi.fn();
     void result.catch(onRejected);
+    const toolCallId = getToolCallId();
 
     abortController.abort(abortError);
     await Promise.resolve();
 
     expect(onRejected).toHaveBeenCalledWith(abortError);
+    expect(postMessage).toHaveBeenLastCalledWith(
+      {
+        channel: FRAME_MESSAGE_CHANNEL,
+        message: { type: "tool-cancel", id: toolCallId },
+      },
+      "*",
+    );
+    expect(vi.getTimerCount()).toBe(0);
+    host.dispose();
+  });
+
+  it("cancels tool calls when they time out", async () => {
+    const { execute, getToolCallId, host, postMessage } = createHost();
+    const result = Promise.resolve(execute({}, executionContext));
+    const toolCallId = getToolCallId();
+    const rejection = expect(result).rejects.toThrow(
+      'Tool call "search" timed out',
+    );
+
+    await vi.advanceTimersByTimeAsync(30000);
+
+    await rejection;
+    expect(postMessage).toHaveBeenLastCalledWith(
+      {
+        channel: FRAME_MESSAGE_CHANNEL,
+        message: { type: "tool-cancel", id: toolCallId },
+      },
+      "*",
+    );
     expect(vi.getTimerCount()).toBe(0);
     host.dispose();
   });
 
+  it("uses unique tool IDs across host instances", () => {
+    const first = createHost();
+    const second = createHost();
+
+    void first.execute({}, executionContext).catch(() => undefined);
+    void second.execute({}, executionContext).catch(() => undefined);
+
+    expect(first.getToolCallId()).not.toBe(second.getToolCallId());
+
+    first.host.dispose();
+    second.host.dispose();
+  });
+
   it("does not post tool calls when execution is already aborted", async () => {
     const { execute, host, postMessage } = createHost();
     const abortController = new AbortController();

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

@@ -2,6 +2,7 @@ import type { ModelContextProvider, ModelContext } from "../types";
 import type { Unsubscribe } from "../../types/unsubscribe";
 import type { Tool } from "assistant-stream";
 import { notifySubscribers as notifyStateSubscribers } from "../../subscribable/subscribable";
+import { generateId } from "../../utils/id";
 import {
   type FrameMessage,
   FRAME_MESSAGE_CHANNEL,
@@ -58,7 +59,6 @@ export class AssistantFrameHost implements ModelContextProvider {
       reject: (error: any) => void;
     }
   >();
-  private _requestCounter = 0;
   private _iframeWindow: Window;
   private _targetOrigin: string;
   private _disposed = false;
@@ -130,7 +130,7 @@ export class AssistantFrameHost implements ModelContextProvider {
     return this.sendRequest(
       {
         type: "tool-call",
-        id: `tool-${this._requestCounter++}`,
+        id: `tool-${generateId()}`,
         toolName,
         args,
       },
@@ -159,6 +159,7 @@ export class AssistantFrameHost implements ModelContextProvider {
         if (!abortSignal) return;
         const pending = this._pendingRequests.get(message.id);
         if (pending) {
+          this.cancelToolCall(message.id);
           pending.reject(getAbortReason(abortSignal));
           this._pendingRequests.delete(message.id);
         }
@@ -182,6 +183,7 @@ export class AssistantFrameHost implements ModelContextProvider {
       timeoutId = setTimeout(() => {
         const pending = this._pendingRequests.get(message.id);
         if (pending) {
+          this.cancelToolCall(message.id);
           pending.reject(new Error(timeoutMessage));
           this._pendingRequests.delete(message.id);
         }
@@ -195,6 +197,16 @@ 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 requestContext() {
     this._iframeWindow.postMessage(
       {
@@ -225,7 +237,8 @@ export class AssistantFrameHost implements ModelContextProvider {
     window.removeEventListener("message", this.handleMessage);
     this._subscribers.clear();
     const error = new Error("AssistantFrameHost has been disposed");
-    for (const pending of this._pendingRequests.values()) {
+    for (const [id, pending] of this._pendingRequests) {
+      this.cancelToolCall(id);
       pending.reject(error);
     }
     this._pendingRequests.clear();