@assistant-ui/core 0.1.7 → 0.1.9

package/src/runtimes/external-store/external-store-thread-runtime-core.ts

@@ -65,6 +65,7 @@ export class ExternalStoreThreadRuntimeCore
     dictation: false,
     attachments: false,
     feedback: false,
+    queue: false,
   };
 
   public get capabilities() {
@@ -139,6 +140,7 @@ export class ExternalStoreThreadRuntimeCore
       unstable_copy: this._store.unstable_capabilities?.copy !== false,
       attachments: !!this._store.adapters?.attachments,
       feedback: !!this._store.adapters?.feedback,
+      queue: false,
     };
     if (!shallowEqual(this._capabilities, newCapabilities)) {
       this._capabilities = newCapabilities;

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

@@ -47,6 +47,7 @@ export class LocalThreadRuntimeCore
     dictation: false,
     attachments: false,
     feedback: false,
+    queue: false,
   };
 
   private abortController: AbortController | null = null;

package/src/runtimes/readonly/ReadonlyThreadRuntimeCore.ts

@@ -191,6 +191,7 @@ export class ReadonlyThreadRuntimeCore
     dictation: false,
     attachments: false,
     feedback: false,
+    queue: false,
   } as const;
 
   isDisabled = false;

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

@@ -165,6 +165,7 @@ export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
     dictation: false,
     attachments: false,
     feedback: false,
+    queue: false,
   },
 
   isDisabled: false,

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

@@ -30,6 +30,17 @@ const pipeTransforms = <TState, TExtra>(
 export class OptimisticState<TState> extends BaseSubscribable {
   private readonly _pendingTransforms: Array<PendingTransform<TState, any>> =
     [];
+
+  /**
+   * `optimistic` callbacks from transforms that have already resolved.
+   * Re-applied after every `then` callback so that a wholesale state
+   * replacement (e.g. list()) cannot erase earlier completed effects
+   * (e.g. delete). Cleared when no pending transforms remain.
+   *
+   * Correctness requirement: `optimistic` callbacks must be idempotent.
+   */
+  private readonly _completedOptimistics: Array<(state: TState) => TState> = [];
+
   private _baseValue: TState;
   private _cachedValue: TState;
 
@@ -77,12 +88,28 @@ export class OptimisticState<TState> extends BaseSubscribable {
         transform.optimistic,
         transform.then,
       ]);
+
+      // Re-apply previously completed optimistic callbacks so that a
+      // then() that does wholesale replacement cannot erase their effects.
+      for (const fn of this._completedOptimistics) {
+        this._baseValue = fn(this._baseValue);
+      }
+
+      if (transform.optimistic) {
+        this._completedOptimistics.push(transform.optimistic);
+      }
+
       return result;
     } finally {
       const index = this._pendingTransforms.indexOf(pendingTransform);
       if (index > -1) {
         this._pendingTransforms.splice(index, 1);
       }
+
+      if (this._pendingTransforms.length === 0) {
+        this._completedOptimistics.length = 0;
+      }
+
       this._updateState();
     }
   }

package/src/store/clients/no-op-composer-client.ts

@@ -17,6 +17,7 @@ export const NoOpComposerClient = resource(
         type: type,
         dictation: undefined,
         quote: undefined,
+        queue: [],
       };
     }, [type]);
 
@@ -61,6 +62,9 @@ export const NoOpComposerClient = resource(
       setQuote: () => {
         throw new Error("Not supported");
       },
+      queueItem: () => {
+        throw new Error("Not supported");
+      },
     };
   },
 );

package/src/store/clients/runtime-adapter.ts

