@assistant-ui/react 0.7.8 → 0.7.10

package/src/runtimes/core/ThreadRuntimeCore.tsx

@@ -43,30 +43,12 @@ export type SubmittedFeedback = {
   readonly type: "negative" | "positive";
 };
 
-export type ThreadMetadata = Readonly<{
-  readonly threadId: string;
-  readonly state: "archived" | "regular" | "new" | "deleted";
-  readonly title?: string | undefined;
-}>;
-
 export type ThreadRuntimeEventType =
-  | "switched-to"
-  | "switched-away"
   | "run-start"
+  | "initialize"
   | "model-config-update";
 
-export type ThreadMetadataRuntimeCore = ThreadMetadata & {
-  create(title?: string): Promise<void>;
-  rename(newTitle: string): Promise<void>;
-  archive(): Promise<void>;
-  unarchive(): Promise<void>;
-  delete(): Promise<void>;
-  subscribe(callback: () => void): Unsubscribe;
-};
-
 export type ThreadRuntimeCore = Readonly<{
-  metadata: ThreadMetadataRuntimeCore;
-
   getMessageById: (messageId: string) =>
     | {
         parentId: string | null;

package/src/runtimes/core/index.ts

@@ -2,5 +2,4 @@ export type {
   AddToolResultOptions,
   SubmitFeedbackOptions,
   ThreadSuggestion,
-  ThreadMetadataRuntimeCore,
 } from "./ThreadRuntimeCore";

package/src/runtimes/external-store/ExternalStoreAdapter.tsx

@@ -2,18 +2,32 @@ import { AppendMessage, ThreadMessage } from "../../types";
 import { AttachmentAdapter } from "../attachment";
 import {
   AddToolResultOptions,
-  ThreadMetadata,
   ThreadSuggestion,
 } from "../core/ThreadRuntimeCore";
 import { FeedbackAdapter } from "../feedback/FeedbackAdapter";
 import { SpeechSynthesisAdapter } from "../speech/SpeechAdapterTypes";
 import { ThreadMessageLike } from "./ThreadMessageLike";
 
+export type ExternalStoreThreadData<TState extends "regular" | "archived"> = {
+  state: TState;
+  threadId: string;
+  title?: string | undefined;
+};
+
 export type ExternalStoreThreadListAdapter = {
+  /**
+   * @deprecated This API is still under active development and might change without notice.
+   */
   threadId?: string | undefined;
-  threads?: readonly ThreadMetadata[] | undefined;
-  archivedThreads?: readonly ThreadMetadata[] | 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,
@@ -54,6 +68,9 @@ type ExternalStoreAdapterBase<T> = {
         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;

package/src/runtimes/external-store/ExternalStoreRuntimeCore.tsx

@@ -12,25 +12,18 @@ const getThreadListAdapter = (store: ExternalStoreAdapter<any>) => {
 export class ExternalStoreRuntimeCore extends BaseAssistantRuntimeCore {
   public readonly threadList;
 
-  private _store: ExternalStoreAdapter<any>;
-
   constructor(store: ExternalStoreAdapter<any>) {
     super();
-    this._store = store;
     this.threadList = new ExternalStoreThreadListRuntimeCore(
       getThreadListAdapter(store),
-      (threadId) =>
-        new ExternalStoreThreadRuntimeCore(
-          this._proxyConfigProvider,
-          threadId,
-          this._store,
-        ),
+      () =>
+        new ExternalStoreThreadRuntimeCore(this._proxyConfigProvider, store),
     );
   }
 
   public setStore(store: ExternalStoreAdapter<any>) {
-    this._store = store;
-    this.threadList.setAdapter(getThreadListAdapter(store));
-    this.threadList.mainThread.setStore(store);
+    // Update the thread list adapter and propagate store changes to the main thread
+    this.threadList.__internal_setAdapter(getThreadListAdapter(store));
+    this.threadList.getMainThreadRuntimeCore().__internal_setStore(store);
   }
 }

package/src/runtimes/external-store/ExternalStoreThreadListRuntimeCore.tsx

@@ -3,9 +3,7 @@ import { ExternalStoreThreadRuntimeCore } from "./ExternalStoreThreadRuntimeCore
 import { ThreadListRuntimeCore } from "../core/ThreadListRuntimeCore";
 import { ExternalStoreThreadListAdapter } from "./ExternalStoreAdapter";
 
-export type ExternalStoreThreadFactory = (
-  threadId: string,
-) => ExternalStoreThreadRuntimeCore;
+export type ExternalStoreThreadFactory = () => ExternalStoreThreadRuntimeCore;
 
 const EMPTY_ARRAY = Object.freeze([]);
 const DEFAULT_THREAD_ID = "DEFAULT_THREAD_ID";
@@ -13,35 +11,40 @@ const DEFAULT_THREAD_ID = "DEFAULT_THREAD_ID";
 export class ExternalStoreThreadListRuntimeCore
   implements ThreadListRuntimeCore
 {
-  private _threads: readonly string[] = [];
-  private _archivedThreads: readonly string[] = [];
+  private _mainThreadId: string = DEFAULT_THREAD_ID;
+  private _threads: readonly string[] = EMPTY_ARRAY;
+  private _archivedThreads: readonly string[] = EMPTY_ARRAY;
 
-  public get newThread() {
+  public get newThreadId() {
     return undefined;
   }
 
-  public get threads() {
+  public get threadIds() {
     return this._threads;
   }
 
-  public get archivedThreads() {
+  public get archivedThreadIds() {
     return this._archivedThreads;
   }
 
   private _mainThread: ExternalStoreThreadRuntimeCore;
 
-  public get mainThread() {
-    return this._mainThread;
+  public get mainThreadId() {
+    return this._mainThreadId;
   }
 
   constructor(
     private adapter: ExternalStoreThreadListAdapter = {},
     private threadFactory: ExternalStoreThreadFactory,
   ) {
-    this._mainThread = this.threadFactory(DEFAULT_THREAD_ID);
+    this._mainThread = this.threadFactory();
+  }
+
+  public getMainThreadRuntimeCore() {
+    return this._mainThread;
   }
 
-  public getThreadMetadataById(threadId: string) {
+  public getItemById(threadId: string) {
     for (const thread of this.adapter.threads ?? []) {
       if (thread.threadId === threadId) return thread;
     }
@@ -51,7 +54,7 @@ export class ExternalStoreThreadListRuntimeCore
     return undefined;
   }
 
-  public setAdapter(adapter: ExternalStoreThreadListAdapter) {
+  public __internal_setAdapter(adapter: ExternalStoreThreadListAdapter) {
     const previousAdapter = this.adapter;
     this.adapter = adapter;
 
@@ -72,42 +75,26 @@ export class ExternalStoreThreadListRuntimeCore
       return;
     }
 
-    if (previousAdapter.threads !== newThreads) {
+    if (previousThreads !== newThreads) {
       this._threads =
         this.adapter.threads?.map((t) => t.threadId) ?? EMPTY_ARRAY;
     }
 
-    if (previousAdapter.archivedThreads !== newArchivedThreads) {
+    if (previousArchivedThreads !== newArchivedThreads) {
       this._archivedThreads =
         this.adapter.archivedThreads?.map((t) => t.threadId) ?? EMPTY_ARRAY;
     }
 
-    if (previousAdapter.threadId !== newThreadId) {
-      this._mainThread._notifyEventSubscribers("switched-away");
-      this._mainThread = this.threadFactory(newThreadId);
-      this._mainThread._notifyEventSubscribers("switched-to");
-    }
-
-    const previousMainState = this._mainThread.metadata.state;
-    const mainState = this.archivedThreads.includes(
-      this._mainThread.metadata.threadId,
-    )
-      ? "archived"
-      : "regular";
-
-    if (previousMainState !== mainState) {
-      if (mainState === "archived") {
-        this._mainThread.metadata.archive();
-      } else {
-        this._mainThread.metadata.unarchive();
-      }
+    if (previousThreadId !== newThreadId) {
+      this._mainThreadId = newThreadId;
+      this._mainThread = this.threadFactory();
     }
 
     this._notifySubscribers();
   }
 
   public async switchToThread(threadId: string): Promise<void> {
-    if (this._mainThread?.metadata.threadId === threadId) return;
+    if (this._mainThreadId === threadId) return;
     const onSwitchToThread = this.adapter.onSwitchToThread;
     if (!onSwitchToThread)
       throw new Error(

package/src/runtimes/external-store/ExternalStoreThreadRuntimeCore.tsx

@@ -18,7 +18,6 @@ import {
   ThreadRuntimeCore,
 } from "../core/ThreadRuntimeCore";
 import { BaseThreadRuntimeCore } from "../core/BaseThreadRuntimeCore";
-import { LocalThreadMetadataRuntimeCore } from "../local/LocalThreadMetadataRuntimeCore";
 
 const EMPTY_ARRAY = Object.freeze([]);
 
@@ -77,16 +76,13 @@ export class ExternalStoreThreadRuntimeCore
 
   constructor(
     configProvider: ModelConfigProvider,
-    threadId: string,
     store: ExternalStoreAdapter<any>,
   ) {
-    const metadata = new LocalThreadMetadataRuntimeCore(threadId);
-    metadata.create();
-    super(configProvider, metadata);
-    this.setStore(store);
+    super(configProvider);
+    this.__internal_setStore(store);
   }
 
-  public setStore(store: ExternalStoreAdapter<any>) {
+  public __internal_setStore(store: ExternalStoreAdapter<any>) {
     if (this._store === store) return;
 
     const isRunning = store.isRunning ?? false;

package/src/runtimes/local/LocalRuntimeCore.tsx

@@ -31,10 +31,9 @@ export class LocalRuntimeCore extends BaseAssistantRuntimeCore {
 
     this._options = options;
 
-    this.threadList = new LocalThreadListRuntimeCore((threadId, data) => {
+    this.threadList = new LocalThreadListRuntimeCore((data) => {
       const thread = new LocalThreadRuntimeCore(
         this._proxyConfigProvider,
-        threadId,
         this._options,
       );
       thread.import(data);
@@ -42,18 +41,12 @@ export class LocalRuntimeCore extends BaseAssistantRuntimeCore {
     });
 
     if (initialMessages) {
-      this.threadList.mainThread.import(
-        getExportFromInitialMessages(initialMessages),
-      );
+      this.threadList
+        .getMainThreadRuntimeCore()
+        .import(getExportFromInitialMessages(initialMessages));
     }
   }
 
-  public setOptions(options: LocalRuntimeOptionsBase) {
-    this._options = options;
-
-    this.threadList.mainThread.setOptions(options);
-  }
-
   public reset({
     initialMessages,
   }: {
@@ -62,8 +55,8 @@ export class LocalRuntimeCore extends BaseAssistantRuntimeCore {
     this.threadList.switchToNewThread();
     if (!initialMessages) return;
 
-    this.threadList.mainThread.import(
-      getExportFromInitialMessages(initialMessages),
-    );
+    this.threadList
+      .getMainThreadRuntimeCore()
+      .import(getExportFromInitialMessages(initialMessages));
   }
 }

package/src/runtimes/local/LocalThreadListRuntimeCore.tsx

@@ -3,206 +3,213 @@ import { ThreadListRuntimeCore } from "../core/ThreadListRuntimeCore";
 import { ExportedMessageRepository } from "../utils/MessageRepository";
 import { generateId } from "../../utils/idUtils";
 import { LocalThreadRuntimeCore } from "./LocalThreadRuntimeCore";
-import { ThreadMetadata } from "../core/ThreadRuntimeCore";
 
 export type ThreadListAdapter = {
   subscribe(callback: () => void): Unsubscribe;
 };
 
 export type LocalThreadData = {
-  runtime: LocalThreadRuntimeCore;
-  lastState: ThreadMetadata["state"];
-  dispose: Unsubscribe;
+  readonly runtime: LocalThreadRuntimeCore;
+  readonly state: "new" | "regular" | "archived";
+  readonly threadId: string;
+  readonly title?: string | undefined;
+
+  dispose(): void;
 };
 
 export type LocalThreadFactory = (
-  threadId: string,
   data: ExportedMessageRepository,
 ) => LocalThreadRuntimeCore;
 
 export class LocalThreadListRuntimeCore implements ThreadListRuntimeCore {
   private _threadData = new Map<string, LocalThreadData>();
-  private _threads: readonly string[] = [];
-  private _archivedThreads: readonly string[] = [];
-  private _newThread: string | undefined;
+  private _threadIds: readonly string[] = [];
+  private _archivedThreadIds: readonly string[] = [];
+  private _newThreadId: string | undefined;
 
-  public get newThread() {
-    return this._newThread;
+  public get newThreadId() {
+    return this._newThreadId;
   }
 
-  public get threads() {
-    return this._threads;
+  public get threadIds() {
+    return this._threadIds;
   }
 
-  public get archivedThreads() {
-    return this._archivedThreads;
+  public get archivedThreadIds() {
+    return this._archivedThreadIds;
   }
 
-  private _mainThread!: LocalThreadRuntimeCore;
+  private _mainThreadId!: string;
 
-  public get mainThread(): LocalThreadRuntimeCore {
-    return this._mainThread;
+  public get mainThreadId(): string {
+    return this._mainThreadId;
   }
 
   constructor(private _threadFactory: LocalThreadFactory) {
     this.switchToNewThread();
   }
 
-  public getThreadMetadataById(threadId: string) {
-    return this._threadData.get(threadId)?.runtime.metadata;
+  public getMainThreadRuntimeCore() {
+    const result = this._threadData.get(this._mainThreadId)?.runtime;
+    if (!result)
+      throw new Error("Main thread not found. This is a bug in assistant-ui.");
+    return result;
+  }
+
+  public getItemById(threadId: string) {
+    return this._threadData.get(threadId);
   }
 
-  public switchToThread(threadId: string): Promise<void> {
-    if (this._mainThread?.metadata.threadId === threadId)
-      return Promise.resolve();
+  public async switchToThread(threadId: string): Promise<void> {
+    if (this._mainThreadId === threadId) return;
 
     const data = this._threadData.get(threadId);
     if (!data) throw new Error("Thread not found");
 
-    if (data.runtime.metadata.state === "archived") this.unarchive(threadId);
+    if (data.state === "archived") await this.unarchive(threadId);
 
-    this._mainThread?._notifyEventSubscribers("switched-away");
-    this._mainThread = data.runtime;
+    this._mainThreadId = data.threadId;
     this._notifySubscribers();
-
-    data.runtime._notifyEventSubscribers("switched-to");
-    return Promise.resolve();
   }
 
   public switchToNewThread(): Promise<void> {
-    if (this._newThread === undefined) {
+    if (this._newThreadId === undefined) {
       let threadId: string;
       do {
         threadId = generateId();
       } while (this._threadData.has(threadId));
 
-      const runtime = this._threadFactory(threadId, { messages: [] });
-      const dispose = runtime.metadata.subscribe(() => {
-        this._syncState(threadId, runtime.metadata);
-        threadId = runtime.metadata.threadId;
+      const runtime = this._threadFactory({ messages: [] });
+      const dispose = runtime.unstable_on("initialize", () => {
+        const data = this._threadData.get(threadId);
+        if (!data) throw new Error("Thread not found");
+
+        this._stateOp(threadId, "regular");
       });
-      this._threadData.set(threadId, { runtime, lastState: "new", dispose });
-      this._newThread = threadId;
+      this._threadData.set(threadId, {
+        runtime,
+        state: "new",
+        threadId,
+        dispose,
+      });
+      this._newThreadId = threadId;
     }
 
-    this.switchToThread(this._newThread);
+    this.switchToThread(this._newThreadId);
     return Promise.resolve();
   }
 
-  private async _syncState(
-    lastThreadId: string,
-    { state, threadId }: ThreadMetadata,
+  private async _stateOp(
+    threadId: string,
+    newState: "regular" | "archived" | "deleted",
   ) {
-    const data = this._threadData.get(lastThreadId);
+    const data = this._threadData.get(threadId);
     if (!data) throw new Error("Thread not found");
-    const lastState = data.lastState;
-    if (lastState === state && lastThreadId === threadId) return;
 
-    if (lastThreadId !== threadId) {
-      this._threadData.delete(lastThreadId);
-      if (lastState === "new") {
-        this._newThread = threadId;
-      }
-      if (lastState === "regular") {
-        this._threads = this._threads.map((t) =>
-          t === lastThreadId ? threadId : t,
-        );
-      }
-      if (lastState === "archived") {
-        this._archivedThreads = this._archivedThreads.map((t) =>
-          t === lastThreadId ? threadId : t,
+    const { state: lastState } = data;
+    if (lastState === newState) return;
+
+    // lastState
+    switch (lastState) {
+      case "new":
+        this._newThreadId = undefined;
+        break;
+      case "regular":
+        this._threadIds = this._threadIds.filter((t) => t !== threadId);
+        break;
+      case "archived":
+        this._archivedThreadIds = this._archivedThreadIds.filter(
+          (t) => t !== threadId,
         );
-      }
-    }
+        break;
 
-    if (lastState !== state) {
-      if (lastState === "new") {
-        this._newThread = undefined;
+      default: {
+        const _exhaustiveCheck: never = lastState;
+        throw new Error(`Unsupported state: ${_exhaustiveCheck}`);
       }
+    }
 
-      if (lastState === "regular") {
-        this._threads = this._threads.filter((t) => t !== threadId);
-      }
+    // newState
+    switch (newState) {
+      case "regular":
+        this._threadIds = [...this._threadIds, data.threadId];
+        break;
 
-      if (lastState === "archived") {
-        this._archivedThreads = this._archivedThreads.filter(
-          (t) => t !== threadId,
-        );
-      }
+      case "archived":
+        this._archivedThreadIds = [...this._archivedThreadIds, data.threadId];
+        break;
 
-      if (state === "new") {
-        if (this._newThread) {
-          this.delete(this._newThread);
-        }
-        this._newThread = threadId;
-      }
-      if (state === "archived") {
-        this._archivedThreads = [
-          ...this._archivedThreads,
-          data.runtime.metadata.threadId,
-        ];
-      }
-      if (state === "regular") {
-        this._threads = [...this._threads, data.runtime.metadata.threadId];
-      }
-      if (state === "deleted") {
-        data.dispose();
+      case "deleted":
         this._threadData.delete(threadId);
-      }
+        data.dispose();
+        break;
 
-      data.lastState = state;
+      default: {
+        const _exhaustiveCheck: never = newState;
+        throw new Error(`Unsupported state: ${_exhaustiveCheck}`);
+      }
     }
 
-    this._notifySubscribers();
+    if (newState !== "deleted") {
+      this._threadData.set(threadId, {
+        ...data,
+        state: newState,
+      });
+    }
 
     if (
-      threadId === this._mainThread.metadata.threadId &&
-      (state === "archived" || state === "deleted")
+      threadId === this._mainThreadId &&
+      (newState === "archived" || newState === "deleted")
     ) {
-      const lastThread = this._threads[0];
-      if (lastThread) {
-        await this.switchToThread(lastThread);
+      const lastThreadId = this._threadIds[0];
+      if (lastThreadId) {
+        await this.switchToThread(lastThreadId);
       } else {
         await this.switchToNewThread();
       }
+    } else {
+      this._notifySubscribers();
     }
   }
 
   public rename(threadId: string, newTitle: string): Promise<void> {
     const data = this._threadData.get(threadId);
     if (!data) throw new Error("Thread not found");
-    data.runtime.metadata.rename(newTitle);
 
+    this._threadData.set(threadId, {
+      ...data,
+      title: newTitle,
+    });
+    this._notifySubscribers();
     return Promise.resolve();
   }
 
   public archive(threadId: string): Promise<void> {
     const data = this._threadData.get(threadId);
     if (!data) throw new Error("Thread not found");
-    if (data.lastState !== "regular")
-      throw new Error("Thread is not yet created or archived");
-    data.runtime.metadata.archive();
+    if (data.state !== "regular")
+      throw new Error("Thread is not yet initialized or already archived");
 
+    this._stateOp(threadId, "archived");
     return Promise.resolve();
   }
 
   public unarchive(threadId: string): Promise<void> {
     const data = this._threadData.get(threadId);
     if (!data) throw new Error("Thread not found");
-    if (data.lastState !== "archived")
-      throw new Error("Thread is not archived");
-    data.runtime.metadata.unarchive();
+    if (data.state !== "archived") throw new Error("Thread is not archived");
 
+    this._stateOp(threadId, "regular");
     return Promise.resolve();
   }
 
   public delete(threadId: string): Promise<void> {
     const data = this._threadData.get(threadId);
     if (!data) throw new Error("Thread not found");
-    if (data.lastState !== "regular" && data.lastState !== "archived")
-      throw new Error("Thread is not yet created or already deleted");
-    data.runtime.metadata.delete();
+    if (data.state !== "regular" && data.state !== "archived")
+      throw new Error("Thread is not yet initalized");
 
+    this._stateOp(threadId, "deleted");
     return Promise.resolve();
   }