@assistant-ui/core 0.1.0

package/src/runtimes/external-store/external-store-adapter.ts

@@ -0,0 +1,111 @@
+import type { AppendMessage, ThreadMessage } from "../../types";
+import type { ThreadMessageLike } from "../../runtime/utils/thread-message-like";
+import type { AttachmentAdapter } from "../../adapters/attachment";
+import type {
+  SpeechSynthesisAdapter,
+  DictationAdapter,
+} from "../../adapters/speech";
+import type { FeedbackAdapter } from "../../adapters/feedback";
+import type {
+  AddToolResultOptions,
+  StartRunConfig,
+  ResumeRunConfig,
+  ThreadSuggestion,
+} from "../../runtime/interfaces/thread-runtime-core";
+import type { ExportedMessageRepository } from "../../runtime/utils/message-repository";
+import type { ReadonlyJSONValue } from "assistant-stream/utils";
+
+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;
+  state?: ReadonlyJSONValue | undefined;
+  extras?: unknown;
+
+  setMessages?: ((messages: readonly T[]) => void) | undefined;
+  onImport?: ((messages: readonly ThreadMessage[]) => void) | undefined;
+  onExportExternalState?: (() => any) | undefined;
+  onLoadExternalState?: ((state: any) => void) | undefined;
+  onNew: (message: AppendMessage) => Promise<void>;
+  onEdit?: ((message: AppendMessage) => Promise<void>) | undefined;
+  onReload?: // TODO: remove parentId in 0.12.0
+    | ((parentId: string | null, config: StartRunConfig) => Promise<void>)
+    | undefined;
+  onResume?: ((config: ResumeRunConfig) => Promise<void>) | undefined;
+  onCancel?: (() => Promise<void>) | undefined;
+  onAddToolResult?:
+    | ((options: AddToolResultOptions) => Promise<void> | void)
+    | undefined;
+  onResumeToolCall?:
+    | ((options: { toolCallId: string; payload: unknown }) => void)
+    | undefined;
+  convertMessage?: ExternalStoreMessageConverter<T> | undefined;
+  adapters?:
+    | {
+        attachments?: AttachmentAdapter | undefined;
+        speech?: SpeechSynthesisAdapter | undefined;
+        dictation?: DictationAdapter | 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/runtimes/external-store/external-store-runtime-core.ts

@@ -0,0 +1,26 @@
+import { BaseAssistantRuntimeCore } from "../../runtime/base/base-assistant-runtime-core";
+import { ExternalStoreThreadListRuntimeCore } from "./external-store-thread-list-runtime-core";
+import type { ExternalStoreAdapter } from "./external-store-adapter";
+import { ExternalStoreThreadRuntimeCore } from "./external-store-thread-runtime-core";
+
+const getThreadListAdapter = (store: ExternalStoreAdapter<any>) => {
+  return store.adapters?.threadList ?? {};
+};
+
+export class ExternalStoreRuntimeCore extends BaseAssistantRuntimeCore {
+  public readonly threads;
+
+  constructor(adapter: ExternalStoreAdapter<any>) {
+    super();
+    this.threads = new ExternalStoreThreadListRuntimeCore(
+      getThreadListAdapter(adapter),
+      () => new ExternalStoreThreadRuntimeCore(this._contextProvider, adapter),
+    );
+  }
+
+  public setAdapter(adapter: ExternalStoreAdapter<any>) {
+    // Update the thread list adapter and propagate store changes to the main thread
+    this.threads.__internal_setAdapter(getThreadListAdapter(adapter));
+    this.threads.getMainThreadRuntimeCore().__internal_setAdapter(adapter);
+  }
+}

package/src/runtimes/external-store/external-store-thread-list-runtime-core.ts

@@ -0,0 +1,235 @@
+import type { Unsubscribe } from "../../types";
+import type { ExternalStoreThreadRuntimeCore } from "./external-store-thread-runtime-core";
+import type {
+  ThreadListItemCoreState,
+  ThreadListRuntimeCore,
+} from "../../runtime/interfaces/thread-list-runtime-core";
+import type { ExternalStoreThreadListAdapter } from "./external-store-adapter";
+
+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 threadItems() {
+    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",
+      );
+    await 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",
+      );
+
+    await 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");
+
+    await 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");
+
+    await 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");
+
+    await 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");
+
+    await onDelete(threadId);
+  }
+
+  public initialize(
+    threadId: string,
+  ): Promise<{ remoteId: string; externalId: string | undefined }> {
+    return Promise.resolve({ remoteId: threadId, externalId: undefined });
+  }
+
+  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();
+  }
+}