@assistant-ui/core 0.3.3 → 0.3.4

package/src/runtime/base/base-composer-runtime-core.ts

@@ -34,6 +34,11 @@ import { notifyEventListeners } from "../../utils/notify-event-listeners";
 const isAttachmentComplete = (a: Attachment): a is CompleteAttachment =>
   a.status.type === "complete";
 
+type AttachmentAddOperation = {
+  cancelled: boolean;
+  attachmentIds: Set<string>;
+};
+
 export abstract class BaseComposerRuntimeCore
   extends BaseSubscribable
   implements ComposerRuntimeCore
@@ -138,6 +143,22 @@ export abstract class BaseComposerRuntimeCore
   protected _isSending = false;
   private _removedDuringSend = new Set<string>();
   private _sendGeneration = 0;
+  private _attachmentAddOperations = new Set<AttachmentAddOperation>();
+
+  private _cancelAttachmentAdd(attachmentId: string) {
+    for (const operation of [...this._attachmentAddOperations]) {
+      if (!operation.attachmentIds.has(attachmentId)) continue;
+      operation.cancelled = true;
+      this._attachmentAddOperations.delete(operation);
+    }
+  }
+
+  private _cancelAllAttachmentAdds() {
+    for (const operation of this._attachmentAddOperations) {
+      operation.cancelled = true;
+    }
+    this._attachmentAddOperations.clear();
+  }
 
   private _emptyTextAndAttachments() {
     this._attachments = [];
@@ -154,6 +175,8 @@ export abstract class BaseComposerRuntimeCore
   }
 
   public async reset() {
+    this._cancelAllAttachmentAdds();
+
     // A send whose adapter never settles must not brick the composer; reset is
     // the escape hatch that releases the in-flight lock. Bumping the generation
     // invalidates that send entirely so a late-settling upload can neither
@@ -182,6 +205,7 @@ export abstract class BaseComposerRuntimeCore
   }
 
   public async clearAttachments() {
+    this._cancelAllAttachmentAdds();
     const task = this._onClearAttachments();
     this.setAttachments([]);
 
@@ -324,23 +348,6 @@ export abstract class BaseComposerRuntimeCore
       return;
     }
 
-    const upsertAttachment = (a: PendingAttachment) => {
-      const idx = this._attachments.findIndex(
-        (attachment) => attachment.id === a.id,
-      );
-      if (idx !== -1)
-        this._attachments = [
-          ...this._attachments.slice(0, idx),
-          a,
-          ...this._attachments.slice(idx + 1),
-        ];
-      else {
-        this._attachments = [...this._attachments, a];
-      }
-
-      this._notifySubscribers();
-    };
-
     const adapter = this.getAttachmentAdapter();
     if (!adapter) {
       const message = "Attachments are not supported";
@@ -361,19 +368,46 @@ export abstract class BaseComposerRuntimeCore
       throw err;
     }
 
