@assistant-ui/react 0.10.50 → 0.11.1

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

@@ -0,0 +1,49 @@
+import { Unsubscribe } from "../../../types";
+import { ThreadRuntimeCore } from "./ThreadRuntimeCore";
+import type { ThreadListItemStatus } from "../../runtime/RuntimeBindings";
+
+export type ThreadListItemCoreState = {
+  readonly id: string;
+  readonly remoteId: string | undefined;
+  readonly externalId: string | undefined;
+
+  readonly status: ThreadListItemStatus;
+  readonly title?: string | undefined;
+
+  readonly runtime?: ThreadRuntimeCore | undefined;
+};
+
+export type ThreadListRuntimeCore = {
+  readonly isLoading: boolean;
+  mainThreadId: string;
+  newThreadId: string | undefined;
+
+  threadIds: readonly string[];
+  archivedThreadIds: readonly string[];
+
+  readonly threadData: Readonly<Record<string, ThreadListItemCoreState>>;
+
+  getMainThreadRuntimeCore(): ThreadRuntimeCore;
+  getThreadRuntimeCore(threadId: string): ThreadRuntimeCore;
+
+  getItemById(threadId: string): ThreadListItemCoreState | undefined;
+
+  switchToThread(threadId: string): Promise<void>;
+  switchToNewThread(): Promise<void>;
+
+  getLoadThreadsPromise(): Promise<void>;
+  // getLoadArchivedThreadsPromise(): Promise<void>;
+
+  detach(threadId: string): Promise<void>;
+  rename(threadId: string, newTitle: string): Promise<void>;
+  archive(threadId: string): Promise<void>;
+  unarchive(threadId: string): Promise<void>;
+  delete(threadId: string): Promise<void>;
+
+  initialize(
+    threadId: string,
+  ): Promise<{ remoteId: string; externalId: string | undefined }>;
+  generateTitle(threadId: string): Promise<void>;
+
+  subscribe(callback: () => void): Unsubscribe;
+};

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

@@ -0,0 +1,125 @@
+import { ReadonlyJSONValue } from "assistant-stream/utils";
+import { ModelContext } from "../../../model-context";
+import { AppendMessage, ThreadMessage } from "../../../types";
+import { RunConfig } from "../../../types/AssistantTypes";
+import type { Unsubscribe } from "../../../types/Unsubscribe";
+import { SpeechSynthesisAdapter } from "../adapters/speech/SpeechAdapterTypes";
+import { ChatModelRunOptions, ChatModelRunResult } from "../local";
+import { ExportedMessageRepository } from "../utils/MessageRepository";
+import { ThreadMessageLike } from "../external-store";
+import {
+  ComposerRuntimeCore,
+  ThreadComposerRuntimeCore,
+} from "./ComposerRuntimeCore";
+
+export type RuntimeCapabilities = {
+  readonly switchToBranch: boolean;
+  readonly edit: boolean;
+  readonly reload: boolean;
+  readonly cancel: boolean;
+  readonly unstable_copy: boolean;
+  readonly speech: boolean;
+  readonly attachments: boolean;
+  readonly feedback: boolean;
+};
+
+export type AddToolResultOptions = {
+  messageId: string;
+  toolName: string;
+  toolCallId: string;
+  result: ReadonlyJSONValue;
+  isError: boolean;
+  artifact?: ReadonlyJSONValue | undefined;
+};
+
+export type SubmitFeedbackOptions = {
+  messageId: string;
+  type: "negative" | "positive";
+};
+
+export type ThreadSuggestion = {
+  prompt: string;
+};
+
+export type SpeechState = {
+  readonly messageId: string;
+  readonly status: SpeechSynthesisAdapter.Status;
+};
+
+export type SubmittedFeedback = {
+  readonly type: "negative" | "positive";
+};
+
+export type ThreadRuntimeEventType =
+  | "run-start"
+  | "run-end"
+  | "initialize"
+  | "model-context-update";
+
+export type StartRunConfig = {
+  parentId: string | null;
+  sourceId: string | null;
+  runConfig: RunConfig;
+};
+
+export type ResumeRunConfig = StartRunConfig & {
+  stream: (
+    options: ChatModelRunOptions,
+  ) => AsyncGenerator<ChatModelRunResult, void, unknown>;
+};
+
+export type ThreadRuntimeCore = Readonly<{
+  getMessageById: (messageId: string) =>
+    | {
+        parentId: string | null;
+        message: ThreadMessage;
+      }
+    | undefined;
+
+  getBranches: (messageId: string) => readonly string[];
+  switchToBranch: (branchId: string) => void;
+
+  append: (message: AppendMessage) => void;
+  startRun: (config: StartRunConfig) => void;
+  resumeRun: (config: ResumeRunConfig) => void;
+  cancelRun: () => void;
+
+  addToolResult: (options: AddToolResultOptions) => void;
+
+  speak: (messageId: string) => void;
+  stopSpeaking: () => void;
+
+  getSubmittedFeedback: (messageId: string) => SubmittedFeedback | undefined;
+  submitFeedback: (feedback: SubmitFeedbackOptions) => void;
+
+  getModelContext: () => ModelContext;
+
+  composer: ThreadComposerRuntimeCore;
+  getEditComposer: (messageId: string) => ComposerRuntimeCore | undefined;
+  beginEdit: (messageId: string) => void;
+
+  speech: SpeechState | undefined;
+
+  capabilities: Readonly<RuntimeCapabilities>;
+  isDisabled: boolean;
+  isLoading: boolean;
+  messages: readonly ThreadMessage[];
+  state: ReadonlyJSONValue;
+  suggestions: readonly ThreadSuggestion[];
+
+  // TODO deprecate for a more elegant solution
+  // /**
+  //  * @deprecated This field is deprecated and will be removed in 0.8.0.
+  //  * Please migrate to using `AssistantRuntimeCore.Provider` instead.
+  //  */
+  extras: unknown;
+
+  subscribe: (callback: () => void) => Unsubscribe;
+
+  import(repository: ExportedMessageRepository): void;
+  export(): ExportedMessageRepository;
+
+  reset(initialMessages?: readonly ThreadMessageLike[]): void;
+
+  unstable_on(event: ThreadRuntimeEventType, callback: () => void): Unsubscribe;
+}>;

