@assistant-ui/react 0.12.9 → 0.12.11

package/src/legacy-runtime/runtime-cores/adapters/attachment/CompositeAttachmentAdapter.ts

@@ -1,107 +0,0 @@
-import {
-  Attachment,
-  PendingAttachment,
-} from "../../../../types/AttachmentTypes";
-import { AttachmentAdapter } from "./AttachmentAdapter";
-
-function fileMatchesAccept(
-  file: { name: string; type: string },
-  acceptString: string,
-) {
-  // Check if the accept string is "*", which allows any file
-  if (acceptString === "*") {
-    return true;
-  }
-
-  // Split the accept string into an array of allowed types
-  const allowedTypes = acceptString
-    .split(",")
-    .map((type) => type.trim().toLowerCase());
-
-  // Get the file's extension and MIME type
-  const fileExtension = `.${file.name.split(".").pop()!.toLowerCase()}`;
-  const fileMimeType = file.type.toLowerCase();
-
-  for (const type of allowedTypes) {
-    // Check for file extension match
-    if (type.startsWith(".") && type === fileExtension) {
-      return true;
-    }
-
-    // Check for exact MIME type match
-    if (type.includes("/") && type === fileMimeType) {
-      return true;
-    }
-
-    if (type === "image/*" || type === "video/*" || type === "audio/*") {
-      // Check for wildcard MIME type match
-      if (type.endsWith("/*")) {
-        const generalType = type.split("/")[0]!;
-        if (fileMimeType.startsWith(`${generalType}/`)) {
-          return true;
-        }
-      }
-    }
-  }
-
-  return false;
-}
-
-export class CompositeAttachmentAdapter implements AttachmentAdapter {
-  private _adapters: AttachmentAdapter[];
-
-  public accept: string;
-
-  constructor(adapters: AttachmentAdapter[]) {
-    this._adapters = adapters;
-
-    const wildcardIdx = adapters.findIndex((a) => a.accept === "*");
-    if (wildcardIdx !== -1) {
-      if (wildcardIdx !== adapters.length - 1)
-        throw new Error(
-          "A wildcard adapter (handling all files) can only be specified as the last adapter.",
-        );
-
-      this.accept = "*";
-    } else {
-      this.accept = adapters.map((a) => a.accept).join(",");
-    }
-  }
-
-  public add(state: { file: File }) {
-    for (const adapter of this._adapters) {
-      if (fileMatchesAccept(state.file, adapter.accept)) {
-        return adapter.add(state);
-      }
-    }
-    throw new Error("No matching adapter found for file");
-  }
-
-  public async send(attachment: PendingAttachment) {
-    const adapters = this._adapters.slice();
-    for (const adapter of adapters) {
-      if (fileMatchesAccept(attachment.file, adapter.accept)) {
-        return adapter.send(attachment);
-      }
-    }
-    throw new Error("No matching adapter found for attachment");
-  }
-
-  public async remove(attachment: Attachment) {
-    const adapters = this._adapters.slice();
-    for (const adapter of adapters) {
-      if (
-        fileMatchesAccept(
-          {
-            name: attachment.name,
-            type: attachment.contentType,
-          },
-          adapter.accept,
-        )
-      ) {
-        return adapter.remove(attachment);
-      }
-    }
-    throw new Error("No matching adapter found for attachment");
-  }
-}

package/src/legacy-runtime/runtime-cores/adapters/attachment/SimpleImageAttachmentAdapter.ts

@@ -1,49 +0,0 @@
-import {
-  PendingAttachment,
-  CompleteAttachment,
-} from "../../../../types/AttachmentTypes";
-import { AttachmentAdapter } from "./AttachmentAdapter";
-
-export class SimpleImageAttachmentAdapter implements AttachmentAdapter {
-  public accept = "image/*";
-
-  public async add(state: { file: File }): Promise<PendingAttachment> {
-    return {
-      id: state.file.name,
-      type: "image",
-      name: state.file.name,
-      contentType: state.file.type,
-      file: state.file,
-      status: { type: "requires-action", reason: "composer-send" },
-    };
-  }
-
-  public async send(
-    attachment: PendingAttachment,
-  ): Promise<CompleteAttachment> {
-    return {
-      ...attachment,
-      status: { type: "complete" },
-      content: [
-        {
-          type: "image",
-          image: await getFileDataURL(attachment.file),
-        },
-      ],
-    };
-  }
-
-  public async remove() {
-    // noop
-  }
-}
-
-const getFileDataURL = (file: File) =>
-  new Promise<string>((resolve, reject) => {
-    const reader = new FileReader();
-
-    reader.onload = () => resolve(reader.result as string);
-    reader.onerror = (error) => reject(error);
-
-    reader.readAsDataURL(file);
-  });

