@assistant-ui/core 0.3.13 → 0.3.15

package/src/adapters/speech.ts

@@ -1,4 +1,5 @@
 import type { Unsubscribe } from "../types/unsubscribe";
+import { notifyEventListeners } from "../utils/notify-event-listeners";
 
 export namespace SpeechSynthesisAdapter {
   export type Status =
@@ -22,21 +23,6 @@ export type SpeechSynthesisAdapter = {
   speak: (text: string) => SpeechSynthesisAdapter.Utterance;
 };
 
-const notifySpeechSynthesisListeners = (
-  listeners: Iterable<() => void>,
-): void => {
-  for (const listener of listeners) {
-    try {
-      listener();
-    } catch (error) {
-      console.error(
-        "[assistant-ui] Speech synthesis listener threw an error",
-        error,
-      );
-    }
-  }
-};
-
 export namespace DictationAdapter {
   export type Status =
     | {
@@ -79,7 +65,7 @@ export class WebSpeechSynthesisAdapter implements SpeechSynthesisAdapter {
       if (res.status.type === "ended") return;
 
       res.status = { type: "ended", reason, error };
-      notifySpeechSynthesisListeners(subscribers);
+      notifyEventListeners(subscribers, undefined, "Speech synthesis");
     };
 
     utterance.addEventListener("end", () => handleEnd("finished"));
@@ -97,7 +83,9 @@ export class WebSpeechSynthesisAdapter implements SpeechSynthesisAdapter {
         if (res.status.type === "ended") {
           let cancelled = false;
           queueMicrotask(() => {
-            if (!cancelled) notifySpeechSynthesisListeners([callback]);
+            if (!cancelled) {
+              notifyEventListeners([callback], undefined, "Speech synthesis");
+            }
           });
           return () => {
             cancelled = true;
@@ -270,7 +258,7 @@ export class WebSpeechDictationAdapter implements DictationAdapter {
     };
 
     recognition.addEventListener("speechstart", () => {
-      for (const cb of speechStartCallbacks) cb();
+      notifyEventListeners(speechStartCallbacks, undefined, "Dictation");
     });
 
     recognition.addEventListener("start", () => {
@@ -292,9 +280,17 @@ export class WebSpeechDictationAdapter implements DictationAdapter {
 
         if (result.isFinal) {
           finalTranscript += transcript;
-          for (const cb of speechCallbacks) cb({ transcript, isFinal: true });
+          notifyEventListeners(
+            speechCallbacks,
+            () => ({ transcript, isFinal: true }),
+            "Dictation",
+          );
         } else {
-          for (const cb of speechCallbacks) cb({ transcript, isFinal: false });
+          notifyEventListeners(
+            speechCallbacks,
+            () => ({ transcript, isFinal: false }),
+            "Dictation",
+          );
         }
       }
     });
@@ -309,8 +305,11 @@ export class WebSpeechDictationAdapter implements DictationAdapter {
         updateStatus({ type: "ended", reason: "stopped" });
       }
       if (finalTranscript) {
-        for (const cb of speechEndCallbacks)
-          cb({ transcript: finalTranscript });
+        notifyEventListeners(
+          speechEndCallbacks,
+          () => ({ transcript: finalTranscript }),
+          "Dictation",
+        );
         finalTranscript = "";
       }
     });

package/src/adapters/thread-history.ts

@@ -39,6 +39,8 @@ export interface MessageFormatAdapter<
 
 export type GenericThreadHistoryAdapter<TMessage> = {
   load(): Promise<MessageFormatRepository<TMessage>>;
+  /** Snapshot the current thread so later writes survive a switch. */
+  pin?(): void;
   append(item: MessageFormatItem<TMessage>): Promise<void>;
   update?(
     item: MessageFormatItem<TMessage>,

package/src/adapters/voice.test.ts

@@ -73,6 +73,140 @@ 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 = {
+      disconnect: vi.fn(),
+      mute: vi.fn(),
+      unmute: vi.fn(),
+    };
+    const session = createVoiceSession(
+      { abortSignal: abortController.signal },
+      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();
+  });
+
+  it("keeps abort teardown available after the session ends", 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.end("error");
+    abortController.abort();
+
+    expect(session.status).toEqual({
+      type: "ended",
+      reason: "error",
+      error: undefined,
+    });
+    expect(controls.disconnect).toHaveBeenCalledOnce();
+  });
+
+  it("cleans up when the adapter disconnect throws", async () => {
+    const disconnectError = new Error("disconnect failed");
+    let helpers: VoiceSessionHelpers | undefined;
+    const session = createVoiceSession({}, async (sessionHelpers) => {
+      helpers = sessionHelpers;
+      return {
+        disconnect: () => {
+          throw disconnectError;
+        },
+        mute: vi.fn(),
+        unmute: vi.fn(),
+      };
+    });
+    await Promise.resolve();
+    if (!helpers) throw new Error("Voice session setup did not start");
+    const transcriptListener = vi.fn();
+    session.onTranscript(transcriptListener);
+
+    expect(() => session.disconnect()).toThrow(disconnectError);
+    expect(helpers.isDisposed()).toBe(true);
+
+    helpers.emitTranscript({ role: "assistant", text: "stale" });
+    expect(transcriptListener).not.toHaveBeenCalled();
+  });
+
   it("continues notifying listeners when one throws", () => {
     const listenerError = new Error("listener failed");
     const consoleError = vi

package/src/adapters/voice.ts

@@ -1,4 +1,5 @@
 import type { Unsubscribe } from "../types/unsubscribe";
+import { notifyEventListeners } from "../utils/notify-event-listeners";
 
 export namespace RealtimeVoiceAdapter {
   export type Status =
@@ -57,22 +58,6 @@ export type VoiceSessionHelpers = {
   isDisposed: () => boolean;
 };
 
-const notifyListeners = <T>(
-  listeners: ReadonlySet<(value: T) => void>,
-  value: T,
-) => {
-  for (const listener of listeners) {
-    try {
-      listener(value);
-    } catch (error) {
-      console.error(
-        "[assistant-ui] Voice session listener threw an error",
-        error,
-      );
-    }
-  }
-};
-
 export function createVoiceSession(
   options: { abortSignal?: AbortSignal },
   setup: (helpers: VoiceSessionHelpers) => Promise<VoiceSessionControls>,
@@ -87,7 +72,17 @@ export function createVoiceSession(
   let currentStatus: RealtimeVoiceAdapter.Status = { type: "starting" };
   let isMuted = false;
   let disposed = false;
+  let disconnected = false;
   let controls: VoiceSessionControls | null = null;
+  const abortSignal = options.abortSignal;
+  let abortHandler: (() => void) | undefined;
+
+  const detachAbortHandler = () => {
+    if (abortHandler) {
+      abortSignal?.removeEventListener("abort", abortHandler);
+      abortHandler = undefined;
+    }
+  };
 
   const cleanup = () => {
     disposed = true;
@@ -101,25 +96,25 @@ export function createVoiceSession(
     setStatus: (status) => {
       if (disposed) return;
       currentStatus = status;
-      notifyListeners(statusCbs, status);
+      notifyEventListeners(statusCbs, status, "Voice session");
     },
     end: (reason, error?) => {
       if (disposed) return;
       currentStatus = { type: "ended", reason, error };
-      notifyListeners(statusCbs, currentStatus);
+      notifyEventListeners(statusCbs, currentStatus, "Voice session");
       cleanup();
     },
     emitTranscript: (item) => {
       if (disposed) return;
-      notifyListeners(transcriptCbs, item);
+      notifyEventListeners(transcriptCbs, item, "Voice session");
     },
     emitMode: (mode) => {
       if (disposed) return;
-      notifyListeners(modeCbs, mode);
+      notifyEventListeners(modeCbs, mode, "Voice session");
     },
     emitVolume: (volume) => {
       if (disposed) return;
-      notifyListeners(volumeCbs, volume);
+      notifyEventListeners(volumeCbs, volume, "Voice session");
     },
     isDisposed: () => disposed,
   };
@@ -132,8 +127,18 @@ export function createVoiceSession(
       return isMuted;
     },
     disconnect: () => {
-      controls?.disconnect();
-      cleanup();
+      if (disconnected) return;
+      disconnected = true;
+      detachAbortHandler();
+      if (currentStatus.type !== "ended") {
+        currentStatus = { type: "ended", reason: "cancelled" };
+        notifyEventListeners(statusCbs, currentStatus, "Voice session");
+      }
+      try {
+        controls?.disconnect();
+      } finally {
+        cleanup();
+      }
     },
     mute: () => {
       controls?.mute();
@@ -161,10 +166,13 @@ export function createVoiceSession(
     },
   };
 
-  if (options.abortSignal) {
-    options.abortSignal.addEventListener("abort", () => session.disconnect(), {
-      once: true,
-    });
+  if (abortSignal) {
+    abortHandler = () => session.disconnect();
+    abortSignal.addEventListener("abort", abortHandler, { once: true });
+    if (abortSignal.aborted) {
+      session.disconnect();
+      return session;
+    }
   }
 
   const doSetup = async () => {

package/src/index.ts

@@ -347,6 +347,7 @@ export {
 // Remote Thread List (user-facing)
 export type {
   RemoteThreadListAdapter,
+  RuntimeAdapters,
   RemoteThreadListOptions,
   RemoteThreadListProviderComponent,
   RemoteThreadInitializeResponse,

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();
@@ -144,4 +203,27 @@ describe("AssistantFrameHost", () => {
     );
     expect(postMessage).toHaveBeenCalledOnce();
   });
+
+  it("isolates subscriber errors while applying context updates", () => {
+    const { dispatchMessage, host } = createHost();
+    const error = new Error("subscriber failed");
+    const laterSubscriber = vi.fn();
+
+    host.subscribe(() => {
+      throw error;
+    });
+    host.subscribe(laterSubscriber);
+
+    expect(() =>
+      dispatchMessage({
+        type: "model-context-update",
+        context: { system: "frame instructions" },
+      }),
+    ).toThrow(error);
+
+    expect(host.getModelContext().system).toBe("frame instructions");
+    expect(laterSubscriber).toHaveBeenCalledOnce();
+
+    host.dispose();
+  });
 });

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

@@ -1,6 +1,8 @@
 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,
@@ -57,7 +59,6 @@ export class AssistantFrameHost implements ModelContextProvider {
       reject: (error: any) => void;
     }
   >();
-  private _requestCounter = 0;
   private _iframeWindow: Window;
   private _targetOrigin: string;
   private _disposed = false;
@@ -129,7 +130,7 @@ export class AssistantFrameHost implements ModelContextProvider {
     return this.sendRequest(
       {
         type: "tool-call",
-        id: `tool-${this._requestCounter++}`,
+        id: `tool-${generateId()}`,
         toolName,
         args,
       },
@@ -158,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);
         }
@@ -181,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);
         }
@@ -194,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(
       {
@@ -207,7 +220,7 @@ export class AssistantFrameHost implements ModelContextProvider {
   }
 
   private notifySubscribers() {
-    this._subscribers.forEach((callback) => callback());
+    notifyStateSubscribers(this._subscribers);
   }
 
   getModelContext(): ModelContext {
@@ -224,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();