@assistant-ui/react 0.11.0 → 0.11.1

package/src/legacy-runtime/runtime/AssistantRuntime.ts

@@ -0,0 +1,109 @@
+import { AssistantRuntimeCore } from "../runtime-cores/core/AssistantRuntimeCore";
+import { ModelContextProvider } from "../../model-context/ModelContextTypes";
+import { ThreadRuntime } from "./ThreadRuntime";
+import { Unsubscribe } from "../../types";
+import { ThreadListRuntime, ThreadListRuntimeImpl } from "./ThreadListRuntime";
+import { ExportedMessageRepository, ThreadMessageLike } from "../runtime-cores";
+
+export type AssistantRuntime = {
+  /**
+   * The threads in this assistant.
+   */
+  readonly threads: ThreadListRuntime;
+
+  /**
+   * The currently selected main thread. Equivalent to `threads.main`.
+   */
+  readonly thread: ThreadRuntime;
+
+  /**
+   * @deprecated This field was renamed to `threads`.
+   */
+  readonly threadList: ThreadListRuntime;
+
+  /**
+   * Switch to a new thread.
+   *
+   * @deprecated This method was moved to `threads.switchToNewThread`.
+   */
+  switchToNewThread(): void;
+
+  /**
+   * Switch to a thread.
+   *
+   * @param threadId The thread ID to switch to.
+   * @deprecated This method was moved to `threads.switchToThread`.
+   */
+  switchToThread(threadId: string): void;
+
+  /**
+   * Register a model context provider. Model context providers are configuration such as system message, temperature, etc. that are set in the frontend.
+   *
+   * @param provider The model context provider to register.
+   */
+  registerModelContextProvider(provider: ModelContextProvider): Unsubscribe;
+
+  /**
+   * @deprecated This method was renamed to `registerModelContextProvider`.
+   */
+  registerModelConfigProvider(provider: ModelContextProvider): Unsubscribe;
+
+  /**
+   * @deprecated Use `runtime.thread.reset(initialMessages)`.
+   */
+  reset: unknown; // make it a type error
+};
+
+export class AssistantRuntimeImpl implements AssistantRuntime {
+  public readonly threads;
+  public get threadList() {
+    return this.threads;
+  }
+
+  public readonly _thread: ThreadRuntime;
+
+  public constructor(private readonly _core: AssistantRuntimeCore) {
+    this.threads = new ThreadListRuntimeImpl(_core.threads);
+    this._thread = this.threads.main;
+
+    this.__internal_bindMethods();
+  }
+
+  protected __internal_bindMethods() {
+    this.switchToNewThread = this.switchToNewThread.bind(this);
+    this.switchToThread = this.switchToThread.bind(this);
+    this.registerModelContextProvider =
+      this.registerModelContextProvider.bind(this);
+    this.registerModelConfigProvider =
+      this.registerModelConfigProvider.bind(this);
+    this.reset = this.reset.bind(this);
+  }
+
+  public get thread() {
+    return this._thread;
+  }
+
+  public switchToNewThread() {
+    return this._core.threads.switchToNewThread();
+  }
+
+  public switchToThread(threadId: string) {
+    return this._core.threads.switchToThread(threadId);
+  }
+
+  public registerModelContextProvider(provider: ModelContextProvider) {
+    return this._core.registerModelContextProvider(provider);
+  }
+
+  public registerModelConfigProvider(provider: ModelContextProvider) {
+    return this.registerModelContextProvider(provider);
+  }
+
+  public reset({
+    initialMessages,
+  }: { initialMessages?: ThreadMessageLike[] } = {}) {
+    return this._core.threads
+      .getMainThreadRuntimeCore()
+      .import(ExportedMessageRepository.fromArray(initialMessages ?? []));
+  }
+}

package/src/legacy-runtime/runtime/AttachmentRuntime.ts

