@assistant-ui/core 0.2.21 → 0.2.22

package/src/adapters/voice.test.ts

@@ -0,0 +1,130 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  createVoiceSession,
+  type VoiceSessionControls,
+  type VoiceSessionHelpers,
+} from "./voice";
+
+const createTestSession = () => {
+  let helpers: VoiceSessionHelpers | undefined;
+  const session = createVoiceSession({}, async (sessionHelpers) => {
+    helpers = sessionHelpers;
+    return {
+      disconnect: vi.fn(),
+      mute: vi.fn(),
+      unmute: vi.fn(),
+    };
+  });
+
+  if (!helpers) throw new Error("Voice session setup did not start");
+  return { helpers, session };
+};
+
+const createPendingTestSession = () => {
+  let resolveControls!: (controls: VoiceSessionControls) => void;
+  const controlsPromise = new Promise<VoiceSessionControls>((resolve) => {
+    resolveControls = resolve;
+  });
+  const controls = {
+    disconnect: vi.fn(),
+    mute: vi.fn(),
+    unmute: vi.fn(),
+  };
+  const session = createVoiceSession({}, () => controlsPromise);
+
+  return {
+    controls,
+    controlsPromise,
+    resolveControls: () => resolveControls(controls),
+    session,
+  };
+};
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("createVoiceSession", () => {
+  it("applies mute requested while setup is pending", async () => {
+    const { controls, controlsPromise, resolveControls, session } =
+      createPendingTestSession();
+
+    session.mute();
+
+    expect(session.isMuted).toBe(true);
+    expect(controls.mute).not.toHaveBeenCalled();
+
+    resolveControls();
+    await controlsPromise;
+
+    expect(controls.mute).toHaveBeenCalledOnce();
+  });
+
+  it("does not apply stale mute after unmuting during setup", async () => {
+    const { controls, controlsPromise, resolveControls, session } =
+      createPendingTestSession();
+
+    session.mute();
+    session.unmute();
+    resolveControls();
+    await controlsPromise;
+
+    expect(session.isMuted).toBe(false);
+    expect(controls.mute).not.toHaveBeenCalled();
+  });
+
+  it("continues notifying listeners when one throws", () => {
+    const listenerError = new Error("listener failed");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const { helpers, session } = createTestSession();
+
+    const transcriptListener = vi.fn();
+    session.onTranscript(() => {
+      throw listenerError;
+    });
+    session.onTranscript(transcriptListener);
+
+    const modeListener = vi.fn();
+    session.onModeChange(() => {
+      throw listenerError;
+    });
+    session.onModeChange(modeListener);
+
+    const volumeListener = vi.fn();
+    session.onVolumeChange(() => {
+      throw listenerError;
+    });
+    session.onVolumeChange(volumeListener);
+
+    const statusListener = vi.fn();
+    session.onStatusChange(() => {
+      throw listenerError;
+    });
+    session.onStatusChange(statusListener);
+
+    helpers.emitTranscript({ role: "assistant", text: "hello" });
+    helpers.emitMode("speaking");
+    helpers.emitVolume(0.5);
+    helpers.end("finished");
+
+    expect(transcriptListener).toHaveBeenCalledWith({
+      role: "assistant",
+      text: "hello",
+    });
+    expect(modeListener).toHaveBeenCalledWith("speaking");
+    expect(volumeListener).toHaveBeenCalledWith(0.5);
+    expect(statusListener).toHaveBeenCalledWith({
+      type: "ended",
+      reason: "finished",
+      error: undefined,
+    });
+    expect(helpers.isDisposed()).toBe(true);
+    expect(consoleError).toHaveBeenCalledTimes(4);
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] Voice session listener threw an error",
+      listenerError,
+    );
+  });
+});

package/src/adapters/voice.ts

