@assistant-ui/core 0.1.16 → 0.2.0

package/src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx

@@ -5,12 +5,13 @@ import { OptimisticState } from "../../runtimes/remote-thread-list/optimistic-st
 import { EMPTY_THREAD_CORE } from "../../runtimes/remote-thread-list/empty-thread-core";
 import type {
   RemoteThreadData,
-  THREAD_MAPPING_ID,
   RemoteThreadState,
 } from "../../runtimes/remote-thread-list/remote-thread-state";
 import {
+  classifyThreads,
   createThreadMappingId,
   getThreadData,
+  normalizeCursor,
   updateStatusReducer,
 } from "../../runtimes/remote-thread-list/remote-thread-state";
 import type { RemoteThreadListOptions } from "../../runtimes/remote-thread-list/types";
@@ -29,11 +30,14 @@ export class RemoteThreadListThreadListRuntimeCore
   private readonly _hookManager: RemoteThreadListHookInstanceManager;
 
   private _loadThreadsPromise: Promise<void> | undefined;
+  private _loadMorePromise: Promise<void> | undefined;
   private _loadGeneration = 0;
 
   private _mainThreadId!: string;
   private readonly _state = new OptimisticState<RemoteThreadState>({
     isLoading: true,
+    isLoadingMore: false,
+    cursor: undefined,
     newThreadId: undefined,
     threadIds: [],
     archivedThreadIds: [],
@@ -61,62 +65,33 @@ export class RemoteThreadListThreadListRuntimeCore
           // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
           then: (state, l) => {
             if (generation !== this._loadGeneration) return state;
-            const newThreadIds = [];
-            const newArchivedThreadIds = [];
-            const newThreadIdMap = {} as Record<string, THREAD_MAPPING_ID>;
-            const newThreadData = {} as Record<
-              THREAD_MAPPING_ID,
-              RemoteThreadData
-            >;
-
-            for (const thread of l.threads) {
-              switch (thread.status) {
-                case "regular":
-                  newThreadIds.push(thread.remoteId);
-                  break;
-                case "archived":
-                  newArchivedThreadIds.push(thread.remoteId);
-                  break;
-                default: {
-                  const _exhaustiveCheck: never = thread.status;
-                  throw new Error(`Unsupported state: ${_exhaustiveCheck}`);
-                }
-              }
-
-              const mappingId = createThreadMappingId(thread.remoteId);
-              newThreadIdMap[thread.remoteId] = mappingId;
-              newThreadData[mappingId] = {
-                id: thread.remoteId,
-                remoteId: thread.remoteId,
-                externalId: thread.externalId,
-                status: thread.status,
-                title: thread.title,
-                custom: thread.custom,
-                initializeTask: Promise.resolve({
-                  remoteId: thread.remoteId,
-                  externalId: thread.externalId,
-                }),
-              };
-            }
+            const fresh = classifyThreads(l.threads, {
+              threadIds: [],
+              archivedThreadIds: [],
+              threadIdMap: {},
+              threadData: {},
+            });
 
             return {
               ...state,
               isLoading: false,
-              threadIds: newThreadIds,
-              archivedThreadIds: newArchivedThreadIds,
+              cursor: normalizeCursor(l.nextCursor),
+              threadIds: fresh.threadIds,
+              archivedThreadIds: fresh.archivedThreadIds,
               threadIdMap: {
                 ...state.threadIdMap,
-                ...newThreadIdMap,
+                ...fresh.threadIdMap,
               },
               threadData: {
                 ...state.threadData,
-                ...newThreadData,
+                ...fresh.threadData,
               },
             };
           },
         })
