@assistant-ui/react 0.5.100 → 0.7.1

package/src/api/ContentPartRuntime.ts

@@ -14,11 +14,7 @@ export type ContentPartState = (
   | ThreadUserContentPart
   | ThreadAssistantContentPart
 ) & {
-  /**
-   * @deprecated You can directly access content part fields in the state. Replace `.part.type` with `.type` etc. This will be removed in 0.6.0.
-   */
-  part: ThreadUserContentPart | ThreadAssistantContentPart;
-  status: ContentPartStatus | ToolCallContentPartStatus;
+  readonly status: ContentPartStatus | ToolCallContentPartStatus;
 };
 
 type ContentPartSnapshotBinding = SubscribableWithState<
@@ -27,7 +23,7 @@ type ContentPartSnapshotBinding = SubscribableWithState<
 >;
 
 export type ContentPartRuntime = {
-  path: ContentPartRuntimePath;
+  readonly path: ContentPartRuntimePath;
 
   getState(): ContentPartState;
   addToolResult(result: any): void;

package/src/api/MessageRuntime.ts

@@ -34,9 +34,9 @@ import { SKIP_UPDATE } from "./subscribable/SKIP_UPDATE";
 import { ShallowMemoizeSubject } from "./subscribable/ShallowMemoizeSubject";
 import { SubscribableWithState } from "./subscribable/Subscribable";
 
-const COMPLETE_STATUS: ContentPartStatus = {
+const COMPLETE_STATUS: ContentPartStatus = Object.freeze({
   type: "complete",
-};
+});
 
 export const toContentPartStatus = (
   message: ThreadMessage,
@@ -58,7 +58,12 @@ export const toContentPartStatus = (
   return isLastPart ? (message.status as ContentPartStatus) : COMPLETE_STATUS;
 };
 
-export const EMPTY_CONTENT = Object.freeze({ type: "text", text: "" });
+export const EMPTY_CONTENT_SYMBOL = Symbol("empty-content");
+const EMPTY_CONTENT = Object.freeze({
+  type: "text",
+  text: "",
+  [EMPTY_CONTENT_SYMBOL]: true,
+});
 
 const getContentPartState = (
   message: MessageState,
@@ -83,29 +88,21 @@ const getContentPartState = (
 
   // if the content part is the same, don't update
   const status = toContentPartStatus(message, partIndex, part);
-  return Object.freeze({ ...part, part, status });
+  return Object.freeze({ ...part, status });
 };
 
 export type MessageState = ThreadMessage & {
-  /**
-   * @deprecated You can directly access message fields in the state. Replace `.message.content` with `.content` etc. This will be removed in 0.6.0.
-   */
-  message: ThreadMessage;
-  parentId: string | null;
-  isLast: boolean;
-  /**
-   * @deprecated Use `branchNumber` and `branchCount` instead. This will be removed in 0.6.0.
-   */
-  branches: readonly string[];
+  readonly parentId: string | null;
+  readonly isLast: boolean;
 
-  branchNumber: number;
-  branchCount: number;
+  readonly branchNumber: number;
+  readonly branchCount: number;
 
   /**
    * @deprecated This API is still under active development and might change without notice.
    */
-  speech: SpeechState | undefined;
-  submittedFeedback: SubmittedFeedback | undefined;
+  readonly speech: SpeechState | undefined;
+  readonly submittedFeedback: SubmittedFeedback | undefined;
 };
 
 export type MessageStateBinding = SubscribableWithState<
@@ -172,7 +169,7 @@ export class MessageRuntimeImpl implements MessageRuntime {
     );
   }
 
-  public composer;
+  public readonly composer;
 
   public getState() {
     return this._core.getState();
@@ -305,7 +302,6 @@ export class MessageRuntimeImpl implements MessageRuntime {
 
           return {
             ...attachment,
-            attachment: attachment,
             source: "message",
           } satisfies AttachmentState & { source: "message" };
         },

package/src/api/RuntimePathTypes.ts

@@ -1,60 +1,60 @@
 export type ThreadListRuntimePath = {
-  ref: string;
+  readonly ref: string;
 };
 
 export type ThreadListItemRuntimePath = {
-  ref: string;
-  threadSelector:
-    | { type: "main" }
-    | { type: "index"; index: number }
-    | { type: "archiveIndex"; index: number }
-    | { type: "threadId"; threadId: string };
+  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 = {
-  ref: string;
-  threadSelector: { type: "main" };
+  readonly ref: string;
+  readonly threadSelector: { type: "main" };
 };
 
 export type MessageRuntimePath = ThreadRuntimePath & {
-  messageSelector:
-    | { type: "messageId"; messageId: string }
-    | { type: "index"; index: number };
+  readonly messageSelector:
+    | { readonly type: "messageId"; readonly messageId: string }
+    | { readonly type: "index"; readonly index: number };
 };
 
 export type ContentPartRuntimePath = MessageRuntimePath & {
-  contentPartSelector:
-    | { type: "index"; index: number }
-    | { type: "toolCallId"; toolCallId: string };
+  readonly contentPartSelector:
+    | { readonly type: "index"; readonly index: number }
+    | { readonly type: "toolCallId"; readonly toolCallId: string };
 };
 
 export type AttachmentRuntimePath = (
   | (MessageRuntimePath & {
-      attachmentSource: "message" | "edit-composer";
+      readonly attachmentSource: "message" | "edit-composer";
     })
   | (ThreadRuntimePath & {
-      attachmentSource: "thread-composer";
+      readonly attachmentSource: "thread-composer";
     })
 ) & {
-  attachmentSelector:
+  readonly attachmentSelector:
     | {
-        type: "index";
-        index: number;
+        readonly type: "index";
+        readonly index: number;
       }
     | {
-        type: "index";
-        index: number;
+        readonly type: "index";
+        readonly index: number;
       }
     | {
-        type: "index";
-        index: number;
+        readonly type: "index";
+        readonly index: number;
       };
 };
 
 export type ComposerRuntimePath =
   | (ThreadRuntimePath & {
-      composerSource: "thread";
+      readonly composerSource: "thread";
     })
   | (MessageRuntimePath & {
-      composerSource: "edit";
+      readonly composerSource: "edit";
     });

package/src/api/ThreadListItemRuntime.ts

@@ -1,22 +1,25 @@
-import { ThreadListMetadata } from "../runtimes/core/ThreadListRuntimeCore";
+import { ThreadMetadata } from "../runtimes/core/ThreadRuntimeCore";
 import { Unsubscribe } from "../types";
 import { ThreadListItemRuntimePath } from "./RuntimePathTypes";
 import { SubscribableWithState } from "./subscribable/Subscribable";
 import { ThreadListRuntimeCoreBinding } from "./ThreadListRuntime";
 
-export type ThreadListItemState = ThreadListMetadata;
+export type ThreadListItemState = ThreadMetadata & {
+  readonly isMain: boolean;
+};
 
-export type ThreadListItemRuntime = Readonly<{
-  path: ThreadListItemRuntimePath;
-  getState(): ThreadListMetadata;
+export type ThreadListItemRuntime = {
+  readonly path: ThreadListItemRuntimePath;
+  getState(): ThreadListItemState;
 
+  switchTo(): Promise<void>;
   rename(newTitle: string): Promise<void>;
   archive(): Promise<void>;
   unarchive(): Promise<void>;
   delete(): Promise<void>;
 
   subscribe(callback: () => void): Unsubscribe;
-}>;
+};
 
 export type ThreadListItemStateBinding = SubscribableWithState<
   ThreadListItemState,
@@ -30,35 +33,40 @@ export class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {
 
   constructor(
     private _core: ThreadListItemStateBinding,
-    private _ThreadListBinding: ThreadListRuntimeCoreBinding,
+    private _threadListBinding: ThreadListRuntimeCoreBinding,
   ) {}
 
   public getState(): ThreadListItemState {
     return this._core.getState();
   }
 
+  public switchTo(): Promise<void> {
+    const state = this._core.getState();
+    return this._threadListBinding.switchToThread(state.threadId);
+  }
+
   public rename(newTitle: string): Promise<void> {
     const state = this._core.getState();
 
-    return this._ThreadListBinding.rename(state.threadId, newTitle);
+    return this._threadListBinding.rename(state.threadId, newTitle);
   }
 
   public archive(): Promise<void> {
     const state = this._core.getState();
 
-    return this._ThreadListBinding.archive(state.threadId);
+    return this._threadListBinding.archive(state.threadId);
   }
 
   public unarchive(): Promise<void> {
     const state = this._core.getState();
 
-    return this._ThreadListBinding.unarchive(state.threadId);
+    return this._threadListBinding.unarchive(state.threadId);
   }
 
   public delete(): Promise<void> {
     const state = this._core.getState();
 
-    return this._ThreadListBinding.delete(state.threadId);
+    return this._threadListBinding.delete(state.threadId);
   }
 
   public subscribe(callback: () => void): Unsubscribe {

package/src/api/ThreadListRuntime.ts

@@ -1,58 +1,60 @@
 import { LazyMemoizeSubject } from "./subscribable/LazyMemoizeSubject";
-import {
-  ThreadListMetadata,
-  ThreadListRuntimeCore,
-} from "../runtimes/core/ThreadListRuntimeCore";
+import { ThreadListRuntimeCore } from "../runtimes/core/ThreadListRuntimeCore";
 import { Unsubscribe } from "../types";
 import { ThreadListRuntimePath } from "./RuntimePathTypes";
 import {
   ThreadListItemRuntime,
   ThreadListItemRuntimeImpl,
+  ThreadListItemState,
 } from "./ThreadListItemRuntime";
 import { SKIP_UPDATE } from "./subscribable/SKIP_UPDATE";
+import { ShallowMemoizeSubject } from "./subscribable/ShallowMemoizeSubject";
 
-export type ThreadListState = Readonly<{
-  threads: readonly ThreadListMetadata[];
-  archivedThreads: readonly ThreadListMetadata[];
-}>;
+export type ThreadListState = {
+  readonly mainThreadId: string;
+  readonly newThread: string | undefined;
+  readonly threads: readonly string[];
+  readonly archivedThreads: readonly string[];
+};
 
-export type ThreadListRuntime = Readonly<{
-  path: ThreadListRuntimePath;
+export type ThreadListRuntime = {
+  readonly path: ThreadListRuntimePath;
   getState(): ThreadListState;
 
-  /**
-   * @deprecated Use `getThreadListItemById(idx).rename(newTitle)` instead. This will be removed in 0.6.0.
-   */
-  rename(threadId: string, newTitle: string): Promise<void>;
-  /**
-   * @deprecated Use `getThreadListItemById(idx).archive()` instead. This will be removed in 0.6.0.
-   */
-  archive(threadId: string): Promise<void>;
-  /**
-   * @deprecated Use `getThreadListItemById(idx).unarchive()` instead. This will be removed in 0.6.0.
-   */
-  unarchive(threadId: string): Promise<void>;
-  /**
-   * @deprecated Use `getThreadListItemById(idx).delete()` instead. This will be removed in 0.6.0.
-   */
-  delete(threadId: string): Promise<void>;
-
   subscribe(callback: () => void): Unsubscribe;
 
   getThreadListItemById(threadId: string): ThreadListItemRuntime;
   getThreadListItemByIndex(idx: number): ThreadListItemRuntime;
   getThreadListArchivedItemByIndex(idx: number): ThreadListItemRuntime;
-}>;
+};
 
 const getThreadListState = (
   threadList: ThreadListRuntimeCore,
 ): ThreadListState => {
   return {
+    mainThreadId: threadList.mainThread.metadata.threadId,
+    newThread: threadList.newThread,
     threads: threadList.threads,
     archivedThreads: threadList.archivedThreads,
   };
 };
 
+const getThreadListItemState = (
+  threadList: ThreadListRuntimeCore,
+  threadId: string | undefined,
+): ThreadListItemState | SKIP_UPDATE => {
+  if (threadId === undefined) return SKIP_UPDATE;
+
+  const threadData = threadList.getThreadMetadataById(threadId);
+  if (!threadData) return SKIP_UPDATE;
+  return {
+    threadId: threadData.threadId,
+    title: threadData.title,
+    state: threadData.state,
+    isMain: threadList.mainThread.metadata.threadId === threadId,
+  };
+};
+
 const THREAD_MANAGER_PATH = {
   ref: "ThreadList",
 };
@@ -79,38 +81,19 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
     return this._getState();
   }
 
-  public rename(threadId: string, newTitle: string): Promise<void> {
-    return this._core.rename(threadId, newTitle);
-  }
-
-  public archive(threadId: string): Promise<void> {
-    return this._core.archive(threadId);
-  }
-
-  public unarchive(threadId: string): Promise<void> {
-    return this._core.unarchive(threadId);
-  }
-
-  public delete(threadId: string): Promise<void> {
-    return this._core.delete(threadId);
-  }
-
   public subscribe(callback: () => void): Unsubscribe {
     return this._core.subscribe(callback);
   }
 
   public getThreadListItemByIndex(idx: number) {
     return new ThreadListItemRuntimeImpl(
-      new LazyMemoizeSubject({
+      new ShallowMemoizeSubject({
         path: {
           ref: this.path.ref + `${this.path.ref}.threadItems[${idx}]`,
           threadSelector: { type: "index", index: idx },
         },
         getState: () => {
-          const threads = this._core.threads;
-          const thread = threads[idx];
-          if (!thread) return SKIP_UPDATE;
-          return thread;
+          return getThreadListItemState(this._core, this._core.threads[idx]);
         },
         subscribe: (callback) => this._core.subscribe(callback),
       }),
@@ -120,16 +103,16 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
 
   public getThreadListArchivedItemByIndex(idx: number) {
     return new ThreadListItemRuntimeImpl(
-      new LazyMemoizeSubject({
+      new ShallowMemoizeSubject({
         path: {
           ref: this.path.ref + `${this.path.ref}.archivedThreadItems[${idx}]`,
           threadSelector: { type: "archiveIndex", index: idx },
         },
         getState: () => {
-          const threads = this._core.archivedThreads;
-          const thread = threads[idx];
-          if (!thread) return SKIP_UPDATE;
-          return thread;
+          return getThreadListItemState(
+            this._core,
+            this._core.archivedThreads[idx],
+          );
         },
         subscribe: (callback) => this._core.subscribe(callback),
       }),
@@ -139,7 +122,7 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
 
   public getThreadListItemById(threadId: string) {
     return new ThreadListItemRuntimeImpl(
-      new LazyMemoizeSubject({
+      new ShallowMemoizeSubject({
         path: {
           ref:
             this.path.ref +
@@ -147,9 +130,7 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
           threadSelector: { type: "threadId", threadId },
         },
         getState: () => {
-          const threadItem = this._core.getThreadMetadataById(threadId);
-          if (!threadItem) return SKIP_UPDATE;
-          return threadItem;
+          return getThreadListItemState(this._core, threadId);
         },
         subscribe: (callback) => this._core.subscribe(callback),
       }),