@@ -57,6 +57,22 @@ 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>,
@@ -85,25 +101,25 @@ export function createVoiceSession(
     setStatus: (status) => {
       if (disposed) return;
       currentStatus = status;
-      for (const cb of statusCbs) cb(status);
+      notifyListeners(statusCbs, status);
     },
     end: (reason, error?) => {
       if (disposed) return;
       currentStatus = { type: "ended", reason, error };
-      for (const cb of statusCbs) cb(currentStatus);
+      notifyListeners(statusCbs, currentStatus);
       cleanup();
     },
     emitTranscript: (item) => {
       if (disposed) return;
-      for (const cb of transcriptCbs) cb(item);
+      notifyListeners(transcriptCbs, item);
     },
     emitMode: (mode) => {
       if (disposed) return;
-      for (const cb of modeCbs) cb(mode);
+      notifyListeners(modeCbs, mode);
     },
     emitVolume: (volume) => {
       if (disposed) return;
-      for (const cb of volumeCbs) cb(volume);
+      notifyListeners(volumeCbs, volume);
     },
     isDisposed: () => disposed,
   };
@@ -155,7 +171,11 @@ export function createVoiceSession(
     try {
       if (disposed) return;
       controls = await setup(helpers);
-      if (disposed) controls.disconnect();
+      if (disposed) {
+        controls.disconnect();
+      } else if (isMuted) {
+        controls.mute();
+      }
     } catch (error) {
       helpers.end("error", error);
     }

package/src/internal.ts

@@ -41,6 +41,7 @@ export { CompositeContextProvider } from "./utils/composite-context-provider";
 // Shared attachment data-URL encoder, reused by framework adapters so the
 // FileReader fallback lives in one place.
 export { getFileDataURL } from "./adapters/attachment";
+export { isCreateAttachment } from "./types/attachment";
 
 // Streaming-stable tool-args stringifier, reused by framework adapters so the
 // key-order stabilization lives in one place.
@@ -53,6 +54,10 @@ export {
 // validation lives in one place.
 export { isJSONValue, isRecord } from "./utils/json/is-json";
 
+// Data-URL decoder and http(s) matcher, reused by framework adapters so the
+// outbound part conversion lives in one place.
+export { httpUrlPattern, parseDataUrl } from "./utils/data-url";
+
 // Runtime extras helper for external-store adapters. Internal because the
 // tap-native runtime path replaces the `thread.extras` side-channel it wraps.
 export {

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

@@ -0,0 +1,100 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { AssistantFrameHost } from "./host";
+import { type FrameMessage, FRAME_MESSAGE_CHANNEL } from "./types";
+
+const executionContext = {
+  toolCallId: "tool-call",
+  abortSignal: new AbortController().signal,
+  human: async () => undefined,
+};
+
+const createHost = () => {
+  let handleMessage: ((event: MessageEvent) => void) | undefined;
+  const addEventListener = vi.fn(
+    (_type: string, listener: EventListenerOrEventListenerObject) => {
+      handleMessage = listener as (event: MessageEvent) => void;
+    },
+  );
+  const removeEventListener = vi.fn();
+  vi.stubGlobal("window", { addEventListener, removeEventListener });
+
+  const postMessage = vi.fn();
+  const iframeWindow = { postMessage } as unknown as Window;
+  const host = new AssistantFrameHost(iframeWindow);
+
+  const dispatchMessage = (message: FrameMessage) =>
+    handleMessage?.({
+      source: iframeWindow,
+      data: {
+        channel: FRAME_MESSAGE_CHANNEL,
+        message,
+      },
+    } as unknown as MessageEvent);
+
+  dispatchMessage({
+    type: "model-context-update",
+    context: {
+      tools: {
+        search: {
+          type: "frontend",
+          parameters: { type: "object", properties: {} },
+        },
+      },
+    },
+  });
+
+  const execute = host.getModelContext().tools?.search?.execute;
+  if (!execute) throw new Error("Expected the search tool to be available");
+
+  return { dispatchMessage, execute, host, postMessage };
+};
+
+beforeEach(() => {
+  vi.useFakeTimers();
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+  vi.unstubAllGlobals();
+});
+
+describe("AssistantFrameHost", () => {
+  it("resolves tool calls from frame results", async () => {
+    const { dispatchMessage, execute, host } = createHost();
+    const result = Promise.resolve(
+      execute({ query: "weather" }, executionContext),
+    );
+
+    dispatchMessage({
+      type: "tool-result",
+      id: "tool-0",
+      result: "sunny",
+    });
+
+    await expect(result).resolves.toBe("sunny");
+    expect(vi.getTimerCount()).toBe(0);
+    host.dispose();
+  });
+
+  it("rejects pending tool calls when disposed", async () => {
+    const { execute, host } = createHost();
+    const result = Promise.resolve(execute({}, executionContext));
+
+    host.dispose();
+
+    await expect(result).rejects.toThrow(
+      "AssistantFrameHost has been disposed",
+    );
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it("rejects tool calls made after disposal without posting a request", async () => {
+    const { execute, host, postMessage } = createHost();
+    host.dispose();
+
+    await expect(execute({}, executionContext)).rejects.toThrow(
+      "AssistantFrameHost has been disposed",
+    );
+    expect(postMessage).toHaveBeenCalledOnce();
+  });
+});

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

@@ -53,6 +53,7 @@ export class AssistantFrameHost implements ModelContextProvider {
   private _requestCounter = 0;
   private _iframeWindow: Window;
   private _targetOrigin: string;
+  private _disposed = false;
 
   constructor(iframeWindow: Window, targetOrigin: string = "*") {
     this._iframeWindow = iframeWindow;
@@ -130,6 +131,10 @@ export class AssistantFrameHost implements ModelContextProvider {
     timeout = 30000,
     timeoutMessage = "Request timed out",
   ): Promise<any> {
+    if (this._disposed) {
+      return Promise.reject(new Error("AssistantFrameHost has been disposed"));
+    }
+
     return new Promise((resolve, reject) => {
       this._pendingRequests.set(message.id, { resolve, reject });
 
@@ -188,8 +193,13 @@ export class AssistantFrameHost implements ModelContextProvider {
   }
 
   dispose() {
+    this._disposed = true;
     window.removeEventListener("message", this.handleMessage);
     this._subscribers.clear();
+    const error = new Error("AssistantFrameHost has been disposed");
+    for (const pending of this._pendingRequests.values()) {
+      pending.reject(error);
+    }
     this._pendingRequests.clear();
   }
 }

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

@@ -0,0 +1,83 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { AssistantFrameProvider } from "./provider";
+import { FRAME_MESSAGE_CHANNEL } from "./types";
+
+describe("AssistantFrameProvider", () => {
+  let messageHandler: ((event: MessageEvent) => void) | undefined;
+  let parentWindow: Window;
+
+  beforeEach(() => {
+    parentWindow = {
+      postMessage: vi.fn(),
+    } as unknown as Window;
+
+    Object.defineProperty(window, "parent", {
+      value: parentWindow,
+      configurable: true,
+    });
+
+    vi.spyOn(window, "addEventListener").mockImplementation(
+      (event, listener) => {
+        if (event === "message" && typeof listener === "function") {
+          messageHandler = listener as (event: MessageEvent) => void;
+        }
+      },
+    );
+    vi.spyOn(window, "removeEventListener").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    AssistantFrameProvider.dispose();
+    vi.restoreAllMocks();
+  });
+
+  it("only accepts tool calls from the parent window", async () => {
+    const execute = vi.fn(async () => "result");
+    AssistantFrameProvider.addModelContextProvider(
+      {
+        getModelContext: () => ({
+          tools: {
+            sensitiveTool: { execute },
+          },
+        }),
+      },
+      "https://parent.example",
+    );
+
+    const toolCall = {
+      channel: FRAME_MESSAGE_CHANNEL,
+      message: {
+        type: "tool-call",
+        id: "tool-call-1",
+        toolName: "sensitiveTool",
+        args: {},
+      },
+    };
+    const otherWindow = {
+      postMessage: vi.fn(),
+    } as unknown as Window;
+
+    messageHandler?.(
+      new MessageEvent("message", {
+        data: toolCall,
+        origin: "https://parent.example",
+        source: otherWindow,
+      }),
+    );
+
+    expect(execute).not.toHaveBeenCalled();
+
+    messageHandler?.(
+      new MessageEvent("message", {
+        data: toolCall,
+        origin: "https://parent.example",
+        source: parentWindow,
+      }),
+    );
+
+    await vi.waitFor(() => expect(execute).toHaveBeenCalledOnce());
+  });
+});

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

@@ -59,6 +59,7 @@ export class AssistantFrameProvider {
   private handleMessage(event: MessageEvent) {
     if (this._targetOrigin !== "*" && event.origin !== this._targetOrigin)
       return;
+    if (event.source !== window.parent) return;
     if (event.data?.channel !== FRAME_MESSAGE_CHANNEL) return;
 
     const message = event.data.message as FrameMessage;

package/src/react/adapters/LocalStorageThreadListAdapter.test.ts

@@ -207,6 +207,88 @@ describe("createLocalStorageAdapter", () => {
     ]);
   });
 
+  it("preserves concurrent metadata mutations across adapters", async () => {
+    const threadsKey = "@assistant-ui:threads";
+    const values = new Map<string, string>();
+    let metadataReads = 0;
+    let metadataWrites = 0;
+    let markFirstWriteStarted!: () => void;
+    let releaseFirstWrite!: () => void;
+    const firstWriteStarted = new Promise<void>((resolve) => {
+      markFirstWriteStarted = resolve;
+    });
+    const firstWriteCanFinish = new Promise<void>((resolve) => {
+      releaseFirstWrite = resolve;
+    });
+    const storage: AsyncStorageLike = {
+      getItem: async (key) => {
+        if (key === threadsKey) metadataReads += 1;
+        return values.get(key) ?? null;
+      },
+      setItem: async (key, value) => {
+        if (key === threadsKey) {
+          metadataWrites += 1;
+          if (metadataWrites === 1) {
+            markFirstWriteStarted();
+            await firstWriteCanFinish;
+          }
+        }
+        values.set(key, value);
+      },
+      removeItem: async (key) => {
+        values.delete(key);
+      },
+    };
+    const firstAdapter = createLocalStorageAdapter({ storage });
+    const secondAdapter = createLocalStorageAdapter({ storage });
+
+    const firstInitialization = firstAdapter.initialize("thread-1");
+    await firstWriteStarted;
+    const secondInitialization = secondAdapter.initialize("thread-2");
+    const readsWhileFirstWritePending = metadataReads;
+
+    releaseFirstWrite();
+    await Promise.all([firstInitialization, secondInitialization]);
+
+    expect(readsWhileFirstWritePending).toBe(1);
+    expect(JSON.parse(values.get(threadsKey) ?? "")).toEqual([
+      { remoteId: "thread-2", status: "regular" },
+      { remoteId: "thread-1", status: "regular" },
+    ]);
+  });
+
+  it("continues processing mutations after a storage failure", async () => {
+    const threadsKey = "@assistant-ui:threads";
+    const values = new Map<string, string>();
+    let shouldFail = true;
+    const storage: AsyncStorageLike = {
+      getItem: async (key) => values.get(key) ?? null,
+      setItem: async (key, value) => {
+        if (shouldFail) {
+          shouldFail = false;
+          throw new Error("Storage unavailable");
+        }
+        values.set(key, value);
+      },
+      removeItem: async (key) => {
+        values.delete(key);
+      },
+    };
+    const adapter = createLocalStorageAdapter({ storage });
+
+    await expect(adapter.initialize("thread-1")).rejects.toThrow(
+      "Storage unavailable",
+    );
+    await expect(adapter.initialize("thread-2")).resolves.toEqual({
+      remoteId: "thread-2",
+      externalId: undefined,
+    });
+
+    expect(JSON.parse(values.get(threadsKey) ?? "")).toEqual([
+      { remoteId: "thread-2", status: "regular" },
+    ]);
+  });
+
   it("includes the thread id when a stored thread cannot be fetched", async () => {
     const storage = createStorage({
       "@assistant-ui:threads": JSON.stringify([