@assistant-ui/core 0.3.14 → 0.3.16

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

@@ -26,21 +26,17 @@ import type {
 } from "../interfaces/composer-runtime-core";
 import type { DictationAdapter } from "../../adapters/speech";
 import type { QueuePlacement } from "../queue/external-thread-queue-adapter";
-import {
-  EMPTY_QUEUE_ITEMS,
-  type QueueItemState,
-} from "../../store/scopes/queue-item";
+import { EMPTY_QUEUE_ITEMS, type QueueItemState } from "../queue/queue-item";
 import { generateId } from "../../utils/id";
 import { notifyEventListeners } from "../../utils/notify-event-listeners";
+import {
+  AttachmentAddOperations,
+  drainAttachmentAdd,
+} from "../utils/attachment-add-operations";
 
 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
@@ -152,21 +148,14 @@ export abstract class BaseComposerRuntimeCore
   protected _isSending = false;
   private _removedDuringSend = new Set<string>();
   private _sendGeneration = 0;
-  private _attachmentAddOperations = new Set<AttachmentAddOperation>();
+  private _attachmentAddOperations = new AttachmentAddOperations();
 
   private _cancelAttachmentAdd(attachmentId: string) {
-    for (const operation of [...this._attachmentAddOperations]) {
-      if (!operation.attachmentIds.has(attachmentId)) continue;
-      operation.cancelled = true;
-      this._attachmentAddOperations.delete(operation);
-    }
+    this._attachmentAddOperations.cancel(attachmentId);
   }
 
   private _cancelAllAttachmentAdds() {
-    for (const operation of this._attachmentAddOperations) {
-      operation.cancelled = true;
-    }
-    this._attachmentAddOperations.clear();
+    this._attachmentAddOperations.cancelAll();
   }
 
   private _emptyTextAndAttachments() {
@@ -466,16 +455,10 @@ export abstract class BaseComposerRuntimeCore
       throw err;
     }
 
