@assistant-ui/core 0.2.20 → 0.2.22

package/src/adapters/attachment.test.ts

@@ -0,0 +1,107 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { getFileDataURL, SimpleImageAttachmentAdapter } from "./attachment";
+
+const originalFileReader = globalThis.FileReader;
+const originalBuffer = globalThis.Buffer;
+
+afterEach(() => {
+  globalThis.FileReader = originalFileReader;
+  globalThis.Buffer = originalBuffer;
+});
+
+describe("getFileDataURL", () => {
+  it("uses FileReader when available", async () => {
+    class FakeFileReader {
+      result: string | null = null;
+      onload: (() => void) | null = null;
+      onerror: ((error: unknown) => void) | null = null;
+      readAsDataURL(file: File) {
+        file
+          .arrayBuffer()
+          .then((buf) => {
+            this.result = `data:${file.type};base64,${originalBuffer.from(buf).toString("base64")}`;
+            this.onload?.();
+          })
+          .catch((error) => this.onerror?.(error));
+      }
+    }
+    globalThis.FileReader = FakeFileReader as unknown as typeof FileReader;
+
+    const file = new File(["hello"], "a.txt", { type: "text/plain" });
+    expect(await getFileDataURL(file)).toBe(
+      `data:text/plain;base64,${originalBuffer.from("hello").toString("base64")}`,
+    );
+  });
+
+  it("falls back to Buffer when FileReader is absent", async () => {
+    globalThis.FileReader = undefined as unknown as typeof FileReader;
+
+    const file = new File(["hello"], "a.txt", { type: "text/plain" });
+    expect(await getFileDataURL(file)).toBe(
+      `data:text/plain;base64,${originalBuffer.from("hello").toString("base64")}`,
+    );
+  });
+
+  it("defaults to application/octet-stream when the file has no type", async () => {
+    globalThis.FileReader = undefined as unknown as typeof FileReader;
+
+    const file = new File(["hello"], "a.bin", { type: "" });
+    expect(await getFileDataURL(file)).toBe(
+      `data:application/octet-stream;base64,${originalBuffer.from("hello").toString("base64")}`,
+    );
+  });
+
+  it("falls back to chunked btoa when neither FileReader nor Buffer exist", async () => {
+    globalThis.FileReader = undefined as unknown as typeof FileReader;
+    globalThis.Buffer = undefined as unknown as typeof Buffer;
+
+    const file = new File(["hello"], "a.txt", { type: "text/plain" });
+    expect(await getFileDataURL(file)).toBe(
+      `data:text/plain;base64,${originalBuffer.from("hello").toString("base64")}`,
+    );
+  });
+
+  it("encodes large inputs without RangeError on the btoa path", async () => {
+    globalThis.FileReader = undefined as unknown as typeof FileReader;
+    globalThis.Buffer = undefined as unknown as typeof Buffer;
+
+    const bytes = new Uint8Array(100_000);
+    for (let i = 0; i < bytes.length; i++) bytes[i] = i % 256;
+    const file = new File([bytes], "big.bin", {
+      type: "application/octet-stream",
+    });
+
+    expect(await getFileDataURL(file)).toBe(
+      `data:application/octet-stream;base64,${originalBuffer.from(bytes).toString("base64")}`,
+    );
+  });
+});
+
+describe("SimpleImageAttachmentAdapter", () => {
+  it("assigns unique IDs to files with the same name", async () => {
+    const adapter = new SimpleImageAttachmentAdapter();
+    const first = await adapter.add({
+      file: new File(["first"], "image.png", { type: "image/png" }),
+    });
+    const second = await adapter.add({
+      file: new File(["second"], "image.png", { type: "image/png" }),
+    });
+
+    expect(first.id).not.toBe(second.id);
+    expect(first.name).toBe("image.png");
+    expect(second.name).toBe("image.png");
+  });
+
+  it("sends an image as a data URL", async () => {
+    globalThis.FileReader = undefined as unknown as typeof FileReader;
+
+    const file = new File(["img"], "a.png", { type: "image/png" });
+    const adapter = new SimpleImageAttachmentAdapter();
+    const result = await adapter.send(await adapter.add({ file }));
+    const part = result.content[0];
+    if (part?.type !== "image") throw new Error("expected image content part");
+    expect(part.image).toBe(
+      `data:image/png;base64,${originalBuffer.from("img").toString("base64")}`,
+    );
+  });
+});

