@assistant-ui/react 0.12.9 → 0.12.11

package/src/legacy-runtime/runtime-cores/adapters/thread-history/MessageFormatAdapter.ts

@@ -1,25 +0,0 @@
-export interface MessageStorageEntry<TPayload> {
-  id: string;
-  parent_id: string | null;
-  format: string;
-  content: TPayload;
-}
-
-export interface MessageFormatItem<TMessage> {
-  parentId: string | null;
-  message: TMessage;
-}
-
-export interface MessageFormatRepository<TMessage> {
-  headId?: string | null;
-  messages: MessageFormatItem<TMessage>[];
-}
-
-export interface MessageFormatAdapter<TMessage, TStorageFormat> {
-  format: string;
-  encode(item: MessageFormatItem<TMessage>): TStorageFormat;
-  decode(
-    stored: MessageStorageEntry<TStorageFormat>,
-  ): MessageFormatItem<TMessage>;
-  getId(message: TMessage): string;
-}

package/src/legacy-runtime/runtime-cores/adapters/thread-history/ThreadHistoryAdapter.ts

@@ -1,26 +0,0 @@
-import { ChatModelRunOptions, ChatModelRunResult } from "../../local";
-import {
-  ExportedMessageRepository,
-  ExportedMessageRepositoryItem,
-} from "../../utils/MessageRepository";
-import {
-  MessageFormatAdapter,
-  MessageFormatItem,
-  MessageFormatRepository,
-} from "./MessageFormatAdapter";
-
-export type GenericThreadHistoryAdapter<TMessage> = {
-  load(): Promise<MessageFormatRepository<TMessage>>;
-  append(item: MessageFormatItem<TMessage>): Promise<void>;
-};
-
-export type ThreadHistoryAdapter = {
-  load(): Promise<ExportedMessageRepository & { unstable_resume?: boolean }>;
-  resume?(
-    options: ChatModelRunOptions,
-  ): AsyncGenerator<ChatModelRunResult, void, unknown>;
-  append(item: ExportedMessageRepositoryItem): Promise<void>;
-  withFormat?<TMessage, TStorageFormat>(
-    formatAdapter: MessageFormatAdapter<TMessage, TStorageFormat>,
-  ): GenericThreadHistoryAdapter<TMessage>;
-};

package/src/legacy-runtime/runtime-cores/composer/BaseComposerRuntimeCore.tsx

