@assistant-ui/core 0.3.12 → 0.3.14

package/src/tests/base-composer-runtime-core-send.test.ts

@@ -3,6 +3,8 @@ import { DefaultThreadComposerRuntimeCore } from "../runtime/base/default-thread
 import type { AttachmentAdapter } from "../adapters/attachment";
 import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
 import type { PendingAttachment } from "../types/attachment";
+import { MessageNotSentError } from "../types/error";
+import { BaseComposerRuntimeCore } from "../runtime/base/base-composer-runtime-core";
 
 const makeAdapter = (
   overrides: Partial<AttachmentAdapter> = {},
@@ -156,6 +158,36 @@ describe("BaseComposerRuntimeCore.send restore-on-failure", () => {
     expect(append).toHaveBeenCalledTimes(1);
   });
 
+  it("snapshots role and run config before uploading attachments", async () => {
+    let resolveSend!: () => void;
+    const adapter = makeAdapter({
+      send: (a) =>
+        new Promise((resolve) => {
+          resolveSend = () =>
+            resolve({ ...a, status: { type: "complete" }, content: [] });
+        }),
+    });
+    const { composer, append } = makeComposer(adapter);
+
+    composer.setText("hello");
+    composer.setRole("assistant");
+    composer.setRunConfig({ custom: { modelName: "model-a" } });
+    await composer.addAttachment(textFile());
+
+    const sendPromise = composer.send();
+    composer.setRole("system");
+    composer.setRunConfig({ custom: { modelName: "model-b" } });
+    resolveSend();
+    await sendPromise;
+
+    expect(append).toHaveBeenCalledWith(
+      expect.objectContaining({
+        role: "assistant",
+        runConfig: { custom: { modelName: "model-a" } },
+      }),
+    );
+  });
+
   it("keeps an attachment added while the upload was in flight", async () => {
     let resolveSend!: () => void;
     const adapter = makeAdapter({
@@ -571,3 +603,127 @@ describe("BaseComposerRuntimeCore send event listener isolation", () => {
     });
   });
 });
+
+describe("BaseComposerRuntimeCore.send restore-on-undispatched", () => {
+  const rejectableAppend = () => {
+    let reject!: (error: unknown) => void;
+    const append = vi.fn(
+      () =>
+        new Promise<void>((_resolve, rejectAppend) => {
+          reject = rejectAppend;
+        }),
+    );
+    return { append, reject: (error: unknown) => reject(error) };
+  };
+
+  it("restores text, quote, and attachments when the message was never sent", async () => {
+    const { append, reject } = rejectableAppend();
+    const { composer } = makeComposer(makeAdapter(), append);
+
+    composer.setText("hello");
+    await composer.addAttachment(textFile());
+    composer.setQuote({ text: "quoted", messageId: "m-1" });
+
+    await composer.send();
+    expect(composer.text).toBe("");
+    expect(composer.attachments).toHaveLength(0);
+
+    reject(new MessageNotSentError());
+
+    await vi.waitFor(() => expect(composer.text).toBe("hello"));
+    expect(composer.quote).toEqual({ text: "quoted", messageId: "m-1" });
+    expect(composer.attachments).toHaveLength(1);
+    expect(composer.attachments[0]!.status).toEqual({ type: "complete" });
+    expect(append).toHaveBeenCalledTimes(1);
+  });
+
+  it("leaves the composer empty for any other rejection", async () => {
+    const { append, reject } = rejectableAppend();
+    const { composer } = makeComposer(makeAdapter(), append);
+
+    composer.setText("hello");
+    await composer.send();
+    reject(new Error("boom"));
+
+    await vi.waitFor(() => expect(append).toHaveBeenCalledTimes(1));
+    expect(composer.text).toBe("");
+  });
+
+  it("does not clobber a draft written after the send", async () => {
+    const { append, reject } = rejectableAppend();
+    const { composer } = makeComposer(makeAdapter(), append);
+
+    composer.setText("hello");
+    await composer.send();
+    composer.setText("new draft");
+    reject(new MessageNotSentError());
+
+    await vi.waitFor(() => expect(append).toHaveBeenCalledTimes(1));
+    expect(composer.text).toBe("new draft");
+  });
+
+  it("does not restore a draft a reset discarded", async () => {
+    const { append, reject } = rejectableAppend();
+    const { composer } = makeComposer(makeAdapter(), append);
+
+    composer.setText("hello");
+    await composer.send();
+    await composer.reset();
+    reject(new MessageNotSentError());
+
+    await vi.waitFor(() => expect(append).toHaveBeenCalledTimes(1));
+    expect(composer.text).toBe("");
+  });
+});
+
+describe("BaseComposerRuntimeCore.send restore-on-undispatched edge cases", () => {
+  class SyncThrowComposerCore extends BaseComposerRuntimeCore {
+    public readonly error = new MessageNotSentError();
+    public get canCancel() {
+      return false;
+    }
+    public get canSend() {
+      return true;
+    }
+    protected getAttachmentAdapter() {
+      return undefined;
+    }
+    protected getDictationAdapter() {
+      return undefined;
+    }
+    protected handleSend(): void {
+      throw this.error;
+    }
+    protected handleCancel(): void {}
+  }
+
+  it("restores the draft when handleSend throws synchronously", async () => {
+    const composer = new SyncThrowComposerCore();
+    composer.setText("hello");
+
+    await expect(composer.send()).rejects.toThrow(composer.error);
+
+    expect(composer.text).toBe("hello");
+  });
+
+  it("restores only the most recent of several queued drafts", async () => {
+    const rejects: ((error: unknown) => void)[] = [];
+    const append = vi.fn(
+      () =>
+        new Promise<void>((_resolve, reject) => {
+          rejects.push(reject);
+        }),
+    );
+    const { composer } = makeComposer(makeAdapter(), append);
+
+    composer.setText("one");
+    await composer.send();
+    composer.setText("two");
+    await composer.send();
+
+    rejects[0]!(new MessageNotSentError());
+    rejects[1]!(new MessageNotSentError());
+
+    await vi.waitFor(() => expect(composer.text).toBe("two"));
+  });
+});

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

@@ -14,8 +14,14 @@ class TestComposerCore extends BaseComposerRuntimeCore {
   protected getAttachmentAdapter() {
     return this._attachmentAdapter;
   }
+  private _dictationAdapter: DictationAdapter | undefined;
+
   protected getDictationAdapter(): DictationAdapter | undefined {
-    return undefined;
+    return this._dictationAdapter;
+  }
+
+  setDictationAdapter(adapter: DictationAdapter | undefined) {
+    this._dictationAdapter = adapter;
   }
 
   setAttachmentAdapter(adapter: AttachmentAdapter | undefined) {
@@ -180,6 +186,34 @@ describe("BaseComposerRuntimeCore", () => {
     expect(composer.attachmentAccept).toBe("image/*");
   });
 
+  it("handles rejected dictation shutdowns", async () => {
+    const session: DictationAdapter.Session = {
+      status: { type: "running" },
+      stop: vi.fn().mockRejectedValue(new Error("shutdown failed")),
+      cancel: vi.fn(),
+      onSpeechStart: vi.fn(() => () => {}),
+      onSpeechEnd: vi.fn(() => () => {}),
+      onSpeech: vi.fn(() => () => {}),
+    };
+    const unhandledRejection = vi.fn();
+    composer.setDictationAdapter({ listen: () => session });
+    process.on("unhandledRejection", unhandledRejection);
+
+    try {
+      composer.startDictation();
+      expect(composer.dictation).toBeDefined();
+
+      composer.stopDictation();
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      expect(session.stop).toHaveBeenCalledOnce();
+      expect(composer.dictation).toBeUndefined();
+      expect(unhandledRejection).not.toHaveBeenCalled();
+    } finally {
+      process.off("unhandledRejection", unhandledRejection);
+    }
+  });
+
   describe("CreateAttachment (external source)", () => {
     const makeCreateAttachment = (
       overrides?: Partial<CreateAttachment>,
@@ -420,3 +454,104 @@ describe("BaseComposerRuntimeCore", () => {
     });
   });
 });
+
+describe("BaseComposerRuntimeCore.restoreDraft", () => {
+  it("refuses while the composer holds something of its own", () => {
+    const composer = new TestComposerCore();
+    composer.setText("mine");
+
+    expect(composer.restoreDraft({ text: "returned" })).toBe(false);
+    expect(composer.text).toBe("mine");
+  });
+
+  it("rebases a live dictation session onto the restored text", () => {
+    let emitSpeech!: (result: { transcript: string }) => void;
+    const composer = new TestComposerCore();
+    composer.setDictationAdapter({
+      listen: () => ({
+        status: { type: "running" },
+        stop: async () => {},
+        cancel: () => {},
+        onSpeechStart: () => () => {},
+        onSpeechEnd: () => () => {},
+        onSpeech: (callback) => {
+          emitSpeech = callback;
+          return () => {};
+        },
+      }),
+    });
+
+    composer.startDictation();
+    expect(composer.restoreDraft({ text: "returned" })).toBe(true);
+    emitSpeech({ transcript: "and this" });
+
+    expect(composer.text).toBe("returned and this");
+  });
+});
+
+describe("BaseComposerRuntimeCore.retractDraft", () => {
+  const makeCompleteAttachment = (id: string) => ({
+    id,
+    type: "file" as const,
+    name: "spec.pdf",
+    contentType: "application/pdf",
+    status: { type: "complete" as const },
+    content: [],
+  });
+
+  it("clears the composer while it still holds the exact draft", () => {
+    const composer = new TestComposerCore();
+    const draft = {
+      text: "returned",
+      quote: { text: "quoted", messageId: "m-1" },
+      attachments: [makeCompleteAttachment("a1")],
+    };
+
+    expect(composer.restoreDraft(draft)).toBe(true);
+    composer.retractDraft(draft);
+
+    expect(composer.text).toBe("");
+    expect(composer.quote).toBeUndefined();
+    expect(composer.attachments).toEqual([]);
+  });
+
+  it("leaves an edited text alone", () => {
+    const composer = new TestComposerCore();
+    const draft = { text: "returned" };
+
+    expect(composer.restoreDraft(draft)).toBe(true);
+    composer.setText("edited");
+    composer.retractDraft(draft);
+
+    expect(composer.text).toBe("edited");
+  });
+
+  it("leaves a changed quote alone", () => {
+    const composer = new TestComposerCore();
+    const draft = { text: "returned", quote: { text: "quoted" } };
+
+    expect(composer.restoreDraft(draft)).toBe(true);
+    composer.setQuote({ text: "other" });
+    composer.retractDraft(draft);
+
+    expect(composer.text).toBe("returned");
+    expect(composer.quote).toEqual({ text: "other" });
+  });
+
+  it("leaves changed attachments alone", () => {
+    const composer = new TestComposerCore();
+    const draft = {
+      text: "returned",
+      attachments: [makeCompleteAttachment("a1")],
+    };
+
+    expect(composer.restoreDraft(draft)).toBe(true);
+    composer.retractDraft({
+      ...draft,
+      attachments: [makeCompleteAttachment("a1")],
+    });
+
+    expect(composer.text).toBe("returned");
+    expect(composer.attachments).toHaveLength(1);
+  });
+});

package/src/tests/composer-can-cancel.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it, vi } from "vitest";
+import { DefaultThreadComposerRuntimeCore } from "../runtime/base/default-thread-composer-runtime-core";
+import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
+import type { ThreadMessage } from "../types/message";
+
+type ThreadRuntimeStub = Omit<ThreadRuntimeCore, "composer"> & {
+  notify: () => void;
+};
+
+const makeRuntimeStub = (
+  overrides: Partial<ThreadRuntimeCore> = {},
+): ThreadRuntimeStub => {
+  const subscribers = new Set<() => void>();
+  return {
+    append: vi.fn(),
+    cancelRun: vi.fn(),
+    getModelContext: () => ({}),
+    subscribe: (cb: () => void) => {
+      subscribers.add(cb);
+      return () => subscribers.delete(cb);
+    },
+    capabilities: { cancel: true },
+    messages: [],
+    isDisabled: false,
+    isSendDisabled: false,
+    isLoading: false,
+    composer: { runConfig: {} },
+    notify: () => {
+      for (const cb of subscribers) cb();
+    },
+    ...overrides,
+  } as unknown as ThreadRuntimeStub;
+};
+
+const runningAssistant = {
+  id: "a1",
+  role: "assistant",
+  status: { type: "running" },
+} as ThreadMessage;
+
+describe("DefaultThreadComposerRuntimeCore.canCancel", () => {
+  it("is false when the runtime is idle even if cancel is supported", () => {
+    const composer = new DefaultThreadComposerRuntimeCore(makeRuntimeStub());
+    expect(composer.canCancel).toBe(false);
+  });
+
+  it("is false when cancel is not a capability", () => {
+    const composer = new DefaultThreadComposerRuntimeCore(
+      makeRuntimeStub({
+        capabilities: { cancel: false },
+        isRunning: true,
+      }),
+    );
+    expect(composer.canCancel).toBe(false);
+  });
+
+  it("is true while the runtime reports isRunning", () => {
+    const composer = new DefaultThreadComposerRuntimeCore(
+      makeRuntimeStub({ isRunning: true }),
+    );
+    expect(composer.canCancel).toBe(true);
+  });
+
+  it("is true while the trailing assistant message is running", () => {
+    const composer = new DefaultThreadComposerRuntimeCore(
+      makeRuntimeStub({ messages: [runningAssistant] }),
+    );
+    expect(composer.canCancel).toBe(true);
+  });
+
+  it("stays false after a runtime notify while idle", () => {
+    const stub = makeRuntimeStub();
+    const composer = new DefaultThreadComposerRuntimeCore(stub);
+    stub.notify();
+    expect(composer.canCancel).toBe(false);
+  });
+
+  it("notifies subscribers when a run starts", () => {
+    const stub = makeRuntimeStub();
+    const composer = new DefaultThreadComposerRuntimeCore(stub);
+    const onChange = vi.fn();
+    composer.subscribe(onChange);
+
+    (stub as { isRunning?: boolean }).isRunning = true;
+    stub.notify();
+
+    expect(onChange).toHaveBeenCalled();
+    expect(composer.canCancel).toBe(true);
+  });
+
+  it("returns to false when the run ends", () => {
+    const stub = makeRuntimeStub({ isRunning: true });
+    const composer = new DefaultThreadComposerRuntimeCore(stub);
+    expect(composer.canCancel).toBe(true);
+
+    (stub as { isRunning?: boolean }).isRunning = false;
+    stub.notify();
+
+    expect(composer.canCancel).toBe(false);
+  });
+});

package/src/tests/default-edit-composer-runtime-core.test.ts

@@ -229,74 +229,6 @@ describe("DefaultEditComposerRuntimeCore", () => {
     });
   });
 