-    const operation: AttachmentAddOperation = {
-      cancelled: false,
-      attachmentIds: new Set(),
-    };
-    const operations = this._attachmentAddOperations;
-    operations.add(operation);
+    const operation = this._attachmentAddOperations.start();
     const upsertAttachment = (a: PendingAttachment) => {
-      if (operation.cancelled) return false;
+      if (!this._attachmentAddOperations.accept(operation, a.id)) return false;
 
-      operation.attachmentIds.add(a.id);
       const idx = this._attachments.findIndex(
         (attachment) => attachment.id === a.id,
       );
@@ -494,18 +477,15 @@ export abstract class BaseComposerRuntimeCore
     };
     let lastAttachment: PendingAttachment | undefined;
     try {
-      const promiseOrGenerator = adapter.add({ file: fileOrAttachment });
-      if (Symbol.asyncIterator in promiseOrGenerator) {
-        for await (const r of promiseOrGenerator) {
-          lastAttachment = r;
-          if (!upsertAttachment(r)) break;
-        }
-      } else {
-        lastAttachment = await promiseOrGenerator;
-        upsertAttachment(lastAttachment);
-      }
+      await drainAttachmentAdd(
+        adapter.add({ file: fileOrAttachment }),
+        (attachment) => {
+          lastAttachment = attachment;
+          return upsertAttachment(attachment);
+        },
+      );
     } catch (e) {
-      if (operation.cancelled) return;
+      if (this._attachmentAddOperations.isCancelled(operation)) return;
       if (lastAttachment) {
         upsertAttachment({
           ...lastAttachment,
@@ -524,10 +504,10 @@ export abstract class BaseComposerRuntimeCore
       );
       throw e;
     } finally {
-      operations.delete(operation);
+      this._attachmentAddOperations.finish(operation);
     }
 
-    if (operation.cancelled) return;
+    if (this._attachmentAddOperations.isCancelled(operation)) return;
     if (
       lastAttachment?.status.type === "incomplete" &&
       lastAttachment.status.reason === "error"

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

@@ -112,6 +112,22 @@ afterEach(() => {
   vi.restoreAllMocks();
 });
 
+describe("BaseThreadRuntimeCore subscriptions", () => {
+  it("notifies later subscribers when an earlier subscriber throws", () => {
+    const runtime = new TestRuntime(createVoiceAdapter());
+    const error = new Error("subscriber failed");
+    const laterSubscriber = vi.fn();
+
+    runtime.subscribe(() => {
+      throw error;
+    });
+    runtime.subscribe(laterSubscriber);
+
+    expect(() => runtime.reset()).toThrow(error);
+    expect(laterSubscriber).toHaveBeenCalledOnce();
+  });
+});
+
 describe("BaseThreadRuntimeCore voice volume subscriptions", () => {
   it("continues notifying subscribers when one throws", () => {
     const consoleError = vi

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

@@ -36,6 +36,7 @@ import type { RealtimeVoiceAdapter } from "../../adapters/voice";
 import type { ThreadMessageLike } from "../utils/thread-message-like";
 import { notifyEventListeners } from "../../utils/notify-event-listeners";
 import { gateInteractableComposerMetadata } from "../../model-context/interactable-composer-metadata";
+import { BaseSubscribable } from "../../subscribable/subscribable";
 
 type BaseThreadAdapters = {
   speech?: SpeechSynthesisAdapter | undefined;
@@ -44,8 +45,10 @@ type BaseThreadAdapters = {
   voice?: RealtimeVoiceAdapter | undefined;
 };
 
-export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
-  private _subscriptions = new Set<() => void>();
+export abstract class BaseThreadRuntimeCore
+  extends BaseSubscribable
+  implements ThreadRuntimeCore
+{
   private _isInitialized = false;
 
   protected readonly repository = new MessageRepository();
@@ -118,6 +121,7 @@ export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
   private readonly _contextProvider: ModelContextProvider;
 
   constructor(_contextProvider: ModelContextProvider) {
+    super();
     this._contextProvider = _contextProvider;
   }
 
@@ -213,10 +217,6 @@ export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
     this._notifySubscribers();
   }
 
-  protected _notifySubscribers() {
-    for (const callback of this._subscriptions) callback();
-  }
-
   public _notifyEventSubscribers<E extends ThreadRuntimeEventType>(
     event: E,
     payload: ThreadRuntimeEventPayload[E],
@@ -227,11 +227,6 @@ export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
     notifyEventListeners(subscribers, payload, `Thread runtime "${event}"`);
   }
 
-  public subscribe(callback: () => void): Unsubscribe {
-    this._subscriptions.add(callback);
-    return () => this._subscriptions.delete(callback);
-  }
-
   public submitFeedback({ messageId, type }: SubmitFeedbackOptions) {
     const adapter = this.adapters?.feedback;
     if (!adapter) throw new Error("Feedback adapter not configured");

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

@@ -8,10 +8,7 @@ import type {
 import type { ThreadRuntimeCore } from "../interfaces/thread-runtime-core";
 import { getThreadRuntimeCoreIsRunning } from "../api/thread-runtime";
 import type { QueuePlacement } from "../queue/external-thread-queue-adapter";
-import {
-  EMPTY_QUEUE_ITEMS,
-  type QueueItemState,
-} from "../../store/scopes/queue-item";
+import { EMPTY_QUEUE_ITEMS, type QueueItemState } from "../queue/queue-item";
 import { BaseComposerRuntimeCore } from "./base-composer-runtime-core";
 
 const isCancelable = (runtime: Omit<ThreadRuntimeCore, "composer">) => {

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

@@ -4,7 +4,7 @@ import type { Attachment, CreateAttachment } from "../../types/attachment";
 import type { Unsubscribe } from "../../types/unsubscribe";
 import type { RunConfig } from "../../types/message";
 import type { DictationAdapter } from "../../adapters/speech";
-import type { QueueItemState } from "../../store/scopes/queue-item";
+import type { QueueItemState } from "../queue/queue-item";
 import type { QueuePlacement } from "../queue/external-thread-queue-adapter";
 
 export type AttachmentAddErrorReason =

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

@@ -16,7 +16,7 @@ import type {
   EditComposerRuntimeCore,
   ThreadComposerRuntimeCore,
 } from "./composer-runtime-core";
-import type { QueueItemState } from "../../store/scopes/queue-item";
+import type { QueueItemState } from "../queue/queue-item";
 import type { QueuePlacement } from "../queue/external-thread-queue-adapter";
 
 export type RuntimeCapabilities = {

package/src/runtime/internal.ts

@@ -56,3 +56,8 @@ export {
   MessageRepository,
 } from "./utils/message-repository";
 export type { ExportedMessageRepositoryItem } from "./utils/message-repository";
+export { createMessageRepositorySession } from "./utils/message-repository-session";
+export type {
+  MessageRepositorySession,
+  MessageRepositorySessionOptions,
+} from "./utils/message-repository-session";

package/src/runtime/queue/external-thread-queue-adapter.ts

@@ -1,5 +1,5 @@
 import type { AppendMessage } from "../../types/message";
-import type { QueueItemState } from "../../store/scopes/queue-item";
+import type { QueueItemState } from "./queue-item";
 
 export type QueuePlacement = {
   readonly lane?: "queue" | "steer";

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

@@ -3,10 +3,7 @@ import type {
   FileMessagePart,
   TextMessagePart,
 } from "../../types/message";
-import {
-  EMPTY_QUEUE_ITEMS,
-  type QueueItemState,
-} from "../../store/scopes/queue-item";
+import { EMPTY_QUEUE_ITEMS, type QueueItemState } from "./queue-item";
 import { generateId } from "../../utils/id";
 import { notifyEventListeners } from "../../utils/notify-event-listeners";
 import { getThreadMessageText } from "../../utils/text";

package/src/runtime/queue/queue-item.ts

@@ -0,0 +1,10 @@
+import type { FileMessagePart, TextMessagePart } from "../../types/message";
+
+export type QueueItemState = {
+  readonly id: string;
+  /** @deprecated Derive from the text parts of `parts` instead. Removal after 2026-11-05. */
+  readonly prompt: string;
+  readonly parts: readonly (FileMessagePart | TextMessagePart)[];
+};
+
+export const EMPTY_QUEUE_ITEMS: readonly QueueItemState[] = Object.freeze([]);

package/src/runtime/utils/abortable-thread-load.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it, vi } from "vitest";
+import { createAbortableThreadLoad } from "./abortable-thread-load";
+
+const callbacks = () => ({
+  onSettled: vi.fn(),
+  onInitialError: vi.fn(),
+});
+
+describe("createAbortableThreadLoad", () => {
+  it("defers a reload to an in-flight initial load", async () => {
+    let resolveInitial!: () => void;
+    const initialLoad = vi.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveInitial = resolve;
+        }),
+    );
+    const reloadLoad = vi.fn(() => Promise.resolve());
+    const controller = createAbortableThreadLoad();
+
+    const initial = controller.run({
+      purpose: "initial",
+      load: initialLoad,
+      ...callbacks(),
+    });
+    const reload = controller.run({
+      purpose: "reload",
+      load: reloadLoad,
+      ...callbacks(),
+    });
+
+    expect(reloadLoad).not.toHaveBeenCalled();
+    resolveInitial();
+    await Promise.all([initial, reload]);
+  });
+
+  it("aborts a superseded load and swallows its failure", async () => {
+    let rejectFirst!: (error: Error) => void;
+    let firstSignal!: AbortSignal;
+    const controller = createAbortableThreadLoad();
+    const first = controller.run({
+      purpose: "reload",
+      load: (signal) => {
+        firstSignal = signal;
+        return new Promise<void>((_, reject) => {
+          rejectFirst = reject;
+        });
+      },
+      ...callbacks(),
+    });
+
+    const second = controller.run({
+      purpose: "initial",
+      load: () => Promise.resolve(),
+      ...callbacks(),
+    });
+    rejectFirst(new Error("aborted"));
+
+    expect(firstSignal.aborted).toBe(true);
+    await expect(first).resolves.toBeUndefined();
+    await second;
+  });
+
+  it("swallows initial failures and surfaces reload failures", async () => {
+    const controller = createAbortableThreadLoad();
+    const initialCallbacks = callbacks();
+    const initialError = new Error("initial");
+
+    await expect(
+      controller.run({
+        purpose: "initial",
+        load: () => Promise.reject(initialError),
+        ...initialCallbacks,
+      }),
+    ).resolves.toBeUndefined();
+    expect(initialCallbacks.onInitialError).toHaveBeenCalledWith(initialError);
+
+    const reloadError = new Error("reload");
+    await expect(
+      controller.run({
+        purpose: "reload",
+        load: () => Promise.reject(reloadError),
+        ...callbacks(),
+      }),
+    ).rejects.toBe(reloadError);
+  });
+});

package/src/runtime/utils/abortable-thread-load.ts

@@ -0,0 +1,53 @@
+export type AbortableThreadLoadPurpose = "initial" | "reload";
+
+type AbortableThreadLoadOptions = {
+  purpose?: AbortableThreadLoadPurpose;
+  load: (signal: AbortSignal) => Promise<void>;
+  onSettled: () => void;
+  onInitialError: (error: unknown) => void;
+};
+
+export const createAbortableThreadLoad = () => {
+  let current: {
+    controller: AbortController;
+    purpose: AbortableThreadLoadPurpose;
+    promise?: Promise<void>;
+  } | null = null;
+
+  return {
+    abort(purpose?: AbortableThreadLoadPurpose) {
+      if (purpose !== undefined && current?.purpose !== purpose) return;
+      current?.controller.abort();
+    },
+    run({
+      purpose = "initial",
+      load,
+      onSettled,
+      onInitialError,
+    }: AbortableThreadLoadOptions): Promise<void> {
+      if (purpose === "reload" && current?.purpose === "initial") {
+        return current.promise ?? Promise.resolve();
+      }
+
+      current?.controller.abort();
+      const controller = new AbortController();
+      const record: NonNullable<typeof current> = { controller, purpose };
+      current = record;
+
+      const task = load(controller.signal)
+        .catch((error: unknown) => {
+          if (controller.signal.aborted) return;
+          throw error;
+        })
+        .finally(() => {
+          if (current?.controller === controller) current = null;
+          if (controller.signal.aborted) return;
+          onSettled();
+        });
+      record.promise = task;
+
+      if (purpose === "reload") return task;
+      return task.catch(onInitialError);
+    },
+  };
+};

package/src/runtime/utils/attachment-add-operations.ts

@@ -0,0 +1,59 @@
+export type AttachmentAddOperation = {
+  cancelled: boolean;
+  attachmentIds: Set<string>;
+};
+
+export class AttachmentAddOperations {
+  private readonly operations = new Set<AttachmentAddOperation>();
+
+  start() {
+    const operation: AttachmentAddOperation = {
+      cancelled: false,
+      attachmentIds: new Set(),
+    };
+    this.operations.add(operation);
+    return operation;
+  }
+
+  accept(operation: AttachmentAddOperation, attachmentId: string) {
+    if (operation.cancelled) return false;
+    operation.attachmentIds.add(attachmentId);
+    return true;
+  }
+
+  finish(operation: AttachmentAddOperation) {
+    this.operations.delete(operation);
+  }
+
+  isCancelled(operation: AttachmentAddOperation) {
+    return operation.cancelled;
+  }
+
+  cancel(attachmentId: string) {
+    for (const operation of [...this.operations]) {
+      if (!operation.attachmentIds.has(attachmentId)) continue;
+      operation.cancelled = true;
+      this.operations.delete(operation);
+    }
+  }
+
+  cancelAll() {
+    for (const operation of this.operations) {
+      operation.cancelled = true;
+    }
+    this.operations.clear();
+  }
+}
+
+export const drainAttachmentAdd = async <T>(
+  result: Promise<T> | AsyncIterable<T>,
+  accept: (attachment: T) => boolean,
+) => {
+  if (Symbol.asyncIterator in result) {
+    for await (const attachment of result) {
+      if (!accept(attachment)) break;
+    }
+  } else {
+    accept(await result);
+  }
+};

package/src/runtime/utils/auto-status.ts

@@ -1,5 +1,26 @@
 import type { MessageStatus } from "../../types/message";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
+import type { ThreadMessageLike } from "./thread-message-like";
+
+type ThreadMessageLikeContentItem = Exclude<
+  ThreadMessageLike["content"],
+  string
+>[number];
+
+export const isPendingToolCall = (c: ThreadMessageLikeContentItem): boolean =>
+  c.type === "tool-call" && c.result === undefined;
+
+export const isInterruptedToolCall = (
+  c: ThreadMessageLikeContentItem,
+): boolean => {
+  if (c.type !== "tool-call" || c.result !== undefined) return false;
+  return (
+    c.interrupt != null ||
+    (c.approval != null &&
+      c.approval.approved === undefined &&
+      c.approval.resolution === undefined)
+  );
+};
 
 const symbolAutoStatus = Symbol("autoStatus");
 
@@ -65,3 +86,15 @@ export const getAutoStatus = (
         ? AUTO_STATUS_PENDING
         : AUTO_STATUS_COMPLETE;
 };
+
+export const getContentAutoStatus = (
+  content: ThreadMessageLike["content"],
+  isLast: boolean,
+  isRunning: boolean,
+): MessageStatus =>
+  getAutoStatus(
+    isLast,
+    isRunning,
+    typeof content !== "string" && content.some(isInterruptedToolCall),
+    typeof content !== "string" && content.some(isPendingToolCall),
+  );

package/src/runtime/utils/external-message-conversion.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  chunkExternalMessages,
+  convertExternalMessageCallback,
+  convertExternalMessageChunk,
+  type ExternalMessageConverterCallback,
+  type ExternalMessageConverterCallbackResult,
+} from "./external-message-conversion";
+
+describe("convertExternalMessageCallback", () => {
+  it.each([
+    ["a missing toolCallId", { role: "tool", result: "ok" }],
+    ["an empty toolCallId", { role: "tool", toolCallId: "", result: "ok" }],
+  ])("warns and drops a tool message with %s", (_label, message) => {
+    const input = { id: "m1" };
+    const callback = (() =>
+      message) as unknown as ExternalMessageConverterCallback<typeof input>;
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    try {
+      const result = convertExternalMessageCallback(input, callback, {});
+      expect(result.outputs).toHaveLength(0);
+      expect(warn).toHaveBeenCalledOnce();
+      expect(warn.mock.calls[0]![0]).toMatch(
+        /dropping a tool result without a toolCallId/,
+      );
+    } finally {
+      warn.mockRestore();
+    }
+  });
+});
+
+describe("chunkExternalMessages", () => {
+  it("keeps a tool result with a non-joining assistant before starting the next chunk", () => {
+    const toolCall = {};
+    const toolResult = {};
+    const answer = {};
+    const callbackResults: ExternalMessageConverterCallbackResult<object>[] = [
+      {
+        input: toolCall,
+        outputs: [
+          {
+            role: "assistant",
+            content: [
+              {
+                type: "tool-call",
+                toolCallId: "call-1",
+                toolName: "search",
+                args: {},
+              },
+            ],
+            convertConfig: { joinStrategy: "none" },
+          },
+        ],
+      },
+      {
+        input: toolResult,
+        outputs: [
+          {
+            role: "tool",
+            toolCallId: "call-1",
+            toolName: "search",
+            result: "result",
+          },
+        ],
+      },
+      {
+        input: answer,
+        outputs: [{ role: "assistant", content: "answer" }],
+      },
+    ];
+
+    const chunks = chunkExternalMessages(callbackResults);
+
+    expect(chunks).toHaveLength(2);
+    expect(chunks[0]?.inputs).toEqual([toolCall, toolResult]);
+    expect(chunks[0]?.outputs).toEqual([
+      callbackResults[0]?.outputs[0],
+      callbackResults[1]?.outputs[0],
+    ]);
+    expect(chunks[1]?.inputs).toEqual([answer]);
+  });
+});
+
+describe("convertExternalMessageChunk", () => {
+  it("reuses a cached message when the error status is unchanged", () => {
+    const input = {};
+    const chunk = {
+      inputs: [input],
+      outputs: [{ role: "assistant" as const, content: "failed" }],
+    };
+    const generatedFallbackMessages = new WeakSet<object>();
+    const first = convertExternalMessageChunk(
+      chunk,
+      0,
+      1,
+      false,
+      { message: "failed" },
+      { message: undefined, generatedFallbackMessages },
+    );
+
+    const second = convertExternalMessageChunk(
+      chunk,
+      0,
+      1,
+      true,
+      { message: "failed" },
+      { message: first, generatedFallbackMessages },
+    );
+
+    expect(second).toBe(first);
+  });
+});