package/src/legacy-runtime/runtime-cores/external-store/ExternalStoreAdapter.tsx

@@ -0,0 +1,98 @@
+import { AppendMessage, ThreadMessage } from "../../../types";
+import { AttachmentAdapter } from "../adapters/attachment";
+import {
+  AddToolResultOptions,
+  StartRunConfig,
+  ThreadSuggestion,
+} from "../core/ThreadRuntimeCore";
+import { FeedbackAdapter } from "../adapters/feedback/FeedbackAdapter";
+import { SpeechSynthesisAdapter } from "../adapters/speech/SpeechAdapterTypes";
+import { ThreadMessageLike } from "./ThreadMessageLike";
+import { ExportedMessageRepository } from "../utils/MessageRepository";
+
+export type ExternalStoreThreadData<TState extends "regular" | "archived"> = {
+  status: TState;
+  id: string;
+  remoteId?: string | undefined;
+  externalId?: string | undefined;
+  title?: string | undefined;
+};
+
+export type ExternalStoreThreadListAdapter = {
+  /**
+   * @deprecated This API is still under active development and might change without notice.
+   */
+  threadId?: string | undefined;
+  isLoading?: boolean | undefined;
+  threads?: readonly ExternalStoreThreadData<"regular">[] | undefined;
+  archivedThreads?: readonly ExternalStoreThreadData<"archived">[] | undefined;
+  /**
+   * @deprecated This API is still under active development and might change without notice.
+   */
+  onSwitchToNewThread?: (() => Promise<void> | void) | undefined;
+  /**
+   * @deprecated This API is still under active development and might change without notice.
+   */
+  onSwitchToThread?: ((threadId: string) => Promise<void> | void) | undefined;
+  onRename?: (
+    threadId: string,
+    newTitle: string,
+  ) => (Promise<void> | void) | undefined;
+  onArchive?: ((threadId: string) => Promise<void> | void) | undefined;
+  onUnarchive?: ((threadId: string) => Promise<void> | void) | undefined;
+  onDelete?: ((threadId: string) => Promise<void> | void) | undefined;
+};
+
+export type ExternalStoreMessageConverter<T> = (
+  message: T,
+  idx: number,
+) => ThreadMessageLike;
+
+type ExternalStoreMessageConverterAdapter<T> = {
+  convertMessage: ExternalStoreMessageConverter<T>;
+};
+
+type ExternalStoreAdapterBase<T> = {
+  isDisabled?: boolean | undefined;
+  isRunning?: boolean | undefined;
+  isLoading?: boolean | undefined;
+  messages?: readonly T[];
+  messageRepository?: ExportedMessageRepository;
+  suggestions?: readonly ThreadSuggestion[] | undefined;
+  extras?: unknown;
+
+  setMessages?: ((messages: readonly T[]) => void) | undefined;
+  onImport?: ((messages: readonly ThreadMessage[]) => void) | undefined;
+  onNew: (message: AppendMessage) => Promise<void>;
+  onEdit?: ((message: AppendMessage) => Promise<void>) | undefined;
+  onReload?: // TODO: remove parentId in 0.8.0
+  | ((parentId: string | null, config: StartRunConfig) => Promise<void>)
+    | undefined;
+  onCancel?: (() => Promise<void>) | undefined;
+  onAddToolResult?:
+    | ((options: AddToolResultOptions) => Promise<void> | void)
+    | undefined;
+  convertMessage?: ExternalStoreMessageConverter<T> | undefined;
+  adapters?:
+    | {
+        attachments?: AttachmentAdapter | undefined;
+        speech?: SpeechSynthesisAdapter | undefined;
+        feedback?: FeedbackAdapter | undefined;
+        /**
+         * @deprecated This API is still under active development and might change without notice.
+         */
+        threadList?: ExternalStoreThreadListAdapter | undefined;
+      }
+    | undefined;
+  unstable_capabilities?:
+    | {
+        copy?: boolean | undefined;
+      }
+    | undefined;
+};
+
+export type ExternalStoreAdapter<T = ThreadMessage> =
+  ExternalStoreAdapterBase<T> &
+    (T extends ThreadMessage
+      ? object
+      : ExternalStoreMessageConverterAdapter<T>);

