@assistant-ui/core 0.3.14 → 0.3.16

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,202 +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;
-  }
-
-  unstable_notifySessionReset(): 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) => ({
@@ -244,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";
+  }
+}

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

@@ -1,238 +1,45 @@
+import type { Unsubscribe } from "../../types/unsubscribe";
 import type { ThreadRuntimeCore } from "../../runtime/interfaces/thread-runtime-core";
+import {
+  InertThreadRuntimeCore,
+  createInertComposer,
+} from "../inert/InertThreadRuntimeCore";
 
 const EMPTY_THREAD_ERROR = new Error(
   "This is the empty thread, a placeholder for the main thread. You cannot perform any actions on this thread instance. This error is probably because you tried to call a thread method in your render function. Call the method inside a `useEffect` hook instead.",
 );
-export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
-  getMessageById() {
-    return undefined;
-  },
-
-  getBranches() {
-    return [];
-  },
-
-  switchToBranch() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  append() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  deleteMessage() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  startRun() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  resumeRun() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  cancelRun() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  addToolResult() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  resumeToolCall() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  respondToToolApproval() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  speak() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  stopSpeaking() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  connectVoice() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  disconnectVoice() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  getVoiceVolume: () => 0,
-  subscribeVoiceVolume: () => () => {},
-
-  muteVoice() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  unmuteVoice() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  submitFeedback() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  getModelContext() {
-    return {};
-  },
-
-  exportExternalState() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  importExternalState() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  unstable_notifySessionReset() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  composer: {
-    attachments: [],
-    attachmentAccept: "*",
-
-    async addAttachment() {
-      throw EMPTY_THREAD_ERROR;
-    },
-
-    async removeAttachment() {
-      throw EMPTY_THREAD_ERROR;
-    },
-
-    isEditing: true,
-
-    canCancel: false,
-    canSend: false,
-    isEmpty: true,
 
-    text: "",
+class EmptyThreadRuntimeCore extends InertThreadRuntimeCore {
+  protected get error() {
+    return EMPTY_THREAD_ERROR;
+  }
 
-    setText() {
-      throw EMPTY_THREAD_ERROR;
-    },
+  messages = [] as never[];
 
-    role: "user",
+  composer = createInertComposer(EMPTY_THREAD_ERROR, true);
 
-    setRole() {
-      throw EMPTY_THREAD_ERROR;
-    },
+  isLoading = true;
 
-    runConfig: {},
-
-    setRunConfig() {
-      throw EMPTY_THREAD_ERROR;
-    },
-
-    async reset() {
-      // noop
-    },
-
-    async clearAttachments() {
-      // noop
-    },
-
-    send() {
-      throw EMPTY_THREAD_ERROR;
-    },
-
-    cancel() {
-      // noop
-    },
-
-    queue: [] as never[],
-    moveQueueItem() {},
-    removeQueueItem() {},
-
-    dictation: undefined,
-
-    startDictation() {
-      throw EMPTY_THREAD_ERROR;
-    },
-
-    stopDictation() {
-      // noop
-    },
-
-    quote: undefined,
-
-    setQuote() {
-      throw EMPTY_THREAD_ERROR;
-    },
-
-    subscribe() {
-      return () => {};
-    },
-
-    unstable_on() {
-      return () => {};
-    },
-  },
-
-  getEditComposer() {
+  getMessageById() {
     return undefined;
-  },
+  }
 
-  beginEdit() {
-    throw EMPTY_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,
-  },
-
-  isDisabled: false,
-  isSendDisabled: false,
-  isLoading: true,
-
-  messages: [],
-
-  state: null,
-
-  suggestions: [],
-
-  extras: undefined,
-
-  subscribe() {
-    return () => {};
-  },
-
-  import() {
-    throw EMPTY_THREAD_ERROR;
-  },
+  getBranches() {
+    return [];
+  }
 
   export() {
     return { messages: [] };
-  },
+  }
 
-  reset() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
-  unstable_on() {
+  override subscribe(): Unsubscribe {
     return () => {};
-  },
-};
+  }
+
+  override waitForUpdate(): Promise<void> {
+    return Promise.reject(EMPTY_THREAD_ERROR);
+  }
+}
+
+export const EMPTY_THREAD_CORE: ThreadRuntimeCore =
+  new EmptyThreadRuntimeCore();

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

@@ -60,4 +60,22 @@ describe("OptimisticState", () => {
 
     expect(state.value.title).toBe("Project Beta");
   });
+
+  it("drops an in-flight transform after reset", async () => {
+    const state = new OptimisticState({ title: "Untitled", extra: 0 });
+    const request = deferred();
+    const update = state.optimisticUpdate({
+      execute: () => request.promise,
+      optimistic: (value) => ({ ...value, title: "Pending" }),
+      then: (value) => ({ ...value, extra: 1 }),
+    });
+
+    expect(state.value.title).toBe("Pending");
+    state.reset({ title: "Fresh", extra: 0 });
+    expect(state.value).toEqual({ title: "Fresh", extra: 0 });
+
+    request.resolve();
+    await update;
+    expect(state.value).toEqual({ title: "Fresh", extra: 0 });
+  });
 });

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

@@ -48,6 +48,7 @@ export class OptimisticState<TState> extends BaseSubscribable {
     [];
 
   private _nextTransformOrder = 0;
+  private _epoch = 0;
 
   private _baseValue: TState;
   private _cachedValue: TState;
@@ -95,9 +96,20 @@ export class OptimisticState<TState> extends BaseSubscribable {
     this._updateState();
   }
 
+  public reset(state: TState): void {
+    // In-flight optimisticUpdate calls must not write into the replacement state.
+    this._epoch++;
+    this._pendingTransforms.length = 0;
+    this._completedOptimistics.length = 0;
+    this._baseValue = state;
+    this._cachedValue = state;
+    this._notifySubscribers();
+  }
+
   public async optimisticUpdate<TResult>(
     transform: Transform<TState, TResult>,
   ): Promise<TResult> {
+    const epoch = this._epoch;
     const order = this._nextTransformOrder++;
     const task = transform.execute();
     const pendingTransform = {
@@ -110,6 +122,7 @@ export class OptimisticState<TState> extends BaseSubscribable {
       this._updateState();
 
       const result = await task;
+      if (epoch !== this._epoch) return result;
       this._baseValue = pipeTransforms(this._baseValue, result, [
         transform.optimistic,
         transform.then,

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

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import {
+  createEmptyRemoteThreadState,
+  createThreadMappingId,
+  seedNewThread,
+} from "./remote-thread-state";
+
+describe("remote thread state", () => {
+  it("creates an empty state", () => {
+    expect(createEmptyRemoteThreadState()).toEqual({
+      isLoading: true,
+      isLoadingMore: false,
+      cursor: undefined,
+      newThreadId: undefined,
+      threadIds: [],
+      archivedThreadIds: [],
+      threadIdMap: {},
+      threadData: {},
+    });
+  });
+
+  it("seeds unique local threads with matching mapping ids", () => {
+    const first = seedNewThread(createEmptyRemoteThreadState());
+    const second = seedNewThread(first.state);
+
+    expect(second.id).not.toBe(first.id);
+    expect(first.state.newThreadId).toBe(first.id);
+    expect(second.state.newThreadId).toBe(second.id);
+    expect(first.state.threadIdMap[first.id]).toBe(
+      createThreadMappingId(first.id),
+    );
+    expect(second.state.threadIdMap[second.id]).toBe(
+      createThreadMappingId(second.id),
+    );
+    expect(Object.keys(second.state.threadData)).toEqual([first.id, second.id]);
+  });
+});