@assistant-ui/react 0.10.50 → 0.11.1

package/src/legacy-runtime/runtime-cores/adapters/RuntimeAdapterProvider.tsx

@@ -0,0 +1,43 @@
+"use client";
+
+import { createContext, FC, ReactNode, useContext } from "react";
+import { ThreadHistoryAdapter } from "./thread-history/ThreadHistoryAdapter";
+import { AttachmentAdapter } from "./attachment/AttachmentAdapter";
+import { ModelContextProvider } from "../../../model-context";
+
+export type RuntimeAdapters = {
+  modelContext?: ModelContextProvider;
+  history?: ThreadHistoryAdapter;
+  attachments?: AttachmentAdapter;
+};
+
+const RuntimeAdaptersContext = createContext<RuntimeAdapters | null>(null);
+
+namespace RuntimeAdapterProvider {
+  export type Props = {
+    adapters: RuntimeAdapters;
+    children: ReactNode;
+  };
+}
+
+export const RuntimeAdapterProvider: FC<RuntimeAdapterProvider.Props> = ({
+  adapters,
+  children,
+}) => {
+  const context = useContext(RuntimeAdaptersContext);
+  return (
+    <RuntimeAdaptersContext.Provider
+      value={{
+        ...context,
+        ...adapters,
+      }}
+    >
+      {children}
+    </RuntimeAdaptersContext.Provider>
+  );
+};
+
+export const useRuntimeAdapters = () => {
+  const adapters = useContext(RuntimeAdaptersContext);
+  return adapters;
+};

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

@@ -0,0 +1,71 @@
+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/CloudFileAttachmentAdapter.ts

@@ -0,0 +1,101 @@
+import type { AssistantCloud } from "assistant-cloud";
+import {
+  Attachment,
+  PendingAttachment,
+  CompleteAttachment,
+} from "../../../../types/AttachmentTypes";
+import { ThreadUserMessagePart } from "../../../../types/MessagePartTypes";
+import { AttachmentAdapter } from "./AttachmentAdapter";
+
+const guessAttachmentType = (
+  contentType: string,
+): "image" | "document" | "file" => {
+  if (contentType.startsWith("image/")) return "image";
+  if (contentType.startsWith("text/")) return "document";
+  return "file";
+};
+
+export class CloudFileAttachmentAdapter implements AttachmentAdapter {
+  public accept = "*";
+
+  constructor(private cloud: AssistantCloud) {}
+
+  private uploadedUrls = new Map<string, string>();
+
+  public async *add({
+    file,
+  }: {
+    file: File;
+  }): AsyncGenerator<PendingAttachment, void> {
+    const id = crypto.randomUUID();
+    const type = guessAttachmentType(file.type);
+    let attachment: PendingAttachment = {
+      id,
+      type,
+      name: file.name,
+      contentType: file.type,
+      file,
+      status: { type: "running", reason: "uploading", progress: 0 },
+    };
+    yield attachment;
+
+    try {
+      const { signedUrl, publicUrl } =
+        await this.cloud.files.generatePresignedUploadUrl({
+          filename: file.name,
+        });
+      await fetch(signedUrl, {
+        method: "PUT",
+        body: file,
+        headers: {
+          "Content-Type": file.type,
+        },
+        mode: "cors",
+      });
+      this.uploadedUrls.set(id, publicUrl);
+      attachment = {
+        ...attachment,
+        status: { type: "requires-action", reason: "composer-send" },
+      };
+      yield attachment;
+    } catch {
+      attachment = {
+        ...attachment,
+        status: { type: "incomplete", reason: "error" },
+      };
+      yield attachment;
+    }
+  }
+
+  public async remove(attachment: Attachment): Promise<void> {
+    this.uploadedUrls.delete(attachment.id);
+  }
+
+  public async send(
+    attachment: PendingAttachment,
+  ): Promise<CompleteAttachment> {
+    const url = this.uploadedUrls.get(attachment.id);
+    if (!url) throw new Error("Attachment not uploaded");
+    this.uploadedUrls.delete(attachment.id);
+
+    let content: ThreadUserMessagePart[];
+    if (attachment.type === "image") {
+      content = [{ type: "image", image: url, filename: attachment.name }];
+    } else {
+      content = [
+        {
+          type: "file",
+          data: url,
+          mimeType: attachment.contentType,
+          filename: attachment.name,
+        },
+      ];
+    }
+
+    return {
+      ...attachment,
+      status: { type: "complete" },
+      content,
+    };
+  }
+}

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

@@ -0,0 +1,107 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,50 @@
+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/attachment/index.ts

@@ -0,0 +1,5 @@
+export type { AttachmentAdapter } from "./AttachmentAdapter";
+export { SimpleImageAttachmentAdapter } from "./SimpleImageAttachmentAdapter";
+export { SimpleTextAttachmentAdapter } from "./SimpleTextAttachmentAdapter";
+export { CompositeAttachmentAdapter } from "./CompositeAttachmentAdapter";
+export { CloudFileAttachmentAdapter } from "./CloudFileAttachmentAdapter";

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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,98 @@
+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 SpeechRecognitionAdapter {
+  export type Status =
+    | {
+        type: "starting" | "running";
+      }
+    | {
+        type: "ended";
+        reason: "stopped" | "cancelled" | "error";
+      };
+
+  export type Result = {
+    transcript: string;
+  };
+
+  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 SpeechRecognitionAdapter = {
+  listen: () => SpeechRecognitionAdapter.Session;
+};

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

@@ -0,0 +1,14 @@
+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>;
+};