@@ -0,0 +1,119 @@
+import { SubscribableWithState } from "./subscribable/Subscribable";
+
+import type { ComposerRuntimeCoreBinding } from "./RuntimeBindings";
+import {
+  Attachment,
+  CompleteAttachment,
+  PendingAttachment,
+  Unsubscribe,
+} from "../../types";
+import { AttachmentRuntimePath } from "./RuntimePathTypes";
+
+type MessageAttachmentState = CompleteAttachment & {
+  readonly source: "message";
+};
+
+type ThreadComposerAttachmentState = PendingAttachment & {
+  readonly source: "thread-composer";
+};
+
+type EditComposerAttachmentState = Attachment & {
+  readonly source: "edit-composer";
+};
+
+export type AttachmentState =
+  | ThreadComposerAttachmentState
+  | EditComposerAttachmentState
+  | MessageAttachmentState;
+
+type AttachmentSnapshotBinding<Source extends AttachmentRuntimeSource> =
+  SubscribableWithState<
+    AttachmentState & { source: Source },
+    AttachmentRuntimePath & { attachmentSource: Source }
+  >;
+
+type AttachmentRuntimeSource = AttachmentState["source"];
+
+export type AttachmentRuntime<
+  TSource extends AttachmentRuntimeSource = AttachmentRuntimeSource,
+> = {
+  readonly path: AttachmentRuntimePath & { attachmentSource: TSource };
+  readonly source: TSource;
+  getState(): AttachmentState & { source: TSource };
+  remove(): Promise<void>;
+  subscribe(callback: () => void): Unsubscribe;
+};
+
+export abstract class AttachmentRuntimeImpl<
+  Source extends AttachmentRuntimeSource = AttachmentRuntimeSource,
+> implements AttachmentRuntime
+{
+  public get path() {
+    return this._core.path;
+  }
+
+  public abstract get source(): Source;
+
+  constructor(private _core: AttachmentSnapshotBinding<Source>) {
+    this.__internal_bindMethods();
+  }
+
+  protected __internal_bindMethods() {
+    this.getState = this.getState.bind(this);
+    this.remove = this.remove.bind(this);
+    this.subscribe = this.subscribe.bind(this);
+  }
+
+  public getState(): AttachmentState & { source: Source } {
+    return this._core.getState();
+  }
+
+  public abstract remove(): Promise<void>;
+
+  public subscribe(callback: () => void) {
+    return this._core.subscribe(callback);
+  }
+}
+
+abstract class ComposerAttachmentRuntime<
+  Source extends "thread-composer" | "edit-composer",
+> extends AttachmentRuntimeImpl<Source> {
+  constructor(
+    core: AttachmentSnapshotBinding<Source>,
+    private _composerApi: ComposerRuntimeCoreBinding,
+  ) {
+    super(core);
+  }
+
+  public remove() {
+    const core = this._composerApi.getState();
+    if (!core) throw new Error("Composer is not available");
+    return core.removeAttachment(this.getState().id);
+  }
+}
+
+export class ThreadComposerAttachmentRuntimeImpl extends ComposerAttachmentRuntime<"thread-composer"> {
+  public get source(): "thread-composer" {
+    return "thread-composer";
+  }
+}
+
+export class EditComposerAttachmentRuntimeImpl extends ComposerAttachmentRuntime<"edit-composer"> {
+  public get source(): "edit-composer" {
+    return "edit-composer";
+  }
+}
+
+export class MessageAttachmentRuntimeImpl extends AttachmentRuntimeImpl<"message"> {
+  public get source(): "message" {
+    return "message";
+  }
+
+  constructor(core: AttachmentSnapshotBinding<"message">) {
+    super(core);
+  }
+
+  public remove(): never {
+    throw new Error("Message attachments cannot be removed");
+  }
+}

package/src/legacy-runtime/runtime/ComposerRuntime.ts