@@ -1,404 +0,0 @@
-import type {
-  Attachment,
-  CompleteAttachment,
-  PendingAttachment,
-} from "../../../types/AttachmentTypes";
-import type { AppendMessage, Unsubscribe } from "../../../types";
-import type { AttachmentAdapter } from "../adapters/attachment";
-import type {
-  ComposerRuntimeCore,
-  ComposerRuntimeEventType,
-  DictationState,
-} from "../core/ComposerRuntimeCore";
-import type { MessageRole, RunConfig } from "../../../types/AssistantTypes";
-import { BaseSubscribable } from "../remote-thread-list/BaseSubscribable";
-import type { DictationAdapter } from "../adapters/speech/SpeechAdapterTypes";
-
-const isAttachmentComplete = (a: Attachment): a is CompleteAttachment =>
-  a.status.type === "complete";
-
-export abstract class BaseComposerRuntimeCore
-  extends BaseSubscribable
-  implements ComposerRuntimeCore
-{
-  public readonly isEditing = true;
-
-  protected abstract getAttachmentAdapter(): AttachmentAdapter | undefined;
-  protected abstract getDictationAdapter(): DictationAdapter | undefined;
-
-  public get attachmentAccept(): string {
-    return this.getAttachmentAdapter()?.accept ?? "*";
-  }
-
-  private _attachments: readonly Attachment[] = [];
-  public get attachments() {
-    return this._attachments;
-  }
-
-  protected setAttachments(value: readonly Attachment[]) {
-    this._attachments = value;
-    this._notifySubscribers();
-  }
-
-  public abstract get canCancel(): boolean;
-
-  public get isEmpty() {
-    return !this.text.trim() && !this.attachments.length;
-  }
-
-  private _text = "";
-
-  get text() {
-    return this._text;
-  }
-
-  private _role: MessageRole = "user";
-
-  get role() {
-    return this._role;
-  }
-
-  private _runConfig: RunConfig = {};
-
-  get runConfig() {
-    return this._runConfig;
-  }
-
-  public setText(value: string) {
-    if (this._text === value) return;
-
-    this._text = value;
-    // When dictation is active and the user manually edits the composer text,
-    // treat the new text as the updated base so speech results are appended
-    // instead of overwriting manual edits.
-    if (this._dictation) {
-      this._dictationBaseText = value;
-      this._currentInterimText = "";
-      const { status, inputDisabled } = this._dictation;
-      this._dictation = inputDisabled ? { status, inputDisabled } : { status };
-    }
-    this._notifySubscribers();
-  }
-
-  public setRole(role: MessageRole) {
-    if (this._role === role) return;
-
-    this._role = role;
-    this._notifySubscribers();
-  }
-
-  public setRunConfig(runConfig: RunConfig) {
-    if (this._runConfig === runConfig) return;
-
-    this._runConfig = runConfig;
-    this._notifySubscribers();
-  }
-
-  private _emptyTextAndAttachments() {
-    this._attachments = [];
-    this._text = "";
-    this._notifySubscribers();
-  }
-
-  private async _onClearAttachments() {
-    const adapter = this.getAttachmentAdapter();
-    if (adapter) {
-      await Promise.all(this._attachments.map((a) => adapter.remove(a)));
-    }
-  }
-
-  public async reset() {
-    if (
-      this._attachments.length === 0 &&
-      this._text === "" &&
-      this._role === "user" &&
-      Object.keys(this._runConfig).length === 0
-    ) {
-      return;
-    }
-
-    this._role = "user";
-    this._runConfig = {};
-
-    const task = this._onClearAttachments();
-    this._emptyTextAndAttachments();
-    await task;
-  }
-
-  public async clearAttachments() {
-    const task = this._onClearAttachments();
-    this.setAttachments([]);
-
-    await task;
-  }
-
-  public async send() {
-    if (this._dictationSession) {
-      this._dictationSession.cancel();
-      this._cleanupDictation();
-    }
-
-    const adapter = this.getAttachmentAdapter();
-    const attachments =
-      adapter && this.attachments.length > 0
-        ? Promise.all(
-            this.attachments.map(async (a) => {
-              if (isAttachmentComplete(a)) return a;
-              const result = await adapter.send(a);
-              return result as CompleteAttachment;
-            }),
-          )
-        : [];
-
-    const text = this.text;
-    this._emptyTextAndAttachments();
-    const message: Omit<AppendMessage, "parentId" | "sourceId"> = {
-      createdAt: new Date(),
-      role: this.role,
-      content: text ? [{ type: "text", text }] : [],
-      attachments: await attachments,
-      runConfig: this.runConfig,
-      metadata: { custom: {} },
-    };
-
-    this.handleSend(message);
-    this._notifyEventSubscribers("send");
-  }
-
-  public cancel() {
-    this.handleCancel();
-  }
-
-  protected abstract handleSend(
-    message: Omit<AppendMessage, "parentId" | "sourceId">,
-  ): void;
-  protected abstract handleCancel(): void;
-
-  async addAttachment(file: File) {
-    const adapter = this.getAttachmentAdapter();
-    if (!adapter) throw new Error("Attachments are not supported");
-
-    const upsertAttachment = (a: PendingAttachment) => {
-      const idx = this._attachments.findIndex(
-        (attachment) => attachment.id === a.id,
-      );
-      if (idx !== -1)
-        this._attachments = [
-          ...this._attachments.slice(0, idx),
-          a,
-          ...this._attachments.slice(idx + 1),
-        ];
-      else {
-        this._attachments = [...this._attachments, a];
-      }
-
-      this._notifySubscribers();
-    };
-
-    const promiseOrGenerator = adapter.add({ file });
-    if (Symbol.asyncIterator in promiseOrGenerator) {
-      for await (const r of promiseOrGenerator) {
-        upsertAttachment(r);
-      }
-    } else {
-      upsertAttachment(await promiseOrGenerator);
-    }
-
-    this._notifyEventSubscribers("attachmentAdd");
-    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.toSpliced(index, 1); - not yet widely supported
-    this._attachments = [
-      ...this._attachments.slice(0, index),
-      ...this._attachments.slice(index + 1),
-    ];
-    this._notifySubscribers();
-  }
-
-  private _dictation: DictationState | undefined;
-  private _dictationSession: DictationAdapter.Session | undefined;
-  private _dictationUnsubscribes: Unsubscribe[] = [];
-  private _dictationBaseText = "";
-  private _currentInterimText = "";
-  private _dictationSessionIdCounter = 0;
-  private _activeDictationSessionId: number | undefined;
-  private _isCleaningDictation = false;
-
-  public get dictation(): DictationState | undefined {
-    return this._dictation;
-  }
-
-  private _isActiveSession(
-    sessionId: number,
-    session: DictationAdapter.Session,
-  ): boolean {
-    return (
-      this._activeDictationSessionId === sessionId &&
-      this._dictationSession === session
-    );
-  }
-
-  public startDictation(): void {
-    const adapter = this.getDictationAdapter();
-    if (!adapter) {
-      throw new Error("Dictation adapter not configured");
-    }
-
-    if (this._dictationSession) {
-      for (const unsub of this._dictationUnsubscribes) {
-        unsub();
-      }
-      this._dictationUnsubscribes = [];
-      const oldSession = this._dictationSession;
-      oldSession.stop().catch(() => {});
-      this._dictationSession = undefined;
-    }
-
-    const inputDisabled = adapter.disableInputDuringDictation ?? false;
-
-    this._dictationBaseText = this._text;
-    this._currentInterimText = "";
-
-    const session = adapter.listen();
-    this._dictationSession = session;
-    const sessionId = ++this._dictationSessionIdCounter;
-    this._activeDictationSessionId = sessionId;
-    this._dictation = { status: session.status, inputDisabled };
-    this._notifySubscribers();
-
-    const unsubSpeech = session.onSpeech((result) => {
-      if (!this._isActiveSession(sessionId, session)) return;
-      const isFinal = result.isFinal !== false;
-
-      const needsSeparator =
-        this._dictationBaseText &&
-        !this._dictationBaseText.endsWith(" ") &&
-        result.transcript;
-      const separator = needsSeparator ? " " : "";
-
-      if (isFinal) {
-        this._dictationBaseText =
-          this._dictationBaseText + separator + result.transcript;
-        this._currentInterimText = "";
-        this._text = this._dictationBaseText;
-
-        if (this._dictation) {
-          const { transcript: _, ...rest } = this._dictation;
-          this._dictation = rest;
-        }
-        this._notifySubscribers();
-      } else {
-        this._currentInterimText = separator + result.transcript;
-        this._text = this._dictationBaseText + this._currentInterimText;
-
-        if (this._dictation) {
-          this._dictation = {
-            ...this._dictation,
-            transcript: result.transcript,
-          };
-        }
-        this._notifySubscribers();
-      }
-    });
-    this._dictationUnsubscribes.push(unsubSpeech);
-
-    const unsubStart = session.onSpeechStart(() => {
-      if (!this._isActiveSession(sessionId, session)) return;
-
-      this._dictation = {
-        status: { type: "running" },
-        inputDisabled,
-        ...(this._dictation?.transcript && {
-          transcript: this._dictation.transcript,
-        }),
-      };
-      this._notifySubscribers();
-    });
-    this._dictationUnsubscribes.push(unsubStart);
-
-    const unsubEnd = session.onSpeechEnd(() => {
-      this._cleanupDictation({ sessionId });
-    });
-    this._dictationUnsubscribes.push(unsubEnd);
-
-    const statusInterval = setInterval(() => {
-      if (!this._isActiveSession(sessionId, session)) return;
-
-      if (session.status.type === "ended") {
-        this._cleanupDictation({ sessionId });
-      }
-    }, 100);
-    this._dictationUnsubscribes.push(() => clearInterval(statusInterval));
-  }
-
-  public stopDictation(): void {
-    if (!this._dictationSession) return;
-
-    const session = this._dictationSession;
-    const sessionId = this._activeDictationSessionId;
-    session.stop().finally(() => {
-      this._cleanupDictation({ sessionId });
-    });
-  }
-
-  private _cleanupDictation(options?: { sessionId: number | undefined }): void {
-    const isStaleSession =
-      options?.sessionId !== undefined &&
-      options.sessionId !== this._activeDictationSessionId;
-    if (isStaleSession || this._isCleaningDictation) return;
-
-    this._isCleaningDictation = true;
-    try {
-      for (const unsub of this._dictationUnsubscribes) {
-        unsub();
-      }
-      this._dictationUnsubscribes = [];
-      this._dictationSession = undefined;
-      this._activeDictationSessionId = undefined;
-      this._dictation = undefined;
-      this._dictationBaseText = "";
-      this._currentInterimText = "";
-      this._notifySubscribers();
-    } finally {
-      this._isCleaningDictation = false;
-    }
-  }
-
-  private _eventSubscribers = new Map<
-    ComposerRuntimeEventType,
-    Set<() => void>
-  >();
-
-  protected _notifyEventSubscribers(event: ComposerRuntimeEventType) {
-    const subscribers = this._eventSubscribers.get(event);
-    if (!subscribers) return;
-
-    for (const callback of subscribers) callback();
-  }
-
-  public unstable_on(event: ComposerRuntimeEventType, callback: () => void) {
-    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);
-      if (!subscribers) return;
-      subscribers.delete(callback);
-    };
-  }
-}