package/src/legacy-runtime/runtime-cores/adapters/attachment/SimpleTextAttachmentAdapter.ts

@@ -1,50 +0,0 @@
-import {
-  CompleteAttachment,
-  PendingAttachment,
-} from "../../../../types/AttachmentTypes";
-import { AttachmentAdapter } from "./AttachmentAdapter";
-
-export class SimpleTextAttachmentAdapter implements AttachmentAdapter {
-  public accept =
-    "text/plain,text/html,text/markdown,text/csv,text/xml,text/json,text/css";
-
-  public async add(state: { file: File }): Promise<PendingAttachment> {
-    return {
-      id: state.file.name,
-      type: "document",
-      name: state.file.name,
-      contentType: state.file.type,
-      file: state.file,
-      status: { type: "requires-action", reason: "composer-send" },
-    };
-  }
-
-  public async send(
-    attachment: PendingAttachment,
-  ): Promise<CompleteAttachment> {
-    return {
-      ...attachment,
-      status: { type: "complete" },
-      content: [
-        {
-          type: "text",
-          text: `<attachment name=${attachment.name}>\n${await getFileText(attachment.file)}\n</attachment>`,
-        },
-      ],
-    };
-  }
-
-  public async remove() {
-    // noop
-  }
-}
-
-const getFileText = (file: File) =>
-  new Promise<string>((resolve, reject) => {
-    const reader = new FileReader();
-
-    reader.onload = () => resolve(reader.result as string);
-    reader.onerror = (error) => reject(error);
-
-    reader.readAsText(file);
-  });

package/src/legacy-runtime/runtime-cores/adapters/feedback/FeedbackAdapter.ts

@@ -1,43 +0,0 @@
-import { ThreadMessage } from "../../../../types/AssistantTypes";
-
-/**
- * Feedback data structure for rating messages.
- */
-type FeedbackAdapterFeedback = {
-  /** The message being rated */
-  message: ThreadMessage;
-  /** The type of feedback being provided */
-  type: "positive" | "negative";
-};
-
-/**
- * Interface for handling user feedback on assistant messages.
- *
- * FeedbackAdapter allows users to provide positive or negative feedback
- * on assistant responses, which can be used for analytics, model improvement,
- * or user experience tracking.
- *
- * @example
- * ```tsx
- * const feedbackAdapter: FeedbackAdapter = {
- *   submit: (feedback) => {
- *     console.log(`User gave ${feedback.type} feedback on message:`, feedback.message.id);
- *
- *     // Send to analytics service
- *     analytics.track('message_feedback', {
- *       messageId: feedback.message.id,
- *       feedbackType: feedback.type,
- *       messageContent: feedback.message.content
- *     });
- *   }
- * };
- * ```
- */
-export type FeedbackAdapter = {
-  /**
-   * Submits user feedback for a message.
-   *
-   * @param feedback - The feedback data containing message and rating type
-   */
-  submit: (feedback: FeedbackAdapterFeedback) => void;
-};

package/src/legacy-runtime/runtime-cores/adapters/speech/SpeechAdapterTypes.ts

