@assistant-ui/core 0.3.12 → 0.3.14

package/dist/utils/composite-context-provider.js

@@ -1,25 +1,41 @@
 import { mergeModelContexts } from "../model-context/types.js";
+import { notifySubscribers } from "../subscribable/subscribable.js";
 //#region src/utils/composite-context-provider.ts
 var CompositeContextProvider = class {
-	_providers = /* @__PURE__ */ new Set();
+	_providers = /* @__PURE__ */ new Map();
+	_providerUnsubscribes = /* @__PURE__ */ new Map();
 	getModelContext() {
-		return mergeModelContexts(this._providers);
+		return mergeModelContexts(new Set(this._providers.values()));
 	}
 	registerModelContextProvider(provider) {
-		this._providers.add(provider);
-		const unsubscribe = provider.subscribe?.(() => {
-			this.notifySubscribers();
-		});
+		const id = Symbol();
+		this._providers.set(id, provider);
+		let unsubscribe;
+		try {
+			unsubscribe = provider.subscribe?.(() => {
+				this.notifySubscribers();
+			});
+		} catch (error) {
+			this._providers.delete(id);
+			try {
+				this.notifySubscribers();
+			} catch (notifyError) {
+				console.error(notifyError);
+			}
+			throw error;
+		}
+		this._providerUnsubscribes.set(id, unsubscribe);
 		this.notifySubscribers();
 		return () => {
-			this._providers.delete(provider);
-			unsubscribe?.();
+			this._providers.delete(id);
+			this._providerUnsubscribes.get(id)?.();
+			this._providerUnsubscribes.delete(id);
 			this.notifySubscribers();
 		};
 	}
 	_subscribers = /* @__PURE__ */ new Set();
 	notifySubscribers() {
-		for (const callback of this._subscribers) callback();
+		notifySubscribers(this._subscribers);
 	}
 	subscribe(callback) {
 		this._subscribers.add(callback);

package/dist/utils/composite-context-provider.js.map

@@ -1 +1 @@
-{"version":3,"file":"composite-context-provider.js","names":["ModelContextProvider","mergeModelContexts","CompositeContextProvider","_providers","Set","getModelContext","registerModelContextProvider","provider","add","unsubscribe","subscribe","notifySubscribers","delete","_subscribers","callback"],"sources":["../../src/utils/composite-context-provider.ts"],"sourcesContent":["import {\n  type ModelContextProvider,\n  mergeModelContexts,\n} from \"../model-context/types\";\n\nexport class CompositeContextProvider implements ModelContextProvider {\n  private _providers = new Set<ModelContextProvider>();\n\n  getModelContext() {\n    return mergeModelContexts(this._providers);\n  }\n\n  registerModelContextProvider(provider: ModelContextProvider) {\n    this._providers.add(provider);\n    const unsubscribe = provider.subscribe?.(() => {\n      this.notifySubscribers();\n    });\n    this.notifySubscribers();\n    return () => {\n      this._providers.delete(provider);\n      unsubscribe?.();\n      this.notifySubscribers();\n    };\n  }\n\n  private _subscribers = new Set<() => void>();\n\n  notifySubscribers() {\n    for (const callback of this._subscribers) callback();\n  }\n\n  subscribe(callback: () => void) {\n    this._subscribers.add(callback);\n    return () => {\n      this._subscribers.delete(callback);\n    };\n  }\n}\n"],"mappings":";;AAKA,IAAaE,2BAAb,MAAsE;CACpE,6BAAqB,IAAIE,IAA0B;CAEnDC,kBAAkB;EAChB,OAAOJ,mBAAmB,KAAKE,UAAU;CAC3C;CAEAG,6BAA6BC,UAAgC;EAC3D,KAAKJ,WAAWK,IAAID,QAAQ;EAC5B,MAAME,cAAcF,SAASG,kBAAkB;GAC7C,KAAKC,kBAAkB;EACzB,CAAC;EACD,KAAKA,kBAAkB;EACvB,aAAa;GACX,KAAKR,WAAWS,OAAOL,QAAQ;GAC/BE,cAAc;GACd,KAAKE,kBAAkB;EACzB;CACF;CAEA,+BAAuB,IAAIP,IAAgB;CAE3CO,oBAAoB;EAClB,KAAK,MAAMG,YAAY,KAAKD,cAAcC,SAAS;CACrD;CAEAJ,UAAUI,UAAsB;EAC9B,KAAKD,aAAaL,IAAIM,QAAQ;EAC9B,aAAa;GACX,KAAKD,aAAaD,OAAOE,QAAQ;EACnC;CACF;AACF"}
+{"version":3,"file":"composite-context-provider.js","names":["ModelContextProvider","mergeModelContexts","notifySubscribers","notifyStateSubscribers","Unsubscribe","CompositeContextProvider","_providers","Map","_providerUnsubscribes","getModelContext","Set","values","registerModelContextProvider","provider","id","Symbol","set","unsubscribe","subscribe","error","delete","notifyError","console","get","_subscribers","callback","add"],"sources":["../../src/utils/composite-context-provider.ts"],"sourcesContent":["import {\n  type ModelContextProvider,\n  mergeModelContexts,\n} from \"../model-context/types\";\nimport { notifySubscribers as notifyStateSubscribers } from \"../subscribable/subscribable\";\nimport type { Unsubscribe } from \"../types/unsubscribe\";\n\nexport class CompositeContextProvider implements ModelContextProvider {\n  private _providers = new Map<symbol, ModelContextProvider>();\n  private _providerUnsubscribes = new Map<symbol, Unsubscribe | undefined>();\n\n  getModelContext() {\n    return mergeModelContexts(new Set(this._providers.values()));\n  }\n\n  registerModelContextProvider(provider: ModelContextProvider) {\n    const id = Symbol();\n    this._providers.set(id, provider);\n    let unsubscribe: Unsubscribe | undefined;\n    try {\n      unsubscribe = provider.subscribe?.(() => {\n        this.notifySubscribers();\n      });\n    } catch (error) {\n      this._providers.delete(id);\n      try {\n        this.notifySubscribers();\n      } catch (notifyError) {\n        console.error(notifyError);\n      }\n      throw error;\n    }\n    this._providerUnsubscribes.set(id, unsubscribe);\n    this.notifySubscribers();\n    return () => {\n      this._providers.delete(id);\n      const unsubscribe = this._providerUnsubscribes.get(id);\n      unsubscribe?.();\n      this._providerUnsubscribes.delete(id);\n      this.notifySubscribers();\n    };\n  }\n\n  private _subscribers = new Set<() => void>();\n\n  notifySubscribers() {\n    notifyStateSubscribers(this._subscribers);\n  }\n\n  subscribe(callback: () => void) {\n    this._subscribers.add(callback);\n    return () => {\n      this._subscribers.delete(callback);\n    };\n  }\n}\n"],"mappings":";;;AAOA,IAAaK,2BAAb,MAAsE;CACpE,6BAAqB,IAAIE,IAAkC;CAC3D,wCAAgC,IAAIA,IAAqC;CAEzEE,kBAAkB;EAChB,OAAOR,mBAAmB,IAAIS,IAAI,KAAKJ,WAAWK,OAAO,CAAC,CAAC;CAC7D;CAEAC,6BAA6BC,UAAgC;EAC3D,MAAMC,KAAKC,OAAO;EAClB,KAAKT,WAAWU,IAAIF,IAAID,QAAQ;EAChC,IAAII;EACJ,IAAI;GACFA,cAAcJ,SAASK,kBAAkB;IACvC,KAAKhB,kBAAkB;GACzB,CAAC;EACH,SAASiB,OAAO;GACd,KAAKb,WAAWc,OAAON,EAAE;GACzB,IAAI;IACF,KAAKZ,kBAAkB;GACzB,SAASmB,aAAa;IACpBC,QAAQH,MAAME,WAAW;GAC3B;GACA,MAAMF;EACR;EACA,KAAKX,sBAAsBQ,IAAIF,IAAIG,WAAW;EAC9C,KAAKf,kBAAkB;EACvB,aAAa;GACX,KAAKI,WAAWc,OAAON,EAAE;GAEzBG,KADyBT,sBAAsBe,IAAIT,EACnDG,CAAW,GAAG;GACd,KAAKT,sBAAsBY,OAAON,EAAE;GACpC,KAAKZ,kBAAkB;EACzB;CACF;CAEA,+BAAuB,IAAIQ,IAAgB;CAE3CR,oBAAoB;EAClBC,kBAAuB,KAAKqB,YAAY;CAC1C;CAEAN,UAAUO,UAAsB;EAC9B,KAAKD,aAAaE,IAAID,QAAQ;EAC9B,aAAa;GACX,KAAKD,aAAaJ,OAAOK,QAAQ;EACnC;CACF;AACF"}

package/dist/utils/notify-event-listeners.d.ts

@@ -1,6 +1,6 @@
 //#region src/utils/notify-event-listeners.d.ts
-type EventListener = (payload?: unknown) => void;
-declare const notifyEventListeners: (listeners: Iterable<EventListener>, payload: unknown, errorContext: string) => void;
+type EventListener<T> = (payload: T) => unknown;
+declare const notifyEventListeners: <T>(listeners: Iterable<EventListener<T>>, payloadOrFactory: T | (() => T), errorContext: string) => void;
 //#endregion
 export { notifyEventListeners };
 //# sourceMappingURL=notify-event-listeners.d.ts.map

package/dist/utils/notify-event-listeners.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"notify-event-listeners.d.ts","names":[],"sources":["../../src/utils/notify-event-listeners.ts"],"mappings":";KAAK,iBAAiB;cAET,uBACX,WAAW,SAAS,gBACpB,kBACA"}
+{"version":3,"file":"notify-event-listeners.d.ts","names":[],"sources":["../../src/utils/notify-event-listeners.ts"],"mappings":";KAAK,cAAc,MAAM,SAAS;cAGrB,uBAAwB,GACnC,WAAW,SAAS,cAAc,KAClC,kBAAkB,WAAW,IAC7B"}

package/dist/utils/notify-event-listeners.js

@@ -1,10 +1,10 @@
 //#region src/utils/notify-event-listeners.ts
-const notifyEventListeners = (listeners, payload, errorContext) => {
+const notifyEventListeners = (listeners, payloadOrFactory, errorContext) => {
 	const reportError = (error) => {
 		console.error(`[assistant-ui] ${errorContext} listener threw an error`, error);
 	};
 	for (const listener of listeners) try {
-		const result = listener(payload);
+		const result = listener(typeof payloadOrFactory === "function" ? payloadOrFactory() : payloadOrFactory);
 		if (result !== null && (typeof result === "object" || typeof result === "function") && "then" in result && typeof result.then === "function") Promise.resolve(result).catch(reportError);
 	} catch (error) {
 		reportError(error);

package/dist/utils/notify-event-listeners.js.map

@@ -1 +1 @@
-{"version":3,"file":"notify-event-listeners.js","names":["EventListener","payload","notifyEventListeners","listeners","Iterable","errorContext","reportError","error","console","listener","result","then","Promise","resolve","catch"],"sources":["../../src/utils/notify-event-listeners.ts"],"sourcesContent":["type EventListener = (payload?: unknown) => void;\n\nexport const notifyEventListeners = (\n  listeners: Iterable<EventListener>,\n  payload: unknown,\n  errorContext: string,\n) => {\n  const reportError = (error: unknown) => {\n    console.error(\n      `[assistant-ui] ${errorContext} listener threw an error`,\n      error,\n    );\n  };\n\n  for (const listener of listeners) {\n    try {\n      const result = listener(payload) as unknown;\n      if (\n        result !== null &&\n        (typeof result === \"object\" || typeof result === \"function\") &&\n        \"then\" in result &&\n        typeof result.then === \"function\"\n      ) {\n        void Promise.resolve(result).catch(reportError);\n      }\n    } catch (error) {\n      reportError(error);\n    }\n  }\n};\n"],"mappings":";AAEA,MAAaE,wBACXC,WACAF,SACAI,iBACG;CACH,MAAMC,eAAeC,UAAmB;EACtCC,QAAQD,MACN,kBAAkBF,aAAY,2BAC9BE,KACF;CACF;CAEA,KAAK,MAAME,YAAYN,WACrB,IAAI;EACF,MAAMO,SAASD,SAASR,OAAO;EAC/B,IACES,WAAW,SACV,OAAOA,WAAW,YAAY,OAAOA,WAAW,eACjD,UAAUA,UACV,OAAOA,OAAOC,SAAS,YAEvB,QAAaE,QAAQH,MAAM,CAAC,CAACI,MAAMR,WAAW;CAElD,SAASC,OAAO;EACdD,YAAYC,KAAK;CACnB;AAEJ"}
+{"version":3,"file":"notify-event-listeners.js","names":["EventListener","payload","T","notifyEventListeners","listeners","Iterable","payloadOrFactory","errorContext","reportError","error","console","listener","result","then","Promise","resolve","catch"],"sources":["../../src/utils/notify-event-listeners.ts"],"sourcesContent":["type EventListener<T> = (payload: T) => unknown;\n\n// A function payload is indistinguishable from a factory and gets invoked; wrap a function-typed payload in a factory.\nexport const notifyEventListeners = <T>(\n  listeners: Iterable<EventListener<T>>,\n  payloadOrFactory: T | (() => T),\n  errorContext: string,\n) => {\n  const reportError = (error: unknown) => {\n    console.error(\n      `[assistant-ui] ${errorContext} listener threw an error`,\n      error,\n    );\n  };\n\n  for (const listener of listeners) {\n    try {\n      const result = listener(\n        typeof payloadOrFactory === \"function\"\n          ? (payloadOrFactory as () => T)()\n          : payloadOrFactory,\n      );\n      if (\n        result !== null &&\n        (typeof result === \"object\" || typeof result === \"function\") &&\n        \"then\" in result &&\n        typeof result.then === \"function\"\n      ) {\n        void Promise.resolve(result).catch(reportError);\n      }\n    } catch (error) {\n      reportError(error);\n    }\n  }\n};\n"],"mappings":";AAGA,MAAaG,wBACXC,WACAE,kBACAC,iBACG;CACH,MAAMC,eAAeC,UAAmB;EACtCC,QAAQD,MACN,kBAAkBF,aAAY,2BAC9BE,KACF;CACF;CAEA,KAAK,MAAME,YAAYP,WACrB,IAAI;EACF,MAAMQ,SAASD,SACb,OAAOL,qBAAqB,aACvBA,iBAA6B,IAC9BA,gBACN;EACA,IACEM,WAAW,SACV,OAAOA,WAAW,YAAY,OAAOA,WAAW,eACjD,UAAUA,UACV,OAAOA,OAAOC,SAAS,YAEvB,QAAaE,QAAQH,MAAM,CAAC,CAACI,MAAMR,WAAW;CAElD,SAASC,OAAO;EACdD,YAAYC,KAAK;CACnB;AAEJ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/core",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "Framework-agnostic core runtime for assistant-ui",
   "keywords": [
     "assistant",
@@ -59,7 +59,7 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "assistant-stream": "^0.3.37",
+    "assistant-stream": "^0.3.38",
     "nanoid": "^6.0.1"
   },
   "optionalDevDependencies": {
@@ -95,11 +95,11 @@
     "react-dom": "^19.2.8",
     "vitest": "^4.1.10",
     "zustand": "^5.0.14",
-    "@assistant-ui/store": "0.3.8",
-    "@assistant-ui/tap": "0.9.11",
-    "@assistant-ui/vite": "0.0.12",
-    "@assistant-ui/x-buildutils": "0.0.22",
-    "assistant-cloud": "0.1.39"
+    "@assistant-ui/store": "0.3.10",
+    "@assistant-ui/tap": "0.9.13",
+    "@assistant-ui/vite": "0.0.14",
+    "@assistant-ui/x-buildutils": "0.0.23",
+    "assistant-cloud": "0.1.41"
   },
   "publishConfig": {
     "access": "public",

package/src/adapters/speech.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { WebSpeechSynthesisAdapter } from "./speech";
+import { WebSpeechDictationAdapter, WebSpeechSynthesisAdapter } from "./speech";
 
 afterEach(() => {
   vi.restoreAllMocks();
@@ -86,3 +86,120 @@ describe("WebSpeechSynthesisAdapter", () => {
     );
   });
 });
+
+describe("WebSpeechDictationAdapter", () => {
+  const stubSpeechRecognition = () => {
+    const listeners = new Map<string, EventListener>();
+    class MockSpeechRecognition {
+      lang = "";
+      continuous = false;
+      interimResults = false;
+
+      addEventListener(type: string, listener: EventListener) {
+        listeners.set(type, listener);
+      }
+
+      start() {}
+      stop() {}
+      abort() {}
+    }
+    vi.stubGlobal("window", {
+      SpeechRecognition: MockSpeechRecognition,
+    });
+    return listeners;
+  };
+
+  it("continues notifying dictation listeners when one throws", () => {
+    const listeners = stubSpeechRecognition();
+    const listenerError = new Error("listener failed");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const session = new WebSpeechDictationAdapter().listen();
+    const laterStartListener = vi.fn();
+    const laterSpeechListener = vi.fn();
+    const laterEndListener = vi.fn();
+
+    session.onSpeechStart(() => {
+      throw listenerError;
+    });
+    session.onSpeechStart(laterStartListener);
+    session.onSpeech(() => {
+      throw listenerError;
+    });
+    session.onSpeech(laterSpeechListener);
+    session.onSpeechEnd(() => {
+      throw listenerError;
+    });
+    session.onSpeechEnd(laterEndListener);
+
+    const event = {
+      resultIndex: 0,
+      results: [
+        {
+          0: { transcript: "Hello" },
+          isFinal: true,
+        },
+      ],
+    } as unknown as Event;
+
+    expect(() =>
+      listeners.get("speechstart")?.(new Event("speechstart")),
+    ).not.toThrow();
+    expect(() => listeners.get("result")?.(event)).not.toThrow();
+    expect(() => listeners.get("end")?.(new Event("end"))).not.toThrow();
+
+    expect(laterStartListener).toHaveBeenCalledOnce();
+    expect(laterSpeechListener).toHaveBeenCalledWith({
+      transcript: "Hello",
+      isFinal: true,
+    });
+    expect(laterEndListener).toHaveBeenCalledWith({
+      transcript: "Hello",
+    });
+    expect(consoleError).toHaveBeenCalledTimes(3);
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] Dictation listener threw an error",
+      listenerError,
+    );
+  });
+
+  it("isolates async failures and payload mutations", async () => {
+    const listeners = stubSpeechRecognition();
+    const listenerError = new Error("async listener failed");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const session = new WebSpeechDictationAdapter().listen();
+    const laterListener = vi.fn();
+
+    session.onSpeech(async (result) => {
+      result.transcript = "Changed";
+      result.isFinal = false;
+      throw listenerError;
+    });
+    session.onSpeech(laterListener);
+
+    const event = {
+      resultIndex: 0,
+      results: [
+        {
+          0: { transcript: "Hello" },
+          isFinal: true,
+        },
+      ],
+    } as unknown as Event;
+
+    expect(() => listeners.get("result")?.(event)).not.toThrow();
+    expect(laterListener).toHaveBeenCalledWith({
+      transcript: "Hello",
+      isFinal: true,
+    });
+    await vi.waitFor(() => {
+      expect(consoleError).toHaveBeenCalledWith(
+        "[assistant-ui] Dictation listener threw an error",
+        listenerError,
+      );
+    });
+  });
+});

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,75 @@ describe("createVoiceSession", () => {
     expect(controls.mute).not.toHaveBeenCalled();
   });
 
+  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();
+
+    session.disconnect();
+    session.disconnect();
+    abortController.abort();
+
+    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;
+    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(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,14 @@ export function createVoiceSession(
       return isMuted;
     },
     disconnect: () => {
-      controls?.disconnect();
-      cleanup();
+      if (disconnected) return;
+      disconnected = true;
+      detachAbortHandler();
+      try {
+        controls?.disconnect();
+      } finally {
+        cleanup();
+      }
     },
     mute: () => {
       controls?.mute();
@@ -161,10 +162,9 @@ 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 });
   }
 
   const doSetup = async () => {

package/src/index.ts

@@ -208,6 +208,7 @@ export type {
   AssistantError,
 } from "./types/error";
 export { toAssistantError, isAssistantError } from "./types/error";
+export { MessageNotSentError, isMessageNotSentError } from "./types/error";
 
 export type {
   RuntimeCapabilities,
@@ -346,6 +347,7 @@ export {
 // Remote Thread List (user-facing)
 export type {
   RemoteThreadListAdapter,
+  RuntimeAdapters,
   RemoteThreadListOptions,
   RemoteThreadListProviderComponent,
   RemoteThreadInitializeResponse,

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

@@ -144,4 +144,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,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 {
   type FrameMessage,
   FRAME_MESSAGE_CHANNEL,
@@ -207,7 +208,7 @@ export class AssistantFrameHost implements ModelContextProvider {
   }
 
   private notifySubscribers() {
-    this._subscribers.forEach((callback) => callback());
+    notifyStateSubscribers(this._subscribers);
   }
 
   getModelContext(): ModelContext {