-        .catch(() => {
+        .catch((error: unknown) => {
           if (generation !== this._loadGeneration) return;
+          console.error("[assistant-ui] thread list load failed:", error);
           this._loadThreadsPromise = undefined;
           this._state.update({
             ...this._state.baseValue,
@@ -129,6 +104,58 @@ export class RemoteThreadListThreadListRuntimeCore
     return this._loadThreadsPromise;
   }
 
+  public loadMore(): Promise<void> {
+    if (this._loadMorePromise) return this._loadMorePromise;
+
+    const initialState = this._state.value;
+    if (initialState.cursor === undefined || initialState.isLoading) {
+      return Promise.resolve();
+    }
+
+    const generation = this._loadGeneration;
+    const adapter = this._options.adapter;
+    const cursor = initialState.cursor;
+
+    const dedup = this._state
+      .optimisticUpdate({
+        execute: () => adapter.list({ after: cursor }),
+        loading: (state) => ({ ...state, isLoadingMore: true }),
+        // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
+        then: (state, l) => {
+          if (generation !== this._loadGeneration) return state;
+          if (adapter !== this._options.adapter) return state;
+
+          const appended = classifyThreads(l.threads, {
+            threadIds: [...state.threadIds],
+            archivedThreadIds: [...state.archivedThreadIds],
+            threadIdMap: { ...state.threadIdMap },
+            threadData: { ...state.threadData },
+          });
+
+          return {
+            ...state,
+            isLoadingMore: false,
+            cursor: normalizeCursor(l.nextCursor),
+            threadIds: appended.threadIds,
+            archivedThreadIds: appended.archivedThreadIds,
+            threadIdMap: appended.threadIdMap,
+            threadData: appended.threadData,
+          };
+        },
+      })
+      .catch((error: unknown) => {
+        console.error("[assistant-ui] thread list loadMore failed:", error);
+      })
+      .then(() => {
+        if (this._loadMorePromise === dedup) {
+          this._loadMorePromise = undefined;
+        }
+      });
+
+    this._loadMorePromise = dedup;
+    return dedup;
+  }
+
   private readonly contextProvider: ModelContextProvider;
 
   constructor(
@@ -156,6 +183,9 @@ export class RemoteThreadListThreadListRuntimeCore
   public __internal_setOptions(options: RemoteThreadListOptions) {
     if (this._options === options) return;
 
+    const adapterChanged =
+      this._options !== undefined && this._options.adapter !== options.adapter;
+
     this._options = options;
 
     const Provider = options.adapter.unstable_Provider ?? Fragment;
@@ -164,6 +194,16 @@ export class RemoteThreadListThreadListRuntimeCore
     }
 
     this._hookManager.setRuntimeHook(options.runtimeHook);
+
+    if (adapterChanged) {
+      this._loadGeneration++;
+      this._loadThreadsPromise = undefined;
+      this._loadMorePromise = undefined;
+      this._state.update({
+        ...this._state.baseValue,
+        cursor: undefined,
+      });
+    }
   }
 
   public __internal_load() {
@@ -179,6 +219,11 @@ export class RemoteThreadListThreadListRuntimeCore
   public reload() {
     this._loadGeneration++;
     this._loadThreadsPromise = undefined;
+    this._loadMorePromise = undefined;
+    this._state.update({
+      ...this._state.baseValue,
+      cursor: undefined,
+    });
     return this.getLoadThreadsPromise();
   }
 
@@ -186,6 +231,14 @@ export class RemoteThreadListThreadListRuntimeCore
     return this._state.value.isLoading;
   }
 
+  public get isLoadingMore() {
+    return this._state.value.isLoadingMore;
+  }
+
+  public get hasMore() {
+    return this._state.value.cursor !== undefined;
+  }
+
   public get threadIds() {
     return this._state.value.threadIds;
   }

package/src/react/utils/groupParts.ts

@@ -0,0 +1,152 @@
+/**
+ * Hierarchical adjacent-coalescing grouping for message parts.
+ *
+ * Given a group path per part (from `groupBy`), builds a tree of group
+ * nodes wrapping individual parts. Adjacent parts sharing a path prefix
+ * coalesce into the same group; ungrouped parts are direct children of
+ * the root.
+ *
+ * Each node gets a structural `nodeKey` built from sibling indices
+ * (`"0.1.0"`), stable under append-only streaming.
+ */
+
+/**
+ * Public group key type. Group keys must be prefixed with `group-` so
+ * that a unified `switch (part.type)` in the renderer can distinguish
+ * a group key (e.g. `"group-thought"`) from a real part type
+ * (`"text"`, `"tool-call"`).
+ */
+export type GroupKey<TKey extends `group-${string}` = `group-${string}`> =
+  | TKey
+  | readonly TKey[]
+  | null
+  | undefined;
+
+export type GroupNode = GroupNodeGroup | GroupNodePart;
+
+export interface GroupNodeGroup {
+  readonly type: "group";
+  /** Current-level group key (last segment of the path). */
+  readonly key: string;
+  /** Structural React key: sibling-index path, e.g. `"0.1.0"`. */
+  readonly nodeKey: string;
+  /** Indices of parts in this subtree, in order. */
+  readonly indices: readonly number[];
+  readonly children: readonly GroupNode[];
+}
+
+export interface GroupNodePart {
+  readonly type: "part";
+  /** Index of the part in the message. */
+  readonly index: number;
+  /** Structural React key: sibling-index path within parent. */
+  readonly nodeKey: string;
+}
+
+const EMPTY_PATH: readonly string[] = Object.freeze([]);
+
+/**
+ * Normalize a `groupBy` return value to a path array.
+ * `null`/`undefined`/`[]` → `[]` (ungrouped).
+ * `"foo"` → `["foo"]`. Arrays pass through.
+ */
+export const normalizeGroupKey = (key: GroupKey): readonly string[] => {
+  if (key == null) return EMPTY_PATH;
+  if (typeof key === "string") return [key];
+  return key;
+};
+
+interface BuildFrame {
+  key: string;
+  nodeKey: string;
+  indices: number[];
+  children: GroupNode[];
+  nextChildIdx: number;
+}
+
+const makeChildNodeKey = (parent: BuildFrame): string => {
+  const idx = parent.nextChildIdx++;
+  return parent.nodeKey === "" ? String(idx) : `${parent.nodeKey}.${idx}`;
+};
+
+/**
+ * Build the group tree from an array of normalized group paths.
+ * `paths[i]` is the path for part `i`. The output tree contains one
+ * `part` node per part and one `group` node per coalesced run.
+ */
+export const buildGroupTree = (
+  paths: readonly (readonly string[])[],
+): readonly GroupNode[] => {
+  const root: BuildFrame = {
+    key: "",
+    nodeKey: "",
+    indices: [],
+    children: [],
+    nextChildIdx: 0,
+  };
+  const stack: BuildFrame[] = [root];
+
+  const closeTop = (): void => {
+    const closing = stack.pop()!;
+    const parent = stack[stack.length - 1]!;
+    parent.children.push({
+      type: "group",
+      key: closing.key,
+      nodeKey: closing.nodeKey,
+      indices: closing.indices,
+      children: closing.children,
+    });
+  };
+
+  for (let i = 0; i < paths.length; i++) {
+    const path = paths[i]!;
+
+    // Find the longest prefix shared between currently-open groups
+    // (excluding root) and this part's path.
+    let common = 0;
+    while (
+      common < stack.length - 1 &&
+      common < path.length &&
+      stack[common + 1]!.key === path[common]
+    ) {
+      common++;
+    }
+
+    // Close groups not on this path.
+    while (stack.length - 1 > common) {
+      closeTop();
+    }
+
+    // Open new groups down to the part's depth.
+    while (stack.length - 1 < path.length) {
+      const parent = stack[stack.length - 1]!;
+      stack.push({
+        key: path[stack.length - 1]!,
+        nodeKey: makeChildNodeKey(parent),
+        indices: [],
+        children: [],
+        nextChildIdx: 0,
+      });
+    }
+
+    // Push this part as a leaf in the deepest open group (or root).
+    const top = stack[stack.length - 1]!;
+    top.children.push({
+      type: "part",
+      index: i,
+      nodeKey: makeChildNodeKey(top),
+    });
+
+    // Record the part index in every open ancestor group.
+    for (let s = 1; s < stack.length; s++) {
+      stack[s]!.indices.push(i);
+    }
+  }
+
+  // Close any still-open groups.
+  while (stack.length > 1) {
+    closeTop();
+  }
+
+  return root.children;
+};

package/src/runtime/api/assistant-runtime.ts

@@ -6,8 +6,6 @@ import {
   type ThreadListRuntime,
   ThreadListRuntimeImpl,
 } from "./thread-list-runtime";
-import { ExportedMessageRepository } from "../utils/message-repository";
-import type { ThreadMessageLike } from "../utils/thread-message-like";
 
 export type AssistantRuntime = {
   /**
@@ -20,49 +18,16 @@ export type AssistantRuntime = {
    */
   readonly thread: ThreadRuntime;
 
-  /**
-   * @deprecated This field was renamed to `threads`.
-   */
-  readonly threadList: ThreadListRuntime;
-
-  /**
-   * Switch to a new thread.
-   *
-   * @deprecated This method was moved to `threads.switchToNewThread`.
-   */
-  switchToNewThread(): void;
-
-  /**
-   * Switch to a thread.
-   *
-   * @param threadId The thread ID to switch to.
-   * @deprecated This method was moved to `threads.switchToThread`.
-   */
-  switchToThread(threadId: string): void;
-
   /**
    * Register a model context provider. Model context providers are configuration such as system message, temperature, etc. that are set in the frontend.
    *
    * @param provider The model context provider to register.
    */
   registerModelContextProvider(provider: ModelContextProvider): Unsubscribe;
-
-  /**
-   * @deprecated This method was renamed to `registerModelContextProvider`.
-   */
-  registerModelConfigProvider(provider: ModelContextProvider): Unsubscribe;
-
-  /**
-   * @deprecated Use `runtime.thread.reset(initialMessages)`.
-   */
-  reset: unknown; // make it a type error
 };
 
 export class AssistantRuntimeImpl implements AssistantRuntime {
   public readonly threads;
-  public get threadList() {
-    return this.threads;
-  }
 
   public readonly _thread: ThreadRuntime;
 
@@ -74,42 +39,15 @@ export class AssistantRuntimeImpl implements AssistantRuntime {
   }
 
   protected __internal_bindMethods() {
-    this.switchToNewThread = this.switchToNewThread.bind(this);
-    this.switchToThread = this.switchToThread.bind(this);
     this.registerModelContextProvider =
       this.registerModelContextProvider.bind(this);
-    this.registerModelConfigProvider =
-      this.registerModelConfigProvider.bind(this);
-    this.reset = this.reset.bind(this);
   }
 
   public get thread() {
     return this._thread;
   }
 
-  public switchToNewThread() {
-    return this._core.threads.switchToNewThread();
-  }
-
-  public switchToThread(threadId: string) {
-    return this._core.threads.switchToThread(threadId);
-  }
-
   public registerModelContextProvider(provider: ModelContextProvider) {
     return this._core.registerModelContextProvider(provider);
   }
-
-  public registerModelConfigProvider(provider: ModelContextProvider) {
-    return this.registerModelContextProvider(provider);
-  }
-
-  public reset({
-    initialMessages,
-  }: {
-    initialMessages?: ThreadMessageLike[];
-  } = {}) {
-    return this._core.threads
-      .getMainThreadRuntimeCore()
-      .import(ExportedMessageRepository.fromArray(initialMessages ?? []));
-  }
 }

package/src/runtime/api/bindings.ts

@@ -5,10 +5,7 @@ import type {
   EditComposerRuntimeCore,
   ThreadComposerRuntimeCore,
 } from "../interfaces/composer-runtime-core";
-import type {
-  SpeechState,
-  SubmittedFeedback,
-} from "../interfaces/thread-runtime-core";
+import type { SpeechState } from "../interfaces/thread-runtime-core";
 import type { ComposerRuntimePath, MessageRuntimePath } from "./paths";
 
 export type ComposerRuntimeCoreBinding = SubscribableWithState<
@@ -34,8 +31,6 @@ export type MessageStateBinding = SubscribableWithState<
     readonly branchNumber: number;
     readonly branchCount: number;
     readonly speech: SpeechState | undefined;
-    /** @deprecated Use `message.metadata.submittedFeedback` instead. This will be removed in 0.12.0. */
-    readonly submittedFeedback: SubmittedFeedback | undefined;
   },
   MessageRuntimePath
 >;

package/src/runtime/api/composer-runtime.ts

@@ -12,6 +12,7 @@ import {
   SKIP_UPDATE,
 } from "../../subscribable/subscribable";
 import type {
+  ComposerRuntimeEventCallback,
   ComposerRuntimeEventType,
   DictationState,
   EditComposerRuntimeCore,
@@ -222,9 +223,9 @@ export type ComposerRuntime = {
   /**
    * @deprecated This API is still under active development and might change without notice.
    */
-  unstable_on(
-    event: ComposerRuntimeEventType,
-    callback: () => void,
+  unstable_on<E extends ComposerRuntimeEventType>(
+    event: E,
+    callback: ComposerRuntimeEventCallback<E>,
   ): Unsubscribe;
 };
 
@@ -332,19 +333,19 @@ export abstract class ComposerRuntimeImpl implements ComposerRuntime {
     EventSubscriptionSubject<ComposerRuntimeEventType>
   >();
 
-  public unstable_on(
-    event: ComposerRuntimeEventType,
-    callback: () => void,
+  public unstable_on<E extends ComposerRuntimeEventType>(
+    event: E,
+    callback: ComposerRuntimeEventCallback<E>,
   ): Unsubscribe {
     let subject = this._eventSubscriptionSubjects.get(event);
     if (!subject) {
-      subject = new EventSubscriptionSubject({
-        event: event,
+      subject = new EventSubscriptionSubject<ComposerRuntimeEventType>({
+        event,
         binding: this._core,
       });
       this._eventSubscriptionSubjects.set(event, subject);
     }
-    return subject.subscribe(callback);
+    return subject.subscribe(callback as (payload?: unknown) => void);
   }
 
   public abstract getAttachmentByIndex(idx: number): AttachmentRuntime;

package/src/runtime/api/message-runtime.ts

@@ -1,7 +1,4 @@
-import type {
-  SpeechState,
-  SubmittedFeedback,
-} from "../interfaces/thread-runtime-core";
+import type { SpeechState } from "../interfaces/thread-runtime-core";
 import { symbolInnerMessage } from "../utils/external-store-message";
 import type {
   ToolCallMessagePartStatus,
@@ -90,10 +87,6 @@ export type MessageState = ThreadMessage & {
    * @deprecated This API is still under active development and might change without notice.
    */
   readonly speech: SpeechState | undefined;
-  /**
-   * @deprecated Use `message.metadata.submittedFeedback` instead. This will be removed in 0.12.0.
-   */
-  readonly submittedFeedback: SubmittedFeedback | undefined;
 };
 
 export type { MessageStateBinding } from "./bindings";

package/src/runtime/api/thread-list-item-runtime.ts

@@ -3,7 +3,26 @@ import type { SubscribableWithState } from "../../subscribable/subscribable";
 import type { ThreadListItemRuntimePath } from "./paths";
 import type { ThreadListRuntimeCoreBinding } from "./thread-list-runtime";
 
-export type ThreadListItemEventType = "switchedTo" | "switchedAway";
+export type ThreadListItemEventPayload = {
+  /**
+   * @deprecated State-derivable. Compare `s.threads.mainThreadId` against the
+   * item's `s.threadListItem.id` via `useAuiState` instead. Kept for backward
+   * compatibility.
+   */
+  switchedTo: Record<string, never>;
+  /**
+   * @deprecated State-derivable. Compare `s.threads.mainThreadId` against the
+   * item's `s.threadListItem.id` via `useAuiState` instead. Kept for backward
+   * compatibility.
+   */
+  switchedAway: Record<string, never>;
+};
+
+export type ThreadListItemEventType = keyof ThreadListItemEventPayload;
+
+export type ThreadListItemEventCallback<E extends ThreadListItemEventType> = (
+  payload: ThreadListItemEventPayload[E],
+) => void;
 
 import type { ThreadListItemState } from "./bindings";
 import type { ThreadListItemStatus } from "../interfaces/thread-list-runtime-core";
@@ -27,9 +46,9 @@ export type ThreadListItemRuntime = {
 
   subscribe(callback: () => void): Unsubscribe;
 
-  unstable_on(
-    event: ThreadListItemEventType,
-    callback: () => void,
+  unstable_on<E extends ThreadListItemEventType>(
+    event: E,
+    callback: ThreadListItemEventCallback<E>,
   ): Unsubscribe;
 
   __internal_getRuntime(): ThreadListItemRuntime;
@@ -112,7 +131,10 @@ export class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {
     return this._threadListBinding.generateTitle(state.id);
   }
 
-  public unstable_on(event: ThreadListItemEventType, callback: () => void) {
+  public unstable_on<E extends ThreadListItemEventType>(
+    event: E,
+    callback: ThreadListItemEventCallback<E>,
+  ) {
     let prevIsMain = this._core.getState().isMain;
     let prevThreadId = this._core.getState().id;
     return this.subscribe(() => {
@@ -125,7 +147,7 @@ export class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {
 
       if (event === "switchedTo" && !newIsMain) return;
       if (event === "switchedAway" && newIsMain) return;
-      callback();
+      (callback as (payload?: unknown) => void)({});
     });
   }
 

package/src/runtime/api/thread-list-runtime.ts

@@ -28,6 +28,8 @@ export type ThreadListState = {
   readonly threadIds: readonly string[];
   readonly archivedThreadIds: readonly string[];
   readonly isLoading: boolean;
+  readonly isLoadingMore: boolean;
+  readonly hasMore: boolean;
   readonly threadItems: Readonly<
     Record<string, Omit<ThreadListItemState, "isMain" | "threadId">>
   >;
@@ -51,6 +53,7 @@ export type ThreadListRuntime = {
 
   getLoadThreadsPromise(): Promise<void>;
   reload(): Promise<void>;
+  loadMore(): Promise<void>;
 };
 
 const getThreadListState = (
@@ -62,6 +65,8 @@ const getThreadListState = (
     threadIds: threadList.threadIds,
     archivedThreadIds: threadList.archivedThreadIds,
     isLoading: threadList.isLoading,
+    isLoadingMore: threadList.isLoadingMore ?? false,
+    hasMore: threadList.hasMore ?? false,
     threadItems: threadList.threadItems,
   };
 };
@@ -138,6 +143,7 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
     this.switchToNewThread = this.switchToNewThread.bind(this);
     this.getLoadThreadsPromise = this.getLoadThreadsPromise.bind(this);
     this.reload = this.reload.bind(this);
+    this.loadMore = this.loadMore.bind(this);
     this.getState = this.getState.bind(this);
     this.subscribe = this.subscribe.bind(this);
     this.getById = this.getById.bind(this);
@@ -162,6 +168,10 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
     return this._core.reload?.() ?? RESOLVED_PROMISE;
   }
 
+  public loadMore(): Promise<void> {
+    return this._core.loadMore?.() ?? RESOLVED_PROMISE;
+  }
+
   public getState(): ThreadListState {
     return this._getState();
   }