@assistant-ui/react 0.5.92 → 0.5.93

package/src/runtimes/attachment/CompositeAttachmentAdapter.ts

@@ -0,0 +1,104 @@
+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 async 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 ?? "unknown/unknown", // TODO remove after 0.6.0
+          },
+          adapter.accept,
+        )
+      ) {
+        return adapter.remove(attachment);
+      }
+    }
+    throw new Error("No matching adapter found for attachment");
+  }
+}

package/src/runtimes/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/runtimes/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/runtimes/attachment/index.ts

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

package/src/runtimes/composer/BaseComposerRuntimeCore.tsx

@@ -0,0 +1,120 @@
+import {
+  Attachment,
+  CompleteAttachment,
+  PendingAttachment,
+} from "../../types/AttachmentTypes";
+import { AppendMessage, Unsubscribe } from "../../types";
+import { AttachmentAdapter } from "../attachment";
+import { ComposerRuntimeCore } from "../core/ComposerRuntimeCore";
+
+const isAttachmentComplete = (a: Attachment): a is CompleteAttachment =>
+  a.status.type === "complete";
+
+export abstract class BaseComposerRuntimeCore implements ComposerRuntimeCore {
+  public readonly isEditing = true;
+
+  protected abstract getAttachmentAdapter(): AttachmentAdapter | undefined;
+
+  public getAttachmentAccept(): string {
+    return this.getAttachmentAdapter()?.accept ?? "*";
+  }
+
+  private _attachments: readonly Attachment[] = [];
+  protected set attachments(value: readonly Attachment[]) {
+    this._attachments = value;
+    this.notifySubscribers();
+  }
+  public get attachments() {
+    return this._attachments;
+  }
+
+  public abstract get canCancel(): boolean;
+
+  public get isEmpty() {
+    return !this.text.trim() && !this.attachments.length;
+  }
+
+  private _text = "";
+
+  get text() {
+    return this._text;
+  }
+
+  setText(value: string) {
+    this._text = value;
+    this.notifySubscribers();
+  }
+
+  reset() {
+    this._text = "";
+    this._attachments = [];
+    this.notifySubscribers();
+  }
+
+  public async send() {
+    const adapter = this.getAttachmentAdapter();
+    const attachments =
+      adapter && this.attachments.length > 0
+        ? await Promise.all(
+            this.attachments.map(async (a) => {
+              if (isAttachmentComplete(a)) return a;
+              const result = await adapter.send(a);
+              // TODO remove after 0.6.0
+              if (result.status?.type !== "complete") {
+                result.status = { type: "complete" };
+              }
+              return result as CompleteAttachment;
+            }),
+          )
+        : [];
+
+    const message: Omit<AppendMessage, "parentId"> = {
+      role: "user",
+      content: this.text ? [{ type: "text", text: this.text }] : [],
+      attachments,
+    };
+    this.reset();
+
+    this.handleSend(message);
+  }
+  public abstract handleSend(message: Omit<AppendMessage, "parentId">): void;
+  public abstract cancel(): void;
+
+  async addAttachment(file: File) {
+    const adapter = this.getAttachmentAdapter();
+    if (!adapter) throw new Error("Attachments are not supported");
+
+    const attachment = await adapter.add({ file });
+    // TODO remove after 0.6.0
+    if (attachment.status === undefined) {
+      attachment.status = { type: "requires-action", reason: "composer-send" };
+    }
+
+    this._attachments = [...this._attachments, attachment as PendingAttachment];
+    this.notifySubscribers();
+  }
+
+  async removeAttachment(attachmentId: string) {
+    const adapter = this.getAttachmentAdapter();
+    if (!adapter) throw new Error("Attachments are not supported");
+
+    const index = this._attachments.findIndex((a) => a.id === attachmentId);
+    if (index === -1) throw new Error("Attachment not found");
+    const attachment = this._attachments[index]!;
+
+    await adapter.remove(attachment);
+
+    this._attachments = this._attachments.toSpliced(index, 1);
+    this.notifySubscribers();
+  }
+
+  private _subscriptions = new Set<() => void>();
+  protected notifySubscribers() {
+    for (const callback of this._subscriptions) callback();
+  }
+
+  public subscribe(callback: () => void): Unsubscribe {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+}

package/src/runtimes/composer/DefaultEditComposerRuntimeCore.tsx

@@ -0,0 +1,56 @@
+import { AppendMessage, ThreadMessage } from "../../types";
+import { getThreadMessageText } from "../../utils/getThreadMessageText";
+import { AttachmentAdapter } from "../attachment";
+import { ThreadRuntimeCore } from "../core/ThreadRuntimeCore";
+import { BaseComposerRuntimeCore } from "./BaseComposerRuntimeCore";
+
+export class DefaultEditComposerRuntimeCore extends BaseComposerRuntimeCore {
+  public get canCancel() {
+    return true;
+  }
+
+  protected getAttachmentAdapter() {
+    return this.runtime.adapters?.attachments;
+  }
+
+  private _nonTextParts;
+  private _previousText;
+  private _parentId;
+  constructor(
+    private runtime: Omit<ThreadRuntimeCore, "composer"> & {
+      adapters?: { attachments?: AttachmentAdapter | undefined } | undefined;
+    },
+    private endEditCallback: () => void,
+    { parentId, message }: { parentId: string | null; message: ThreadMessage },
+  ) {
+    super();
+    this._parentId = parentId;
+    this._previousText = getThreadMessageText(message);
+    this.setText(this._previousText);
+
+    this._nonTextParts = message.content.filter(
+      (part) => part.type !== "text" && part.type !== "ui",
+    );
+
+    this.attachments = message.attachments ?? [];
+  }
+
+  public async handleSend(message: Omit<AppendMessage, "parentId">) {
+    const text = getThreadMessageText(message as AppendMessage);
+    if (text !== this._previousText) {
+      this.runtime.append({
+        ...(message as AppendMessage),
+        content: [...message.content, ...this._nonTextParts] as any,
+        parentId: this._parentId,
+      });
+    }
+
+    this.endEditCallback();
+    this.notifySubscribers();
+  }
+
+  public async cancel() {
+    this.endEditCallback();
+    this.notifySubscribers();
+  }
+}

package/src/runtimes/composer/DefaultThreadComposerRuntimeCore.tsx

@@ -0,0 +1,52 @@
+import { AppendMessage, PendingAttachment } from "../../types";
+import { AttachmentAdapter } from "../attachment";
+import { ThreadComposerRuntimeCore } from "../core/ComposerRuntimeCore";
+import { ThreadRuntimeCore } from "../core/ThreadRuntimeCore";
+import { BaseComposerRuntimeCore } from "./BaseComposerRuntimeCore";
+
+export class DefaultThreadComposerRuntimeCore
+  extends BaseComposerRuntimeCore
+  implements ThreadComposerRuntimeCore
+{
+  private _canCancel = false;
+  public get canCancel() {
+    return this._canCancel;
+  }
+
+  public override get attachments(): readonly PendingAttachment[] {
+    return super.attachments as readonly PendingAttachment[];
+  }
+
+  protected getAttachmentAdapter() {
+    return this.runtime.adapters?.attachments;
+  }
+
+  constructor(
+    private runtime: Omit<ThreadRuntimeCore, "composer"> & {
+      adapters?: { attachments?: AttachmentAdapter | undefined } | undefined;
+    },
+  ) {
+    super();
+    this.connect();
+  }
+
+  public connect() {
+    return this.runtime.subscribe(() => {
+      if (this.canCancel !== this.runtime.capabilities.cancel) {
+        this._canCancel = this.runtime.capabilities.cancel;
+        this.notifySubscribers();
+      }
+    });
+  }
+
+  public async handleSend(message: Omit<AppendMessage, "parentId">) {
+    this.runtime.append({
+      ...(message as AppendMessage),
+      parentId: this.runtime.messages.at(-1)?.id ?? null,
+    });
+  }
+
+  public async cancel() {
+    this.runtime.cancelRun();
+  }
+}

package/src/runtimes/core/AssistantRuntimeCore.tsx

@@ -0,0 +1,9 @@
+import type { ModelConfigProvider } from "../../types/ModelConfigTypes";
+import type { Unsubscribe } from "../../types/Unsubscribe";
+import { ThreadManagerRuntimeCore } from "./ThreadManagerRuntimeCore";
+
+export type AssistantRuntimeCore = {
+  readonly threadManager: ThreadManagerRuntimeCore;
+
+  registerModelConfigProvider: (provider: ModelConfigProvider) => Unsubscribe;
+};

package/src/runtimes/core/BaseAssistantRuntimeCore.tsx

@@ -0,0 +1,18 @@
+import { type ModelConfigProvider } from "../../types/ModelConfigTypes";
+import type { Unsubscribe } from "../../types/Unsubscribe";
+import type { AssistantRuntimeCore } from "./AssistantRuntimeCore";
+import { ProxyConfigProvider } from "../../utils/ProxyConfigProvider";
+import { ThreadManagerRuntimeCore } from "./ThreadManagerRuntimeCore";
+
+export abstract class BaseAssistantRuntimeCore implements AssistantRuntimeCore {
+  protected readonly _proxyConfigProvider = new ProxyConfigProvider();
+  public abstract get threadManager(): ThreadManagerRuntimeCore;
+
+  constructor() {}
+
+  public registerModelConfigProvider(
+    provider: ModelConfigProvider,
+  ): Unsubscribe {
+    return this._proxyConfigProvider.registerModelConfigProvider(provider);
+  }
+}

package/src/runtimes/core/BaseThreadRuntimeCore.tsx

@@ -0,0 +1,194 @@
+import type {
+  ModelConfigProvider,
+  AppendMessage,
+  Unsubscribe,
+} from "../../types";
+import {
+  ExportedMessageRepository,
+  MessageRepository,
+} from "../utils/MessageRepository";
+import { DefaultThreadComposerRuntimeCore } from "../composer/DefaultThreadComposerRuntimeCore";
+import {
+  AddToolResultOptions,
+  ThreadSuggestion,
+  SubmitFeedbackOptions,
+  ThreadRuntimeCore,
+  SpeechState,
+  RuntimeCapabilities,
+  SubmittedFeedback,
+  ThreadRuntimeEventType,
+} from "../core/ThreadRuntimeCore";
+import { DefaultEditComposerRuntimeCore } from "../composer/DefaultEditComposerRuntimeCore";
+import { SpeechSynthesisAdapter } from "../speech/SpeechAdapterTypes";
+import { FeedbackAdapter } from "../feedback/FeedbackAdapter";
+import { AttachmentAdapter } from "../attachment";
+import { getThreadMessageText } from "../../utils/getThreadMessageText";
+
+type BaseThreadAdapters = {
+  speech?: SpeechSynthesisAdapter | undefined;
+  feedback?: FeedbackAdapter | undefined;
+  attachments?: AttachmentAdapter | undefined;
+};
+
+export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
+  private _subscriptions = new Set<() => void>();
+
+  protected readonly repository = new MessageRepository();
+  public abstract get adapters(): BaseThreadAdapters | undefined;
+
+  public abstract get threadId(): string;
+  public abstract get isDisabled(): boolean;
+  public abstract get suggestions(): readonly ThreadSuggestion[];
+  public abstract get extras(): unknown;
+
+  public abstract get capabilities(): RuntimeCapabilities;
+  public abstract append(message: AppendMessage): void;
+  public abstract startRun(parentId: string | null): void;
+  public abstract addToolResult(options: AddToolResultOptions): void;
+  public abstract cancelRun(): void;
+
+  public get messages() {
+    return this.repository.getMessages();
+  }
+
+  public readonly composer = new DefaultThreadComposerRuntimeCore(this);
+
+  constructor(private configProvider: ModelConfigProvider) {}
+
+  public getModelConfig() {
+    return this.configProvider.getModelConfig();
+  }
+
+  private _editComposers = new Map<string, DefaultEditComposerRuntimeCore>();
+  public getEditComposer(messageId: string) {
+    return this._editComposers.get(messageId);
+  }
+  public beginEdit(messageId: string) {
+    if (this._editComposers.has(messageId))
+      throw new Error("Edit already in progress");
+
+    this._editComposers.set(
+      messageId,
+      new DefaultEditComposerRuntimeCore(
+        this,
+        () => this._editComposers.delete(messageId),
+        this.repository.getMessage(messageId),
+      ),
+    );
+    this._notifySubscribers();
+  }
+
+  public getMessageById(messageId: string) {
+    return this.repository.getMessage(messageId);
+  }
+
+  public getBranches(messageId: string): string[] {
+    return this.repository.getBranches(messageId);
+  }
+
+  public switchToBranch(branchId: string): void {
+    this.repository.switchToBranch(branchId);
+    this._notifySubscribers();
+  }
+
+  protected _notifySubscribers() {
+    for (const callback of this._subscriptions) callback();
+  }
+
+  public _notifyEventSubscribers(event: ThreadRuntimeEventType) {
+    const subscribers = this._eventSubscribers.get(event);
+    if (!subscribers) return;
+
+    for (const callback of subscribers) callback();
+  }
+
+  public subscribe(callback: () => void): Unsubscribe {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+
+  private _submittedFeedback: Record<string, SubmittedFeedback> = {};
+
+  public getSubmittedFeedback(messageId: string) {
+    return this._submittedFeedback[messageId];
+  }
+
+  public submitFeedback({ messageId, type }: SubmitFeedbackOptions) {
+    const adapter = this.adapters?.feedback;
+    if (!adapter) throw new Error("Feedback adapter not configured");
+
+    const { message } = this.repository.getMessage(messageId);
+    adapter.submit({ message, type });
+
+    this._submittedFeedback[messageId] = { type };
+    this._notifySubscribers();
+  }
+
+  private _stopSpeaking: Unsubscribe | undefined;
+  public speech: SpeechState | undefined;
+
+  public speak(messageId: string) {
+    const adapter = this.adapters?.speech;
+    if (!adapter) throw new Error("Speech adapter not configured");
+
+    const { message } = this.repository.getMessage(messageId);
+
+    this._stopSpeaking?.();
+
+    const utterance = adapter.speak(getThreadMessageText(message));
+    const unsub = utterance.subscribe(() => {
+      if (utterance.status.type === "ended") {
+        this._stopSpeaking = undefined;
+        this.speech = undefined;
+      } else {
+        this.speech = { messageId, status: utterance.status };
+      }
+      this._notifySubscribers();
+    });
+
+    this.speech = { messageId, status: utterance.status };
+    this._notifySubscribers();
+
+    this._stopSpeaking = () => {
+      utterance.cancel();
+      unsub();
+      this.speech = undefined;
+      this._stopSpeaking = undefined;
+    };
+  }
+
+  public stopSpeaking() {
+    if (!this._stopSpeaking) throw new Error("No message is being spoken");
+    this._stopSpeaking();
+    this._notifySubscribers();
+  }
+
+  public export() {
+    return this.repository.export();
+  }
+
+  public import(data: ExportedMessageRepository) {
+    this.repository.import(data);
+    this._notifySubscribers();
+  }
+
+  private _eventSubscribers = new Map<string, Set<() => void>>();
+
+  public unstable_on(event: ThreadRuntimeEventType, callback: () => void) {
+    if (event === "model-config-update") {
+      return this.configProvider.subscribe?.(callback) ?? (() => {});
+    }
+
+    const subscribers = this._eventSubscribers.get(event);
+    if (!subscribers) {
+      this._eventSubscribers.set(event, new Set([callback]));
+    } else {
+      subscribers.add(callback);
+    }
+
+    return () => {
+      const subscribers = this._eventSubscribers.get(event)!;
+      subscribers.delete(callback);
+    };
+  }
+}

package/src/runtimes/core/ComposerRuntimeCore.tsx

@@ -0,0 +1,32 @@
+import type { Attachment, PendingAttachment, Unsubscribe } from "../../types";
+
+export type ComposerRuntimeCore = Readonly<{
+  attachments: readonly Attachment[];
+
+  getAttachmentAccept(): string;
+  addAttachment: (file: File) => Promise<void>;
+  removeAttachment: (attachmentId: string) => Promise<void>;
+
+  isEditing: boolean;
+
+  canCancel: boolean;
+  isEmpty: boolean;
+
+  text: string;
+  setText: (value: string) => void;
+
+  /**
+   * @deprecated This method will be removed in 0.6.0. Submit feedback if you need this functionality.
+   */
+  reset: () => void;
+
+  send: () => void;
+  cancel: () => void;
+
+  subscribe: (callback: () => void) => Unsubscribe;
+}>;
+
+export type ThreadComposerRuntimeCore = ComposerRuntimeCore &
+  Readonly<{
+    attachments: readonly PendingAttachment[];
+  }>;