package/src/legacy-runtime/runtime-cores/composer/DefaultEditComposerRuntimeCore.tsx

@@ -1,72 +0,0 @@
-import type { AppendMessage, ThreadMessage } from "../../../types";
-import { getThreadMessageText } from "../../../utils/getThreadMessageText";
-import type { AttachmentAdapter } from "../adapters/attachment";
-import type { DictationAdapter } from "../adapters/speech/SpeechAdapterTypes";
-import type { 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;
-  }
-
-  protected getDictationAdapter() {
-    return this.runtime.adapters?.dictation;
-  }
-
-  private _nonTextParts;
-  private _previousText;
-  private _parentId;
-  private _sourceId;
-  constructor(
-    private runtime: ThreadRuntimeCore & {
-      adapters?:
-        | {
-            attachments?: AttachmentAdapter | undefined;
-            dictation?: DictationAdapter | undefined;
-          }
-        | undefined;
-    },
-    private endEditCallback: () => void,
-    { parentId, message }: { parentId: string | null; message: ThreadMessage },
-  ) {
-    super();
-    this._parentId = parentId;
-    this._sourceId = message.id;
-    this._previousText = getThreadMessageText(message);
-    this.setText(this._previousText);
-
-    this.setRole(message.role);
-    this.setAttachments(message.attachments ?? []);
-
-    this._nonTextParts = message.content.filter((part) => part.type !== "text");
-
-    // Use the runConfig from the regular (non-edit) composer as the initial runConfig for the edit composer
-    this.setRunConfig({ ...runtime.composer.runConfig });
-  }
-
-  public async handleSend(
-    message: Omit<AppendMessage, "parentId" | "sourceId">,
-  ) {
-    const text = getThreadMessageText(message as AppendMessage);
-    if (text !== this._previousText) {
-      this.runtime.append({
-        ...message,
-        content: [...message.content, ...this._nonTextParts] as any,
-        parentId: this._parentId,
-        sourceId: this._sourceId,
-      });
-    }
-
-    this.handleCancel();
-  }
-
-  public handleCancel() {
-    this.endEditCallback();
-    this._notifySubscribers();
-  }
-}

