@assistant-ui/react 0.10.50 → 0.11.1

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

@@ -0,0 +1,330 @@
+import {
+  SpeechState,
+  SubmittedFeedback,
+} from "../runtime-cores/core/ThreadRuntimeCore";
+import { symbolInnerMessage } from "../runtime-cores/external-store/getExternalStoreMessage";
+import {
+  ThreadMessage,
+  ThreadAssistantMessagePart,
+  ThreadUserMessagePart,
+  Unsubscribe,
+} from "../../types";
+import {
+  MessagePartStatus,
+  RunConfig,
+  ToolCallMessagePartStatus,
+} from "../../types/AssistantTypes";
+import { getThreadMessageText } from "../../utils/getThreadMessageText";
+import {
+  AttachmentRuntime,
+  AttachmentState,
+  MessageAttachmentRuntimeImpl,
+} from "./AttachmentRuntime";
+import {
+  EditComposerRuntime,
+  EditComposerRuntimeImpl,
+} from "./ComposerRuntime";
+import {
+  MessagePartRuntime,
+  MessagePartRuntimeImpl,
+  MessagePartState,
+} from "./MessagePartRuntime";
+import { MessageRuntimePath } from "./RuntimePathTypes";
+import { ThreadRuntimeCoreBinding } from "./ThreadRuntime";
+import { NestedSubscriptionSubject } from "./subscribable/NestedSubscriptionSubject";
+import { SKIP_UPDATE } from "./subscribable/SKIP_UPDATE";
+import { ShallowMemoizeSubject } from "./subscribable/ShallowMemoizeSubject";
+import type { MessageStateBinding } from "./RuntimeBindings";
+
+const COMPLETE_STATUS: MessagePartStatus = Object.freeze({
+  type: "complete",
+});
+
+export const toMessagePartStatus = (
+  message: ThreadMessage,
+  partIndex: number,
+  part: ThreadUserMessagePart | ThreadAssistantMessagePart,
+): ToolCallMessagePartStatus => {
+  if (message.role !== "assistant") return COMPLETE_STATUS;
+
+  if (part.type === "tool-call") {
+    if (!part.result) {
+      return message.status as ToolCallMessagePartStatus;
+    } else {
+      return COMPLETE_STATUS;
+    }
+  }
+
+  const isLastPart = partIndex === Math.max(0, message.content.length - 1);
+  if (message.status.type === "requires-action") return COMPLETE_STATUS;
+  return isLastPart ? (message.status as MessagePartStatus) : COMPLETE_STATUS;
+};
+
+const getMessagePartState = (
+  message: MessageState,
+  partIndex: number,
+): MessagePartState | SKIP_UPDATE => {
+  const part = message.content[partIndex];
+  if (!part) {
+    return SKIP_UPDATE;
+  }
+
+  // if the message part is the same, don't update
+  const status = toMessagePartStatus(message, partIndex, part);
+  return Object.freeze({
+    ...part,
+    ...{ [symbolInnerMessage]: (part as any)[symbolInnerMessage] },
+    status,
+  });
+};
+
+export type MessageState = ThreadMessage & {
+  readonly parentId: string | null;
+  readonly isLast: boolean;
+
+  readonly branchNumber: number;
+  readonly branchCount: number;
+
+  /**
+   * @deprecated This API is still under active development and might change without notice.
+   */
+  readonly speech: SpeechState | undefined;
+  readonly submittedFeedback: SubmittedFeedback | undefined;
+};
+
+export type { MessageStateBinding } from "./RuntimeBindings";
+
+type ReloadConfig = {
+  runConfig?: RunConfig;
+};
+
+export type MessageRuntime = {
+  readonly path: MessageRuntimePath;
+
+  readonly composer: EditComposerRuntime;
+
+  getState(): MessageState;
+  reload(config?: ReloadConfig): void;
+  /**
+   * @deprecated This API is still under active development and might change without notice.
+   */
+  speak(): void;
+  /**
+   * @deprecated This API is still under active development and might change without notice.
+   */
+  stopSpeaking(): void;
+  submitFeedback({ type }: { type: "positive" | "negative" }): void;
+  switchToBranch({
+    position,
+    branchId,
+  }: {
+    position?: "previous" | "next" | undefined;
+    branchId?: string | undefined;
+  }): void;
+  unstable_getCopyText(): string;
+
+  subscribe(callback: () => void): Unsubscribe;
+
+  getMessagePartByIndex(idx: number): MessagePartRuntime;
+  getMessagePartByToolCallId(toolCallId: string): MessagePartRuntime;
+
+  getAttachmentByIndex(idx: number): AttachmentRuntime & { source: "message" };
+};
+
+export class MessageRuntimeImpl implements MessageRuntime {
+  public get path() {
+    return this._core.path;
+  }
+
+  constructor(
+    private _core: MessageStateBinding,
+    private _threadBinding: ThreadRuntimeCoreBinding,
+  ) {
+    this.composer = new EditComposerRuntimeImpl(
+      new NestedSubscriptionSubject({
+        path: {
+          ...this.path,
+          ref: this.path.ref + `${this.path.ref}.composer`,
+          composerSource: "edit",
+        },
+        getState: this._getEditComposerRuntimeCore,
+        subscribe: (callback) => this._threadBinding.subscribe(callback),
+      }),
+      () => this._threadBinding.getState().beginEdit(this._core.getState().id),
+    );
+
+    this.__internal_bindMethods();
+  }
+
+  protected __internal_bindMethods() {
+    this.reload = this.reload.bind(this);
+    this.getState = this.getState.bind(this);
+    this.subscribe = this.subscribe.bind(this);
+    this.getMessagePartByIndex = this.getMessagePartByIndex.bind(this);
+    this.getMessagePartByToolCallId =
+      this.getMessagePartByToolCallId.bind(this);
+    this.getAttachmentByIndex = this.getAttachmentByIndex.bind(this);
+    this.unstable_getCopyText = this.unstable_getCopyText.bind(this);
+    this.speak = this.speak.bind(this);
+    this.stopSpeaking = this.stopSpeaking.bind(this);
+    this.submitFeedback = this.submitFeedback.bind(this);
+    this.switchToBranch = this.switchToBranch.bind(this);
+  }
+
+  public readonly composer;
+
+  private _getEditComposerRuntimeCore = () => {
+    return this._threadBinding
+      .getState()
+      .getEditComposer(this._core.getState().id);
+  };
+
+  public getState() {
+    return this._core.getState();
+  }
+
+  public reload(reloadConfig: ReloadConfig = {}) {
+    const editComposerRuntimeCore = this._getEditComposerRuntimeCore();
+    const composerRuntimeCore =
+      editComposerRuntimeCore ?? this._threadBinding.getState().composer;
+    const composer = editComposerRuntimeCore ?? composerRuntimeCore;
+
+    const { runConfig = composer.runConfig } = reloadConfig;
+    const state = this._core.getState();
+    if (state.role !== "assistant")
+      throw new Error("Can only reload assistant messages");
+
+    this._threadBinding.getState().startRun({
+      parentId: state.parentId,
+      sourceId: state.id,
+      runConfig,
+    });
+  }
+
+  public speak() {
+    const state = this._core.getState();
+    return this._threadBinding.getState().speak(state.id);
+  }
+
+  public stopSpeaking() {
+    const state = this._core.getState();
+    const thread = this._threadBinding.getState();
+    if (thread.speech?.messageId === state.id) {
+      this._threadBinding.getState().stopSpeaking();
+    } else {
+      throw new Error("Message is not being spoken");
+    }
+  }
+
+  public submitFeedback({ type }: { type: "positive" | "negative" }) {
+    const state = this._core.getState();
+    this._threadBinding.getState().submitFeedback({
+      messageId: state.id,
+      type,
+    });
+  }
+
+  public switchToBranch({
+    position,
+    branchId,
+  }: {
+    position?: "previous" | "next" | undefined;
+    branchId?: string | undefined;
+  }) {
+    const state = this._core.getState();
+    if (branchId && position) {
+      throw new Error("May not specify both branchId and position");
+    } else if (!branchId && !position) {
+      throw new Error("Must specify either branchId or position");
+    }
+
+    const thread = this._threadBinding.getState();
+    const branches = thread.getBranches(state.id);
+    let targetBranch = branchId;
+    if (position === "previous") {
+      targetBranch = branches[state.branchNumber - 2];
+    } else if (position === "next") {
+      targetBranch = branches[state.branchNumber];
+    }
+    if (!targetBranch) throw new Error("Branch not found");
+
+    this._threadBinding.getState().switchToBranch(targetBranch);
+  }
+
+  public unstable_getCopyText() {
+    return getThreadMessageText(this.getState());
+  }
+
+  public subscribe(callback: () => void) {
+    return this._core.subscribe(callback);
+  }
+
+  public getMessagePartByIndex(idx: number) {
+    if (idx < 0) throw new Error("Message part index must be >= 0");
+    return new MessagePartRuntimeImpl(
+      new ShallowMemoizeSubject({
+        path: {
+          ...this.path,
+          ref: this.path.ref + `${this.path.ref}.content[${idx}]`,
+          messagePartSelector: { type: "index", index: idx },
+        },
+        getState: () => {
+          return getMessagePartState(this.getState(), idx);
+        },
+        subscribe: (callback) => this._core.subscribe(callback),
+      }),
+      this._core,
+      this._threadBinding,
+    );
+  }
+
+  public getMessagePartByToolCallId(toolCallId: string) {
+    return new MessagePartRuntimeImpl(
+      new ShallowMemoizeSubject({
+        path: {
+          ...this.path,
+          ref:
+            this.path.ref +
+            `${this.path.ref}.content[toolCallId=${JSON.stringify(toolCallId)}]`,
+          messagePartSelector: { type: "toolCallId", toolCallId },
+        },
+        getState: () => {
+          const state = this._core.getState();
+          const idx = state.content.findIndex(
+            (part) =>
+              part.type === "tool-call" && part.toolCallId === toolCallId,
+          );
+          if (idx === -1) return SKIP_UPDATE;
+          return getMessagePartState(state, idx);
+        },
+        subscribe: (callback) => this._core.subscribe(callback),
+      }),
+      this._core,
+      this._threadBinding,
+    );
+  }
+
+  public getAttachmentByIndex(idx: number) {
+    return new MessageAttachmentRuntimeImpl(
+      new ShallowMemoizeSubject({
+        path: {
+          ...this.path,
+          ref: this.path.ref + `${this.path.ref}.attachments[${idx}]`,
+          attachmentSource: "message",
+          attachmentSelector: { type: "index", index: idx },
+        },
+        getState: () => {
+          const attachments = this.getState().attachments;
+          const attachment = attachments?.[idx];
+          if (!attachment) return SKIP_UPDATE;
+
+          return {
+            ...attachment,
+            source: "message",
+          } satisfies AttachmentState & { source: "message" };
+        },
+        subscribe: (callback) => this._core.subscribe(callback),
+      }),
+    );
+  }
+}

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

