@assistant-ui/core 0.2.21 → 0.2.22

package/src/react/runtimes/cloud/AssistantCloudThreadHistoryAdapter.test.tsx

@@ -0,0 +1,69 @@
+// @vitest-environment jsdom
+
+import { renderHook } from "@testing-library/react";
+import type { AssistantCloud } from "assistant-cloud";
+import { describe, expect, it, vi } from "vitest";
+import { useAssistantCloudThreadHistoryAdapter } from "./AssistantCloudThreadHistoryAdapter";
+
+const mocks = vi.hoisted(() => {
+  const threadListItem = {
+    getState: () => ({ remoteId: "thread-1" }),
+  };
+
+  return {
+    assistantClient: {
+      threadListItem: () => threadListItem,
+    },
+  };
+});
+
+vi.mock("@assistant-ui/store", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@assistant-ui/store")>()),
+  useAui: () => mocks.assistantClient,
+}));
+
+const makeCloud = () =>
+  ({
+    threads: {
+      messages: {
+        list: vi.fn().mockResolvedValue({ messages: [] }),
+      },
+    },
+  }) as unknown as AssistantCloud;
+
+describe("useAssistantCloudThreadHistoryAdapter", () => {
+  it("refreshes formatted persistence when the Cloud client changes", async () => {
+    const firstCloud = makeCloud();
+    const secondCloud = makeCloud();
+    const cloudRef = { current: firstCloud };
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter(cloudRef),
+    );
+    const formatted = result.current.withFormat<
+      { id: string },
+      Record<string, unknown>
+    >({
+      format: "test",
+      encode: ({ message }) => message,
+      decode: ({ parent_id, content }) => ({
+        parentId: parent_id,
+        message: content as { id: string },
+      }),
+      getId: (message) => message.id,
+    });
+
+    await formatted.load();
+    await formatted.load();
+
+    expect(firstCloud.threads.messages.list).toHaveBeenCalledTimes(2);
+
+    cloudRef.current = secondCloud;
+    await formatted.load();
+
+    expect(firstCloud.threads.messages.list).toHaveBeenCalledTimes(2);
+    expect(secondCloud.threads.messages.list).toHaveBeenCalledOnce();
+    expect(secondCloud.threads.messages.list).toHaveBeenCalledWith("thread-1", {
+      format: "test",
+    });
+  });
+});

package/src/react/runtimes/cloud/AssistantCloudThreadHistoryAdapter.ts

@@ -32,7 +32,7 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
     if (!globalPersistence.has(key)) {
       globalPersistence.set(
         key,
-        new CloudMessagePersistence(this.cloudRef.current),
+        new CloudMessagePersistence(() => this.cloudRef.current),
       );
     }
     return globalPersistence.get(key)!;

package/src/react/runtimes/cloud/CloudFileAttachmentAdapter.test.ts

@@ -57,6 +57,22 @@ describe("CloudFileAttachmentAdapter", () => {
     ]);
   });
 