-  describe("interactables snapshot gating", () => {
-    const live = (state: unknown) => ({
-      interactables: [{ id: "n1", name: "note", state }],
-    });
-    const snapshotMessage = (id: string, state: unknown): ThreadMessage =>
-      makeUserMessage({
-        id,
-        metadata: {
-          custom: { interactables: [{ id: "n1", name: "note", state }] },
-        },
-      } as Partial<ThreadMessage>);
-
-    it("re-stamps the baseline when the edited message carried the only snapshot", async () => {
-      // The new branch's prefix (before the edited message) has no snapshot,
-      // so the live (unchanged) state becomes the branch's baseline.
-      const edited = snapshotMessage("msg-1", { v: 1 });
-      const { runtime, append } = makeRuntime({
-        messages: [edited],
-        composerMetadata: live({ v: 1 }),
-      });
-      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
-        parentId: null,
-        message: edited,
-      });
-      composer.setText("new");
-      await composer.send();
-      const appended = append.mock.calls[0]![0] as AppendMessage;
-      expect(appended.metadata?.custom?.interactables).toEqual([
-        { id: "n1", name: "note", state: { v: 1 } },
-      ]);
-    });
-
-    it("stamps the newest live state when the interactable was edited after the original message", async () => {
-      const edited = snapshotMessage("msg-1", { v: 1 });
-      const { runtime, append } = makeRuntime({
-        messages: [edited],
-        composerMetadata: live({ v: 2 }),
-      });
-      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
-        parentId: null,
-        message: edited,
-      });
-      composer.setText("new");
-      await composer.send();
-      const appended = append.mock.calls[0]![0] as AppendMessage;
-      expect(appended.metadata?.custom?.interactables).toEqual([
-        { id: "n1", name: "note", state: { v: 2 } },
-      ]);
-    });
-
-    it("stamps nothing when the branch prefix already carries the live state", async () => {
-      const parent = snapshotMessage("parent-1", { v: 1 });
-      const edited = makeUserMessage({ id: "msg-1" });
-      const { runtime, append } = makeRuntime({
-        messages: [parent, edited],
-        composerMetadata: live({ v: 1 }),
-      });
-      const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
-        parentId: "parent-1",
-        message: edited,
-      });
-      composer.setText("new");
-      await composer.send();
-      const appended = append.mock.calls[0]![0] as AppendMessage;
-      expect(appended.metadata?.custom?.interactables).toBeUndefined();
-    });
-  });
-
   describe("non-user messages", () => {
     it("does not lift non-text parts for assistant messages", () => {
       const { runtime } = makeRuntime();

package/src/tests/external-store-thread-list-runtime-core.test.ts

@@ -1,7 +1,10 @@
 import { describe, expect, it, vi } from "vitest";
 import { ExternalStoreThreadListRuntimeCore } from "../runtimes/external-store/external-store-thread-list-runtime-core";
 import type { ExternalStoreThreadRuntimeCore } from "../runtimes/external-store/external-store-thread-runtime-core";
+import { ExternalStoreThreadRuntimeCore as ExternalStoreThreadRuntimeCoreImpl } from "../runtimes/external-store/external-store-thread-runtime-core";
 import type { ExternalStoreThreadListAdapter } from "../runtimes/external-store/external-store-adapter";
+import type { ExternalStoreAdapter } from "../runtimes/external-store/external-store-adapter";
+import type { ModelContextProvider } from "../model-context/types";
 import { ThreadListRuntimeImpl } from "../runtime/api/thread-list-runtime";
 
 const makeFactory = (overrides: Record<string, unknown> = {}) =>
@@ -18,6 +21,21 @@ const makeAdapter = (
   overrides: Partial<ExternalStoreThreadListAdapter> = {},
 ): ExternalStoreThreadListAdapter => ({ ...overrides });
 
+const mockContextProvider: ModelContextProvider = {
+  getModelContext: () => ({}),
+};
+
+const appendMessage = () => ({
+  parentId: null,
+  sourceId: null,
+  runConfig: {},
+  role: "user" as const,
+  content: [{ type: "text" as const, text: "hello" }],
+  attachments: [],
+  metadata: { custom: {} },
+  createdAt: new Date(0),
+});
+
 describe("ExternalStoreThreadListRuntimeCore - construction", () => {
   it("assigns a resolvable fallback mainThreadId when adapter has no threadId", () => {
     const core = new ExternalStoreThreadListRuntimeCore(
@@ -149,6 +167,26 @@ describe("ExternalStoreThreadListRuntimeCore - __internal_setAdapter", () => {
     expect(callback).toHaveBeenCalled();
   });
 
+  it("notifies later subscribers when an earlier subscriber throws", () => {
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      makeFactory(),
+    );
+    const error = new Error("subscriber failed");
+    const laterSubscriber = vi.fn();
+
+    core.subscribe(() => {
+      throw error;
+    });
+    core.subscribe(laterSubscriber);
+
+    expect(() =>
+      core.__internal_setAdapter(makeAdapter({ threadId: "thread-beta" })),
+    ).toThrow(error);
+    expect(core.mainThreadId).toBe("thread-beta");
+    expect(laterSubscriber).toHaveBeenCalledOnce();
+  });
+
   it("synthesizes mainThreadId entry after a switch to a threadId not in the threads list", () => {
     const core = new ExternalStoreThreadListRuntimeCore(
       makeAdapter({ threadId: "thread-alpha" }),
@@ -175,6 +213,69 @@ describe("ExternalStoreThreadListRuntimeCore - __internal_setAdapter", () => {
       "thread-gamma",
     ]);
   });
+
+  it("dispatches an append before a thread switch", async () => {
+    let resolveInitialization!: () => void;
+    const initialization = new Promise<void>((resolve) => {
+      resolveInitialization = resolve;
+    });
+    const onNew = vi.fn(async () => {});
+    const firstRuntime = new ExternalStoreThreadRuntimeCoreImpl(
+      mockContextProvider,
+      { messages: [], onNew } as ExternalStoreAdapter,
+    );
+    firstRuntime.__internal_setGetInitializePromise(() => initialization);
+    const secondRuntime = new ExternalStoreThreadRuntimeCoreImpl(
+      mockContextProvider,
+      { messages: [], onNew: vi.fn() } as ExternalStoreAdapter,
+    );
+    const factory = vi
+      .fn()
+      .mockReturnValueOnce(firstRuntime)
+      .mockReturnValueOnce(secondRuntime);
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      factory,
+    );
+
+    const appendPromise = firstRuntime.append(appendMessage());
+    await Promise.resolve();
+
+    expect(onNew).toHaveBeenCalledTimes(1);
+
+    core.__internal_setAdapter(makeAdapter({ threadId: "thread-beta" }));
+    resolveInitialization();
+
+    await appendPromise;
+    expect(onNew).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("ExternalStoreThreadListRuntimeCore - detach", () => {
+  it("leaves the main thread's pending append alone when an item detaches", async () => {
+    let resolveInitialization!: () => void;
+    const initialization = new Promise<void>((resolve) => {
+      resolveInitialization = resolve;
+    });
+    const onNew = vi.fn(async () => {});
+    const runtime = new ExternalStoreThreadRuntimeCoreImpl(
+      mockContextProvider,
+      { messages: [], onNew } as ExternalStoreAdapter,
+    );
+    runtime.__internal_setGetInitializePromise(() => initialization);
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter(),
+      vi.fn(() => runtime),
+    );
+
+    const appendPromise = runtime.append(appendMessage());
+    await Promise.resolve();
+    await core.detach();
+    resolveInitialization();
+
+    await appendPromise;
+    expect(onNew).toHaveBeenCalledTimes(1);
+  });
 });
 
 describe("ExternalStoreThreadListRuntimeCore - isMain via ThreadListRuntimeImpl", () => {