@@ -0,0 +1,70 @@
+import type {
+  ComposerRuntimeCore,
+  ThreadComposerRuntimeCore,
+} from "../runtime-cores/core/ComposerRuntimeCore";
+import type { ThreadRuntimeCore } from "../runtime-cores/core/ThreadRuntimeCore";
+import type { ThreadListRuntimeCore } from "../runtime-cores/core/ThreadListRuntimeCore";
+import type { SubscribableWithState } from "./subscribable/Subscribable";
+import type { ThreadMessage } from "../../types";
+import type {
+  SpeechState,
+  SubmittedFeedback,
+} from "../runtime-cores/core/ThreadRuntimeCore";
+import type {
+  ComposerRuntimePath,
+  ThreadRuntimePath,
+  ThreadListItemRuntimePath,
+  MessageRuntimePath,
+} from "./RuntimePathTypes";
+
+export type ComposerRuntimeCoreBinding = SubscribableWithState<
+  ComposerRuntimeCore | undefined,
+  ComposerRuntimePath
+>;
+
+export type ThreadComposerRuntimeCoreBinding = SubscribableWithState<
+  ThreadComposerRuntimeCore | undefined,
+  ComposerRuntimePath & { composerSource: "thread" }
+>;
+
+export type EditComposerRuntimeCoreBinding = SubscribableWithState<
+  ComposerRuntimeCore | undefined,
+  ComposerRuntimePath & { composerSource: "edit" }
+>;
+
+export type ThreadRuntimeCoreBinding = SubscribableWithState<
+  ThreadRuntimeCore,
+  ThreadRuntimePath
+>;
+
+export type ThreadListRuntimeCoreBinding = SubscribableWithState<
+  ThreadListRuntimeCore,
+  ThreadListItemRuntimePath
+>;
+
+export type MessageStateBinding = SubscribableWithState<
+  ThreadMessage & {
+    readonly parentId: string | null;
+    readonly isLast: boolean;
+    readonly branchNumber: number;
+    readonly branchCount: number;
+    readonly speech: SpeechState | undefined;
+    readonly submittedFeedback: SubmittedFeedback | undefined;
+  },
+  MessageRuntimePath
+>;
+
+export type ThreadListItemStatus = "archived" | "regular" | "new" | "deleted";
+
+export type ThreadListItemState = {
+  readonly isMain: boolean;
+  readonly id: string;
+  readonly remoteId: string | undefined;
+  readonly externalId: string | undefined;
+  /**
+   * @deprecated Use `id` instead. This field will be removed in version 0.8.0.
+   */
+  readonly threadId: string;
+  readonly status: ThreadListItemStatus;
+  readonly title?: string | undefined;
+};

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

