@assistant-ui/core 0.1.16 → 0.2.0

package/src/runtimes/local/local-thread-runtime-core.ts

@@ -226,10 +226,6 @@ export class LocalThreadRuntimeCore
     throw new Error("Runtime does not support importing external states.");
   }
 
-  public unstable_loadExternalState(): void {
-    throw new Error("Runtime does not support importing external states.");
-  }
-
   public async startRun(
     { parentId, runConfig }: StartRunConfig,
     runCallback?: ChatModelAdapter["run"],
@@ -253,7 +249,7 @@ export class LocalThreadRuntimeCore
       createdAt: new Date(),
     };
 
-    this._notifyEventSubscribers("runStart");
+    this._notifyEventSubscribers("runStart", {});
 
     try {
       this._suggestions = [];
@@ -271,7 +267,7 @@ export class LocalThreadRuntimeCore
         runCallback = undefined;
       } while (shouldContinue(message, this._options.unstable_humanToolNames));
     } finally {
-      this._notifyEventSubscribers("runEnd");
+      this._notifyEventSubscribers("runEnd", {});
     }
 
     this._suggestionsController = new AbortController();
@@ -405,7 +401,6 @@ export class LocalThreadRuntimeCore
         runConfig: this._lastRunConfig,
         abortSignal,
         context,
-        config: context,
         unstable_assistantMessageId: message.id,
         unstable_threadId: threadId,
         unstable_parentId: parentId,

package/src/runtimes/readonly/ReadonlyThreadRuntimeCore.ts

@@ -104,10 +104,6 @@ export class ReadonlyThreadRuntimeCore
     throw READONLY_THREAD_ERROR;
   }
 
