@assistant-ui/react 0.12.10 → 0.12.12

package/src/legacy-runtime/runtime/subscribable/EventSubscriptionSubject.ts

@@ -1,44 +0,0 @@
-import { Unsubscribe } from "../../../types";
-import { BaseSubject } from "./BaseSubject";
-import { EventSubscribable } from "./Subscribable";
-
-export class EventSubscriptionSubject<
-  TEvent extends string,
-> extends BaseSubject {
-  constructor(private config: EventSubscribable<TEvent>) {
-    super();
-  }
-
-  public getState() {
-    return this.config.binding.getState();
-  }
-
-  public outerSubscribe(callback: () => void) {
-    return this.config.binding.subscribe(callback);
-  }
-
-  protected _connect(): Unsubscribe {
-    const callback = () => {
-      this.notifySubscribers();
-    };
-
-    let lastState = this.config.binding.getState();
-    let innerUnsubscribe = lastState?.unstable_on(this.config.event, callback);
-    const onRuntimeUpdate = () => {
-      const newState = this.config.binding.getState();
-      if (newState === lastState) return;
-      lastState = newState;
-
-      innerUnsubscribe?.();
-      innerUnsubscribe = this.config.binding
-        .getState()
-        ?.unstable_on(this.config.event, callback);
-    };
-
-    const outerUnsubscribe = this.outerSubscribe(onRuntimeUpdate);
-    return () => {
-      outerUnsubscribe?.();
-      innerUnsubscribe?.();
-    };
-  }
-}

package/src/legacy-runtime/runtime/subscribable/LazyMemoizeSubject.ts

@@ -1,42 +0,0 @@
-import { BaseSubject } from "./BaseSubject";
-import { SKIP_UPDATE } from "./SKIP_UPDATE";
-import { SubscribableWithState } from "./Subscribable";
-
-export class LazyMemoizeSubject<TState extends object, TPath>
-  extends BaseSubject
-  implements SubscribableWithState<TState, TPath>
-{
-  public get path() {
-    return this.binding.path;
-  }
-
-  constructor(
-    private binding: SubscribableWithState<TState | SKIP_UPDATE, TPath>,
-  ) {
-    super();
-  }
-
-  private _previousStateDirty = true;
-  private _previousState: TState | undefined;
-  public getState = () => {
-    if (!this.isConnected || this._previousStateDirty) {
-      const newState = this.binding.getState();
-      if (newState !== SKIP_UPDATE) {
-        this._previousState = newState;
-      }
-      this._previousStateDirty = false;
-    }
-    if (this._previousState === undefined)
-      throw new Error("Entry not available in the store");
-    return this._previousState;
-  };
-
-  protected _connect() {
-    const callback = () => {
-      this._previousStateDirty = true;
-      this.notifySubscribers();
-    };
-
-    return this.binding.subscribe(callback);
-  }
-}

package/src/legacy-runtime/runtime/subscribable/NestedSubscriptionSubject.ts

@@ -1,58 +0,0 @@
-import { Unsubscribe } from "../../../types";
-import { BaseSubject } from "./BaseSubject";
-import {
-  NestedSubscribable,
-  Subscribable,
-  SubscribableWithState,
-} from "./Subscribable";
-
-export class NestedSubscriptionSubject<
-    TState extends Subscribable | undefined,
-    TPath,
-  >
-  extends BaseSubject
-  implements
-    SubscribableWithState<TState, TPath>,
-    NestedSubscribable<TState, TPath>
-{
-  public get path() {
-    return this.binding.path;
-  }
-
-  constructor(private binding: NestedSubscribable<TState, TPath>) {
-    super();
-  }
-
-  public getState() {
-    return this.binding.getState();
-  }
-
-  public outerSubscribe(callback: () => void) {
-    return this.binding.subscribe(callback);
-  }
-
-  protected _connect(): Unsubscribe {
-    const callback = () => {
-      this.notifySubscribers();
-    };
-
-    let lastState = this.binding.getState();
-    let innerUnsubscribe = lastState?.subscribe(callback);
-    const onRuntimeUpdate = () => {
-      const newState = this.binding.getState();
-      if (newState === lastState) return;
-      lastState = newState;
-
-      innerUnsubscribe?.();
-      innerUnsubscribe = this.binding.getState()?.subscribe(callback);
-
-      callback();
-    };
-
-    const outerUnsubscribe = this.outerSubscribe(onRuntimeUpdate);
-    return () => {
-      outerUnsubscribe?.();
-      innerUnsubscribe?.();
-    };
-  }
-}

package/src/legacy-runtime/runtime/subscribable/SKIP_UPDATE.ts

@@ -1,2 +0,0 @@
-export const SKIP_UPDATE = Symbol("skip-update");
-export type SKIP_UPDATE = typeof SKIP_UPDATE;

package/src/legacy-runtime/runtime/subscribable/ShallowMemoizeSubject.ts