@@ -30,38 +30,27 @@ export const RuntimeAdapterResource = resource((runtime: AssistantRuntime) => {
 export const baseRuntimeAdapterTransformScopes = (
   scopes: ScopesConfig,
   parent: AssistantClient,
-): ScopesConfig => {
-  const result = {
-    ...scopes,
-    thread:
-      scopes.thread ??
-      Derived({
-        source: "threads",
-        query: { type: "main" },
-        get: (aui) => aui.threads().thread("main"),
-      }),
-    threadListItem:
-      scopes.threadListItem ??
-      Derived({
-        source: "threads",
-        query: { type: "main" },
-        get: (aui) => aui.threads().item("main"),
-      }),
-    composer:
-      scopes.composer ??
-      Derived({
-        source: "thread",
-        query: {},
-        get: (aui) => aui.threads().thread("main").composer(),
-      }),
-  };
+): void => {
+  scopes.thread ??= Derived({
+    source: "threads",
+    query: { type: "main" },
+    get: (aui) => aui.threads().thread("main"),
+  });
+  scopes.threadListItem ??= Derived({
+    source: "threads",
+    query: { type: "main" },
+    get: (aui) => aui.threads().item("main"),
+  });
+  scopes.composer ??= Derived({
+    source: "thread",
+    query: {},
+    get: (aui) => aui.threads().thread("main").composer(),
+  });
 
-  if (!result.modelContext && parent.modelContext.source === null) {
-    result.modelContext = ModelContext();
+  if (!scopes.modelContext && parent.modelContext.source === null) {
+    scopes.modelContext = ModelContext();
   }
-  if (!result.suggestions && parent.suggestions.source === null) {
-    result.suggestions = Suggestions();
+  if (!scopes.suggestions && parent.suggestions.source === null) {
+    scopes.suggestions = Suggestions();
   }
-
-  return result;
 };

package/src/store/index.ts

@@ -35,10 +35,17 @@ export type {
 export type {
   ComposerState,
   ComposerMethods,
+  ComposerSendOptions,
   ComposerMeta,
   ComposerEvents,
   ComposerClientSchema,
 } from "./scopes/composer";
+export type {
+  QueueItemState,
+  QueueItemMethods,
+  QueueItemMeta,
+  QueueItemClientSchema,
+} from "./scopes/queue-item";
 export type {
   AttachmentState,
   AttachmentMethods,

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

@@ -16,7 +16,6 @@ import {
   ComposerRuntime,
   EditComposerRuntime,
 } from "../../runtime/api/composer-runtime";
-import { ComposerRuntimeEventType } from "../../runtime/interfaces/composer-runtime-core";
 import { ComposerState } from "../scopes/composer";
 import { AttachmentRuntimeClient } from "./attachment-runtime-client";
 import { tapSubscribable } from "./tap-subscribable";
@@ -54,12 +53,7 @@ export const ComposerClient = resource(
       const unsubscribers: Unsubscribe[] = [];
 
       // Subscribe to composer events
-      const composerEvents: ComposerRuntimeEventType[] = [
-        "send",
-        "attachmentAdd",
-      ];
-
-      for (const event of composerEvents) {
+      for (const event of ["send", "attachmentAdd"] as const) {
         const unsubscribe = runtime.unstable_on(event, () => {
           emit(`composer.${event}`, {
             threadId: threadIdRef.current,
@@ -69,6 +63,23 @@ 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",
+            );
+          emit("composer.attachmentAddError", {
+            threadId: threadIdRef.current,
+            ...(messageIdRef && { messageId: messageIdRef.current }),
+            ...(errorAttachment && { attachmentId: errorAttachment.id }),
+          });
+        }),
+      );
+
       return () => {
         for (const unsub of unsubscribers) unsub();
       };
@@ -101,6 +112,7 @@ export const ComposerClient = resource(
         type: runtimeState.type ?? "thread",
         dictation: runtimeState.dictation,
         quote: runtimeState.quote,
+        queue: [],
       };
     }, [runtimeState, attachments.state]);
 
@@ -129,6 +141,9 @@ export const ComposerClient = resource(
           return attachments.get(selector);
         }
       },
+      queueItem: () => {
+        throw new Error("Queue is not supported in this runtime");
+      },
       __internal_getRuntime: () => runtime,
     };
   },

package/src/store/scope-registration.ts

@@ -9,6 +9,7 @@ import type { ModelContextClientSchema } from "./scopes/model-context";
 import type { SuggestionsClientSchema } from "./scopes/suggestions";
 import type { SuggestionClientSchema } from "./scopes/suggestion";
 import type { ChainOfThoughtClientSchema } from "./scopes/chain-of-thought";
+import type { QueueItemClientSchema } from "./scopes/queue-item";
 
 declare module "@assistant-ui/store" {
   interface ScopeRegistry {
@@ -23,5 +24,6 @@ declare module "@assistant-ui/store" {
     suggestions: SuggestionsClientSchema;
     suggestion: SuggestionClientSchema;
     chainOfThought: ChainOfThoughtClientSchema;
+    queueItem: QueueItemClientSchema;
   }
 }

package/src/store/scopes/composer.ts

@@ -5,6 +5,15 @@ import type { RunConfig } from "../../types/message";
 import type { ComposerRuntime } from "../../runtime/api/composer-runtime";
 import type { DictationState } from "../../runtime/interfaces/composer-runtime-core";
 import type { AttachmentMethods } from "./attachment";
+import type { QueueItemState, QueueItemMethods } from "./queue-item";
+
+export type ComposerSendOptions = {
+  /**
+   * Whether to steer (interrupt the current run and process this message immediately).
+   * When false (default), the message is queued and processed in order.
+   */
+  steer?: boolean;
+};
 
 export type ComposerState = {
   readonly text: string;
@@ -28,6 +37,12 @@ export type ComposerState = {
    * Undefined when no quote is set.
    */
   readonly quote: QuoteInfo | undefined;
+
+  /**
+   * The queue of messages waiting to be processed.
+   * Empty when no messages are queued.
+   */
+  readonly queue: readonly QueueItemState[];
 };
 
 export type ComposerMethods = {
@@ -39,7 +54,7 @@ export type ComposerMethods = {
   clearAttachments(): Promise<void>;
   attachment(selector: { index: number } | { id: string }): AttachmentMethods;
   reset(): Promise<void>;
-  send(): void;
+  send(opts?: ComposerSendOptions): void;
   cancel(): void;
   beginEdit(): void;
 
@@ -59,6 +74,11 @@ export type ComposerMethods = {
    */
   setQuote(quote: QuoteInfo | undefined): void;
 
+  /**
+   * Access a queue item by index.
+   */
+  queueItem(selector: { index: number }): QueueItemMethods;
+
   __internal_getRuntime?(): ComposerRuntime;
 };
 
@@ -70,6 +90,11 @@ export type ComposerMeta = {
 export type ComposerEvents = {
   "composer.send": { threadId: string; messageId?: string };
   "composer.attachmentAdd": { threadId: string; messageId?: string };
+  "composer.attachmentAddError": {
+    threadId: string;
+    messageId?: string;
+    attachmentId?: string;
+  };
 };
 
 export type ComposerClientSchema = {

package/src/store/scopes/queue-item.ts

@@ -0,0 +1,20 @@
+export type QueueItemState = {
+  readonly id: string;
+  readonly prompt: string;
+};
+
+export type QueueItemMethods = {
+  getState(): QueueItemState;
+  steer(): void;
+  remove(): void;
+};
+
+export type QueueItemMeta = {
+  source: "composer";
+  query: { index: number };
+};
+
+export type QueueItemClientSchema = {
+  methods: QueueItemMethods;
+  meta: QueueItemMeta;
+};

package/src/tests/OptimisticState-list-race.test.ts

@@ -0,0 +1,256 @@
+import { describe, it, expect } from "vitest";
+import { OptimisticState } from "../runtimes/remote-thread-list/optimistic-state";
+import {
+  type RemoteThreadState,
+  type RemoteThreadData,
+  type THREAD_MAPPING_ID,
+  createThreadMappingId,
+  updateStatusReducer,
+} from "../runtimes/remote-thread-list/remote-thread-state";
+
+/**
+ * Reproduces the race condition where a stale list() response
+ * re-introduces a thread that was deleted/archived while the list
+ * was in flight.
+ *
+ * Root cause (before fix): OptimisticState's `then` callback could
+ * overwrite `_baseValue`, erasing effects from transforms that had
+ * already completed. The fix re-applies completed `optimistic`
+ * callbacks after every `then`.
+ */
+
+const EMPTY_STATE: RemoteThreadState = {
+  isLoading: false,
+  newThreadId: undefined,
+  threadIds: [],
+  archivedThreadIds: [],
+  threadIdMap: {},
+  threadData: {},
+};
+
+type ListResult = {
+  threads: {
+    remoteId: string;
+    status: "regular" | "archived";
+    title?: string;
+    externalId?: string | undefined;
+  }[];
+};
+
+/** Simulates getLoadThreadsPromise's then callback (plain version, no workarounds). */
+const applyListResult = (
+  state: RemoteThreadState,
+  l: ListResult,
+): RemoteThreadState => {
+  const newThreadIds: string[] = [];
+  const newArchivedThreadIds: string[] = [];
+  const newThreadIdMap = {} as Record<string, THREAD_MAPPING_ID>;
+  const newThreadData = {} as Record<THREAD_MAPPING_ID, RemoteThreadData>;
+
+  for (const thread of l.threads) {
+    if (thread.status === "regular") newThreadIds.push(thread.remoteId);
+    else newArchivedThreadIds.push(thread.remoteId);
+
+    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,
+      initializeTask: Promise.resolve({
+        remoteId: thread.remoteId,
+        externalId: thread.externalId,
+      }),
+    };
+  }
+
+  return {
+    ...state,
+    threadIds: newThreadIds,
+    archivedThreadIds: newArchivedThreadIds,
+    threadIdMap: { ...state.threadIdMap, ...newThreadIdMap },
+    threadData: { ...state.threadData, ...newThreadData },
+  };
+};
+
+/** Creates a deferred promise for controlling resolution order. */
+function deferred<T>() {
+  let resolve!: (v: T) => void;
+  const promise = new Promise<T>((r) => {
+    resolve = r;
+  });
+  return { promise, resolve };
+}
+
+describe("list + delete race condition", () => {
+  it("stale list() does not re-add a thread deleted while list was in flight", async () => {
+    const state = new OptimisticState<RemoteThreadState>(EMPTY_STATE);
+
+    const listDeferred = deferred<ListResult>();
+    const deleteDeferred = deferred<void>();
+
+    // 1. list() starts
+    const listPromise = state.optimisticUpdate({
+      execute: () => listDeferred.promise,
+      loading: (s) => ({ ...s, isLoading: true }),
+      then: applyListResult,
+    });
+
+    // 2. delete starts (while list is in flight)
+    const deletePromise = state.optimisticUpdate({
+      execute: () => deleteDeferred.promise,
+      optimistic: (s) => updateStatusReducer(s, "thread-A", "deleted"),
+    });
+
+    // 3. DELETE resolves first
+    deleteDeferred.resolve();
+    await deletePromise;
+
+    // 4. list resolves with stale data that includes deleted thread
+    listDeferred.resolve({
+      threads: [{ remoteId: "thread-A", status: "regular", title: "A" }],
+    });
+    await listPromise;
+
+    // Thread A must NOT reappear
+    expect(state.value.threadIds).not.toContain("thread-A");
+    expect(
+      state.value.threadData[createThreadMappingId("thread-A")],
+    ).toBeUndefined();
+  });
+
+  it("stale list() does not revert archive back to regular", async () => {
+    // Start with thread A already in state
+    const mappingId = createThreadMappingId("thread-A");
+    const initial: RemoteThreadState = {
+      ...EMPTY_STATE,
+      threadIds: ["thread-A"],
+      threadIdMap: { "thread-A": mappingId },
+      threadData: {
+        [mappingId]: {
+          id: "thread-A",
+          remoteId: "thread-A",
+          externalId: undefined,
+          status: "regular",
+          title: "A",
+          initializeTask: Promise.resolve({
+            remoteId: "thread-A",
+            externalId: undefined,
+          }),
+        },
+      },
+    };
+
+    const state = new OptimisticState<RemoteThreadState>(initial);
+
+    const listDeferred = deferred<ListResult>();
+    const archiveDeferred = deferred<void>();
+
+    // 1. list() starts
+    const listPromise = state.optimisticUpdate({
+      execute: () => listDeferred.promise,
+      loading: (s) => ({ ...s, isLoading: true }),
+      then: applyListResult,
+    });
+
+    // 2. archive starts
+    const archivePromise = state.optimisticUpdate({
+      execute: () => archiveDeferred.promise,
+      optimistic: (s) => updateStatusReducer(s, "thread-A", "archived"),
+    });
+
+    // 3. archive resolves first
+    archiveDeferred.resolve();
+    await archivePromise;
+
+    // 4. list resolves with stale data (thread-A as regular)
+    listDeferred.resolve({
+      threads: [{ remoteId: "thread-A", status: "regular", title: "A" }],
+    });
+    await listPromise;
+
+    // Thread A should remain archived, NOT be reverted to regular
+    expect(state.value.threadIds).not.toContain("thread-A");
+    expect(state.value.archivedThreadIds).toContain("thread-A");
+    expect(
+      state.value.threadData[createThreadMappingId("thread-A")]?.status,
+    ).toBe("archived");
+  });
+
+  it("threads NOT modified during list() are loaded normally", async () => {
+    const state = new OptimisticState<RemoteThreadState>(EMPTY_STATE);
+
+    const listDeferred = deferred<ListResult>();
+    const deleteDeferred = deferred<void>();
+
+    // 1. list() starts
+    const listPromise = state.optimisticUpdate({
+      execute: () => listDeferred.promise,
+      loading: (s) => ({ ...s, isLoading: true }),
+      then: applyListResult,
+    });
+
+    // 2. delete thread A (while list is in flight)
+    const deletePromise = state.optimisticUpdate({
+      execute: () => deleteDeferred.promise,
+      optimistic: (s) => updateStatusReducer(s, "thread-A", "deleted"),
+    });
+
+    deleteDeferred.resolve();
+    await deletePromise;
+
+    // 3. list resolves with [A, B] — A should be filtered, B should load
+    listDeferred.resolve({
+      threads: [
+        { remoteId: "thread-A", status: "regular", title: "A" },
+        { remoteId: "thread-B", status: "regular", title: "B" },
+      ],
+    });
+    await listPromise;
+
+    expect(state.value.threadIds).toEqual(["thread-B"]);
+    expect(state.value.threadIds).not.toContain("thread-A");
+    expect(
+      state.value.threadData[createThreadMappingId("thread-B")],
+    ).toBeDefined();
+  });
+
+  it("list resolves before delete — no race, both work correctly", async () => {
+    const state = new OptimisticState<RemoteThreadState>(EMPTY_STATE);
+
+    const listDeferred = deferred<ListResult>();
+    const deleteDeferred = deferred<void>();
+
+    const listPromise = state.optimisticUpdate({
+      execute: () => listDeferred.promise,
+      loading: (s) => ({ ...s, isLoading: true }),
+      then: applyListResult,
+    });
+
+    const deletePromise = state.optimisticUpdate({
+      execute: () => deleteDeferred.promise,
+      optimistic: (s) => updateStatusReducer(s, "thread-A", "deleted"),
+    });
+
+    // list resolves FIRST this time
+    listDeferred.resolve({
+      threads: [{ remoteId: "thread-A", status: "regular", title: "A" }],
+    });
+    await listPromise;
+
+    // thread A is in base state now, but delete's optimistic still hides it
+    expect(state.value.threadIds).not.toContain("thread-A");
+
+    // delete resolves
+    deleteDeferred.resolve();
+    await deletePromise;
+
+    // thread A is gone from both base and cached
+    expect(state.value.threadIds).not.toContain("thread-A");
+    expect(
+      state.value.threadData[createThreadMappingId("thread-A")],
+    ).toBeUndefined();
+  });
+});