-  unstable_loadExternalState(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
   composer = {
     attachments: [] as never[],
     attachmentAccept: "*",

package/src/runtimes/remote-thread-list/empty-thread-core.ts

@@ -83,10 +83,6 @@ export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
     throw EMPTY_THREAD_ERROR;
   },
 
-  unstable_loadExternalState() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
   composer: {
     attachments: [],
     attachmentAccept: "*",

package/src/runtimes/remote-thread-list/remote-thread-state.ts

@@ -1,4 +1,7 @@
-import type { RemoteThreadInitializeResponse } from "./types";
+import type {
+  RemoteThreadInitializeResponse,
+  RemoteThreadMetadata,
+} from "./types";
 
 export type RemoteThreadData =
   | {
@@ -34,8 +37,58 @@ export function createThreadMappingId(id: string): THREAD_MAPPING_ID {
   return id as THREAD_MAPPING_ID;
 }
 
+export const normalizeCursor = (c: string | undefined): string | undefined =>
+  c || undefined;
+
+type ClassifyAccumulator = {
+  threadIds: string[];
+  archivedThreadIds: string[];
+  threadIdMap: Record<string, THREAD_MAPPING_ID>;
+  threadData: Record<THREAD_MAPPING_ID, RemoteThreadData>;
+};
+
+export const classifyThreads = (
+  threads: readonly RemoteThreadMetadata[],
+  acc: ClassifyAccumulator,
+): ClassifyAccumulator => {
+  for (const thread of threads) {
+    if (acc.threadIdMap[thread.remoteId] !== undefined) continue;
+
+    switch (thread.status) {
+      case "regular":
+        acc.threadIds.push(thread.remoteId);
+        break;
+      case "archived":
+        acc.archivedThreadIds.push(thread.remoteId);
+        break;
+      default: {
+        const _exhaustiveCheck: never = thread.status;
+        throw new Error(`Unsupported state: ${_exhaustiveCheck}`);
+      }
+    }
+
+    const mappingId = createThreadMappingId(thread.remoteId);
+    acc.threadIdMap[thread.remoteId] = mappingId;
+    acc.threadData[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,
+      }),
+    };
+  }
+  return acc;
+};
+
 export type RemoteThreadState = {
   readonly isLoading: boolean;
+  readonly isLoadingMore: boolean;
+  readonly cursor: string | undefined;
   readonly newThreadId: string | undefined;
   readonly threadIds: readonly string[];
   readonly archivedThreadIds: readonly string[];

package/src/runtimes/remote-thread-list/types.ts

@@ -18,10 +18,15 @@ export type RemoteThreadMetadata = {
 
 export type RemoteThreadListResponse = {
   threads: RemoteThreadMetadata[];
+  nextCursor?: string | undefined;
+};
+
+export type RemoteThreadListPageOptions = {
+  after?: string | undefined;
 };
 
 export type RemoteThreadListAdapter = {
-  list(): Promise<RemoteThreadListResponse>;
+  list(params?: RemoteThreadListPageOptions): Promise<RemoteThreadListResponse>;
 
   rename(remoteId: string, newTitle: string): Promise<void>;
   archive(remoteId: string): Promise<void>;

package/src/store/clients/thread-message-client.ts

@@ -106,7 +106,6 @@ export const ThreadMessageClient = resource(
         branchNumber,
         branchCount,
         speech: undefined,
-        submittedFeedback: message.metadata.submittedFeedback,
         isCopied: isCopiedState,
         isHovering: isHoveringState,
       };

package/src/store/runtime-clients/composer-runtime-client.ts

@@ -63,19 +63,15 @@ export const ComposerClient = resource(
         unsubscribers.push(unsubscribe);
       }
 
-      // attachmentAddError carries the failed attachment ID
       unsubscribers.push(
-        runtime.unstable_on("attachmentAddError", () => {
-          const errorAttachment = runtime
-            .getState()
-            .attachments.findLast(
-              (a) =>
-                a.status.type === "incomplete" && a.status.reason === "error",
-            );
+        runtime.unstable_on("attachmentAddError", (payload) => {
+          // payload.error omitted: raw Error is not store-serializable; use runtime.unstable_on for it.
           emit("composer.attachmentAddError", {
             threadId: threadIdRef.current,
             ...(messageIdRef && { messageId: messageIdRef.current }),
-            ...(errorAttachment && { attachmentId: errorAttachment.id }),
+            ...(payload.attachmentId && { attachmentId: payload.attachmentId }),
+            reason: payload.reason,
+            message: payload.message,
           });
         }),
       );

package/src/store/runtime-clients/thread-list-runtime-client.ts

@@ -53,6 +53,8 @@ export const ThreadListClient = resource(
         mainThreadId: runtimeState.mainThreadId,
         newThreadId: runtimeState.newThreadId ?? null,
         isLoading: runtimeState.isLoading,
+        isLoadingMore: runtimeState.isLoadingMore,
+        hasMore: runtimeState.hasMore,
         threadIds: runtimeState.threadIds,
         archivedThreadIds: runtimeState.archivedThreadIds,
         threadItems: threadItems.state,
@@ -87,6 +89,7 @@ export const ThreadListClient = resource(
       },
       getLoadThreadsPromise: () => runtime.getLoadThreadsPromise(),
       reload: () => runtime.reload(),
+      loadMore: () => runtime.loadMore(),
       __internal_getAssistantRuntime: () => __internal_assistantRuntime,
     };
   },

package/src/store/runtime-clients/thread-runtime-client.ts

@@ -116,7 +116,6 @@ export const ThreadClient = resource(
       append: runtime.append,
       startRun: runtime.startRun,
       resumeRun: runtime.resumeRun,
-      unstable_resumeRun: runtime.resumeRun,
       cancelRun: runtime.cancelRun,
       getModelContext: runtime.getModelContext,
       export: runtime.export,

package/src/store/scopes/composer.ts

@@ -4,6 +4,7 @@ import type { QuoteInfo } from "../../types/quote";
 import type { RunConfig } from "../../types/message";
 import type { ComposerRuntime } from "../../runtime/api/composer-runtime";
 import type {
+  AttachmentAddErrorReason,
   DictationState,
   SendOptions,
 } from "../../runtime/interfaces/composer-runtime-core";
@@ -91,12 +92,22 @@ export type ComposerMeta = {
 };
 
 export type ComposerEvents = {
+  /**
+   * @deprecated State-derivable. Observe composer `text` clearing via
+   * `useAuiState` instead. Kept for backward compatibility.
+   */
   "composer.send": { threadId: string; messageId?: string };
+  /**
+   * @deprecated State-derivable. Observe composer `attachments` via
+   * `useAuiState` instead. Kept for backward compatibility.
+   */
   "composer.attachmentAdd": { threadId: string; messageId?: string };
   "composer.attachmentAddError": {
     threadId: string;
     messageId?: string;
     attachmentId?: string;
+    reason: AttachmentAddErrorReason;
+    message: string;
   };
 };
 

package/src/store/scopes/message.ts

@@ -1,9 +1,6 @@
 import type { ThreadMessage } from "../../types/message";
 import type { RunConfig } from "../../types/message";
-import type {
-  SpeechState,
-  SubmittedFeedback,
-} from "../../runtime/interfaces/thread-runtime-core";
+import type { SpeechState } from "../../runtime/interfaces/thread-runtime-core";
 import type { MessageRuntime } from "../../runtime/api/message-runtime";
 import type { ComposerMethods, ComposerState } from "./composer";
 import type { PartMethods, PartState } from "./part";
@@ -31,8 +28,6 @@ export type MessageState = ThreadMessage & {
    * });
    */
   readonly speech: SpeechState | undefined;
-  /** @deprecated Use `message.metadata.submittedFeedback` instead. This will be removed in 0.12.0. */
-  readonly submittedFeedback: SubmittedFeedback | undefined;
   readonly composer: ComposerState;
   readonly parts: readonly PartState[];
   readonly isCopied: boolean;

package/src/store/scopes/thread-list-item.ts

@@ -32,7 +32,17 @@ export type ThreadListItemMeta = {
 };
 
 export type ThreadListItemEvents = {
+  /**
+   * @deprecated State-derivable. Compare `s.threads.mainThreadId` against the
+   * item's `s.threadListItem.id` via `useAuiState` instead. Kept for backward
+   * compatibility.
+   */
   "threadListItem.switchedTo": { threadId: string };
+  /**
+   * @deprecated State-derivable. Compare `s.threads.mainThreadId` against the
+   * item's `s.threadListItem.id` via `useAuiState` instead. Kept for backward
+   * compatibility.
+   */
   "threadListItem.switchedAway": { threadId: string };
 };
 

package/src/store/scopes/thread.ts

@@ -98,11 +98,6 @@ export type ThreadMethods = {
    * @param config The configuration for resuming the run
    */
   resumeRun(config: CreateResumeRunConfig): void;
-
-  /**
-   * @deprecated Use `resumeRun` instead.
-   */
-  unstable_resumeRun(config: CreateResumeRunConfig): void;
   cancelRun(): void;
   getModelContext(): ModelContext;
   export(): ExportedMessageRepository;
@@ -130,9 +125,26 @@ export type ThreadMeta = {
 };
 
 export type ThreadEvents = {
+  /**
+   * @deprecated State-derivable. Observe `isRunning` flipping to `true` via
+   * `useAuiState` instead. Kept for backward compatibility.
+   */
   "thread.runStart": { threadId: string };
+  /**
+   * @deprecated State-derivable. Observe `isRunning` flipping to `false` via
+   * `useAuiState` instead. Kept for backward compatibility.
+   */
   "thread.runEnd": { threadId: string };
+  /**
+   * @deprecated State-derivable. This event fires before the first message is
+   * added; observe `messages` becoming non-empty via `useAuiState` instead of
+   * reading state inside this event handler. Kept for backward compatibility.
+   */
   "thread.initialize": { threadId: string };
+  /**
+   * Truly transient. Model context lives in a provider, not in thread state,
+   * so this event has no state-derivable equivalent.
+   */
   "thread.modelContextUpdate": { threadId: string };
 };
 

package/src/store/scopes/threads.ts

@@ -9,6 +9,8 @@ export type ThreadsState = {
   readonly mainThreadId: string;
   readonly newThreadId: string | null;
   readonly isLoading: boolean;
+  readonly isLoadingMore: boolean;
+  readonly hasMore: boolean;
   readonly threadIds: readonly string[];
   readonly archivedThreadIds: readonly string[];
   readonly threadItems: readonly ThreadListItemState[];
@@ -28,6 +30,7 @@ export type ThreadsMethods = {
   thread(selector: "main"): ThreadMethods;
   getLoadThreadsPromise(): Promise<void>;
   reload(): Promise<void>;
+  loadMore(): Promise<void>;
   __internal_getAssistantRuntime?(): AssistantRuntime;
 };
 

package/src/subscribable/subscribable.ts

@@ -21,7 +21,10 @@ export type EventSubscribable<TEvent extends string> = {
   event: TEvent;
   binding: SubscribableWithState<
     | {
-        unstable_on: (event: TEvent, callback: () => void) => Unsubscribe;
+        unstable_on: (
+          event: TEvent,
+          callback: (payload?: unknown) => void,
+        ) => Unsubscribe;
       }
     | undefined,
     unknown
@@ -87,7 +90,7 @@ export class BaseSubscribable {
 
 // lazy connect/disconnect: only opens upstream subscription while it has subscribers
 export abstract class BaseSubject {
-  private _subscriptions = new Set<() => void>();
+  private _subscriptions = new Set<(payload?: unknown) => void>();
   private _connection: Unsubscribe | undefined;
 
   protected get isConnected() {
@@ -96,8 +99,8 @@ export abstract class BaseSubject {
 
   protected abstract _connect(): Unsubscribe;
 
-  protected notifySubscribers() {
-    for (const callback of this._subscriptions) callback();
+  protected notifySubscribers(payload?: unknown) {
+    for (const callback of this._subscriptions) callback(payload);
   }
 
   private _updateConnection() {
@@ -110,7 +113,7 @@ export abstract class BaseSubject {
     }
   }
 
-  public subscribe(callback: () => void) {
+  public subscribe(callback: (payload?: unknown) => void) {
     this._subscriptions.add(callback);
     this._updateConnection();
 
@@ -270,8 +273,8 @@ export class EventSubscriptionSubject<
   }
 
   protected _connect(): Unsubscribe {
-    const callback = () => {
-      this.notifySubscribers();
+    const callback = (payload?: unknown) => {
+      this.notifySubscribers(payload);
     };
 
     let lastState = this.config.binding.getState();