+  it("uploads when Web Crypto is unavailable", async () => {
+    vi.stubGlobal("crypto", undefined);
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue({ ok: true }));
+    const adapter = new CloudFileAttachmentAdapter(makeCloud());
+
+    const yields = await drain(adapter);
+
+    expect(yields).toHaveLength(2);
+    expect(yields[0]?.id).toBeTruthy();
+    expect(yields[1]?.id).toBe(yields[0]?.id);
+    expect(yields.at(-1)?.status).toEqual({
+      type: "requires-action",
+      reason: "composer-send",
+    });
+  });
+
   it("marks the attachment incomplete when the upload returns an HTTP error", async () => {
     const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
     vi.stubGlobal(

package/src/react/runtimes/cloud/CloudFileAttachmentAdapter.ts

@@ -6,6 +6,7 @@ import type {
 } from "../../../types/attachment";
 import type { ThreadUserMessagePart } from "../../../types/message";
 import type { AttachmentAdapter } from "../../../adapters/attachment";
+import { generateId } from "../../../utils/id";
 
 const guessAttachmentType = (
   contentType: string,
@@ -27,7 +28,7 @@ export class CloudFileAttachmentAdapter implements AttachmentAdapter {
   }: {
     file: File;
   }): AsyncGenerator<PendingAttachment, void> {
-    const id = crypto.randomUUID();
+    const id = generateId();
     const type = guessAttachmentType(file.type);
     let attachment: PendingAttachment = {
       id,

package/src/react/runtimes/external-message-converter.test.tsx

@@ -99,4 +99,25 @@ describe("useExternalMessageConverter", () => {
       text: "HELLO",
     });
   });
+
+  it.each([
+    ["false", false],
+    ["zero", 0],
+    ["an empty string", ""],
+  ])("preserves %s assistant state", (_label, state) => {
+    const callback: useExternalMessageConverter.Callback<TestMessage> = (
+      message,
+    ) => ({
+      role: message.role,
+      id: message.id,
+      content: [{ type: "text", text: message.text }],
+      ...(message.role === "assistant"
+        ? { metadata: { unstable_state: state } }
+        : undefined),
+    });
+
+    const { result } = renderConverter({ callback });
+
+    expect(result.current[1]?.metadata.unstable_state).toBe(state);
+  });
 });

package/src/react/runtimes/external-message-converter.ts

@@ -170,7 +170,7 @@ const joinExternalMessages = (
 
             if (output.metadata) {
               assistantMessage.metadata ??= {};
-              if (output.metadata.unstable_state) {
+              if (output.metadata.unstable_state !== undefined) {
                 assistantMessage.metadata.unstable_state =
                   output.metadata.unstable_state;
               }

package/src/react/runtimes/useLocalRuntime.test.tsx

@@ -0,0 +1,56 @@
+// @vitest-environment jsdom
+
+import { render, waitFor } from "@testing-library/react";
+import { StrictMode } from "react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { ChatModelAdapter } from "../../runtime/utils/chat-model-adapter";
+import { AssistantRuntimeProvider } from "../AssistantRuntimeProvider";
+import { useLocalRuntime } from "./useLocalRuntime";
+
+const chatModel: ChatModelAdapter = {
+  run: async () => ({ content: [] }),
+};
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("useLocalRuntime", () => {
+  it("handles rejected history loads", async () => {
+    const error = new Error("history unavailable");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const history = {
+      load: vi.fn().mockRejectedValue(error),
+      append: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const App = () => {
+      const runtime = useLocalRuntime(chatModel, { adapters: { history } });
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          <div />
+        </AssistantRuntimeProvider>
+      );
+    };
+
+    const renderApp = () => (
+      <StrictMode>
+        <App />
+      </StrictMode>
+    );
+    const { rerender } = render(renderApp());
+
+    await waitFor(() => {
+      expect(consoleError).toHaveBeenCalledWith(
+        "[assistant-ui] local thread history load failed:",
+        error,
+      );
+    });
+
+    rerender(renderApp());
+    expect(history.load).toHaveBeenCalledTimes(1);
+    expect(consoleError).toHaveBeenCalledTimes(1);
+  });
+});

package/src/react/runtimes/useLocalRuntime.ts

@@ -35,6 +35,7 @@ const useLocalThreadRuntime = (
   const [runtime] = useState(() => new LocalRuntimeCore(opt, initialMessages));
 
   const threadIdRef = useRef<string | undefined>(undefined);
+  const historyLoadPromiseRef = useRef<Promise<void> | undefined>(undefined);
   threadIdRef.current = useAuiState((s) => s.threadListItem.remoteId);
 
   useEffect(() => {
@@ -51,9 +52,20 @@ const useLocalThreadRuntime = (
 
   useEffect(() => {
     runtime.threads.getMainThreadRuntimeCore().__internal_setOptions(opt);
-    runtime.threads.getMainThreadRuntimeCore().__internal_load();
   });
 
+  useEffect(() => {
+    const loadPromise = runtime.threads
+      .getMainThreadRuntimeCore()
+      .__internal_load();
+    if (historyLoadPromiseRef.current === loadPromise) return;
+
+    historyLoadPromiseRef.current = loadPromise;
+    void loadPromise.catch((error: unknown) => {
+      console.error("[assistant-ui] local thread history load failed:", error);
+    });
+  }, [runtime]);
+
   useEffect(() => {
     if (!modelContext) return undefined;
     return runtime.registerModelContextProvider(modelContext);

package/src/runtime/api/message-runtime.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it } from "vitest";
+import type { CompleteAttachment } from "../../types/attachment";
+import type { ThreadRuntimeCoreBinding } from "./thread-runtime";
+import {
+  MessageRuntimeImpl,
+  type MessageState,
+  type MessageStateBinding,
+} from "./message-runtime";
+
+const messagePath = {
+  ref: "threads.main.messages[0]",
+  threadSelector: { type: "main" as const },
+  messageSelector: { type: "index" as const, index: 0 },
+};
+
+const attachment: CompleteAttachment = {
+  id: "attachment-1",
+  type: "file",
+  name: "notes.txt",
+  contentType: "text/plain",
+  content: [{ type: "text", text: "notes" }],
+  status: { type: "complete" },
+};
+
+const message: MessageState = {
+  id: "message-1",
+  role: "assistant",
+  createdAt: new Date(0),
+  content: [
+    { type: "text", text: "Hello" },
+    {
+      type: "tool-call",
+      toolCallId: "call-1",
+      toolName: "weather",
+      args: {},
+      argsText: "{}",
+    },
+  ],
+  attachments: [attachment],
+  status: { type: "complete", reason: "stop" },
+  metadata: {
+    unstable_state: null,
+    unstable_annotations: [],
+    unstable_data: [],
+    steps: [],
+    custom: {},
+  },
+  parentId: null,
+  index: 0,
+  isLast: true,
+  branchNumber: 1,
+  branchCount: 1,
+  speech: undefined,
+};
+
+const messageBinding: MessageStateBinding = {
+  path: messagePath,
+  getState: () => message,
+  subscribe: () => () => {},
+};
+
+const threadBinding = {
+  subscribe: () => () => {},
+} as unknown as ThreadRuntimeCoreBinding;
+
+describe("MessageRuntimeImpl paths", () => {
+  it("appends nested selectors to the message path", () => {
+    const runtime = new MessageRuntimeImpl(messageBinding, threadBinding);
+
+    expect(runtime.composer.path.ref).toBe("threads.main.messages[0].composer");
+    expect(runtime.getMessagePartByIndex(0).path.ref).toBe(
+      "threads.main.messages[0].content[0]",
+    );
+    expect(runtime.getMessagePartByToolCallId("call-1").path.ref).toBe(
+      'threads.main.messages[0].content[toolCallId="call-1"]',
+    );
+    expect(runtime.getAttachmentByIndex(0).path.ref).toBe(
+      "threads.main.messages[0].attachments[0]",
+    );
+  });
+});

package/src/runtime/api/message-runtime.ts

@@ -142,7 +142,7 @@ export class MessageRuntimeImpl implements MessageRuntime {
       new NestedSubscriptionSubject({
         path: {
           ...this.path,
-          ref: `${this.path.ref}${this.path.ref}.composer`,
+          ref: `${this.path.ref}.composer`,
           composerSource: "edit",
         },
         getState: this._getEditComposerRuntimeCore,
@@ -269,7 +269,7 @@ export class MessageRuntimeImpl implements MessageRuntime {
       new ShallowMemoizeSubject({
         path: {
           ...this.path,
-          ref: `${this.path.ref}${this.path.ref}.content[${idx}]`,
+          ref: `${this.path.ref}.content[${idx}]`,
           messagePartSelector: { type: "index", index: idx },
         },
         getState: () => {
@@ -287,9 +287,7 @@ export class MessageRuntimeImpl implements MessageRuntime {
       new ShallowMemoizeSubject({
         path: {
           ...this.path,
-          ref:
-            this.path.ref +
-            `${this.path.ref}.content[toolCallId=${JSON.stringify(toolCallId)}]`,
+          ref: `${this.path.ref}.content[toolCallId=${JSON.stringify(toolCallId)}]`,
           messagePartSelector: { type: "toolCallId", toolCallId },
         },
         getState: () => {
@@ -313,7 +311,7 @@ export class MessageRuntimeImpl implements MessageRuntime {
       new ShallowMemoizeSubject({
         path: {
           ...this.path,
-          ref: `${this.path.ref}${this.path.ref}.attachments[${idx}]`,
+          ref: `${this.path.ref}.attachments[${idx}]`,
           attachmentSource: "message",
           attachmentSelector: { type: "index", index: idx },
         },

package/src/runtime/api/thread-list-item-runtime.ts

@@ -2,6 +2,7 @@ import type { Unsubscribe } from "../../types/unsubscribe";
 import type { SubscribableWithState } from "../../subscribable/subscribable";
 import type { ThreadListItemRuntimePath } from "./paths";
 import type { ThreadListRuntimeCoreBinding } from "./thread-list-runtime";
+import { notifyEventListeners } from "../../utils/notify-event-listeners";
 
 export type ThreadListItemEventPayload = {
   /**
@@ -162,7 +163,11 @@ export class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {
 
       if (event === "switchedTo" && !newIsMain) return;
       if (event === "switchedAway" && newIsMain) return;
-      (callback as (payload?: unknown) => void)({});
+      notifyEventListeners(
+        [callback as (payload?: unknown) => void],
+        {},
+        `Thread list item "${event}"`,
+      );
     });
   }
 

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

@@ -1,8 +1,9 @@
-import type {
-  Attachment,
-  CompleteAttachment,
-  CreateAttachment,
-  PendingAttachment,
+import {
+  isCreateAttachment,
+  type Attachment,
+  type CompleteAttachment,
+  type CreateAttachment,
+  type PendingAttachment,
 } from "../../types/attachment";
 import type { MessageRole, AppendMessage } from "../../types/message";
 import type { QuoteInfo } from "../../types/quote";
@@ -28,6 +29,7 @@ import {
   type QueueItemState,
 } from "../../store/scopes/queue-item";
 import { generateId } from "../../utils/id";
+import { notifyEventListeners } from "../../utils/notify-event-listeners";
 
 const isAttachmentComplete = (a: Attachment): a is CompleteAttachment =>
   a.status.type === "complete";
@@ -133,6 +135,10 @@ export abstract class BaseComposerRuntimeCore
     this._notifySubscribers();
   }
 
+  protected _isSending = false;
+  private _removedDuringSend = new Set<string>();
+  private _sendGeneration = 0;
+
   private _emptyTextAndAttachments() {
     this._attachments = [];
     this._text = "";
@@ -148,6 +154,14 @@ export abstract class BaseComposerRuntimeCore
   }
 
   public async reset() {
+    // 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
+    // append the discarded draft nor touch a newer send's lock.
+    this._sendGeneration++;
+    this._isSending = false;
+    this._removedDuringSend.clear();
+
     if (
       this._attachments.length === 0 &&
       this._text === "" &&
@@ -175,7 +189,7 @@ export abstract class BaseComposerRuntimeCore
   }
 
   public async send(options?: SendOptions) {
-    if (!this.canSend) return;
+    if (!this.canSend || this._isSending) return;
 
     if (this._dictationSession) {
       this._dictationSession.cancel();
@@ -183,47 +197,75 @@ export abstract class BaseComposerRuntimeCore
     }
 
     const adapter = this.getAttachmentAdapter();
-    const attachments =
-      this.attachments.length > 0
-        ? Promise.all(
-            this.attachments.map(async (a) => {
-              if (isAttachmentComplete(a)) return a;
-              if (!adapter) throw new Error("Attachments are not supported");
-              const result = await adapter.send(a);
-              return result as CompleteAttachment;
-            }),
-          )
-        : [];
+    const attachmentTasks = this.attachments.map(async (a) => {
+      if (isAttachmentComplete(a)) return a;
+      if (!adapter) throw new Error("Attachments are not supported");
+      const result = await adapter.send(a);
+      return result as CompleteAttachment;
+    });
 
     const originalAttachments = this.attachments;
     const text = this.text;
     const quote = this._quote;
     this._quote = undefined;
-    this._emptyTextAndAttachments();
+    this._text = "";
+    this._isSending = true;
+    const generation = ++this._sendGeneration;
+    this._notifySubscribers();
 
-    let resolvedAttachments: Awaited<typeof attachments>;
+    let resolvedAttachments: CompleteAttachment[];
     try {
-      resolvedAttachments = await attachments;
+      resolvedAttachments = await Promise.all(attachmentTasks);
     } catch (e) {
-      if (this.isEmpty && this._quote === undefined) {
-        this._attachments = originalAttachments;
-        this._text = text;
-        this._quote = quote;
-        this._notifySubscribers();
+      if (generation === this._sendGeneration) {
+        if (!this.text.trim() && this._quote === undefined) {
+          this._text = text;
+          this._quote = quote;
+          this._notifySubscribers();
+        }
+        // Promise.all rejects on the first failure, but sibling uploads from
+        // this batch keep running; the send rejects immediately while the
+        // retry lock is held until they settle, or a retry could re-send
+        // attachments that are still in flight.
+        void Promise.allSettled(attachmentTasks).then(() => {
+          if (generation !== this._sendGeneration) return;
+          this._removedDuringSend.clear();
+          this._isSending = false;
+          this._notifySubscribers();
+        });
       }
       throw e;
     }
 
+    // A reset during the upload discarded this send's draft; the settled
+    // uploads must not append it or touch the lock a newer send may own.
+    if (generation !== this._sendGeneration) return;
+
+    // Drop by id, not wholesale: the user may have added or removed chips while
+    // the upload was in flight.
+    const sentIds = new Set(originalAttachments.map((a) => a.id));
+    this._attachments = this._attachments.filter((a) => !sentIds.has(a.id));
+    this._isSending = false;
+    this._notifySubscribers();
+
+    // An attachment removed mid-upload can't be cancelled, but it can still be
+    // dropped from the outgoing message instead of silently being sent anyway.
+    const finalAttachments = resolvedAttachments.filter(
+      (a) => !this._removedDuringSend.has(a.id),
+    );
+    this._removedDuringSend.clear();
+
     const message: Omit<AppendMessage, "parentId" | "sourceId"> = {
       createdAt: new Date(),
       role: this.role,
       content: text ? [{ type: "text", text }] : [],
-      attachments: resolvedAttachments,
+      attachments: finalAttachments,
       runConfig: this.runConfig,
       metadata: { custom: { ...(quote ? { quote } : {}) } },
     };
 
-    this.handleSend(message, options);
+    const sendTask = this.handleSend(message, options);
+    if (sendTask) void sendTask.catch(() => {});
     this._notifyEventSubscribers("send", {});
   }
 
@@ -241,11 +283,11 @@ export abstract class BaseComposerRuntimeCore
   protected abstract handleSend(
     message: Omit<AppendMessage, "parentId" | "sourceId">,
     options?: SendOptions,
-  ): void;
+  ): void | Promise<void>;
   protected abstract handleCancel(): void;
 
   async addAttachment(fileOrAttachment: File | CreateAttachment) {
-    if (!(fileOrAttachment instanceof File)) {
+    if (isCreateAttachment(fileOrAttachment)) {
       const adapter = this.getAttachmentAdapter();
       if (
         adapter &&
@@ -392,12 +434,16 @@ export abstract class BaseComposerRuntimeCore
     if (index === -1) throw new Error("Attachment not found");
     const attachment = this._attachments[index]!;
 
+    // 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.
+    if (this._isSending) this._removedDuringSend.add(attachmentId);
+
     if (!isAttachmentComplete(attachment)) {
       const adapter = this.getAttachmentAdapter();
       if (!adapter) throw new Error("Attachments are not supported");
       await adapter.remove(attachment);
     }
-
     this._attachments = this._attachments.filter((a) => a.id !== attachmentId);
     this._notifySubscribers();
   }
@@ -563,7 +609,7 @@ export abstract class BaseComposerRuntimeCore
     const subscribers = this._eventSubscribers.get(event);
     if (!subscribers) return;
 
-    for (const callback of subscribers) callback(payload);
+    notifyEventListeners(subscribers, payload, `Composer runtime "${event}"`);
   }
 
   public unstable_on<E extends ComposerRuntimeEventType>(

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

@@ -34,6 +34,7 @@ import type { FeedbackAdapter } from "../../adapters/feedback";
 import type { AttachmentAdapter } from "../../adapters/attachment";
 import type { RealtimeVoiceAdapter } from "../../adapters/voice";
 import type { ThreadMessageLike } from "../utils/thread-message-like";
+import { notifyEventListeners } from "../../utils/notify-event-listeners";
 
 type BaseThreadAdapters = {
   speech?: SpeechSynthesisAdapter | undefined;
@@ -182,7 +183,7 @@ export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
     const subscribers = this._eventSubscribers.get(event);
     if (!subscribers) return;
 
-    for (const callback of subscribers) callback(payload);
+    notifyEventListeners(subscribers, payload, `Thread runtime "${event}"`);
   }
 
   public subscribe(callback: () => void): Unsubscribe {

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

@@ -15,7 +15,7 @@ export class DefaultEditComposerRuntimeCore extends BaseComposerRuntimeCore {
   }
 
   public get canSend() {
-    return !this.isEmpty;
+    return !this.isEmpty && !this._isSending;
   }
 
   protected getAttachmentAdapter() {
@@ -80,6 +80,7 @@ export class DefaultEditComposerRuntimeCore extends BaseComposerRuntimeCore {
     message: Omit<AppendMessage, "parentId" | "sourceId">,
     options?: SendOptions,
   ) {
+    let appendTask: void | Promise<void> = undefined;
     const text = getThreadMessageText(message as AppendMessage);
     const attachmentsChanged = !attachmentsEqual(
       message.attachments ?? [],
@@ -114,7 +115,7 @@ export class DefaultEditComposerRuntimeCore extends BaseComposerRuntimeCore {
         message,
         composerMetadata,
       );
-      this.runtime.append({
+      appendTask = this.runtime.append({
         ...enriched,
         content,
         parentId: this._parentId,
@@ -124,6 +125,7 @@ export class DefaultEditComposerRuntimeCore extends BaseComposerRuntimeCore {
     }
 
     this.handleCancel();
+    return appendTask;
   }
 
   public handleCancel() {

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

@@ -23,7 +23,7 @@ export class DefaultThreadComposerRuntimeCore
   }
 
   public get canSend() {
-    return !this.isEmpty && !this.runtime.isSendDisabled;
+    return !this.isEmpty && !this.runtime.isSendDisabled && !this._isSending;
   }
 
   public override get queue(): readonly QueueItemState[] {
@@ -94,7 +94,7 @@ export class DefaultThreadComposerRuntimeCore
     );
     const enriched = this.enrichWithComposerMetadata(message, composerMetadata);
 
-    this.runtime.append({
+    return this.runtime.append({
       ...(enriched as AppendMessage),
       parentId: this.runtime.messages.at(-1)?.id ?? null,
       sourceId: null,

package/src/runtime/utils/thread-message-like.ts

@@ -266,6 +266,7 @@ export const fromThreadMessageLike = (
         })),
         metadata: {
           custom: metadata?.custom ?? {},
+          ...(metadata?.isOptimistic && { isOptimistic: true }),
         },
       } satisfies ThreadUserMessage;