@assistant-ui/core 0.3.13 → 0.3.15

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

@@ -22,7 +22,7 @@ import type {
   ThreadAssistantMessage,
 } from "../../types/message";
 import type { RunConfig } from "../../types/message";
-import { toAssistantError } from "../../types/error";
+import { MessageNotSentError, toAssistantError } from "../../types/error";
 import type { ModelContextProvider } from "../../model-context/types";
 import {
   createMessageQueue,
@@ -33,6 +33,11 @@ import {
   EMPTY_QUEUE_ITEMS,
   type QueueItemState,
 } from "../../store/scopes/queue-item";
+import {
+  captureThreadRuntimeGeneration,
+  invalidateThreadRuntime,
+  isThreadRuntimeGenerationCurrent,
+} from "../../runtime/utils/thread-runtime-lifecycle";
 
 class AbortError extends Error {
   override name = "AbortError";
@@ -162,6 +167,7 @@ export class LocalThreadRuntimeCore
   public __internal_setOptions(options: LocalRuntimeOptionsBase) {
     if (this._options === options) return;
 
+    const previousHistory = this._options?.adapters.history;
     this._options = options;
 
     let hasUpdates = false;
@@ -234,13 +240,31 @@ export class LocalThreadRuntimeCore
     }
 
     if (hasUpdates) this._notifySubscribers();
+
+    if (
+      this._loadRequested &&
+      !this._loadPromise &&
+      !previousHistory &&
+      options.adapters.history &&
+      this.messages.length === 0
+    ) {
+      void this.__internal_load().catch((error: unknown) => {
+        console.error(
+          "[assistant-ui] local thread history load failed:",
+          error,
+        );
+      });
+    }
   }
 
   private _loadPromise: Promise<void> | undefined;
+  private _loadRequested = false;
   public __internal_load() {
+    this._loadRequested = true;
     if (this._loadPromise) return this._loadPromise;
+    if (!this.adapters.history) return Promise.resolve();
 
-    const promise = this.adapters.history?.load() ?? Promise.resolve(null);
+    const promise = this.adapters.history.load();
 
     this._isLoading = true;
     this._notifySubscribers();
@@ -312,38 +336,72 @@ export class LocalThreadRuntimeCore
     this._queue?.adapter.remove(queueItemId);
   }
 
+  private _rollbackAppend(messageId: string) {
+    try {
+      this.repository.deleteMessage(messageId);
+    } catch {
+      return;
+    }
+    this._notifySubscribers();
+  }
+
   private async _runAppend(rawMessage: AppendMessage): Promise<void> {
     // Stamped here rather than in `append` so a queued message is gated after
     // the flush re-pointed its parentId at the current tail.
+    const generation = captureThreadRuntimeGeneration(this);
     const message = this.enrichAppendMetadata(rawMessage);
     this.ensureInitialized();
 
-    const initPromise = this._getInitializePromise?.();
-    if (initPromise) {
-      await initPromise;
-    }
-
     const newMessage = fromThreadMessageLike(message, generateId(), {
       type: "complete",
       reason: "unknown",
     });
     this.repository.addOrUpdateMessage(message.parentId, newMessage);
-    this._options.adapters.history?.append({
+    this._notifySubscribers();
+
+    // Initialization only gates the history write and the run; the message
+    // is already on screen. A failed barrier rolls the optimistic message
+    // back and rejects as an unsent message so the composer restores the
+    // draft; a thread invalidated mid-wait rolls back silently.
+    try {
+      const initPromise = this._getInitializePromise?.();
+      if (initPromise) {
+        await initPromise;
+      }
+    } catch (error) {
+      this._rollbackAppend(newMessage.id);
+      if (!isThreadRuntimeGenerationCurrent(this, generation)) return;
+      const notSent = new MessageNotSentError();
+      notSent.cause = error;
+      throw notSent;
+    }
+    if (!isThreadRuntimeGenerationCurrent(this, generation)) {
+      this._rollbackAppend(newMessage.id);
+      return;
+    }
+    const historyWrite = this._options.adapters.history?.append({
       parentId: message.parentId,
       message: newMessage,
       ...(message.runConfig !== undefined && { runConfig: message.runConfig }),
     });
+    void historyWrite?.catch(() => {});
 
     const startRun = message.startRun ?? message.role === "user";
     if (startRun) {
-      await this.startRun({
-        parentId: newMessage.id,
-        sourceId: message.sourceId,
-        runConfig: message.runConfig ?? {},
-      });
+      const [runResult, historyResult] = await Promise.allSettled([
+        this.startRun({
+          parentId: newMessage.id,
+          sourceId: message.sourceId,
+          runConfig: message.runConfig ?? {},
+        }),
+        historyWrite,
+      ]);
+      if (runResult.status === "rejected") throw runResult.reason;
+      if (historyResult.status === "rejected") throw historyResult.reason;
     } else {
       this.repository.resetHead(newMessage.id);
       this._notifySubscribers();
+      await historyWrite;
     }
   }
 
@@ -380,6 +438,10 @@ export class LocalThreadRuntimeCore
     throw new Error("Runtime does not support importing external states.");
   }
 
+  public unstable_notifySessionReset(): void {
+    throw new Error("Runtime does not support resetting sessions.");
+  }
+
   public async startRun(
     { parentId, runConfig }: StartRunConfig,
     runCallback?: ChatModelAdapter["run"],
@@ -424,6 +486,7 @@ export class LocalThreadRuntimeCore
     this._activeRun = run;
     this._runGeneration++;
 
+    let active = false;
     try {
       // mark busy for runs not started through the queue (regenerate, resume)
       this._queue?.notifyBusy();
@@ -438,16 +501,18 @@ export class LocalThreadRuntimeCore
           message,
           runConfig,
           alreadyPersisted,
+          run,
           runCallback,
         );
         runCallback = undefined;
+        if (this._activeRun !== run) break;
       } while (shouldContinue(message, this._options.unstable_humanToolNames));
     } finally {
       this._notifyEventSubscribers("runEnd", {});
       // the settle belongs to this run only while it is still the active run
       // or was cancelled (the engine expects a cancelled run's settle); a run
       // superseded by a newer one stays silent
-      const active = this._activeRun === run;
+      active = this._activeRun === run;
       if (active) this._activeRun = null;
       if (active || run.cancelled) {
         queueMicrotask(() => this._queue?.notifyIdle());
@@ -455,6 +520,7 @@ export class LocalThreadRuntimeCore
     }
 
     if (
+      active &&
       this.adapters.suggestion &&
       message.status?.type !== "requires-action"
     ) {
@@ -484,6 +550,7 @@ export class LocalThreadRuntimeCore
     message: ThreadAssistantMessage,
     runConfig: RunConfig | undefined,
     alreadyPersisted: boolean,
+    run: { cancelled: boolean },
     runCallback?: ChatModelAdapter["run"],
   ) {
     const messages = parentId ? this.repository.getMessages(parentId) : [];
@@ -498,7 +565,23 @@ export class LocalThreadRuntimeCore
     const initialData = message.metadata?.unstable_data;
     const initialSteps = message.metadata?.steps;
     const initialCustom = message.metadata?.custom;
+    let hasStoredMessage = true;
+    try {
+      this.repository.getMessage(message.id);
+    } catch {
+      hasStoredMessage = false;
+    }
+    // Other writers replace the stored message object, so identity distinguishes this run from a newer owner.
+    const ownsMessage = () => {
+      if (!hasStoredMessage) return this._activeRun === run;
+      try {
+        return this.repository.getMessage(message.id).message === message;
+      } catch {
+        return false;
+      }
+    };
     const updateMessage = (m: Partial<ChatModelRunResult>) => {
+      if (!ownsMessage()) return;
       const newSteps = m.metadata?.steps;
       const steps = newSteps
         ? [...(initialSteps ?? []), ...newSteps]
@@ -545,6 +628,7 @@ export class LocalThreadRuntimeCore
           : undefined),
       };
       this.repository.addOrUpdateMessage(parentId, message);
+      hasStoredMessage = true;
       this._notifySubscribers();
     };
 
@@ -583,6 +667,12 @@ export class LocalThreadRuntimeCore
         this.adapters.chatModel.run.bind(this.adapters.chatModel);
 
       const abortSignal = abortController.signal;
+      const shouldCancelMessage = () =>
+        abortSignal.aborted &&
+        (message.status.type === "running" ||
+          (message.status.type === "requires-action" &&
+            (this._activeRun !== run ||
+              shouldContinue(message, this._options.unstable_humanToolNames))));
       const threadId = this._getThreadId?.();
       const promiseOrGenerator = runCallback({
         messages,
@@ -601,9 +691,11 @@ export class LocalThreadRuntimeCore
       if (Symbol.asyncIterator in promiseOrGenerator) {
         for await (const r of promiseOrGenerator) {
           if (abortSignal.aborted) {
-            updateMessage({
-              status: { type: "incomplete", reason: "cancelled" },
-            });
+            if (shouldCancelMessage()) {
+              updateMessage({
+                status: { type: "incomplete", reason: "cancelled" },
+              });
+            }
             break;
           }
 
@@ -613,11 +705,13 @@ export class LocalThreadRuntimeCore
         updateMessage(await promiseOrGenerator);
       }
 
-      if (message.status.type === "running") {
+      if (shouldCancelMessage()) {
+        updateMessage({
+          status: { type: "incomplete", reason: "cancelled" },
+        });
+      } else if (message.status.type === "running") {
         updateMessage({
-          status: abortSignal.aborted
-            ? { type: "incomplete", reason: "cancelled" }
-            : { type: "complete", reason: "unknown" },
+          status: { type: "complete", reason: "unknown" },
         });
       }
     } catch (e) {
@@ -660,7 +754,7 @@ export class LocalThreadRuntimeCore
 
       // Pauses are written only for adapters that can rewrite the entry later;
       // an append-only adapter would strand a half-finished run in history.
-      if (isTerminal || (isPausing && history?.update)) {
+      if (ownsMessage() && (isTerminal || (isPausing && history?.update))) {
         const write =
           alreadyPersisted && history?.update
             ? history.update.bind(history)
@@ -674,6 +768,7 @@ export class LocalThreadRuntimeCore
   }
 
   public detach() {
+    invalidateThreadRuntime(this);
     // drop the queue so pending items cannot dispatch on a detached thread
     this._queue = null;
     const error = new AbortError(true);

package/src/runtimes/readonly/ReadonlyThreadRuntimeCore.ts

@@ -1,16 +1,18 @@
-import type { Unsubscribe } from "../../types/unsubscribe";
 import type { ThreadMessage } from "../../types/message";
-import type { ThreadRuntimeCore } from "../../runtime/interfaces/thread-runtime-core";
-import { BaseSubscribable } from "../../subscribable/subscribable";
+import {
+  InertThreadRuntimeCore,
+  createInertComposer,
+} from "../inert/InertThreadRuntimeCore";
 
 const READONLY_THREAD_ERROR = new Error(
   "This is a readonly thread. You cannot perform mutations on readonly threads.",
 );
 
-export class ReadonlyThreadRuntimeCore
-  extends BaseSubscribable
-  implements ThreadRuntimeCore
-{
+export class ReadonlyThreadRuntimeCore extends InertThreadRuntimeCore {
+  protected get error() {
+    return READONLY_THREAD_ERROR;
+  }
+
   private _messages: readonly ThreadMessage[] = [];
 
   get messages() {
@@ -39,198 +41,6 @@ export class ReadonlyThreadRuntimeCore
     return [messageId];
   }
 
-  switchToBranch(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
-  append(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
-  deleteMessage(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
-  startRun(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
-  resumeRun(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
-  cancelRun(): void {}
-
-  addToolResult(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
-  resumeToolCall(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
-  respondToToolApproval(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
-  speak(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
-  stopSpeaking(): void {}
-
-  connectVoice(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
-  disconnectVoice(): void {}
-
-  getVoiceVolume = () => 0;
-  subscribeVoiceVolume = (): Unsubscribe => () => {};
-
-  muteVoice(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
-  unmuteVoice(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
-  submitFeedback(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
-  getModelContext() {
-    return {};
-  }
-
-  exportExternalState() {
-    throw READONLY_THREAD_ERROR;
-  }
-
-  importExternalState(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
-  composer = {
-    attachments: [] as never[],
-    attachmentAccept: "*",
-
-    async addAttachment() {
-      throw READONLY_THREAD_ERROR;
-    },
-
-    async removeAttachment() {
-      throw READONLY_THREAD_ERROR;
-    },
-
-    isEditing: false as const,
-    canCancel: false,
-    canSend: false,
-    isEmpty: true,
-    text: "",
-
-    setText() {
-      throw READONLY_THREAD_ERROR;
-    },
-
-    role: "user" as const,
-
-    setRole() {
-      throw READONLY_THREAD_ERROR;
-    },
-
-    runConfig: {},
-
-    setRunConfig() {
-      throw READONLY_THREAD_ERROR;
-    },
-
-    async reset() {
-      // noop
-    },
-
-    async clearAttachments() {
-      // noop
-    },
-
-    send() {
-      throw READONLY_THREAD_ERROR;
-    },
-
-    cancel() {
-      // noop
-    },
-
-    queue: [] as never[],
-    moveQueueItem() {},
-    removeQueueItem() {},
-
-    dictation: undefined,
-
-    startDictation() {
-      throw READONLY_THREAD_ERROR;
-    },
-
-    stopDictation() {
-      // noop
-    },
-
-    quote: undefined,
-
-    setQuote() {
-      throw READONLY_THREAD_ERROR;
-    },
-
-    subscribe() {
-      return () => {};
-    },
-
-    unstable_on() {
-      return () => {};
-    },
-  };
-
-  getEditComposer() {
-    return undefined;
-  }
-
-  beginEdit(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
-  speech = undefined;
-  voice = undefined;
-
-  capabilities = {
-    switchToBranch: false,
-    switchBranchDuringRun: false,
-    edit: false,
-    delete: false,
-    reload: false,
-    refetchThread: false,
-    cancel: false,
-    unstable_copy: false,
-    speech: false,
-    dictation: false,
-    voice: false,
-    attachments: false,
-    feedback: false,
-    queue: false,
-  } as const;
-
-  isDisabled = false;
-  isSendDisabled = false;
-  isLoading = false;
-
-  state = null;
-  suggestions = [] as never[];
-  extras = undefined;
-
-  import(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
   export() {
     return {
       messages: this._messages.map((message, idx) => ({
@@ -240,11 +50,13 @@ export class ReadonlyThreadRuntimeCore
     };
   }
 
-  reset(): void {
-    throw READONLY_THREAD_ERROR;
-  }
+  composer = createInertComposer(READONLY_THREAD_ERROR, false);
 
-  unstable_on(): Unsubscribe {
-    return () => {};
-  }
+  isLoading = false;
+
+  override cancelRun(): void {}
+
+  override stopSpeaking(): void {}
+
+  override disconnectVoice(): void {}
 }

package/src/runtimes/remote-thread-list/adapter-changed.ts

@@ -0,0 +1,10 @@
+import { SILENT_RUNTIME_ACTION } from "../../utils/silent-runtime-action";
+
+export class ThreadListAdapterChangedError extends Error {
+  readonly [SILENT_RUNTIME_ACTION] = true;
+
+  constructor() {
+    super("Thread list adapter changed while an operation was pending.");
+    this.name = "ThreadListAdapterChangedError";
+  }
+}