@assistant-ui/core 0.1.0

package/src/runtime/api/message-part-runtime.ts

@@ -0,0 +1,108 @@
+import type {
+  ThreadAssistantMessagePart,
+  ThreadUserMessagePart,
+  MessagePartStatus,
+  ToolCallMessagePartStatus,
+  Unsubscribe,
+} from "../../types";
+import type { SubscribableWithState } from "../../subscribable/subscribable";
+import type { ThreadRuntimeCoreBinding } from "./thread-runtime";
+import type { MessageStateBinding } from "./bindings";
+import type { MessagePartRuntimePath } from "./paths";
+import { ToolResponse } from "assistant-stream";
+
+export type MessagePartState = (
+  | ThreadUserMessagePart
+  | ThreadAssistantMessagePart
+) & {
+  readonly status: MessagePartStatus | ToolCallMessagePartStatus;
+};
+
+type MessagePartSnapshotBinding = SubscribableWithState<
+  MessagePartState,
+  MessagePartRuntimePath
+>;
+
+export type MessagePartRuntime = {
+  addToolResult(result: any | ToolResponse<any>): void;
+  resumeToolCall(payload: unknown): void;
+
+  readonly path: MessagePartRuntimePath;
+  getState(): MessagePartState;
+  subscribe(callback: () => void): Unsubscribe;
+};
+
+export class MessagePartRuntimeImpl implements MessagePartRuntime {
+  public get path() {
+    return this.contentBinding.path;
+  }
+
+  constructor(
+    private contentBinding: MessagePartSnapshotBinding,
+    private messageApi?: MessageStateBinding,
+    private threadApi?: ThreadRuntimeCoreBinding,
+  ) {
+    this.__internal_bindMethods();
+  }
+
+  protected __internal_bindMethods() {
+    this.addToolResult = this.addToolResult.bind(this);
+    this.resumeToolCall = this.resumeToolCall.bind(this);
+    this.getState = this.getState.bind(this);
+    this.subscribe = this.subscribe.bind(this);
+  }
+
+  public getState() {
+    return this.contentBinding.getState();
+  }
+
+  public addToolResult(result: any | ToolResponse<any>) {
+    const state = this.contentBinding.getState();
+    if (!state) throw new Error("Message part is not available");
+
+    if (state.type !== "tool-call")
+      throw new Error("Tried to add tool result to non-tool message part");
+
+    if (!this.messageApi)
+      throw new Error(
+        "Message API is not available. This is likely a bug in assistant-ui.",
+      );
+    if (!this.threadApi) throw new Error("Thread API is not available");
+
+    const message = this.messageApi.getState();
+    if (!message) throw new Error("Message is not available");
+
+    const toolName = state.toolName;
+    const toolCallId = state.toolCallId;
+
+    const response = ToolResponse.toResponse(result);
+    this.threadApi.getState().addToolResult({
+      messageId: message.id,
+      toolName,
+      toolCallId,
+      result: response.result,
+      artifact: response.artifact,
+      isError: response.isError,
+    });
+  }
+
+  public resumeToolCall(payload: unknown) {
+    const state = this.contentBinding.getState();
+    if (!state) throw new Error("Message part is not available");
+
+    if (state.type !== "tool-call")
+      throw new Error("Tried to resume tool call on non-tool message part");
+
+    if (!this.threadApi) throw new Error("Thread API is not available");
+
+    const toolCallId = state.toolCallId;
+    this.threadApi.getState().resumeToolCall({
+      toolCallId,
+      payload,
+    });
+  }
+
+  public subscribe(callback: () => void) {
+    return this.contentBinding.subscribe(callback);
+  }
+}

package/src/runtime/api/message-runtime.ts