package/src/legacy-runtime/runtime-cores/composer/DefaultThreadComposerRuntimeCore.tsx

@@ -1,65 +0,0 @@
-import type { AppendMessage, PendingAttachment } from "../../../types";
-import type { AttachmentAdapter } from "../adapters/attachment";
-import type { DictationAdapter } from "../adapters/speech/SpeechAdapterTypes";
-import type { ThreadComposerRuntimeCore } from "../core/ComposerRuntimeCore";
-import type { 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;
-  }
-
-  protected getDictationAdapter() {
-    return this.runtime.adapters?.dictation;
-  }
-
-  constructor(
-    private runtime: Omit<ThreadRuntimeCore, "composer"> & {
-      adapters?:
-        | {
-            attachments?: AttachmentAdapter | undefined;
-            dictation?: DictationAdapter | 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" | "sourceId">,
-  ) {
-    this.runtime.append({
-      ...(message as AppendMessage),
-      parentId: this.runtime.messages.at(-1)?.id ?? null,
-      sourceId: null,
-    });
-  }
-
-  public async handleCancel() {
-    this.runtime.cancelRun();
-  }
-}

package/src/legacy-runtime/runtime-cores/core/AssistantRuntimeCore.tsx

@@ -1,19 +0,0 @@
-import { ComponentType } from "react";
-import type { ModelContextProvider } from "../../../model-context/ModelContextTypes";
-import type { Unsubscribe } from "../../../types/Unsubscribe";
-import { ThreadListRuntimeCore } from "./ThreadListRuntimeCore";
-
-export type AssistantRuntimeCore = {
-  readonly threads: ThreadListRuntimeCore;
-
-  registerModelContextProvider: (provider: ModelContextProvider) => Unsubscribe;
-  getModelContextProvider: () => ModelContextProvider;
-
-  /**
-   * EXPERIMENTAL: A component that is rendered inside the AssistantRuntimeProvider.
-   *
-   * Note: This field is expected to never change.
-   * To update the component, use a zustand store.
-   */
-  readonly RenderComponent?: ComponentType | undefined;
-};

package/src/legacy-runtime/runtime-cores/core/BaseAssistantRuntimeCore.tsx

@@ -1,20 +0,0 @@
-import { type ModelContextProvider } from "../../../model-context/ModelContextTypes";
-import type { Unsubscribe } from "../../../types/Unsubscribe";
-import type { AssistantRuntimeCore } from "./AssistantRuntimeCore";
-import { CompositeContextProvider } from "../../../utils/CompositeContextProvider";
-import { ThreadListRuntimeCore } from "./ThreadListRuntimeCore";
-
-export abstract class BaseAssistantRuntimeCore implements AssistantRuntimeCore {
-  protected readonly _contextProvider = new CompositeContextProvider();
-  public abstract get threads(): ThreadListRuntimeCore;
-
-  public registerModelContextProvider(
-    provider: ModelContextProvider,
-  ): Unsubscribe {
-    return this._contextProvider.registerModelContextProvider(provider);
-  }
-
-  public getModelContextProvider(): ModelContextProvider {
-    return this._contextProvider;
-  }
-}