@@ -0,0 +1,443 @@
+import { Attachment, PendingAttachment } from "../../types/AttachmentTypes";
+import {
+  ComposerRuntimeCore,
+  ComposerRuntimeEventType,
+  ThreadComposerRuntimeCore,
+} from "../runtime-cores/core/ComposerRuntimeCore";
+import { Unsubscribe } from "../../types";
+
+import { LazyMemoizeSubject } from "./subscribable/LazyMemoizeSubject";
+import {
+  AttachmentRuntime,
+  AttachmentState,
+  EditComposerAttachmentRuntimeImpl,
+  ThreadComposerAttachmentRuntimeImpl,
+} from "./AttachmentRuntime";
+import { ShallowMemoizeSubject } from "./subscribable/ShallowMemoizeSubject";
+import { SKIP_UPDATE } from "./subscribable/SKIP_UPDATE";
+import { ComposerRuntimePath } from "./RuntimePathTypes";
+import { MessageRole, RunConfig } from "../../types/AssistantTypes";
+import { EventSubscriptionSubject } from "./subscribable/EventSubscriptionSubject";
+import type {
+  ThreadComposerRuntimeCoreBinding,
+  EditComposerRuntimeCoreBinding,
+  ComposerRuntimeCoreBinding,
+} from "./RuntimeBindings";
+
+export type {
+  ThreadComposerRuntimeCoreBinding,
+  EditComposerRuntimeCoreBinding,
+  ComposerRuntimeCoreBinding,
+};
+
+type BaseComposerState = {
+  readonly canCancel: boolean;
+  readonly isEditing: boolean;
+  readonly isEmpty: boolean;
+
+  readonly text: string;
+  readonly role: MessageRole;
+  readonly attachments: readonly Attachment[];
+  readonly runConfig: RunConfig;
+
+  readonly attachmentAccept: string;
+};
+
+export type ThreadComposerState = BaseComposerState & {
+  readonly type: "thread";
+
+  readonly attachments: readonly PendingAttachment[];
+};
+
+export type EditComposerState = BaseComposerState & {
+  readonly type: "edit";
+};
+
+export type ComposerState = ThreadComposerState | EditComposerState;
+
+const EMPTY_ARRAY = Object.freeze([]);
+const EMPTY_OBJECT = Object.freeze({});
+const getThreadComposerState = (
+  runtime: ThreadComposerRuntimeCore | undefined,
+): ThreadComposerState => {
+  return Object.freeze({
+    type: "thread",
+
+    isEditing: runtime?.isEditing ?? false,
+    canCancel: runtime?.canCancel ?? false,
+    isEmpty: runtime?.isEmpty ?? true,
+
+    attachments: runtime?.attachments ?? EMPTY_ARRAY,
+    text: runtime?.text ?? "",
+    role: runtime?.role ?? "user",
+    runConfig: runtime?.runConfig ?? EMPTY_OBJECT,
+    attachmentAccept: runtime?.attachmentAccept ?? "",
+
+    value: runtime?.text ?? "",
+  });
+};
+
+const getEditComposerState = (
+  runtime: ComposerRuntimeCore | undefined,
+): EditComposerState => {
+  return Object.freeze({
+    type: "edit",
+
+    isEditing: runtime?.isEditing ?? false,
+    canCancel: runtime?.canCancel ?? false,
+    isEmpty: runtime?.isEmpty ?? true,
+
+    text: runtime?.text ?? "",
+    role: runtime?.role ?? "user",
+    attachments: runtime?.attachments ?? EMPTY_ARRAY,
+    runConfig: runtime?.runConfig ?? EMPTY_OBJECT,
+    attachmentAccept: runtime?.attachmentAccept ?? "",
+
+    value: runtime?.text ?? "",
+  });
+};
+
+export type ComposerRuntime = {
+  readonly path: ComposerRuntimePath;
+  readonly type: "edit" | "thread";
+
+  /**
+   * Get the current state of the composer. Includes any data that has been added to the composer.
+   */
+  getState(): ComposerState;
+
+  /**
+   * Given a standard js File object, add it to the composer. A composer can have multiple attachments.
+   * @param file The file to add to the composer.
+   */
+  addAttachment(file: File): Promise<void>;
+
+  /**
+   * Set the text of the composer.
+   * @param text The text to set in the composer.
+   */
+  setText(text: string): void;
+
+  /**
+   * Set the role of the composer. For instance, if you'd like a specific message to have the 'assistant' role, you can do so here.
+   * @param role The role to set in the composer.
+   */
+  setRole(role: MessageRole): void;
+
+  /**
+   * Set the run config of the composer. This is used to send custom configuration data to the model.
+   * Within your backend, you can access this data using the `runConfig` object.
+   * Example:
+   * ```ts
+   * composerRuntime.setRunConfig({
+   *   custom: { customField: "customValue" }
+   * });
+   * ```
+   * @param runConfig The run config to set in the composer.
+   */
+  setRunConfig(runConfig: RunConfig): void;
+
+  /**
+   * Reset the composer. This will clear the entire state of the composer, including all text and attachments.
+   */
+  reset(): Promise<void>;
+
+  /**
+   * Clear all attachments from the composer.
+   */
+  clearAttachments(): Promise<void>;
+
+  /**
+   * Send a message. This will send whatever text or attachments are in the composer.
+   */
+  send(): void;
+
+  /**
+   * Cancel the current run. In edit mode, this will exit edit mode.
+   */
+  cancel(): void;
+
+  /**
+   * Listens for changes to the composer state.
+   * @param callback The callback to call when the composer state changes.
+   */
+  subscribe(callback: () => void): Unsubscribe;
+
+  /**
+   * Get an attachment by index.
+   * @param idx The index of the attachment to get.
+   */
+  getAttachmentByIndex(idx: number): AttachmentRuntime;
+
+  /**
+   * @deprecated This API is still under active development and might change without notice.
+   */
+  unstable_on(
+    event: ComposerRuntimeEventType,
+    callback: () => void,
+  ): Unsubscribe;
+};
+
+export abstract class ComposerRuntimeImpl implements ComposerRuntime {
+  public get path() {
+    return this._core.path;
+  }
+
+  public abstract get type(): "edit" | "thread";
+
+  constructor(protected _core: ComposerRuntimeCoreBinding) {}
+
+  protected __internal_bindMethods() {
+    this.setText = this.setText.bind(this);
+    this.setRunConfig = this.setRunConfig.bind(this);
+    this.getState = this.getState.bind(this);
+    this.subscribe = this.subscribe.bind(this);
+    this.addAttachment = this.addAttachment.bind(this);
+    this.reset = this.reset.bind(this);
+    this.clearAttachments = this.clearAttachments.bind(this);
+    this.send = this.send.bind(this);
+    this.cancel = this.cancel.bind(this);
+    this.setRole = this.setRole.bind(this);
+    this.getAttachmentByIndex = this.getAttachmentByIndex.bind(this);
+    this.unstable_on = this.unstable_on.bind(this);
+  }
+
+  public abstract getState(): ComposerState;
+
+  public setText(text: string) {
+    const core = this._core.getState();
+    if (!core) throw new Error("Composer is not available");
+    core.setText(text);
+  }
+
+  public setRunConfig(runConfig: RunConfig) {
+    const core = this._core.getState();
+    if (!core) throw new Error("Composer is not available");
+    core.setRunConfig(runConfig);
+  }
+
+  public addAttachment(file: File) {
+    const core = this._core.getState();
+    if (!core) throw new Error("Composer is not available");
+    return core.addAttachment(file);
+  }
+
+  public reset() {
+    const core = this._core.getState();
+    if (!core) throw new Error("Composer is not available");
+    return core.reset();
+  }
+
+  public clearAttachments() {
+    const core = this._core.getState();
+    if (!core) throw new Error("Composer is not available");
+    return core.clearAttachments();
+  }
+
+  public send() {
+    const core = this._core.getState();
+    if (!core) throw new Error("Composer is not available");
+    core.send();
+  }
+
+  public cancel() {
+    const core = this._core.getState();
+    if (!core) throw new Error("Composer is not available");
+    core.cancel();
+  }
+
+  public setRole(role: MessageRole) {
+    const core = this._core.getState();
+    if (!core) throw new Error("Composer is not available");
+    core.setRole(role);
+  }
+
+  public subscribe(callback: () => void) {
+    return this._core.subscribe(callback);
+  }
+
+  private _eventSubscriptionSubjects = new Map<
+    string,
+    EventSubscriptionSubject<ComposerRuntimeEventType>
+  >();
+
+  public unstable_on(
+    event: ComposerRuntimeEventType,
+    callback: () => void,
+  ): Unsubscribe {
+    let subject = this._eventSubscriptionSubjects.get(event);
+    if (!subject) {
+      subject = new EventSubscriptionSubject({
+        event: event,
+        binding: this._core,
+      });
+      this._eventSubscriptionSubjects.set(event, subject);
+    }
+    return subject.subscribe(callback);
+  }
+
+  public abstract getAttachmentByIndex(idx: number): AttachmentRuntime;
+}
+
+export type ThreadComposerRuntime = Omit<
+  ComposerRuntime,
+  "getState" | "getAttachmentByIndex"
+> & {
+  readonly path: ComposerRuntimePath & { composerSource: "thread" };
+  readonly type: "thread";
+  getState(): ThreadComposerState;
+
+  getAttachmentByIndex(
+    idx: number,
+  ): AttachmentRuntime & { source: "thread-composer" };
+};
+
+export class ThreadComposerRuntimeImpl
+  extends ComposerRuntimeImpl
+  implements ThreadComposerRuntime
+{
+  public override get path() {
+    return this._core.path as ComposerRuntimePath & {
+      composerSource: "thread";
+    };
+  }
+
+  public get type() {
+    return "thread" as const;
+  }
+
+  private _getState;
+
+  constructor(core: ThreadComposerRuntimeCoreBinding) {
+    const stateBinding = new LazyMemoizeSubject({
+      path: core.path,
+      getState: () => getThreadComposerState(core.getState()),
+      subscribe: (callback) => core.subscribe(callback),
+    });
+    super({
+      path: core.path,
+      getState: () => core.getState(),
+      subscribe: (callback) => stateBinding.subscribe(callback),
+    });
+    this._getState = stateBinding.getState.bind(stateBinding);
+
+    this.__internal_bindMethods();
+  }
+
+  public override getState(): ThreadComposerState {
+    return this._getState();
+  }
+
+  public getAttachmentByIndex(idx: number) {
+    return new ThreadComposerAttachmentRuntimeImpl(
+      new ShallowMemoizeSubject({
+        path: {
+          ...this.path,
+          attachmentSource: "thread-composer",
+          attachmentSelector: { type: "index", index: idx },
+          ref: this.path.ref + `${this.path.ref}.attachments[${idx}]`,
+        },
+        getState: () => {
+          const attachments = this.getState().attachments;
+          const attachment = attachments[idx];
+          if (!attachment) return SKIP_UPDATE;
+
+          return {
+            ...attachment,
+            source: "thread-composer",
+          } satisfies AttachmentState & { source: "thread-composer" };
+        },
+        subscribe: (callback) => this._core.subscribe(callback),
+      }),
+      this._core,
+    );
+  }
+}
+
+export type EditComposerRuntime = Omit<
+  ComposerRuntime,
+  "getState" | "getAttachmentByIndex"
+> & {
+  readonly path: ComposerRuntimePath & { composerSource: "edit" };
+  readonly type: "edit";
+
+  getState(): EditComposerState;
+  beginEdit(): void;
+
+  getAttachmentByIndex(
+    idx: number,
+  ): AttachmentRuntime & { source: "edit-composer" };
+};
+
+export class EditComposerRuntimeImpl
+  extends ComposerRuntimeImpl
+  implements EditComposerRuntime
+{
+  public override get path() {
+    return this._core.path as ComposerRuntimePath & { composerSource: "edit" };
+  }
+
+  public get type() {
+    return "edit" as const;
+  }
+
+  private _getState;
+  constructor(
+    core: EditComposerRuntimeCoreBinding,
+    private _beginEdit: () => void,
+  ) {
+    const stateBinding = new LazyMemoizeSubject({
+      path: core.path,
+      getState: () => getEditComposerState(core.getState()),
+      subscribe: (callback) => core.subscribe(callback),
+    });
+
+    super({
+      path: core.path,
+      getState: () => core.getState(),
+      subscribe: (callback) => stateBinding.subscribe(callback),
+    });
+
+    this._getState = stateBinding.getState.bind(stateBinding);
+
+    this.__internal_bindMethods();
+  }
+
+  public override __internal_bindMethods() {
+    super.__internal_bindMethods();
+    this.beginEdit = this.beginEdit.bind(this);
+  }
+
+  public override getState(): EditComposerState {
+    return this._getState();
+  }
+
+  public beginEdit() {
+    this._beginEdit();
+  }
+
+  public getAttachmentByIndex(idx: number) {
+    return new EditComposerAttachmentRuntimeImpl(
+      new ShallowMemoizeSubject({
+        path: {
+          ...this.path,
+          attachmentSource: "edit-composer",
+          attachmentSelector: { type: "index", index: idx },
+          ref: this.path.ref + `${this.path.ref}.attachments[${idx}]`,
+        },
+        getState: () => {
+          const attachments = this.getState().attachments;
+          const attachment = attachments[idx];
+          if (!attachment) return SKIP_UPDATE;
+
+          return {
+            ...attachment,
+            source: "edit-composer",
+          } satisfies AttachmentState & { source: "edit-composer" };
+        },
+        subscribe: (callback) => this._core.subscribe(callback),
+      }),
+      this._core,
+    );
+  }
+}