@@ -0,0 +1,335 @@
+import {
+  SpeechState,
+  SubmittedFeedback,
+} from "../interfaces/thread-runtime-core";
+import { symbolInnerMessage } from "../utils/external-store-message";
+import type {
+  MessagePartStatus,
+  RunConfig,
+  ToolCallMessagePartStatus,
+  ThreadMessage,
+  ThreadAssistantMessagePart,
+  ThreadUserMessagePart,
+  Unsubscribe,
+} from "../../types";
+import { getThreadMessageText } from "../../utils/text";
+import {
+  NestedSubscriptionSubject,
+  SKIP_UPDATE,
+  ShallowMemoizeSubject,
+} from "../../subscribable";
+import {
+  AttachmentRuntime,
+  AttachmentState,
+  MessageAttachmentRuntimeImpl,
+} from "./attachment-runtime";
+import {
+  EditComposerRuntime,
+  EditComposerRuntimeImpl,
+} from "./composer-runtime";
+import {
+  MessagePartRuntime,
+  MessagePartRuntimeImpl,
+  MessagePartState,
+} from "./message-part-runtime";
+import { MessageRuntimePath } from "./paths";
+import { ThreadRuntimeCoreBinding } from "./thread-runtime";
+import type { MessageStateBinding } from "./bindings";
+
+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;
+  /** The position of this message in the thread (0 for first message) */
+  readonly index: number;
+  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;
+  /**
+   * @deprecated Use `message.metadata.submittedFeedback` instead. This will be removed in 0.12.0.
+   */
+  readonly submittedFeedback: SubmittedFeedback | undefined;
+};
+
+export type { MessageStateBinding } from "./bindings";
+
+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/runtime/api/paths.ts

@@ -0,0 +1,61 @@
+export type ThreadListItemRuntimePath = {
+  readonly ref: string;
+  readonly threadSelector:
+    | { readonly type: "main" }
+    | { readonly type: "index"; readonly index: number }
+    | { readonly type: "archiveIndex"; readonly index: number }
+    | { readonly type: "threadId"; readonly threadId: string };
+};
+
+export type ThreadRuntimePath = {
+  readonly ref: string;
+  readonly threadSelector:
+    | { readonly type: "main" }
+    | {
+        readonly type: "threadId";
+        readonly threadId: string;
+      };
+};
+
+export type MessageRuntimePath = ThreadRuntimePath & {
+  readonly messageSelector:
+    | { readonly type: "messageId"; readonly messageId: string }
+    | { readonly type: "index"; readonly index: number };
+};
+
+export type MessagePartRuntimePath = MessageRuntimePath & {
+  readonly messagePartSelector:
+    | { readonly type: "index"; readonly index: number }
+    | { readonly type: "toolCallId"; readonly toolCallId: string };
+};
+
+export type AttachmentRuntimePath = (
+  | (MessageRuntimePath & {
+      readonly attachmentSource: "message" | "edit-composer";
+    })
+  | (ThreadRuntimePath & {
+      readonly attachmentSource: "thread-composer";
+    })
+) & {
+  readonly attachmentSelector:
+    | {
+        readonly type: "index";
+        readonly index: number;
+      }
+    | {
+        readonly type: "index";
+        readonly index: number;
+      }
+    | {
+        readonly type: "index";
+        readonly index: number;
+      };
+};
+
+export type ComposerRuntimePath =
+  | (ThreadRuntimePath & {
+      readonly composerSource: "thread";
+    })
+  | (MessageRuntimePath & {
+      readonly composerSource: "edit";
+    });

package/src/runtime/api/thread-list-item-runtime.ts

@@ -0,0 +1,145 @@
+import type { Unsubscribe } from "../../types";
+import type { SubscribableWithState } from "../../subscribable/subscribable";
+import type { ThreadListItemRuntimePath } from "./paths";
+import type { ThreadListRuntimeCoreBinding } from "./thread-list-runtime";
+
+export type ThreadListItemEventType = "switchedTo" | "switchedAway";
+
+import type { ThreadListItemState } from "./bindings";
+import type { ThreadListItemStatus } from "../interfaces/thread-list-runtime-core";
+
+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>;
+
+  detach(): void;
+
+  subscribe(callback: () => void): Unsubscribe;
+
+  unstable_on(
+    event: ThreadListItemEventType,
+    callback: () => void,
+  ): Unsubscribe;
+
+  __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) {
+    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 === "switchedTo" && !newIsMain) return;
+      if (event === "switchedAway" && 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);
+  }
+
+  public __internal_getRuntime(): ThreadListItemRuntime {
+    return this;
+  }
+}