@@ -1,121 +0,0 @@
-import { Unsubscribe } from "../../../../types";
-
-/**
- * Types and interfaces for speech synthesis (text-to-speech) functionality.
- */
-export namespace SpeechSynthesisAdapter {
-  /**
-   * Status of a speech synthesis operation.
-   */
-  export type Status =
-    | {
-        /** Speech is starting or currently running */
-        type: "starting" | "running";
-      }
-    | {
-        /** Speech has ended */
-        type: "ended";
-        /** Reason why speech ended */
-        reason: "finished" | "cancelled" | "error";
-        /** Error details if speech ended due to error */
-        error?: unknown;
-      };
-
-  /**
-   * Represents a single speech utterance with control and status tracking.
-   */
-  export type Utterance = {
-    /** Current status of the utterance */
-    status: Status;
-    /** Cancel the current speech */
-    cancel: () => void;
-    /** Subscribe to status changes */
-    subscribe: (callback: () => void) => Unsubscribe;
-  };
-}
-
-/**
- * Interface for text-to-speech functionality.
- *
- * SpeechSynthesisAdapter provides the ability to convert text content
- * into spoken audio, with status tracking and cancellation support.
- *
- * @example
- * ```tsx
- * const speechAdapter: SpeechSynthesisAdapter = {
- *   speak: (text) => {
- *     const utterance = new SpeechSynthesisUtterance(text);
- *     speechSynthesis.speak(utterance);
- *
- *     return {
- *       status: { type: "starting" },
- *       cancel: () => speechSynthesis.cancel(),
- *       subscribe: (callback) => {
- *         utterance.addEventListener('end', callback);
- *         return () => utterance.removeEventListener('end', callback);
- *       }
- *     };
- *   }
- * };
- * ```
- */
-export type SpeechSynthesisAdapter = {
-  /**
-   * Converts text to speech and returns an utterance object for control.
-   *
-   * @param text - The text content to speak
-   * @returns An utterance object with status and control methods
-   */
-  speak: (text: string) => SpeechSynthesisAdapter.Utterance;
-};
-
-export namespace DictationAdapter {
-  export type Status =
-    | {
-        type: "starting" | "running";
-      }
-    | {
-        type: "ended";
-        reason: "stopped" | "cancelled" | "error";
-      };
-
-  export type Result = {
-    /** The transcribed text */
-    transcript: string;
-    /**
-     * Whether this is a final (committed) result or an interim (partial) result.
-     *
-     * - `true` (final): The text should be appended to the composer input.
-     *   This text is finalized and won't change.
-     *
-     * - `false` (interim/partial): The text is a preview that may change.
-     *   It should be displayed as a preview but not appended to the input yet.
-     *   Subsequent interim results replace the previous interim result.
-     *
-     * Defaults to `true` for backwards compatibility with adapters that
-     * don't set this flag.
-     */
-    isFinal?: boolean;
-  };
-
-  export type Session = {
-    status: Status;
-    stop: () => Promise<void>;
-    cancel: () => void;
-    onSpeechStart: (callback: () => void) => Unsubscribe;
-    onSpeechEnd: (callback: (result: Result) => void) => Unsubscribe;
-    onSpeech: (callback: (result: Result) => void) => Unsubscribe;
-  };
-}
-
-export type DictationAdapter = {
-  listen: () => DictationAdapter.Session;
-
-  /**
-   * Whether to disable text input while dictation is active.
-   * Some adapters (like ElevenLabs Scribe) return cumulative transcripts
-   * that conflict with simultaneous typing.
-   * @default false
-   */
-  disableInputDuringDictation?: boolean;
-};

package/src/legacy-runtime/runtime-cores/adapters/speech/WebSpeechDictationAdapter.ts