package/src/adapters/attachment.ts

@@ -20,7 +20,7 @@ export class SimpleImageAttachmentAdapter implements AttachmentAdapter {
 
   public async add(state: { file: File }): Promise<PendingAttachment> {
     return {
-      id: state.file.name,
+      id: generateId(),
       type: "image",
       name: state.file.name,
       contentType: state.file.type,
@@ -49,21 +49,31 @@ export class SimpleImageAttachmentAdapter implements AttachmentAdapter {
   }
 }
 
-const bytesToBase64 = (bytes: Uint8Array): string =>
-  (
+const bytesToBase64 = (bytes: Uint8Array): string => {
+  const nodeBuffer = (
     globalThis as {
-      Buffer: {
+      Buffer?: {
         from(bytes: Uint8Array): { toString(encoding: string): string };
       };
     }
-  ).Buffer.from(bytes).toString("base64");
+  ).Buffer;
+  if (nodeBuffer) {
+    return nodeBuffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  const chunkSize = 0x8000;
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+  }
+  return btoa(binary);
+};
 
 // React Native's Blob polyfill has FileReader but not file.text()/arrayBuffer(); Node has
 // the reverse. Prefer FileReader when present, falling back to the Blob methods otherwise.
-const getFileDataURL = async (file: File): Promise<string> => {
+export const getFileDataURL = async (file: File): Promise<string> => {
   if (typeof FileReader === "undefined") {
     const buffer = await file.arrayBuffer();
-    return `data:${file.type};base64,${bytesToBase64(new Uint8Array(buffer))}`;
+    return `data:${file.type || "application/octet-stream"};base64,${bytesToBase64(new Uint8Array(buffer))}`;
   }
   return new Promise<string>((resolve, reject) => {
     const reader = new FileReader();
@@ -75,11 +85,11 @@ const getFileDataURL = async (file: File): Promise<string> => {
 
 export class SimpleTextAttachmentAdapter implements AttachmentAdapter {
   public accept =
-    "text/plain,text/html,text/markdown,text/csv,text/xml,text/json,text/css";
+    "text/plain,text/html,text/markdown,text/csv,text/xml,text/json,application/json,text/css";
 
   public async add(state: { file: File }): Promise<PendingAttachment> {
     return {
-      id: state.file.name,
+      id: generateId(),
       type: "document",
       name: state.file.name,
       contentType: state.file.type,
@@ -133,7 +143,7 @@ export function fileMatchesAccept(
     .map((type) => type.trim().toLowerCase());
 
   const fileExtension = `.${file.name.split(".").pop()!.toLowerCase()}`;
-  const fileMimeType = file.type.toLowerCase();
+  const fileMimeType = file.type.split(";", 1)[0]!.trim().toLowerCase();
 
   for (const type of allowedTypes) {
     if (type.startsWith(".") && type === fileExtension) {

package/src/adapters/index.ts

@@ -19,7 +19,12 @@ export type { VoiceSessionControls, VoiceSessionHelpers } from "./voice";
 export type { FeedbackAdapter } from "./feedback";
 
 // Suggestion adapter
-export type { SuggestionAdapter } from "./suggestion";
+export type {
+  SuggestionAdapter,
+  SuggestionAdapterGenerateOptions,
+  CreateSuggestionAdapterOptions,
+} from "./suggestion";
+export { createSuggestionAdapter } from "./suggestion";
 
 // Trigger adapter (generic)
 export type { Unstable_TriggerAdapter } from "./trigger";

package/src/adapters/speech.test.ts

@@ -0,0 +1,88 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { WebSpeechSynthesisAdapter } from "./speech";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+
+describe("WebSpeechSynthesisAdapter", () => {
+  it("isolates a late subscriber that throws after the utterance ended", async () => {
+    const listeners = new Map<string, EventListener>();
+    class MockSpeechSynthesisUtterance {
+      addEventListener(type: string, listener: EventListener) {
+        listeners.set(type, listener);
+      }
+    }
+    vi.stubGlobal("SpeechSynthesisUtterance", MockSpeechSynthesisUtterance);
+    vi.stubGlobal("window", {
+      speechSynthesis: {
+        speak: vi.fn(),
+        cancel: vi.fn(),
+      },
+    });
+    const listenerError = new Error("late listener failed");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    const result = new WebSpeechSynthesisAdapter().speak("Hello");
+    listeners.get("end")!(new Event("end"));
+
+    const lateListener = vi.fn();
+    result.subscribe(() => {
+      throw listenerError;
+    });
+    result.subscribe(lateListener);
+    await Promise.resolve();
+
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] Speech synthesis listener threw an error",
+      listenerError,
+    );
+    expect(lateListener).toHaveBeenCalledOnce();
+  });
+
+  it("continues notifying listeners when one throws", () => {
+    const listeners = new Map<string, EventListener>();
+    class MockSpeechSynthesisUtterance {
+      addEventListener(type: string, listener: EventListener) {
+        listeners.set(type, listener);
+      }
+    }
+    const speak = vi.fn();
+    vi.stubGlobal("SpeechSynthesisUtterance", MockSpeechSynthesisUtterance);
+    vi.stubGlobal("window", {
+      speechSynthesis: {
+        speak,
+        cancel: vi.fn(),
+      },
+    });
+    const listenerError = new Error("listener failed");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const result = new WebSpeechSynthesisAdapter().speak("Hello");
+    const laterListener = vi.fn();
+
+    result.subscribe(() => {
+      throw listenerError;
+    });
+    result.subscribe(laterListener);
+    listeners.get("end")?.({} as Event);
+
+    expect(speak).toHaveBeenCalledWith(
+      expect.any(MockSpeechSynthesisUtterance),
+    );
+    expect(laterListener).toHaveBeenCalledOnce();
+    expect(result.status).toEqual({
+      type: "ended",
+      reason: "finished",
+      error: undefined,
+    });
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] Speech synthesis listener threw an error",
+      listenerError,
+    );
+  });
+});

package/src/adapters/speech.ts

@@ -22,6 +22,21 @@ 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 =
     | {
@@ -64,7 +79,7 @@ export class WebSpeechSynthesisAdapter implements SpeechSynthesisAdapter {
       if (res.status.type === "ended") return;
 
       res.status = { type: "ended", reason, error };
-      subscribers.forEach((handler) => handler());
+      notifySpeechSynthesisListeners(subscribers);
     };
 
     utterance.addEventListener("end", () => handleEnd("finished"));
@@ -82,7 +97,7 @@ export class WebSpeechSynthesisAdapter implements SpeechSynthesisAdapter {
         if (res.status.type === "ended") {
           let cancelled = false;
           queueMicrotask(() => {
-            if (!cancelled) callback();
+            if (!cancelled) notifySpeechSynthesisListeners([callback]);
           });
           return () => {
             cancelled = true;

package/src/adapters/suggestion.test.ts

@@ -0,0 +1,187 @@
+import { describe, expect, it, vi } from "vitest";
+import { consumeSuggestionResult, createSuggestionAdapter } from "./suggestion";
+import type { ThreadMessage } from "../types/message";
+import type { ThreadSuggestion } from "../runtime/interfaces/thread-runtime-core";
+
+const message = (
+  role: "user" | "assistant" | "system",
+  text: string,
+  id = `${role}-${text}`,
+): ThreadMessage =>
+  ({
+    id,
+    role,
+    content: text ? [{ type: "text", text }] : [],
+    createdAt: new Date(),
+    status:
+      role === "assistant" ? { type: "complete", reason: "stop" } : undefined,
+    metadata: {
+      unstable_state: null,
+      unstable_annotations: [],
+      unstable_data: [],
+      custom: {},
+    },
+  }) as unknown as ThreadMessage;
+
+describe("createSuggestionAdapter", () => {
+  it("builds a role-labeled transcript from recent messages and honors maxMessages", async () => {
+    const complete = vi.fn().mockResolvedValue(["follow up"]);
+    const adapter = createSuggestionAdapter({ complete, maxMessages: 2 });
+
+    await adapter.generate({
+      messages: [
+        message("user", "first"),
+        message("assistant", "second"),
+        message("user", "third"),
+        message("assistant", "fourth"),
+      ],
+    });
+
+    expect(complete).toHaveBeenCalledTimes(1);
+    const prompt = complete.mock.calls[0]![0].prompt as string;
+    expect(prompt).toContain("user: third");
+    expect(prompt).toContain("assistant: fourth");
+    expect(prompt).not.toContain("user: first");
+    expect(prompt).not.toContain("assistant: second");
+  });
+
+  it("skips messages with empty text in the transcript", async () => {
+    const complete = vi.fn().mockResolvedValue(["follow up"]);
+    const adapter = createSuggestionAdapter({ complete });
+
+    await adapter.generate({
+      messages: [
+        message("user", "hello"),
+        message("assistant", ""),
+        message("user", "again"),
+      ],
+    });
+
+    const prompt = complete.mock.calls[0]![0].prompt as string;
+    expect(prompt).toContain("user: hello");
+    expect(prompt).toContain("user: again");
+    expect(prompt).not.toMatch(/^assistant:/m);
+  });
+
+  it("includes count and instructions in the prompt", async () => {
+    const complete = vi.fn().mockResolvedValue(["a", "b", "c", "d", "e"]);
+    const adapter = createSuggestionAdapter({
+      complete,
+      count: 5,
+      instructions: "Prefer short product questions",
+    });
+
+    await adapter.generate({
+      messages: [message("user", "hello")],
+    });
+
+    const prompt = complete.mock.calls[0]![0].prompt as string;
+    expect(prompt).toContain("exactly 5");
+    expect(prompt).toContain("Prefer short product questions");
+  });
+
+  it("trims, drops empties, and clamps results to count", async () => {
+    const complete = vi
+      .fn()
+      .mockResolvedValue(["  one  ", "", "  ", "two", "three", "four"]);
+    const adapter = createSuggestionAdapter({ complete, count: 2 });
+
+    const result = await adapter.generate({
+      messages: [message("user", "hello")],
+    });
+
+    expect(result).toEqual([{ prompt: "one" }, { prompt: "two" }]);
+  });
+
+  it("forwards the generate signal to complete when defined", async () => {
+    const complete = vi.fn().mockResolvedValue(["ok"]);
+    const adapter = createSuggestionAdapter({ complete });
+    const controller = new AbortController();
+
+    await adapter.generate({
+      messages: [message("user", "hello")],
+      signal: controller.signal,
+    });
+
+    expect(complete).toHaveBeenCalledWith({
+      prompt: expect.any(String),
+      signal: controller.signal,
+    });
+  });
+
+  it("omits signal from complete options when generate has no signal", async () => {
+    const complete = vi.fn().mockResolvedValue(["ok"]);
+    const adapter = createSuggestionAdapter({ complete });
+
+    await adapter.generate({
+      messages: [message("user", "hello")],
+    });
+
+    expect(complete).toHaveBeenCalledWith({
+      prompt: expect.any(String),
+    });
+    expect(complete.mock.calls[0]![0]).not.toHaveProperty("signal");
+  });
+
+  it("treats maxMessages 0 as an empty transcript while still calling complete", async () => {
+    const complete = vi.fn().mockResolvedValue(["follow up"]);
+    const adapter = createSuggestionAdapter({ complete, maxMessages: 0 });
+
+    await adapter.generate({
+      messages: [message("user", "first"), message("assistant", "second")],
+    });
+
+    expect(complete).toHaveBeenCalledTimes(1);
+    const prompt = complete.mock.calls[0]![0].prompt as string;
+    expect(prompt).toContain("Conversation:\n");
+    expect(prompt).not.toContain("user: first");
+    expect(prompt).not.toContain("assistant: second");
+    expect(prompt).toContain("exactly 3");
+  });
+});
+
+describe("consumeSuggestionResult", () => {
+  it("calls onUpdate for each yield and stops after abort mid-stream", async () => {
+    const controller = new AbortController();
+    const updates: ThreadSuggestion[][] = [];
+    const onUpdate = vi.fn((s: readonly ThreadSuggestion[]) => {
+      updates.push([...s]);
+    });
+
+    async function* generate() {
+      yield [{ prompt: "one" }];
+      yield [{ prompt: "two" }];
+      controller.abort();
+      yield [{ prompt: "three" }];
+      yield [{ prompt: "four" }];
+    }
+
+    await consumeSuggestionResult(generate(), {
+      signal: controller.signal,
+      onUpdate,
+    });
+
+    expect(onUpdate).toHaveBeenCalledTimes(2);
+    expect(updates).toEqual([[{ prompt: "one" }], [{ prompt: "two" }]]);
+  });
+
+  it("drops the promise result when aborted before resolve", async () => {
+    const controller = new AbortController();
+    const onUpdate = vi.fn();
+    let resolve!: (value: readonly ThreadSuggestion[]) => void;
+    const promise = new Promise<readonly ThreadSuggestion[]>((r) => {
+      resolve = r;
+    });
+
+    const consumption = consumeSuggestionResult(promise, {
+      signal: controller.signal,
+      onUpdate,
+    });
+
+    controller.abort();
+    resolve([{ prompt: "late" }]);
+    await consumption;
+
+    expect(onUpdate).not.toHaveBeenCalled();
+  });
+});

package/src/adapters/suggestion.ts

@@ -1,8 +1,10 @@
 import type { ThreadMessage } from "../types/message";
 import type { ThreadSuggestion } from "../runtime/interfaces/thread-runtime-core";
+import { getThreadMessageText } from "../utils/text";
 
-type SuggestionAdapterGenerateOptions = {
+export type SuggestionAdapterGenerateOptions = {
   messages: readonly ThreadMessage[];
+  signal?: AbortSignal;
 };
 
 export type SuggestionAdapter = {
@@ -12,3 +14,75 @@ export type SuggestionAdapter = {
     | Promise<readonly ThreadSuggestion[]>
     | AsyncGenerator<readonly ThreadSuggestion[], void>;
 };
+
+export const consumeSuggestionResult = async (
+  result: ReturnType<SuggestionAdapter["generate"]>,
+  options: {
+    signal: AbortSignal;
+    onUpdate: (suggestions: readonly ThreadSuggestion[]) => void;
+  },
+): Promise<void> => {
+  const { signal, onUpdate } = options;
+  if (Symbol.asyncIterator in result) {
+    for await (const r of result) {
+      if (signal.aborted) break;
+      onUpdate(r);
+    }
+  } else {
+    const suggestions = await result;
+    if (signal.aborted) return;
+    onUpdate(suggestions);
+  }
+};
+
+export type CreateSuggestionAdapterOptions = {
+  complete: (options: {
+    prompt: string;
+    signal?: AbortSignal;
+  }) => Promise<readonly string[]>;
+  count?: number | undefined;
+  instructions?: string | undefined;
+  maxMessages?: number | undefined;
+};
+
+export const createSuggestionAdapter = (
+  options: CreateSuggestionAdapterOptions,
+): SuggestionAdapter => {
+  const count = options.count ?? 3;
+  const maxMessages = options.maxMessages ?? 10;
+
+  return {
+    async generate({ messages, signal }) {
+      const limit = Math.max(0, Math.floor(maxMessages));
+      const recent = limit === 0 ? [] : messages.slice(-limit);
+      const transcript = recent
+        .map((message) => {
+          const text = getThreadMessageText(message).trim();
+          if (!text) return null;
+          return `${message.role}: ${text}`;
+        })
+        .filter((line): line is string => line != null)
+        .join("\n");
+
+      let prompt =
+        `Based on the following conversation, suggest exactly ${count} short follow-up prompts that the USER would plausibly send next. ` +
+        `Write each prompt in the user's voice as something they would type. ` +
+        `Return only the prompts, one per line, with no numbering or extra commentary.\n\n` +
+        `Conversation:\n${transcript}`;
+
+      if (options.instructions) {
+        prompt += `\n\nAdditional instructions:\n${options.instructions}`;
+      }
+
+      const results = await options.complete({
+        prompt,
+        ...(signal !== undefined && { signal }),
+      });
+      return results
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0)
+        .slice(0, count)
+        .map((text) => ({ prompt: text }));
+    },
+  };
+};