package/src/legacy-runtime/runtime-cores/external-store/ExternalStoreThreadListRuntimeCore.tsx

@@ -0,0 +1,233 @@
+import type { Unsubscribe } from "../../../types";
+import { ExternalStoreThreadRuntimeCore } from "./ExternalStoreThreadRuntimeCore";
+import {
+  ThreadListItemCoreState,
+  ThreadListRuntimeCore,
+} from "../core/ThreadListRuntimeCore";
+import { ExternalStoreThreadListAdapter } from "./ExternalStoreAdapter";
+
+export type ExternalStoreThreadFactory = () => ExternalStoreThreadRuntimeCore;
+
+const EMPTY_ARRAY = Object.freeze([]);
+const DEFAULT_THREAD_ID = "DEFAULT_THREAD_ID";
+const DEFAULT_THREADS = Object.freeze([DEFAULT_THREAD_ID]);
+const DEFAULT_THREAD = Object.freeze({
+  id: DEFAULT_THREAD_ID,
+  remoteId: undefined,
+  externalId: undefined,
+  status: "regular",
+});
+const RESOLVED_PROMISE = Promise.resolve();
+const DEFAULT_THREAD_DATA = Object.freeze({
+  [DEFAULT_THREAD_ID]: DEFAULT_THREAD,
+});
+
+export class ExternalStoreThreadListRuntimeCore
+  implements ThreadListRuntimeCore
+{
+  private _mainThreadId: string = DEFAULT_THREAD_ID;
+  private _threads: readonly string[] = DEFAULT_THREADS;
+  private _archivedThreads: readonly string[] = EMPTY_ARRAY;
+  private _threadData: Readonly<Record<string, ThreadListItemCoreState>> =
+    DEFAULT_THREAD_DATA;
+
+  public get isLoading() {
+    return this.adapter.isLoading ?? false;
+  }
+
+  public get newThreadId() {
+    return undefined;
+  }
+
+  public get threadIds() {
+    return this._threads;
+  }
+
+  public get archivedThreadIds() {
+    return this._archivedThreads;
+  }
+
+  public get threadData() {
+    return this._threadData;
+  }
+
+  public getLoadThreadsPromise() {
+    return RESOLVED_PROMISE;
+  }
+
+  private _mainThread: ExternalStoreThreadRuntimeCore;
+
+  public get mainThreadId() {
+    return this._mainThreadId;
+  }
+
+  constructor(
+    private adapter: ExternalStoreThreadListAdapter = {},
+    private threadFactory: ExternalStoreThreadFactory,
+  ) {
+    this._mainThread = this.threadFactory();
+    this.__internal_setAdapter(adapter, true);
+  }
+
+  public getMainThreadRuntimeCore() {
+    return this._mainThread;
+  }
+
+  public getThreadRuntimeCore(): never {
+    throw new Error("Method not implemented.");
+  }
+
+  public getItemById(threadId: string) {
+    for (const thread of this.adapter.threads ?? []) {
+      if (thread.id === threadId) return thread as any;
+    }
+    for (const thread of this.adapter.archivedThreads ?? []) {
+      if (thread.id === threadId) return thread as any;
+    }
+    if (threadId === DEFAULT_THREAD_ID) return DEFAULT_THREAD;
+    return undefined;
+  }
+
+  public __internal_setAdapter(
+    adapter: ExternalStoreThreadListAdapter,
+    initialLoad = false,
+  ) {
+    const previousAdapter = this.adapter;
+    this.adapter = adapter;
+
+    const newThreadId = adapter.threadId ?? DEFAULT_THREAD_ID;
+    const newThreads = adapter.threads ?? EMPTY_ARRAY;
+    const newArchivedThreads = adapter.archivedThreads ?? EMPTY_ARRAY;
+
+    const previousThreadId = previousAdapter.threadId ?? DEFAULT_THREAD_ID;
+    const previousThreads = previousAdapter.threads ?? EMPTY_ARRAY;
+    const previousArchivedThreads =
+      previousAdapter.archivedThreads ?? EMPTY_ARRAY;
+
+    if (
+      !initialLoad &&
+      previousThreadId === newThreadId &&
+      previousThreads === newThreads &&
+      previousArchivedThreads === newArchivedThreads
+    ) {
+      return;
+    }
+
+    this._threadData = {
+      ...DEFAULT_THREAD_DATA,
+      ...Object.fromEntries(
+        adapter.threads?.map((t) => [
+          t.id,
+          {
+            ...t,
+            remoteId: t.remoteId,
+            externalId: t.externalId,
+            status: "regular",
+          },
+        ]) ?? [],
+      ),
+      ...Object.fromEntries(
+        adapter.archivedThreads?.map((t) => [
+          t.id,
+          {
+            ...t,
+            remoteId: t.remoteId,
+            externalId: t.externalId,
+            status: "archived",
+          },
+        ]) ?? [],
+      ),
+    };
+
+    if (previousThreads !== newThreads) {
+      this._threads = this.adapter.threads?.map((t) => t.id) ?? EMPTY_ARRAY;
+    }
+
+    if (previousArchivedThreads !== newArchivedThreads) {
+      this._archivedThreads =
+        this.adapter.archivedThreads?.map((t) => t.id) ?? EMPTY_ARRAY;
+    }
+
+    if (previousThreadId !== newThreadId) {
+      this._mainThreadId = newThreadId;
+      this._mainThread = this.threadFactory();
+    }
+
+    this._notifySubscribers();
+  }
+
+  public async switchToThread(threadId: string): Promise<void> {
+    if (this._mainThreadId === threadId) return;
+    const onSwitchToThread = this.adapter.onSwitchToThread;
+    if (!onSwitchToThread)
+      throw new Error(
+        "External store adapter does not support switching to thread",
+      );
+    onSwitchToThread(threadId);
+  }
+
+  public async switchToNewThread(): Promise<void> {
+    const onSwitchToNewThread = this.adapter.onSwitchToNewThread;
+    if (!onSwitchToNewThread)
+      throw new Error(
+        "External store adapter does not support switching to new thread",
+      );
+
+    onSwitchToNewThread();
+  }
+
+  public async rename(threadId: string, newTitle: string): Promise<void> {
+    const onRename = this.adapter.onRename;
+    if (!onRename)
+      throw new Error("External store adapter does not support renaming");
+
+    onRename(threadId, newTitle);
+  }
+
+  public async detach(): Promise<void> {
+    // no-op
+  }
+
+  public async archive(threadId: string): Promise<void> {
+    const onArchive = this.adapter.onArchive;
+    if (!onArchive)
+      throw new Error("External store adapter does not support archiving");
+
+    onArchive(threadId);
+  }
+
+  public async unarchive(threadId: string): Promise<void> {
+    const onUnarchive = this.adapter.onUnarchive;
+    if (!onUnarchive)
+      throw new Error("External store adapter does not support unarchiving");
+
+    onUnarchive(threadId);
+  }
+
+  public async delete(threadId: string): Promise<void> {
+    const onDelete = this.adapter.onDelete;
+    if (!onDelete)
+      throw new Error("External store adapter does not support deleting");
+
+    onDelete(threadId);
+  }
+
+  public initialize(): never {
+    throw new Error("Method not implemented.");
+  }
+
+  public generateTitle(): never {
+    throw new Error("Method not implemented.");
+  }
+
+  private _subscriptions = new Set<() => void>();
+
+  public subscribe(callback: () => void): Unsubscribe {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+
+  private _notifySubscribers() {
+    for (const callback of this._subscriptions) callback();
+  }
+}