@@ -1,255 +0,0 @@
-import type { Unsubscribe } from "../../../../types";
-import type { DictationAdapter } from "./SpeechAdapterTypes";
-
-// Type definitions for Web Speech API
-// Users can install @types/dom-speech-recognition for full type support
-interface SpeechRecognitionResultItem {
-  transcript: string;
-  confidence: number;
-}
-
-interface SpeechRecognitionResult {
-  readonly length: number;
-  item(index: number): SpeechRecognitionResultItem;
-  readonly isFinal: boolean;
-  [index: number]: SpeechRecognitionResultItem;
-}
-
-interface SpeechRecognitionResultList {
-  readonly length: number;
-  item(index: number): SpeechRecognitionResult;
-  [index: number]: SpeechRecognitionResult;
-}
-
-interface SpeechRecognitionEvent extends Event {
-  readonly resultIndex: number;
-  readonly results: SpeechRecognitionResultList;
-}
-
-interface SpeechRecognitionErrorEvent extends Event {
-  readonly error: string;
-  readonly message: string;
-}
-
-interface SpeechRecognitionInstance extends EventTarget {
-  lang: string;
-  continuous: boolean;
-  interimResults: boolean;
-  start(): void;
-  stop(): void;
-  abort(): void;
-}
-
-interface SpeechRecognitionConstructor {
-  new (): SpeechRecognitionInstance;
-}
-
-declare global {
-  interface Window {
-    SpeechRecognition?: SpeechRecognitionConstructor;
-    webkitSpeechRecognition?: SpeechRecognitionConstructor;
-  }
-}
-
-const getSpeechRecognitionAPI = ():
-  | SpeechRecognitionConstructor
-  | undefined => {
-  if (typeof window === "undefined") return undefined;
-  return window.SpeechRecognition ?? window.webkitSpeechRecognition;
-};
-
-/**
- * WebSpeechDictationAdapter provides speech-to-text (dictation) functionality using
- * the browser's Web Speech API (SpeechRecognition).
- *
- * @example
- * ```tsx
- * const runtime = useChatRuntime({
- *   api: "/api/chat",
- *   adapters: {
- *     dictation: new WebSpeechDictationAdapter(),
- *   },
- * });
- * ```
- */
-export class WebSpeechDictationAdapter implements DictationAdapter {
-  private _language: string;
-  private _continuous: boolean;
-  private _interimResults: boolean;
-
-  constructor(
-    options: {
-      /**
-       * The language for dictation (e.g., "en-US", "zh-CN").
-       * Defaults to the browser's language.
-       */
-      language?: string;
-      /**
-       * Whether to keep recording after the user stops speaking.
-       * Defaults to true.
-       */
-      continuous?: boolean;
-      /**
-       * Whether to return interim (partial) results.
-       * Defaults to true for real-time feedback.
-       */
-      interimResults?: boolean;
-    } = {},
-  ) {
-    const defaultLanguage =
-      typeof navigator !== "undefined" && navigator.language
-        ? navigator.language
-        : "en-US";
-    this._language = options.language ?? defaultLanguage;
-    this._continuous = options.continuous ?? true;
-    this._interimResults = options.interimResults ?? true;
-  }
-
-  /**
-   * Check if the browser supports the Web Speech Recognition API.
-   */
-  static isSupported(): boolean {
-    return getSpeechRecognitionAPI() !== undefined;
-  }
-
-  listen(): DictationAdapter.Session {
-    const SpeechRecognitionAPI = getSpeechRecognitionAPI();
-    if (!SpeechRecognitionAPI) {
-      throw new Error(
-        "SpeechRecognition is not supported in this browser. " +
-          "Try using Chrome, Edge, or Safari.",
-      );
-    }
-
-    const recognition = new SpeechRecognitionAPI();
-    recognition.lang = this._language;
-    recognition.continuous = this._continuous;
-    recognition.interimResults = this._interimResults;
-
-    const speechStartCallbacks = new Set<() => void>();
-    const speechEndCallbacks = new Set<
-      (result: DictationAdapter.Result) => void
-    >();
-    const speechCallbacks = new Set<
-      (result: DictationAdapter.Result) => void
-    >();
-
-    let finalTranscript = "";
-
-    const session: DictationAdapter.Session = {
-      status: { type: "starting" },
-
-      stop: async () => {
-        recognition.stop();
-        return new Promise<void>((resolve) => {
-          const checkEnded = () => {
-            if (session.status.type === "ended") {
-              resolve();
-            } else {
-              setTimeout(checkEnded, 50);
-            }
-          };
-          checkEnded();
-        });
-      },
-
-      cancel: () => {
-        recognition.abort();
-      },
-
-      onSpeechStart: (callback: () => void): Unsubscribe => {
-        speechStartCallbacks.add(callback);
-        return () => {
-          speechStartCallbacks.delete(callback);
-        };
-      },
-
-      onSpeechEnd: (
-        callback: (result: DictationAdapter.Result) => void,
-      ): Unsubscribe => {
-        speechEndCallbacks.add(callback);
-        return () => {
-          speechEndCallbacks.delete(callback);
-        };
-      },
-
-      onSpeech: (
-        callback: (result: DictationAdapter.Result) => void,
-      ): Unsubscribe => {
-        speechCallbacks.add(callback);
-        return () => {
-          speechCallbacks.delete(callback);
-        };
-      },
-    };
-
-    const updateStatus = (newStatus: DictationAdapter.Status) => {
-      session.status = newStatus;
-    };
-
-    recognition.addEventListener("speechstart", () => {
-      for (const cb of speechStartCallbacks) cb();
-    });
-
-    recognition.addEventListener("start", () => {
-      updateStatus({ type: "running" });
-    });
-
-    recognition.addEventListener("result", (event) => {
-      const speechEvent = event as unknown as SpeechRecognitionEvent;
-
-      for (
-        let i = speechEvent.resultIndex;
-        i < speechEvent.results.length;
-        i++
-      ) {
-        const result = speechEvent.results[i];
-        if (!result) continue;
-
-        const transcript = result[0]?.transcript ?? "";
-
-        if (result.isFinal) {
-          finalTranscript += transcript;
-          for (const cb of speechCallbacks) cb({ transcript, isFinal: true });
-        } else {
-          for (const cb of speechCallbacks) cb({ transcript, isFinal: false });
-        }
-      }
-    });
-
-    recognition.addEventListener("speechend", () => {
-      // speechend fires when user stops speaking, but 'end' handles final cleanup
-    });
-
-    recognition.addEventListener("end", () => {
-      const currentStatus = session.status;
-      if (currentStatus.type !== "ended") {
-        updateStatus({ type: "ended", reason: "stopped" });
-      }
-      if (finalTranscript) {
-        for (const cb of speechEndCallbacks)
-          cb({ transcript: finalTranscript });
-        finalTranscript = "";
-      }
-    });
-
-    recognition.addEventListener("error", (event) => {
-      const errorEvent = event as unknown as SpeechRecognitionErrorEvent;
-      if (errorEvent.error === "aborted") {
-        updateStatus({ type: "ended", reason: "cancelled" });
-      } else {
-        updateStatus({ type: "ended", reason: "error" });
-        console.error("Dictation error:", errorEvent.error, errorEvent.message);
-      }
-    });
-
-    try {
-      recognition.start();
-    } catch (error) {
-      updateStatus({ type: "ended", reason: "error" });
-      throw error;
-    }
-
-    return session;
-  }
-}

