@assistant-ui/react 0.5.99 → 0.7.0

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

@@ -5,9 +5,6 @@ import { ExternalStoreThreadRuntimeCore } from "./ExternalStoreThreadRuntimeCore
 
 const getThreadListAdapter = (store: ExternalStoreAdapter<any>) => {
   return {
-    threadId: store.threadId,
-    onSwitchToNewThread: store.onSwitchToNewThread,
-    onSwitchToThread: store.onSwitchToThread,
     ...store.adapters?.threadList,
   };
 };

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

@@ -13,12 +13,19 @@ const DEFAULT_THREAD_ID = "DEFAULT_THREAD_ID";
 export class ExternalStoreThreadListRuntimeCore
   implements ThreadListRuntimeCore
 {
+  private _threads: readonly string[] = [];
+  private _archivedThreads: readonly string[] = [];
+
+  public get newThread() {
+    return undefined;
+  }
+
   public get threads() {
-    return this.adapter.threads ?? EMPTY_ARRAY;
+    return this._threads;
   }
 
   public get archivedThreads() {
-    return this.adapter.archivedThreads ?? EMPTY_ARRAY;
+    return this._archivedThreads;
   }
 
   private _mainThread: ExternalStoreThreadRuntimeCore;
@@ -35,10 +42,10 @@ export class ExternalStoreThreadListRuntimeCore
   }
 
   public getThreadMetadataById(threadId: string) {
-    for (const thread of this.threads) {
+    for (const thread of this.adapter.threads ?? []) {
       if (thread.threadId === threadId) return thread;
     }
-    for (const thread of this.archivedThreads) {
+    for (const thread of this.adapter.archivedThreads ?? []) {
       if (thread.threadId === threadId) return thread;
     }
     return undefined;
@@ -52,25 +59,55 @@ export class ExternalStoreThreadListRuntimeCore
     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 (
-      previousAdapter.threadId === newThreadId &&
-      previousAdapter.threads === newThreads &&
-      previousAdapter.archivedThreads === newArchivedThreads
+      previousThreadId === newThreadId &&
+      previousThreads === newThreads &&
+      previousArchivedThreads === newArchivedThreads
     ) {
       return;
     }
 
+    if (previousAdapter.threads !== newThreads) {
+      this._threads =
+        this.adapter.threads?.map((t) => t.threadId) ?? EMPTY_ARRAY;
+    }
+
+    if (previousAdapter.archivedThreads !== 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();
+      }
+    }
+
     this._notifySubscribers();
   }
 
-  public switchToThread(threadId: string): void {
-    if (this._mainThread?.threadId === threadId) return;
+  public async switchToThread(threadId: string): Promise<void> {
+    if (this._mainThread?.metadata.threadId === threadId) return;
     const onSwitchToThread = this.adapter.onSwitchToThread;
     if (!onSwitchToThread)
       throw new Error(
@@ -79,7 +116,7 @@ export class ExternalStoreThreadListRuntimeCore
     onSwitchToThread(threadId);
   }
 
-  public switchToNewThread(): void {
+  public async switchToNewThread(): Promise<void> {
     const onSwitchToNewThread = this.adapter.onSwitchToNewThread;
     if (!onSwitchToNewThread)
       throw new Error(

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

@@ -18,6 +18,7 @@ import {
   ThreadRuntimeCore,
 } from "../core/ThreadRuntimeCore";
 import { BaseThreadRuntimeCore } from "../core/BaseThreadRuntimeCore";
+import { LocalThreadMetadataRuntimeCore } from "../local/LocalThreadMetadataRuntimeCore";
 
 const EMPTY_ARRAY = Object.freeze([]);
 
@@ -49,7 +50,6 @@ export class ExternalStoreThreadRuntimeCore
     return this._capabilities;
   }
 
-  public threadId!: string;
   private _messages!: ThreadMessage[];
   public isDisabled!: boolean;
 
@@ -80,8 +80,9 @@ export class ExternalStoreThreadRuntimeCore
     threadId: string,
     store: ExternalStoreAdapter<any>,
   ) {
-    super(configProvider);
-    this.threadId = threadId;
+    const metadata = new LocalThreadMetadataRuntimeCore(threadId);
+    metadata.create();
+    super(configProvider, metadata);
     this.setStore(store);
   }
 
@@ -239,8 +240,13 @@ export class ExternalStoreThreadRuntimeCore
   }
 
   private updateMessages = (messages: ThreadMessage[]) => {
-    this._store.setMessages?.(
-      messages.flatMap(getExternalStoreMessage).filter((m) => m != null),
-    );
+    const hasConverter = this._store.convertMessage !== undefined;
+    if (hasConverter) {
+      this._store.setMessages?.(
+        messages.flatMap(getExternalStoreMessage).filter((m) => m != null),
+      );
+    } else {
+      this._store.setMessages?.(messages);
+    }
   };
 }

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

@@ -33,6 +33,7 @@ export type ThreadMessageLike = {
   createdAt?: Date | undefined;
   status?: MessageStatus | undefined;
   attachments?: CompleteAttachment[] | undefined;
+  // TODO metadata
 };
 
 export const fromThreadMessageLike = (
@@ -53,9 +54,9 @@ export const fromThreadMessageLike = (
 
   if (role !== "user" && attachments)
     throw new Error("Attachments are only supported for user messages");
-  // TODO add in 0.6
-  // if (role !== "assistant" && status)
-  //   throw new Error("Status is only supported for assistant messages");
+
+  if (role !== "assistant" && status)
+    throw new Error("Status is only supported for assistant messages");
 
   switch (role) {
     case "assistant":

package/src/runtimes/local/ChatModelAdapter.tsx

@@ -17,10 +17,6 @@ export type ChatModelRunResult = {
   content?: ThreadAssistantContentPart[];
   status?: MessageStatus;
   metadata?: {
-    /**
-     * @internal Use `steps` instead. This field will be removed in v0.6.
-     */
-    roundtrips?: ThreadStep[];
     steps?: ThreadStep[];
     custom?: Record<string, unknown>;
   };
@@ -32,11 +28,6 @@ export type ChatModelRunOptions = {
   config: ModelConfig;
 
   unstable_assistantMessageId?: string;
-
-  /**
-   * @deprecated Declare the run function as an AsyncGenerator instead. This method will be removed in v0.6
-   */
-  onUpdate: (result: ChatModelRunUpdate) => void;
 };
 
 export type ChatModelAdapter = {

package/src/runtimes/local/LocalRuntimeOptions.tsx

@@ -6,10 +6,6 @@ import { ChatModelAdapter } from "./ChatModelAdapter";
 
 export type LocalRuntimeOptionsBase = {
   maxSteps?: number | undefined;
-  /**
-   * @deprecated Use `maxSteps` (which is `maxToolRoundtrips` + 1; if you set `maxToolRoundtrips` to 2, set `maxSteps` to 3) instead. This field will be removed in v0.6.
-   */
-  maxToolRoundtrips?: number | undefined;
   adapters: {
     chatModel: ChatModelAdapter;
     attachments?: AttachmentAdapter | undefined;
@@ -27,13 +23,11 @@ export type LocalRuntimeOptions = Omit<LocalRuntimeOptionsBase, "adapters"> & {
 export const splitLocalRuntimeOptions = <T extends LocalRuntimeOptions>(
   options: T,
 ) => {
-  const { initialMessages, maxToolRoundtrips, maxSteps, adapters, ...rest } =
-    options;
+  const { initialMessages, maxSteps, adapters, ...rest } = options;
 
   return {
     localRuntimeOptions: {
       initialMessages,
-      maxToolRoundtrips,
       maxSteps,
       adapters,
     },

package/src/runtimes/local/LocalThreadListRuntimeCore.tsx

@@ -1,16 +1,18 @@
 import type { Unsubscribe } from "../../types";
-import {
-  ThreadListMetadata,
-  ThreadListRuntimeCore,
-} from "../core/ThreadListRuntimeCore";
+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 = {
-  data: ExportedMessageRepository;
-  metadata: ThreadListMetadata;
-  isArchived: boolean;
+  runtime: LocalThreadRuntimeCore;
+  lastState: ThreadMetadata["state"];
+  dispose: Unsubscribe;
 };
 
 export type LocalThreadFactory = (
@@ -20,9 +22,13 @@ export type LocalThreadFactory = (
 
 export class LocalThreadListRuntimeCore implements ThreadListRuntimeCore {
   private _threadData = new Map<string, LocalThreadData>();
+  private _threads: readonly string[] = [];
+  private _archivedThreads: readonly string[] = [];
+  private _newThread: string | undefined;
 
-  private _threads: readonly ThreadListMetadata[] = [];
-  private _archivedThreads: readonly ThreadListMetadata[] = [];
+  public get newThread() {
+    return this._newThread;
+  }
 
   public get threads() {
     return this._threads;
@@ -32,134 +38,172 @@ export class LocalThreadListRuntimeCore implements ThreadListRuntimeCore {
     return this._archivedThreads;
   }
 
-  private _mainThread: LocalThreadRuntimeCore;
+  private _mainThread!: LocalThreadRuntimeCore;
 
   public get mainThread(): LocalThreadRuntimeCore {
     return this._mainThread;
   }
 
   constructor(private _threadFactory: LocalThreadFactory) {
-    const threadId = generateId();
-    this._threadData.set(threadId, {
-      data: { messages: [] },
-      metadata: { threadId },
-      isArchived: false,
-    });
-    this._threads = [{ threadId }];
-    this._mainThread = this._threadFactory(threadId, { messages: [] });
+    this.switchToNewThread();
   }
 
   public getThreadMetadataById(threadId: string) {
-    return this._threadData.get(threadId)?.metadata;
+    return this._threadData.get(threadId)?.runtime.metadata;
   }
 
-  public switchToThread(threadId: string): void {
-    if (this._mainThread.threadId === threadId) return;
+  public switchToThread(threadId: string): Promise<void> {
+    if (this._mainThread?.metadata.threadId === threadId)
+      return Promise.resolve();
 
     const data = this._threadData.get(threadId);
     if (!data) throw new Error("Thread not found");
 
-    const thread = this._threadFactory(threadId, data.data);
-    this._performThreadSwitch(thread);
-  }
+    if (data.runtime.metadata.state === "archived") this.unarchive(threadId);
 
-  public switchToNewThread(): void {
-    const threadId = generateId();
-    this._threadData.set(threadId, {
-      data: { messages: [] },
-      metadata: { threadId },
-      isArchived: false,
-    });
-    this._threads = [{ threadId }];
-    const thread = this._threadFactory(threadId, { messages: [] });
-    this._performThreadSwitch(thread);
-  }
-
-  private _performThreadSwitch(newThreadCore: LocalThreadRuntimeCore) {
-    const data = this._threadData.get(this._mainThread.threadId);
-    if (!data) throw new Error("Thread not found");
+    this._mainThread?._notifyEventSubscribers("switched-away");
+    this._mainThread = data.runtime;
+    this._notifySubscribers();
 
-    const exprt = this._mainThread.export();
-    data.data = exprt;
+    data.runtime._notifyEventSubscribers("switched-to");
+    return Promise.resolve();
+  }
 
-    this._mainThread._notifyEventSubscribers("switched-away");
-    this._mainThread = newThreadCore;
-    newThreadCore._notifyEventSubscribers("switched-to");
+  public switchToNewThread(): Promise<void> {
+    if (this._newThread === 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;
+      });
+      this._threadData.set(threadId, { runtime, lastState: "new", dispose });
+      this._newThread = threadId;
+    }
 
-    this._notifySubscribers();
+    this.switchToThread(this._newThread);
+    return Promise.resolve();
   }
 
-  private _performMoveOp(
-    threadId: string,
-    operation: "archive" | "unarchive" | "delete",
+  private async _syncState(
+    lastThreadId: string,
+    { state, threadId }: ThreadMetadata,
   ) {
-    const data = this._threadData.get(threadId);
+    const data = this._threadData.get(lastThreadId);
     if (!data) throw new Error("Thread not found");
-
-    if (operation === "archive" && data.isArchived) return;
-    if (operation === "unarchive" && !data.isArchived) return;
-
-    if (operation === "archive") {
-      data.isArchived = true;
-      this._archivedThreads = [...this._archivedThreads, data.metadata];
-    }
-    if (operation === "unarchive") {
-      data.isArchived = false;
-      this._threads = [...this._threads, data.metadata];
-    }
-    if (operation === "delete") {
-      this._threadData.delete(threadId);
+    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,
+        );
+      }
     }
 
-    if (
-      operation === "archive" ||
-      (operation === "delete" && data.isArchived)
-    ) {
-      this._archivedThreads = this._archivedThreads.filter(
-        (t) => t.threadId !== threadId,
-      );
+    if (lastState !== state) {
+      if (lastState === "new") {
+        this._newThread = undefined;
+      }
+
+      if (lastState === "regular") {
+        this._threads = this._threads.filter((t) => t !== threadId);
+      }
+
+      if (lastState === "archived") {
+        this._archivedThreads = this._archivedThreads.filter(
+          (t) => t !== threadId,
+        );
+      }
+
+      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();
+        this._threadData.delete(threadId);
+      }
+
+      data.lastState = state;
     }
 
+    this._notifySubscribers();
+
     if (
-      operation === "unarchive" ||
-      (operation === "delete" && !data.isArchived)
+      threadId === this._mainThread.metadata.threadId &&
+      (state === "archived" || state === "deleted")
     ) {
-      this._threads = this._threads.filter((t) => t.threadId !== threadId);
+      const lastThread = this._threads[0];
+      if (lastThread) {
+        await this.switchToThread(lastThread);
+      } else {
+        await this.switchToNewThread();
+      }
     }
-
-    this._notifySubscribers();
   }
 
-  public async rename(threadId: string, newTitle: string): Promise<void> {
+  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);
 
-    data.metadata = {
-      ...data.metadata,
-      title: newTitle,
-    };
-
-    const threadList = data.isArchived ? this.archivedThreads : this.threads;
-    const idx = threadList.findIndex((t) => t.threadId === threadId);
-    const updatedThreadList = threadList.toSpliced(idx, 1, data.metadata);
-    if (data.isArchived) {
-      this._archivedThreads = updatedThreadList;
-    } else {
-      this._threads = updatedThreadList;
-    }
-    this._notifySubscribers();
+    return Promise.resolve();
   }
 
-  public async archive(threadId: string): Promise<void> {
-    this._performMoveOp(threadId, "archive");
+  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();
+
+    return Promise.resolve();
   }
 
-  public async unarchive(threadId: string): Promise<void> {
-    this._performMoveOp(threadId, "unarchive");
+  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();
+
+    return Promise.resolve();
   }
 
-  public async delete(threadId: string): Promise<void> {
-    this._performMoveOp(threadId, "delete");
+  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();
+
+    return Promise.resolve();
   }
 
   private _subscriptions = new Set<() => void>();

package/src/runtimes/local/LocalThreadMetadataRuntimeCore.tsx

@@ -0,0 +1,79 @@
+import { ThreadMetadataRuntimeCore } from "../core/ThreadRuntimeCore";
+
+export class LocalThreadMetadataRuntimeCore
+  implements ThreadMetadataRuntimeCore
+{
+  private _state: "regular" | "archived" | "deleted" | "new" = "new";
+  private _title: string | undefined;
+  private _subscribers = new Set<() => void>();
+
+  constructor(private _threadId: string) {}
+
+  public get threadId() {
+    return this._threadId;
+  }
+
+  public get state() {
+    return this._state;
+  }
+
+  public get title() {
+    return this._title;
+  }
+
+  public rename(newTitle: string) {
+    this._title = newTitle;
+    this._notifySubscribers();
+
+    return Promise.resolve();
+  }
+
+  public archive() {
+    if (this._state === "new") throw new Error("Thread not created");
+    if (this._state === "archived") throw new Error("Thread already archived");
+    if (this._state === "deleted") throw new Error("Thread deleted");
+
+    this._state = "archived";
+    this._notifySubscribers();
+
+    return Promise.resolve();
+  }
+
+  public unarchive() {
+    if (this._state !== "archived") throw new Error("Thread not archived");
+
+    this._state = "regular";
+    this._notifySubscribers();
+
+    return Promise.resolve();
+  }
+
+  public delete() {
+    if (this._state === "new") throw new Error("Thread not created");
+    if (this._state === "deleted") throw new Error("Thread already deleted");
+
+    this._state = "deleted";
+    this._notifySubscribers();
+
+    return Promise.resolve();
+  }
+
+  public create(title?: string) {
+    if (this.state !== "new") throw new Error("Thread not new");
+
+    this._state = "regular";
+    this._title = title ?? this._title;
+    this._notifySubscribers();
+
+    return Promise.resolve();
+  }
+
+  public subscribe(callback: () => void) {
+    this._subscribers.add(callback);
+    return () => this._subscribers.delete(callback);
+  }
+
+  private _notifySubscribers() {
+    for (const callback of this._subscribers) callback();
+  }
+}