@@ -0,0 +1,155 @@
+import { Unsubscribe } from "../../types";
+import { ThreadListItemRuntimePath } from "./RuntimePathTypes";
+import { SubscribableWithState } from "./subscribable/Subscribable";
+import { ThreadListRuntimeCoreBinding } from "./ThreadListRuntime";
+
+export type ThreadListItemEventType = "switched-to" | "switched-away";
+
+import type {
+  ThreadListItemState,
+  ThreadListItemStatus,
+} from "./RuntimeBindings";
+
+export type { ThreadListItemState, ThreadListItemStatus };
+
+export type ThreadListItemRuntime = {
+  readonly path: ThreadListItemRuntimePath;
+  getState(): ThreadListItemState;
+
+  initialize(): Promise<{ remoteId: string; externalId: string | undefined }>;
+  generateTitle(): Promise<void>;
+
+  switchTo(): Promise<void>;
+  rename(newTitle: string): Promise<void>;
+  archive(): Promise<void>;
+  unarchive(): Promise<void>;
+  delete(): Promise<void>;
+
+  /**
+   * Detaches the ThreadListItem instance, unmounting the ThreadRuntime hook.
+   */
+  detach(): void;
+
+  subscribe(callback: () => void): Unsubscribe;
+
+  unstable_on(
+    event: ThreadListItemEventType,
+    callback: () => void,
+  ): Unsubscribe;
+
+  /** @internal */
+  __internal_getRuntime(): ThreadListItemRuntime;
+};
+
+export type ThreadListItemStateBinding = SubscribableWithState<
+  ThreadListItemState,
+  ThreadListItemRuntimePath
+>;
+
+export class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {
+  public get path() {
+    return this._core.path;
+  }
+
+  constructor(
+    private _core: ThreadListItemStateBinding,
+    private _threadListBinding: ThreadListRuntimeCoreBinding,
+  ) {
+    this.__internal_bindMethods();
+  }
+
+  protected __internal_bindMethods() {
+    this.switchTo = this.switchTo.bind(this);
+    this.rename = this.rename.bind(this);
+    this.archive = this.archive.bind(this);
+    this.unarchive = this.unarchive.bind(this);
+    this.delete = this.delete.bind(this);
+    this.initialize = this.initialize.bind(this);
+    this.generateTitle = this.generateTitle.bind(this);
+    this.subscribe = this.subscribe.bind(this);
+    this.unstable_on = this.unstable_on.bind(this);
+    this.getState = this.getState.bind(this);
+    this.detach = this.detach.bind(this);
+  }
+
+  public getState(): ThreadListItemState {
+    return this._core.getState();
+  }
+
+  public switchTo(): Promise<void> {
+    const state = this._core.getState();
+    return this._threadListBinding.switchToThread(state.id);
+  }
+
+  public rename(newTitle: string): Promise<void> {
+    const state = this._core.getState();
+
+    return this._threadListBinding.rename(state.id, newTitle);
+  }
+
+  public archive(): Promise<void> {
+    const state = this._core.getState();
+
+    return this._threadListBinding.archive(state.id);
+  }
+
+  public unarchive(): Promise<void> {
+    const state = this._core.getState();
+
+    return this._threadListBinding.unarchive(state.id);
+  }
+
+  public delete(): Promise<void> {
+    const state = this._core.getState();
+
+    return this._threadListBinding.delete(state.id);
+  }
+
+  public initialize(): Promise<{
+    remoteId: string;
+    externalId: string | undefined;
+  }> {
+    const state = this._core.getState();
+    return this._threadListBinding.initialize(state.id);
+  }
+
+  public generateTitle(): Promise<void> {
+    const state = this._core.getState();
+    return this._threadListBinding.generateTitle(state.id);
+  }
+
+  public unstable_on(event: ThreadListItemEventType, callback: () => void) {
+    // if the runtime is bound to a specific thread, trigger if isMain is toggled
+    // if the runtime is bound to the main thread, trigger switched-to if threadId changes
+
+    let prevIsMain = this._core.getState().isMain;
+    let prevThreadId = this._core.getState().id;
+    return this.subscribe(() => {
+      const currentState = this._core.getState();
+      const newIsMain = currentState.isMain;
+      const newThreadId = currentState.id;
+      if (prevIsMain === newIsMain && prevThreadId === newThreadId) return;
+      prevIsMain = newIsMain;
+      prevThreadId = newThreadId;
+
+      if (event === "switched-to" && !newIsMain) return;
+      if (event === "switched-away" && newIsMain) return;
+      callback();
+    });
+  }
+
+  public subscribe(callback: () => void): Unsubscribe {
+    return this._core.subscribe(callback);
+  }
+
+  public detach(): void {
+    const state = this._core.getState();
+
+    this._threadListBinding.detach(state.id);
+  }
+
+  /** @internal */
+  public __internal_getRuntime(): ThreadListItemRuntime {
+    return this;
+  }
+}