@@ -1,47 +0,0 @@
-import { shallowEqual } from "./shallowEqual";
-import { BaseSubject } from "./BaseSubject";
-import { SubscribableWithState } from "./Subscribable";
-import { SKIP_UPDATE } from "./SKIP_UPDATE";
-
-export class ShallowMemoizeSubject<TState extends object, TPath>
-  extends BaseSubject
-  implements SubscribableWithState<TState, TPath>
-{
-  public get path() {
-    return this.binding.path;
-  }
-
-  constructor(
-    private binding: SubscribableWithState<TState | SKIP_UPDATE, TPath>,
-  ) {
-    super();
-    const state = binding.getState();
-    if (state === SKIP_UPDATE)
-      throw new Error("Entry not available in the store");
-    this._previousState = state;
-  }
-
-  private _previousState: TState;
-  public getState = () => {
-    if (!this.isConnected) this._syncState();
-    return this._previousState;
-  };
-
-  private _syncState() {
-    const state = this.binding.getState();
-    if (state === SKIP_UPDATE) return false;
-    if (shallowEqual(state, this._previousState)) return false;
-    this._previousState = state;
-    return true;
-  }
-
-  protected _connect() {
-    const callback = () => {
-      if (this._syncState()) {
-        this.notifySubscribers();
-      }
-    };
-
-    return this.binding.subscribe(callback);
-  }
-}

package/src/legacy-runtime/runtime/subscribable/Subscribable.ts

@@ -1,26 +0,0 @@
-import { Unsubscribe } from "../../../types";
-
-export type Subscribable = {
-  subscribe: (callback: () => void) => Unsubscribe;
-};
-
-export type SubscribableWithState<TState, TPath> = Subscribable & {
-  path: TPath;
-  getState: () => TState;
-};
-
-export type NestedSubscribable<
-  TState extends Subscribable | undefined,
-  TPath,
-> = SubscribableWithState<TState, TPath>;
-
-export type EventSubscribable<TEvent extends string> = {
-  event: TEvent;
-  binding: SubscribableWithState<
-    | {
-        unstable_on: (event: TEvent, callback: () => void) => Unsubscribe;
-      }
-    | undefined,
-    unknown
-  >;
-};

package/src/legacy-runtime/runtime/subscribable/shallowEqual.ts

@@ -1,16 +0,0 @@
-export function shallowEqual<T extends object>(
-  objA: T | undefined,
-  objB: T | undefined,
-) {
-  if (objA === undefined && objB === undefined) return true;
-  if (objA === undefined) return false;
-  if (objB === undefined) return false;
-
-  for (const key of Object.keys(objA)) {
-    const valueA = objA[key as keyof T];
-    const valueB = objB[key as keyof T];
-    if (!Object.is(valueA, valueB)) return false;
-  }
-
-  return true;
-}

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

@@ -1,71 +0,0 @@
-import {
-  Attachment,
-  PendingAttachment,
-  CompleteAttachment,
-} from "../../../../types/AttachmentTypes";
-
-/**
- * Interface for handling file attachments in the assistant runtime.
- *
- * AttachmentAdapter provides methods for managing file attachments throughout
- * their lifecycle: adding, processing, removing, and sending attachments with messages.
- *
- * @example
- * ```tsx
- * const imageAdapter: AttachmentAdapter = {
- *   accept: "image/*",
- *
- *   async add({ file }) {
- *     return {
- *       id: generateId(),
- *       type: "image",
- *       name: file.name,
- *       file,
- *       status: { type: "uploading" }
- *     };
- *   },
- *
- *   async remove(attachment) {
- *     // Clean up resources
- *   },
- *
- *   async send(attachment) {
- *     const url = await uploadFile(attachment.file);
- *     return { ...attachment, url, status: { type: "complete" } };
- *   }
- * };
- * ```
- */
-export type AttachmentAdapter = {
-  /**
-   * MIME type pattern for accepted file types (e.g., "image/*", "text/plain").
-   */
-  accept: string;
-
-  /**
-   * Processes a file when it's added as an attachment.
-   *
-   * @param state - Object containing the file to process
-   * @param state.file - The File object to be attached
-   * @returns Promise or AsyncGenerator yielding PendingAttachment states
-   */
-  add(state: {
-    file: File;
-  }): Promise<PendingAttachment> | AsyncGenerator<PendingAttachment, void>;
-
-  /**
-   * Removes an attachment and cleans up associated resources.
-   *
-   * @param attachment - The attachment to remove
-   * @returns Promise that resolves when removal is complete
-   */
-  remove(attachment: Attachment): Promise<void>;
-
-  /**
-   * Finalizes an attachment for sending with a message.
-   *
-   * @param attachment - The pending attachment to finalize
-   * @returns Promise resolving to the complete attachment
-   */
-  send(attachment: PendingAttachment): Promise<CompleteAttachment>;
-};

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;
-};