+    const operation: AttachmentAddOperation = {
+      cancelled: false,
+      attachmentIds: new Set(),
+    };
+    const operations = this._attachmentAddOperations;
+    operations.add(operation);
+    const upsertAttachment = (a: PendingAttachment) => {
+      if (operation.cancelled) return false;
+
+      operation.attachmentIds.add(a.id);
+      const idx = this._attachments.findIndex(
+        (attachment) => attachment.id === a.id,
+      );
+      if (idx !== -1)
+        this._attachments = [
+          ...this._attachments.slice(0, idx),
+          a,
+          ...this._attachments.slice(idx + 1),
+        ];
+      else {
+        this._attachments = [...this._attachments, a];
+      }
+
+      this._notifySubscribers();
+      return true;
+    };
     let lastAttachment: PendingAttachment | undefined;
     try {
       const promiseOrGenerator = adapter.add({ file: fileOrAttachment });
       if (Symbol.asyncIterator in promiseOrGenerator) {
         for await (const r of promiseOrGenerator) {
           lastAttachment = r;
-          upsertAttachment(r);
+          if (!upsertAttachment(r)) break;
         }
       } else {
         lastAttachment = await promiseOrGenerator;
         upsertAttachment(lastAttachment);
       }
     } catch (e) {
+      if (operation.cancelled) return;
       if (lastAttachment) {
         upsertAttachment({
           ...lastAttachment,
@@ -391,8 +425,11 @@ export abstract class BaseComposerRuntimeCore
         e instanceof Error ? e : undefined,
       );
       throw e;
+    } finally {
+      operations.delete(operation);
     }
 
+    if (operation.cancelled) return;
     if (
       lastAttachment?.status.type === "incomplete" &&
       lastAttachment.status.reason === "error"
@@ -434,6 +471,8 @@ export abstract class BaseComposerRuntimeCore
     if (index === -1) throw new Error("Attachment not found");
     const attachment = this._attachments[index]!;
 
+    this._cancelAttachmentAdd(attachmentId);
+
     // A send in flight may already be uploading this attachment; the upload
     // can't be cancelled, so mark it to be dropped from the outgoing message
     // before any await gives the upload a chance to settle first.
@@ -442,7 +481,21 @@ export abstract class BaseComposerRuntimeCore
     if (!isAttachmentComplete(attachment)) {
       const adapter = this.getAttachmentAdapter();
       if (!adapter) throw new Error("Attachments are not supported");
-      await adapter.remove(attachment);
+      try {
+        await adapter.remove(attachment);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this._attachments = this._attachments.map((candidate) =>
+          candidate.id === attachmentId && !isAttachmentComplete(candidate)
+            ? {
+                ...candidate,
+                status: { type: "incomplete", reason: "error", message },
+              }
+            : candidate,
+        );
+        this._notifySubscribers();
+        throw error;
+      }
     }
     this._attachments = this._attachments.filter((a) => a.id !== attachmentId);
     this._notifySubscribers();

package/src/runtime/interfaces/thread-list-runtime-core.ts

@@ -31,6 +31,16 @@ export type ThreadListRuntimeCore = {
   getMainThreadRuntimeCore(): ThreadRuntimeCore;
   getThreadRuntimeCore(threadId: string): ThreadRuntimeCore;
 
+  /**
+   * Whether the thread currently has a run in progress, including a run on a
+   * thread that is not the main one. Implemented by thread lists that keep
+   * runtimes alive for non-main threads, and they notify their subscribers
+   * whenever the answer changes. A thread list that mounts only the main thread
+   * leaves this undefined: its other threads have no runtime and so cannot be
+   * running, and the main thread's run state is read from its runtime directly.
+   */
+  unstable_isThreadRunning?(threadId: string): boolean;
+
   getItemById(threadId: string): ThreadListItemCoreState | undefined;
 
   switchToThread(
@@ -41,6 +51,7 @@ export type ThreadListRuntimeCore = {
 
   getLoadThreadsPromise(): Promise<void>;
   reload?(): Promise<void>;
+  reloadMainThread?(): Promise<void>;
   loadMore?(): Promise<void>;
 
   detach(threadId: string): Promise<void>;

package/src/runtime/interfaces/thread-runtime-core.ts

@@ -23,6 +23,8 @@ export type RuntimeCapabilities = {
   readonly switchBranchDuringRun: boolean;
   readonly edit: boolean;
   readonly reload: boolean;
+  /** Whether the runtime can refetch this thread's remote state in place. */
+  readonly refetchThread: boolean;
   readonly delete: boolean;
   readonly cancel: boolean;
   readonly unstable_copy: boolean;
@@ -216,6 +218,19 @@ export type ThreadRuntimeCore = Readonly<{
 
   reset(initialMessages?: readonly ThreadMessageLike[]): void;
 
+  /**
+   * Re-fetches this thread's state from its backing store, in place: no
+   * runtime-hook remount, so runtime identity and composer drafts survive.
+   * Presence signals the capability to `threads.reloadMainThread()`, which
+   * calls this and propagates its rejection. It does not touch a run in
+   * progress first, because stopping one is `cancelRun`, whose contract is
+   * that the user abandoned a send: it returns the trailing user message to
+   * the composer. An implementation is therefore responsible for whatever
+   * coordination a concurrent run needs. Runtimes without remote state leave
+   * it undefined.
+   */
+  unstable_refetchThread?: (() => Promise<void>) | undefined;
+
   /**
    * @deprecated This API is still under active development and might change without notice.
    * For state-derivable transitions, prefer `subscribe` + `getState`. This channel is the

package/src/runtimes/external-store/external-store-adapter.ts

@@ -143,6 +143,15 @@ type ExternalStoreAdapterBase<T> = {
     | undefined;
   onResume?: ((config: ResumeRunConfig) => Promise<void>) | undefined;
   onCancel?: (() => Promise<void>) | undefined;
+  /**
+   * Re-fetches the thread's state from the backing store, in place; a
+   * rejection reaches the `threads.reloadMainThread()` caller. Unrelated to
+   * `onReload`, which re-generates an assistant message.
+   *
+   * The caller does not stop a run in progress first, so an adapter that can
+   * stream owns whatever coordination one needs.
+   */
+  onRefetchThread?: (() => Promise<void>) | undefined;
   onAddToolResult?:
     | ((options: AddToolResultOptions) => Promise<void> | void)
     | undefined;

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

@@ -169,6 +169,15 @@ export class ExternalStoreThreadListRuntimeCore implements ThreadListRuntimeCore
     this._notifySubscribers();
   }
 
+  public async reloadMainThread(): Promise<void> {
+    // There is no runtime hook to remount here, so the capability is the only
+    // path and an adapter without it has nothing to refetch with.
+    if (!this._mainThread.unstable_refetchThread) return;
+    // No unsent-thread guard: every entry here is regular or archived, so the
+    // "new" status the remote thread list has to exclude cannot occur.
+    await this._mainThread.unstable_refetchThread();
+  }
+
   public async switchToThread(
     threadId: string,
     _options?: { unarchive?: boolean },

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

@@ -65,6 +65,7 @@ export class ExternalStoreThreadRuntimeCore
     edit: false,
     delete: false,
     reload: false,
+    refetchThread: false,
     cancel: false,
     unstable_copy: false,
     speech: false,
@@ -102,6 +103,12 @@ export class ExternalStoreThreadRuntimeCore
     return this._store.adapters;
   }
 
+  // A getter, not a method, so its presence tracks the adapter.
+  public get unstable_refetchThread(): (() => Promise<void>) | undefined {
+    if (!this._store.onRefetchThread) return undefined;
+    return () => this._store.onRefetchThread!();
+  }
+
   public suggestions: readonly ThreadSuggestion[] = [];
   public extras: unknown = undefined;
 
@@ -156,6 +163,7 @@ export class ExternalStoreThreadRuntimeCore
         this._store.onDelete !== undefined ||
         this._store.setMessages !== undefined,
       reload: this._store.onReload !== undefined,
+      refetchThread: this._store.onRefetchThread !== undefined,
       cancel: this._store.onCancel !== undefined,
       speech: this._store.adapters?.speech !== undefined,
       dictation: this._store.adapters?.dictation !== undefined,

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

@@ -53,6 +53,7 @@ export class LocalThreadRuntimeCore
     edit: true,
     delete: false,
     reload: true,
+    refetchThread: false,
     cancel: true,
     unstable_copy: true,
     speech: false,

package/src/runtimes/readonly/ReadonlyThreadRuntimeCore.ts

@@ -208,6 +208,7 @@ export class ReadonlyThreadRuntimeCore
     edit: false,
     delete: false,
     reload: false,
+    refetchThread: false,
     cancel: false,
     unstable_copy: false,
     speech: false,

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

@@ -189,6 +189,7 @@ export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
     edit: false,
     delete: false,
     reload: false,
+    refetchThread: false,
     cancel: false,
     unstable_copy: false,
     speech: false,

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

@@ -1,5 +1,5 @@
 import type { Unsubscribe } from "../../types/unsubscribe";
-import { useEffect } from "react";
+import { useEffect, useMemo } from "react";
 import { resource } from "@assistant-ui/tap";
 import { type ClientOutput, useAssistantEmit } from "@assistant-ui/store";
 import type {
@@ -10,10 +10,21 @@ import { useSubscribable } from "./useSubscribable";
 
 const useThreadListItemClient = ({
   runtime,
+  mainThreadIsRunning = false,
 }: {
   runtime: ThreadListItemRuntime;
+  // A thread list that cannot report per-thread run state still leaves the open
+  // thread observable, and the thread client tracks that reactively. Omitted
+  // where the runtime state is already authoritative for every thread.
+  mainThreadIsRunning?: boolean | undefined;
 }): ClientOutput<"threadListItem"> => {
-  const state = useSubscribable(runtime);
+  const runtimeState = useSubscribable(runtime);
+  const state = useMemo(() => {
+    const isRunning =
+      runtimeState.isRunning || (runtimeState.isMain && mainThreadIsRunning);
+    if (isRunning === runtimeState.isRunning) return runtimeState;
+    return { ...runtimeState, isRunning };
+  }, [runtimeState, mainThreadIsRunning]);
   const emit = useAssistantEmit();
 
   // Bind thread list item events to event manager

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

@@ -15,9 +15,11 @@ import type { ThreadsState } from "../scopes/threads";
 const useThreadListItemClientById = ({
   runtime,
   id,
+  mainThreadIsRunning,
 }: {
   runtime: ThreadListRuntime;
   id: string;
+  mainThreadIsRunning: boolean;
 }) => {
   const threadListItemRuntime = useMemo(
     () => runtime.getItemById(id),
@@ -26,6 +28,7 @@ const useThreadListItemClientById = ({
   return useResource(
     ThreadListItemClient({
       runtime: threadListItemRuntime,
+      mainThreadIsRunning,
     }),
   );
 };
@@ -48,7 +51,15 @@ const useThreadListClient = ({
   );
   const threadItems = useClientLookup(
     Object.keys(runtimeState.threadItems).map((id) =>
-      withKey(id, ThreadListItemClientById({ runtime, id }), [runtime, id]),
+      withKey(
+        id,
+        ThreadListItemClientById({
+          runtime,
+          id,
+          mainThreadIsRunning: main.state.isRunning,
+        }),
+        [runtime, id, main.state.isRunning],
+      ),
     ),
   );
 
@@ -93,6 +104,7 @@ const useThreadListClient = ({
     },
     getLoadThreadsPromise: () => runtime.getLoadThreadsPromise(),
     reload: () => runtime.reload(),
+    reloadMainThread: () => runtime.reloadMainThread(),
     loadMore: () => runtime.loadMore(),
     __internal_getAssistantRuntime: () => __internal_assistantRuntime,
   };

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

@@ -9,6 +9,13 @@ export type ThreadListItemState = {
   readonly lastMessageAt?: Date | undefined;
   readonly status: ThreadListItemStatus;
   readonly custom?: Record<string, unknown> | undefined;
+  /**
+   * Whether this thread has a run in progress, including a run that continues
+   * after the user switches to another thread. A thread list that mounts only
+   * the open thread has no runtime to run the others, so they read as not
+   * running rather than as unknown.
+   */
+  readonly isRunning: boolean;
 };
 
 export type ThreadListItemMethods = {

package/src/store/scopes/threads.ts

@@ -30,6 +30,7 @@ export type ThreadsMethods = {
   thread(selector: "main"): ThreadMethods;
   getLoadThreadsPromise(): Promise<void>;
   reload(): Promise<void>;
+  reloadMainThread(): Promise<void>;
   loadMore(): Promise<void>;
   __internal_getAssistantRuntime?(): AssistantRuntime;
 };

package/src/tests/RemoteThreadListThreadListRuntimeCore-reloadMainThread.test.ts

@@ -0,0 +1,257 @@
+import { describe, it, expect, vi } from "vitest";
+import { createCore, makeAdapter } from "./remote-thread-list-test-helpers";
+import type { RemoteThreadListThreadListRuntimeCore } from "../react/runtimes/RemoteThreadListThreadListRuntimeCore";
+
+type HookManagerStub = {
+  startThreadRuntime: (id: string) => Promise<unknown>;
+  __internal_restartThreadRuntime: (id: string) => Promise<unknown>;
+  getThreadRuntimeCore: (id: string) =>
+    | {
+        unstable_refetchThread?: () => Promise<void>;
+        capabilities?: { cancel: boolean };
+        cancelRun?: () => void;
+      }
+    | undefined;
+};
+
+const hookManagerOf = (core: RemoteThreadListThreadListRuntimeCore) =>
+  (core as unknown as { _hookManager: HookManagerStub })._hookManager;
+
+const openRegularThread = async () => {
+  const core = createCore(
+    makeAdapter({
+      list: async () => ({
+        threads: [
+          {
+            status: "regular" as const,
+            remoteId: "t-1",
+            externalId: "t-1",
+            title: "Open",
+          },
+        ],
+      }),
+    }),
+  );
+  await core.getLoadThreadsPromise();
+  await core.switchToThread("t-1");
+  return core;
+};
+
+describe("RemoteThreadListThreadListRuntimeCore.reloadMainThread", () => {
+  it("restarts the runtime of the thread that is currently open", async () => {
+    const core = await openRegularThread();
+    const threadId = core.mainThreadId;
+
+    const restart = vi.fn(async () => ({}));
+    hookManagerOf(core).__internal_restartThreadRuntime = restart;
+
+    await core.reloadMainThread();
+
+    expect(restart).toHaveBeenCalledExactlyOnceWith(threadId);
+  });
+
+  it("notifies subscribers so the reloaded thread re-renders", async () => {
+    const core = await openRegularThread();
+    hookManagerOf(core).__internal_restartThreadRuntime = async () => ({});
+
+    const callback = vi.fn();
+    core.subscribe(callback);
+    await core.reloadMainThread();
+
+    expect(callback).toHaveBeenCalled();
+  });
+
+  it("leaves an unsent thread alone, since it holds no remote state", async () => {
+    const core = createCore(makeAdapter());
+    await core.switchToNewThread();
+
+    const restart = vi.fn(async () => ({}));
+    hookManagerOf(core).__internal_restartThreadRuntime = restart;
+
+    await expect(core.reloadMainThread()).resolves.toBeUndefined();
+    expect(restart).not.toHaveBeenCalled();
+  });
+
+  it("does nothing before the initial thread is open", async () => {
+    // the constructor switches to a new thread, so this is the window between
+    // construction and that switch settling
+    const core = createCore(makeAdapter());
+    (core as unknown as { _mainThreadId: string | undefined })._mainThreadId =
+      undefined;
+
+    const restart = vi.fn(async () => ({}));
+    hookManagerOf(core).__internal_restartThreadRuntime = restart;
+
+    await expect(core.reloadMainThread()).resolves.toBeUndefined();
+    expect(restart).not.toHaveBeenCalled();
+  });
+
+  it("still notifies when a redundant switch to the same thread lands mid-reload", async () => {
+    const core = await openRegularThread();
+    const threadId = core.mainThreadId;
+
+    let releaseRestart!: () => void;
+    hookManagerOf(core).__internal_restartThreadRuntime = () =>
+      new Promise((resolve) => {
+        releaseRestart = () => resolve({});
+      });
+
+    const reloadTask = core.reloadMainThread();
+    // bumps the switch generation without changing the main thread
+    await core.switchToThread(threadId);
+
+    const callback = vi.fn();
+    core.subscribe(callback);
+    releaseRestart();
+    await reloadTask;
+
+    expect(callback).toHaveBeenCalled();
+  });
+
+  it("resolves quietly when the thread is removed mid-reload", async () => {
+    const core = await openRegularThread();
+
+    hookManagerOf(core).__internal_restartThreadRuntime = async () => {
+      (core as unknown as { _mainThreadId: string })._mainThreadId = "other";
+      throw new Error("Thread was deleted before runtime was started");
+    };
+
+    await expect(core.reloadMainThread()).resolves.toBeUndefined();
+  });
+
+  it("surfaces a restart failure that is not a lifecycle handover", async () => {
+    const core = await openRegularThread();
+
+    hookManagerOf(core).__internal_restartThreadRuntime = async () => {
+      throw new Error("boom");
+    };
+
+    await expect(core.reloadMainThread()).rejects.toThrow("boom");
+  });
+
+  it("lets a switch to a different thread win the notification", async () => {
+    const core = await openRegularThread();
+
+    let releaseRestart!: () => void;
+    hookManagerOf(core).__internal_restartThreadRuntime = () =>
+      new Promise((resolve) => {
+        releaseRestart = () => resolve({});
+      });
+
+    const reloadTask = core.reloadMainThread();
+    (core as unknown as { _mainThreadId: string })._mainThreadId = "elsewhere";
+
+    const callback = vi.fn();
+    core.subscribe(callback);
+    releaseRestart();
+    await reloadTask;
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});
+
+describe("RemoteThreadListThreadListRuntimeCore.reloadMainThread capability dispatch", () => {
+  it("prefers the runtime's in-place reload over remounting", async () => {
+    const core = await openRegularThread();
+    const reload = vi.fn(async () => {});
+    const restart = vi.fn(async () => ({}));
+    hookManagerOf(core).getThreadRuntimeCore = () => ({
+      unstable_refetchThread: reload,
+      capabilities: { cancel: false },
+    });
+    hookManagerOf(core).__internal_restartThreadRuntime = restart;
+
+    await core.reloadMainThread();
+
+    expect(reload).toHaveBeenCalledOnce();
+    expect(restart).not.toHaveBeenCalled();
+  });
+
+  it("leaves a run in progress to the capability implementation", async () => {
+    const core = await openRegularThread();
+    const cancelRun = vi.fn();
+    hookManagerOf(core).getThreadRuntimeCore = () => ({
+      unstable_refetchThread: async () => {},
+      capabilities: { cancel: true },
+      isRunning: true,
+      cancelRun,
+    });
+
+    await core.reloadMainThread();
+
+    // cancelRun returns the trailing user message to the composer, which is
+    // the wrong thing to do to a thread that is only being refetched
+    expect(cancelRun).not.toHaveBeenCalled();
+  });
+
+  it("notifies subscribers after an in-place reload", async () => {
+    const core = await openRegularThread();
+    hookManagerOf(core).getThreadRuntimeCore = () => ({
+      unstable_refetchThread: async () => {},
+      capabilities: { cancel: false },
+    });
+
+    const callback = vi.fn();
+    core.subscribe(callback);
+    await core.reloadMainThread();
+
+    expect(callback).toHaveBeenCalled();
+  });
+
+  it("falls back to remounting when the runtime lacks the capability", async () => {
+    const core = await openRegularThread();
+    const restart = vi.fn(async () => ({}));
+    hookManagerOf(core).getThreadRuntimeCore = () => ({});
+    hookManagerOf(core).__internal_restartThreadRuntime = restart;
+
+    await core.reloadMainThread();
+
+    expect(restart).toHaveBeenCalledExactlyOnceWith(core.mainThreadId);
+  });
+
+  it("falls back to remounting when no runtime is attached yet", async () => {
+    const core = await openRegularThread();
+    const restart = vi.fn(async () => ({}));
+    hookManagerOf(core).getThreadRuntimeCore = () => undefined;
+    hookManagerOf(core).__internal_restartThreadRuntime = restart;
+
+    await core.reloadMainThread();
+
+    expect(restart).toHaveBeenCalledOnce();
+  });
+
+  it("lets a switch to a different thread win the notification after an in-place reload", async () => {
+    const core = await openRegularThread();
+
+    let releaseReload!: () => void;
+    hookManagerOf(core).getThreadRuntimeCore = () => ({
+      unstable_refetchThread: () =>
+        new Promise<void>((resolve) => {
+          releaseReload = resolve;
+        }),
+      capabilities: { cancel: false },
+    });
+
+    const reloadTask = core.reloadMainThread();
+    (core as unknown as { _mainThreadId: string })._mainThreadId = "elsewhere";
+
+    const callback = vi.fn();
+    core.subscribe(callback);
+    releaseReload();
+    await reloadTask;
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+
+  it("propagates an in-place reload failure", async () => {
+    const core = await openRegularThread();
+    hookManagerOf(core).getThreadRuntimeCore = () => ({
+      unstable_refetchThread: async () => {
+        throw new Error("refetch failed");
+      },
+      capabilities: { cancel: false },
+    });
+
+    await expect(core.reloadMainThread()).rejects.toThrow("refetch failed");
+  });
+});