@assistant-ui/core 0.3.17 → 0.3.19

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

@@ -11,6 +11,7 @@ import {
   type MessageStateBinding,
 } from "./message-runtime";
 import { toMessagePartStatus } from "../../utils/normalizePartStatus";
+import { convertExternalMessageChunk } from "../utils/external-message-conversion";
 
 const messagePath = {
   ref: "threads.main.messages[0]",
@@ -256,6 +257,80 @@ describe("toMessagePartStatus", () => {
 });
 
 describe("MessageRuntimeImpl paths", () => {
+  it.each([undefined, ""])(
+    "looks up separate tool calls with ID %s without breaking provider result matching",
+    (toolCallId) => {
+      const id = toolCallId === undefined ? {} : { toolCallId };
+      const converted = convertExternalMessageChunk(
+        {
+          inputs: [{}],
+          outputs: [
+            {
+              role: "assistant",
+              content: [
+                { type: "tool-call", ...id, toolName: "weather", args: {} },
+                { type: "tool-call", ...id, toolName: "search", args: {} },
+                {
+                  type: "tool-call",
+                  toolCallId: "provider-call",
+                  toolName: "calendar",
+                  args: { day: "Monday" },
+                },
+              ],
+            },
+            {
+              role: "assistant",
+              content: [
+                {
+                  type: "tool-call",
+                  toolCallId: "provider-call",
+                  toolName: "calendar",
+                  args: { day: "Tuesday" },
+                },
+              ],
+            },
+            {
+              role: "tool",
+              toolCallId: "provider-call",
+              toolName: "calendar",
+              result: "Meeting at noon",
+            },
+          ],
+        },
+        0,
+        1,
+        false,
+        undefined,
+      );
+      const runtime = new MessageRuntimeImpl(
+        {
+          ...messageBinding,
+          getState: () => ({ ...message, ...converted }),
+        },
+        threadBinding,
+      );
+      const calls = converted.content.filter(
+        (part) => part.type === "tool-call",
+      );
+
+      expect(
+        calls.map((call) =>
+          runtime.getMessagePartByToolCallId(call.toolCallId).getState(),
+        ),
+      ).toMatchObject([
+        { type: "tool-call", toolName: "weather" },
+        { type: "tool-call", toolName: "search" },
+        {
+          type: "tool-call",
+          toolCallId: "provider-call",
+          toolName: "calendar",
+          args: { day: "Tuesday" },
+          result: "Meeting at noon",
+        },
+      ]);
+    },
+  );
+
   it("appends nested selectors to the message path", () => {
     const runtime = new MessageRuntimeImpl(messageBinding, threadBinding);
 

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

@@ -30,12 +30,17 @@ import type { ThreadListItemStatus } from "../interfaces/thread-list-runtime-cor
 
 export type { ThreadListItemState, ThreadListItemStatus };
 
+export type ThreadListItemGenerateTitleOptions = {
+  /** Marks a generation started by the automatic title trigger. */
+  automatic?: boolean;
+};
+
 export type ThreadListItemRuntime = {
   readonly path: ThreadListItemRuntimePath;
   getState(): ThreadListItemState;
 
   initialize(): Promise<{ remoteId: string; externalId: string | undefined }>;
-  generateTitle(): Promise<void>;
+  generateTitle(options?: ThreadListItemGenerateTitleOptions): Promise<void>;
 
   switchTo(options?: { unarchive?: boolean }): Promise<void>;
   rename(newTitle: string): Promise<void>;
@@ -147,9 +152,11 @@ export class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {
     return this._threadListBinding.initialize(state.id);
   }
 
-  public generateTitle(): Promise<void> {
+  public generateTitle(
+    options?: ThreadListItemGenerateTitleOptions,
+  ): Promise<void> {
     const state = this._core.getState();
-    return this._threadListBinding.generateTitle(state.id);
+    return this._threadListBinding.generateTitle(state.id, options);
   }
 
   public unstable_on<E extends ThreadListItemEventType>(

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

@@ -15,6 +15,7 @@ import {
   type ThreadListItemRuntime,
   ThreadListItemRuntimeImpl,
   type ThreadListItemState,
+  type ThreadListItemStateBinding,
 } from "./thread-list-item-runtime";
 import {
   type ThreadListItemRuntimeBinding,
@@ -32,6 +33,8 @@ export type ThreadListState = {
   readonly threadIds: readonly string[];
   readonly archivedThreadIds: readonly string[];
   readonly isLoading: boolean;
+  /** The error thrown by the most recent thread list load that failed, cleared when a later load starts. */
+  readonly loadError: unknown;
   readonly isLoadingMore: boolean;
   readonly hasMore: boolean;
   readonly threadItems: Readonly<
@@ -97,6 +100,7 @@ const getThreadListState = (
     threadIds: threadList.threadIds,
     archivedThreadIds: threadList.archivedThreadIds,
     isLoading: threadList.isLoading,
+    loadError: threadList.loadError,
     isLoadingMore: threadList.isLoadingMore ?? false,
     hasMore: threadList.hasMore ?? false,
     threadItems: threadList.threadItems,
@@ -250,6 +254,21 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
     return this._mainThreadListItemRuntime;
   }
 
+  private _createItemStateBinding(
+    threadId: string,
+  ): ThreadListItemStateBinding {
+    return new ShallowMemoizeSubject({
+      path: {
+        ref: `threadItems[threadId=${threadId}]`,
+        threadSelector: { type: "threadId", threadId },
+      },
+      getState: () => {
+        return getThreadListItemState(this._core, threadId);
+      },
+      subscribe: (callback) => this._core.subscribe(callback),
+    });
+  }
+
   public getById(threadId: string) {
     return new this._runtimeFactory(
       new NestedSubscriptionSubject({
@@ -260,7 +279,7 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
         getState: () => this._core.getThreadRuntimeCore(threadId),
         subscribe: (callback) => this._core.subscribe(callback),
       }),
-      this.mainItem,
+      this._createItemStateBinding(threadId),
     );
   }
 
@@ -301,16 +320,7 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
 
   public getItemById(threadId: string) {
     return new ThreadListItemRuntimeImpl(
-      new ShallowMemoizeSubject({
-        path: {
-          ref: `threadItems[threadId=${threadId}]`,
-          threadSelector: { type: "threadId", threadId },
-        },
-        getState: () => {
-          return getThreadListItemState(this._core, threadId);
-        },
-        subscribe: (callback) => this._core.subscribe(callback),
-      }),
+      this._createItemStateBinding(threadId),
       this._core,
     );
   }

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

@@ -0,0 +1,136 @@
+import { describe, expect, it, vi } from "vitest";
+import { LocalRuntimeCore } from "../../runtimes/local/local-runtime-core";
+import { ExternalStoreRuntimeCore } from "../../runtimes/external-store/external-store-runtime-core";
+import { ReadonlyThreadRuntimeCore } from "../../runtimes/readonly/ReadonlyThreadRuntimeCore";
+import { AssistantRuntimeImpl } from "./assistant-runtime";
+import {
+  ThreadRuntimeImpl,
+  type ThreadListItemRuntimeBinding,
+  type ThreadRuntimeCoreBinding,
+} from "./thread-runtime";
+
+describe("ThreadRuntime.append", () => {
+  it.each([
+    { parent: { parentId: null }, expectedParent: null, visible: ["new"] },
+    {
+      parent: {},
+      expectedParent: "tail",
+      visible: ["root", "tail", "new"],
+    },
+    {
+      parent: { parentId: "root" },
+      expectedParent: "root",
+      visible: ["root", "new"],
+    },
+  ])(
+    "selects the branch under $expectedParent",
+    ({ parent, expectedParent, visible }) => {
+      const core = new LocalRuntimeCore(
+        { adapters: { chatModel: { run: async () => ({ content: [] }) } } },
+        [
+          { id: "root", role: "user", content: "root" },
+          { id: "tail", role: "assistant", content: "tail" },
+        ],
+      );
+      const thread = new AssistantRuntimeImpl(core).thread;
+
+      thread.append({
+        ...parent,
+        content: [{ type: "text", text: "new" }],
+        startRun: false,
+      });
+
+      expect(
+        thread.getState().messages.map((message) => message.content),
+      ).toEqual(visible.map((text) => [{ type: "text", text }]));
+      expect(thread.export().messages.at(-1)?.parentId).toBe(expectedParent);
+    },
+  );
+});
+
+describe("ThreadRuntime.append with an external store", () => {
+  it("routes an explicit root parent to onEdit instead of onNew", async () => {
+    const onNew = vi.fn(async () => {});
+    const onEdit = vi.fn(async () => {});
+    const core = new ExternalStoreRuntimeCore({
+      messages: [
+        {
+          id: "old",
+          role: "user",
+          content: [{ type: "text", text: "old" }],
+          createdAt: new Date(0),
+          attachments: [],
+          metadata: { custom: {} },
+        },
+      ],
+      onNew,
+      onEdit,
+    });
+    const thread = new AssistantRuntimeImpl(core).thread;
+
+    thread.append({
+      parentId: null,
+      content: [{ type: "text", text: "new root" }],
+      startRun: false,
+    });
+
+    await vi.waitFor(() =>
+      expect(onEdit).toHaveBeenCalledExactlyOnceWith(
+        expect.objectContaining({ parentId: null }),
+      ),
+    );
+    expect(onNew).not.toHaveBeenCalled();
+  });
+});
+
+describe("ThreadRuntime state subscriptions", () => {
+  it("tears down every source before reconnecting after an error", () => {
+    const core = new ReadonlyThreadRuntimeCore();
+    const cleanupError = new Error("thread cleanup failed");
+    const threadCleanup = vi.fn(() => {
+      throw cleanupError;
+    });
+    const itemCleanup = vi.fn();
+    let threadSubscriptions = 0;
+    let itemSubscriptions = 0;
+    const path = {
+      ref: "test.thread",
+      threadSelector: { type: "main" as const },
+    };
+    const runtime = new ThreadRuntimeImpl(
+      {
+        path,
+        getState: () => core,
+        subscribe: () => {
+          threadSubscriptions += 1;
+          return threadCleanup;
+        },
+        outerSubscribe: () => () => {},
+      } satisfies ThreadRuntimeCoreBinding,
+      {
+        path,
+        getState: () => ({
+          id: "test",
+          remoteId: undefined,
+          externalId: undefined,
+          isMain: true,
+          isRunning: false,
+          status: "regular",
+          title: undefined,
+        }),
+        subscribe: () => {
+          itemSubscriptions += 1;
+          return itemCleanup;
+        },
+      } satisfies ThreadListItemRuntimeBinding,
+    );
+
+    const unsubscribe = runtime.subscribe(() => {});
+    expect(() => unsubscribe()).toThrow(cleanupError);
+    expect(itemCleanup).toHaveBeenCalledOnce();
+
+    runtime.subscribe(() => {});
+    expect(threadSubscriptions).toBe(2);
+    expect(itemSubscriptions).toBe(2);
+  });
+});

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

@@ -18,6 +18,7 @@ import {
 } from "./message-runtime";
 import { NestedSubscriptionSubject } from "../../subscribable/subscribable";
 import {
+  runCleanups,
   ShallowMemoizeSubject,
   SKIP_UPDATE,
 } from "../../subscribable/subscribable";
@@ -77,6 +78,10 @@ const toStartRunConfig = (message: CreateStartRunConfig): StartRunConfig => {
 export type CreateAppendMessage =
   | string
   | {
+      /**
+       * An omitted value or `undefined` selects the current tail.
+       * `null` selects a root branch.
+       */
       parentId?: string | null | undefined;
       sourceId?: string | null | undefined;
       role?: AppendMessage["role"] | undefined;
@@ -107,7 +112,10 @@ const toAppendMessage = (
 
   return {
     createdAt: message.createdAt ?? new Date(),
-    parentId: message.parentId ?? messages.at(-1)?.id ?? null,
+    parentId:
+      message.parentId === undefined
+        ? (messages.at(-1)?.id ?? null)
+        : message.parentId,
     sourceId: message.sourceId ?? null,
     role: message.role ?? "user",
     content: message.content,
@@ -365,10 +373,7 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
       subscribe: (callback) => {
         const sub1 = threadBinding.subscribe(callback);
         const sub2 = threadListItemBinding.subscribe(callback);
-        return () => {
-          sub1();
-          sub2();
-        };
+        return () => runCleanups([sub1, sub2]);
       },
     });
 

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

@@ -1,4 +1,5 @@
 import {
+  isAttachmentComplete,
   isCreateAttachment,
   type Attachment,
   type CompleteAttachment,
@@ -34,9 +35,6 @@ import {
   drainAttachmentAdd,
 } from "../utils/attachment-add-operations";
 
-const isAttachmentComplete = (a: Attachment): a is CompleteAttachment =>
-  a.status.type === "complete";
-
 export abstract class BaseComposerRuntimeCore
   extends BaseSubscribable
   implements ComposerRuntimeCore
@@ -161,6 +159,7 @@ export abstract class BaseComposerRuntimeCore
   private _emptyTextAndAttachments() {
     this._attachments = [];
     this._text = "";
+    this._rebaseDictation("");
     this._notifySubscribers();
   }
 
@@ -168,7 +167,7 @@ export abstract class BaseComposerRuntimeCore
     const adapter = this.getAttachmentAdapter();
     if (adapter) {
       const pending = this._attachments.filter((a) => !isAttachmentComplete(a));
-      await Promise.all(pending.map((a) => adapter.remove(a)));
+      await Promise.all(pending.map(async (a) => adapter.remove(a)));
     }
   }
 
@@ -204,6 +203,10 @@ export abstract class BaseComposerRuntimeCore
 
   public async clearAttachments() {
     this._cancelAllAttachmentAdds();
+    if (this._isSending) {
+      for (const attachment of this._attachments)
+        this._removedDuringSend.add(attachment.id);
+    }
     const task = this._onClearAttachments();
     this.setAttachments([]);
 
@@ -214,8 +217,13 @@ export abstract class BaseComposerRuntimeCore
     if (!this.canSend || this._isSending) return;
 
     if (this._dictationSession) {
-      this._dictationSession.cancel();
-      this._cleanupDictation();
+      try {
+        this._dictationSession.cancel();
+      } catch (error) {
+        console.error("[assistant-ui] Dictation session cancel threw", error);
+      } finally {
+        this._cleanupDictation();
+      }
     }
 
     const adapter = this.getAttachmentAdapter();
@@ -301,7 +309,10 @@ export abstract class BaseComposerRuntimeCore
       void sendTask.catch((error) => {
         this._restoreUnsentDraft(error, generation, draft);
       });
-    this._notifyEventSubscribers("send", {});
+    this._notifyEventSubscribers("send", {
+      chars: text.length,
+      attachments: finalAttachments.length,
+    });
   }
 
   /**
@@ -417,6 +428,7 @@ export abstract class BaseComposerRuntimeCore
           message,
           undefined,
           err,
+          fileOrAttachment.contentType,
         );
         throw err;
       }
@@ -431,7 +443,9 @@ export abstract class BaseComposerRuntimeCore
       };
       this._attachments = [...this._attachments, a];
       this._notifySubscribers();
-      this._notifyEventSubscribers("attachmentAdd", {});
+      this._notifyEventSubscribers("attachmentAdd", {
+        ...(a.contentType ? { contentType: a.contentType } : undefined),
+      });
       return;
     }
 
@@ -439,7 +453,13 @@ export abstract class BaseComposerRuntimeCore
     if (!adapter) {
       const message = "Attachments are not supported";
       const err = new Error(message);
-      this._safeEmitAttachmentAddError("no-adapter", message, undefined, err);
+      this._safeEmitAttachmentAddError(
+        "no-adapter",
+        message,
+        undefined,
+        err,
+        fileOrAttachment.type,
+      );
       throw err;
     }
 
@@ -451,7 +471,13 @@ export abstract class BaseComposerRuntimeCore
     ) {
       const message = `File type ${fileOrAttachment.type || "unknown"} is not accepted. Accepted types: ${adapter.accept}`;
       const err = new Error(message);
-      this._safeEmitAttachmentAddError("not-accepted", message, undefined, err);
+      this._safeEmitAttachmentAddError(
+        "not-accepted",
+        message,
+        undefined,
+        err,
+        fileOrAttachment.type,
+      );
       throw err;
     }
 
@@ -501,6 +527,7 @@ export abstract class BaseComposerRuntimeCore
         e instanceof Error ? e.message : String(e),
         lastAttachment?.id,
         e instanceof Error ? e : undefined,
+        lastAttachment?.contentType || fileOrAttachment.type,
       );
       throw e;
     } finally {
@@ -517,9 +544,17 @@ export abstract class BaseComposerRuntimeCore
         lastAttachment.status.message ??
           "Attachment upload did not complete successfully.",
         lastAttachment.id,
+        undefined,
+        lastAttachment.contentType || fileOrAttachment.type,
       );
     } else {
-      this._notifyEventSubscribers("attachmentAdd", {});
+      this._notifyEventSubscribers("attachmentAdd", {
+        ...(lastAttachment?.contentType
+          ? { contentType: lastAttachment.contentType }
+          : fileOrAttachment.type
+            ? { contentType: fileOrAttachment.type }
+            : undefined),
+      });
     }
   }
 
@@ -528,6 +563,7 @@ export abstract class BaseComposerRuntimeCore
     message: string,
     attachmentId?: string,
     error?: Error,
+    contentType?: string,
   ) {
     try {
       this._notifyEventSubscribers("attachmentAddError", {
@@ -535,6 +571,7 @@ export abstract class BaseComposerRuntimeCore
         message,
         ...(attachmentId !== undefined && { attachmentId }),
         ...(error !== undefined && { error }),
+        ...(contentType ? { contentType } : undefined),
       });
     } catch (subscriberError) {
       console.error(
@@ -608,14 +645,11 @@ export abstract class BaseComposerRuntimeCore
       throw new Error("Dictation adapter not configured");
     }
 
+    const isReplacing = this._dictationSession !== undefined;
     if (this._dictationSession) {
-      for (const unsub of this._dictationUnsubscribes) {
-        unsub();
-      }
-      this._dictationUnsubscribes = [];
       const oldSession = this._dictationSession;
-      oldSession.stop().catch(() => {});
-      this._dictationSession = undefined;
+      this._cleanupDictation({ notify: false });
+      this._stopDictationSession(oldSession);
     }
 
     const inputDisabled = adapter.disableInputDuringDictation ?? false;
@@ -623,7 +657,22 @@ export abstract class BaseComposerRuntimeCore
     this._dictationBaseText = this._text;
     this._currentInterimText = "";
 
-    const session = adapter.listen();
+    let session: DictationAdapter.Session;
+    try {
+      session = adapter.listen();
+    } catch (error) {
+      if (isReplacing) {
+        try {
+          this._notifySubscribers();
+        } catch (notifyError) {
+          console.error(
+            "[assistant-ui] Dictation replacement rollback notification threw",
+            notifyError,
+          );
+        }
+      }
+      throw error;
+    }
     this._dictationSession = session;
     const sessionId = ++this._dictationSessionIdCounter;
     this._activeDictationSessionId = sessionId;
@@ -701,27 +750,59 @@ export abstract class BaseComposerRuntimeCore
     const session = this._dictationSession;
     const sessionId = this._activeDictationSessionId;
     const cleanup = () => this._cleanupDictation({ sessionId });
-    void session.stop().then(cleanup, cleanup);
+    this._stopDictationSession(session, cleanup);
+  }
+
+  private _stopDictationSession(
+    session: DictationAdapter.Session,
+    onSettled: () => void = () => {},
+  ): void {
+    let task: Promise<void>;
+    try {
+      task = session.stop();
+    } catch (error) {
+      console.error("[assistant-ui] Dictation session stop threw", error);
+      onSettled();
+      return;
+    }
+
+    void task.then(onSettled, (error) => {
+      console.error("[assistant-ui] Dictation session stop rejected", error);
+      onSettled();
+    });
   }
 
-  private _cleanupDictation(options?: { sessionId: number | undefined }): void {
+  private _cleanupDictation(options?: {
+    sessionId?: number | undefined;
+    notify?: boolean | undefined;
+  }): void {
     const isStaleSession =
       options?.sessionId !== undefined &&
       options.sessionId !== this._activeDictationSessionId;
     if (isStaleSession || this._isCleaningDictation) return;
 
     this._isCleaningDictation = true;
-    try {
-      for (const unsub of this._dictationUnsubscribes) {
-        unsub();
+    const runCleanup = (cleanup: () => void) => {
+      try {
+        cleanup();
+      } catch (error) {
+        console.error("[assistant-ui] Dictation cleanup threw", error);
       }
+    };
+
+    try {
+      const unsubscribes = this._dictationUnsubscribes;
       this._dictationUnsubscribes = [];
       this._dictationSession = undefined;
       this._activeDictationSessionId = undefined;
       this._dictation = undefined;
       this._dictationBaseText = "";
       this._currentInterimText = "";
-      this._notifySubscribers();
+
+      for (const unsubscribe of unsubscribes) runCleanup(unsubscribe);
+      if (options?.notify !== false) {
+        runCleanup(() => this._notifySubscribers());
+      }
     } finally {
       this._isCleaningDictation = false;
     }