package/src/legacy-runtime/runtime-cores/adapters/speech/WebSpeechSynthesisAdapter.ts

@@ -1,48 +0,0 @@
-import { SpeechSynthesisAdapter } from "./SpeechAdapterTypes";
-
-export class WebSpeechSynthesisAdapter implements SpeechSynthesisAdapter {
-  speak(text: string): SpeechSynthesisAdapter.Utterance {
-    const utterance = new SpeechSynthesisUtterance(text);
-
-    const subscribers = new Set<() => void>();
-    const handleEnd = (
-      reason: "finished" | "error" | "cancelled",
-      error?: unknown,
-    ) => {
-      if (res.status.type === "ended") return;
-
-      res.status = { type: "ended", reason, error };
-      subscribers.forEach((handler) => handler());
-    };
-
-    utterance.addEventListener("end", () => handleEnd("finished"));
-    utterance.addEventListener("error", (e) => handleEnd("error", e.error));
-
-    window.speechSynthesis.speak(utterance);
-
-    const res: SpeechSynthesisAdapter.Utterance = {
-      status: { type: "running" },
-      cancel: () => {
-        window.speechSynthesis.cancel();
-        handleEnd("cancelled");
-      },
-      subscribe: (callback) => {
-        if (res.status.type === "ended") {
-          let cancelled = false;
-          queueMicrotask(() => {
-            if (!cancelled) callback();
-          });
-          return () => {
-            cancelled = true;
-          };
-        } else {
-          subscribers.add(callback);
-          return () => {
-            subscribers.delete(callback);
-          };
-        }
-      },
-    };
-    return res;
-  }
-}

package/src/legacy-runtime/runtime-cores/adapters/suggestion/SuggestionAdapter.ts

@@ -1,14 +0,0 @@
-import { ThreadMessage } from "../../../../types/AssistantTypes";
-import { ThreadSuggestion } from "../../core";
-
-type SuggestionAdapterGenerateOptions = {
-  messages: readonly ThreadMessage[];
-};
-
-export type SuggestionAdapter = {
-  generate: (
-    options: SuggestionAdapterGenerateOptions,
-  ) =>
-    | Promise<readonly ThreadSuggestion[]>
-    | AsyncGenerator<readonly ThreadSuggestion[], void>;
-};