@assistant-ui/core 0.3.13 → 0.3.14

package/src/subscribable/subscribable.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
 import type { SubscribableWithState } from "./subscribable";
-import { ShallowMemoizeSubject } from "./subscribable";
+import { LazyMemoizeSubject, ShallowMemoizeSubject } from "./subscribable";
 
 type TestState = {
   status: string;
@@ -26,6 +26,9 @@ const createBinding = (initialState: TestState) => {
       state = nextState;
       for (const callback of subscribers) callback();
     },
+    replace(nextState: TestState) {
+      state = nextState;
+    },
   };
 };
 
@@ -55,4 +58,77 @@ describe("ShallowMemoizeSubject", () => {
 
     expect(subscriber).not.toHaveBeenCalled();
   });
+
+  it("notifies later subscribers when one throws", () => {
+    const source = createBinding({ status: "empty" });
+    const subject = new ShallowMemoizeSubject(source.binding);
+    const error = new Error("subscriber failed");
+    const laterSubscriber = vi.fn();
+    subject.subscribe(() => {
+      throw error;
+    });
+    subject.subscribe(laterSubscriber);
+
+    expect(() => source.update({ status: "ready" })).toThrow(error);
+    expect(laterSubscriber).toHaveBeenCalledOnce();
+    expect(subject.getState()).toEqual({ status: "ready" });
+  });
+
+  it("reads a value that landed while nobody was subscribed", () => {
+    const source = createBinding({ status: "empty" });
+    const subject = new ShallowMemoizeSubject(source.binding);
+    expect(subject.getState()).toEqual({ status: "empty" });
+
+    source.update({ status: "ready" });
+    const subscriber = vi.fn();
+    subject.subscribe(subscriber);
+
+    expect(subject.getState()).toEqual({ status: "ready" });
+    expect(subscriber).not.toHaveBeenCalled();
+  });
+});
+
+describe("LazyMemoizeSubject", () => {
+  it("notifies later subscribers when one throws", () => {
+    const source = createBinding({ status: "empty" });
+    const subject = new LazyMemoizeSubject(source.binding);
+    const error = new Error("subscriber failed");
+    const laterSubscriber = vi.fn();
+    subject.subscribe(() => {
+      throw error;
+    });
+    subject.subscribe(laterSubscriber);
+
+    expect(() => source.update({ status: "ready" })).toThrow(error);
+    expect(laterSubscriber).toHaveBeenCalledOnce();
+    expect(subject.getState()).toEqual({ status: "ready" });
+  });
+
+  it("reads a value replaced before connecting", () => {
+    const source = createBinding({ status: "empty" });
+    const subject = new LazyMemoizeSubject(source.binding);
+    expect(subject.getState()).toEqual({ status: "empty" });
+
+    source.replace({ status: "ready" });
+    const subscriber = vi.fn();
+    const unsubscribe = subject.subscribe(subscriber);
+
+    expect(subject.getState()).toEqual({ status: "ready" });
+    expect(subscriber).not.toHaveBeenCalled();
+    unsubscribe();
+  });
+
+  it("resynchronizes after reconnecting", () => {
+    const source = createBinding({ status: "empty" });
+    const subject = new LazyMemoizeSubject(source.binding);
+    expect(subject.getState()).toEqual({ status: "empty" });
+
+    const unsubscribe = subject.subscribe(() => {});
+    unsubscribe();
+    source.replace({ status: "ready" });
+    const reconnect = subject.subscribe(() => {});
+
+    expect(subject.getState()).toEqual({ status: "ready" });
+    reconnect();
+  });
 });

package/src/subscribable/subscribable.ts

@@ -32,6 +32,31 @@ export type EventSubscribable<TEvent extends string> = {
   >;
 };
 
+export const notifySubscribers = <TArgs extends unknown[]>(
+  subscribers: Iterable<(...args: TArgs) => void>,
+  ...args: TArgs
+): void => {
+  const errors: unknown[] = [];
+  for (const callback of subscribers) {
+    try {
+      callback(...args);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+
+  if (errors.length === 1) {
+    throw errors[0];
+  }
+
+  if (errors.length > 1) {
+    for (const error of errors) {
+      console.error(error);
+    }
+    throw new AggregateError(errors);
+  }
+};
+
 function shallowEqual<T extends object>(
   objA: T | undefined,
   objB: T | undefined,
@@ -70,25 +95,7 @@ export class BaseSubscribable {
   }
 
   protected _notifySubscribers() {
-    const errors = [];
-    for (const callback of this._subscribers) {
-      try {
-        callback();
-      } catch (error) {
-        errors.push(error);
-      }
-    }
-
-    if (errors.length > 0) {
-      if (errors.length === 1) {
-        throw errors[0];
-      } else {
-        for (const error of errors) {
-          console.error(error);
-        }
-        throw new AggregateError(errors);
-      }
-    }
+    notifySubscribers(this._subscribers);
   }
 }
 
@@ -109,7 +116,7 @@ export abstract class BaseSubject {
       return;
     }
 
-    for (const callback of this._subscriptions) callback(payload);
+    notifySubscribers(this._subscriptions, payload);
   }
 
   private _updateConnection() {
@@ -173,7 +180,9 @@ export class ShallowMemoizeSubject<TState extends object, TPath>
       }
     };
 
-    return this.binding.subscribe(callback);
+    const unsubscribe = this.binding.subscribe(callback);
+    this._syncState();
+    return unsubscribe;
   }
 }
 
@@ -197,7 +206,11 @@ export class LazyMemoizeSubject<TState extends object, TPath>
   public getState = () => {
     if (!this.isConnected || this._previousStateDirty) {
       const newState = this.binding.getState();
-      if (newState !== SKIP_UPDATE) {
+      if (
+        newState !== SKIP_UPDATE &&
+        (this._previousState === undefined ||
+          !shallowEqual(newState, this._previousState))
+      ) {
         this._previousState = newState;
       }
       this._previousStateDirty = false;
@@ -213,7 +226,9 @@ export class LazyMemoizeSubject<TState extends object, TPath>
       this.notifySubscribers();
     };
 
-    return this.binding.subscribe(callback);
+    const unsubscribe = this.binding.subscribe(callback);
+    this._previousStateDirty = true;
+    return unsubscribe;
   }
 }
 

package/src/tests/RemoteThreadListThreadListRuntimeCore-switchToThread-unarchive.test.ts

@@ -63,6 +63,31 @@ describe("RemoteThreadListThreadListRuntimeCore.switchToThread unarchive option"
     expect(core.mainThreadId).toBe(core.getItemById(THREAD_ID)?.id);
   });
 
+  it("restores an initialized draft's archived thread when unarchive fails", async () => {
+    const THREAD_ID = "archived-initialized-draft";
+    const error = new Error("unarchive failed");
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({ threads: [archivedThread(THREAD_ID)] })),
+      unarchive: vi.fn(async () => {
+        throw error;
+      }),
+    });
+
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+    const draftId = core.newThreadId;
+    if (draftId === undefined) throw new Error("Expected seeded draft");
+    await core.initialize(draftId);
+    expect(core.newThreadId).toBeUndefined();
+    await core.switchToThread(THREAD_ID, { unarchive: false });
+
+    await expect(core.unarchive(THREAD_ID)).rejects.toBe(error);
+    expect(core.mainThreadId).not.toBe(THREAD_ID);
+    expect(core.getItemById(THREAD_ID)?.status).toBe("archived");
+    expect(core.archivedThreadIds).toContain(THREAD_ID);
+    expect(core.threadIds).not.toContain(THREAD_ID);
+  });
+
   it("does not call unarchive when the target is already regular, regardless of option", async () => {
     const THREAD_ID = "regular-target";
     const adapter = makeAdapter({

package/src/tests/auiV0Encode.test.ts

@@ -330,6 +330,33 @@ describe("auiV0Encode", () => {
       { type: "data", name: "telemetry", data: { runs: 3 } },
     ]);
   });
+
+  it("preserves data message parts verbatim in the core cloud encoder", () => {
+    const encoded = auiV0Encode({
+      id: "m1",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "assistant",
+      status: { type: "complete", reason: "stop" },
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+      content: [
+        { type: "text", text: "planned" },
+        { type: "data", name: "PredictState", data: { steps: ["a"] } },
+        { type: "data", name: "PredictState", data: '{"steps":["a","b"]}' },
+      ],
+    });
+
+    expect(encoded.content).toEqual([
+      { type: "text", text: "planned" },
+      { type: "data", name: "PredictState", data: { steps: ["a"] } },
+      { type: "data", name: "PredictState", data: '{"steps":["a","b"]}' },
+    ]);
+  });
 });
 
 describe("auiV0Decode", () => {
@@ -573,4 +600,43 @@ describe("auiV0Decode", () => {
     const toolCall = message.content.find((p) => p.type === "tool-call");
     expect(toolCall).toHaveProperty("result", false);
   });
+
+  it("round-trips data message parts, keeping repeated names in order", () => {
+    const content = auiV0Encode({
+      id: "local",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "assistant",
+      status: { type: "complete", reason: "stop" },
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+      content: [
+        { type: "text", text: "planned" },
+        { type: "data", name: "PredictState", data: { steps: ["a"] } },
+        { type: "data", name: "PredictState", data: '{"steps":["a","b"]}' },
+      ],
+    });
+
+    const decoded = auiV0Decode({
+      id: "cloud",
+      parent_id: null,
+      height: 0,
+      created_at: new Date("2026-03-15T00:00:00.000Z"),
+      updated_at: new Date("2026-03-15T00:00:00.000Z"),
+      format: "aui/v0",
+      content: content as never,
+    });
+
+    if (decoded.message.role !== "assistant")
+      throw new Error("expected assistant");
+    expect(decoded.message.content).toEqual([
+      { type: "text", text: "planned" },
+      { type: "data", name: "PredictState", data: { steps: ["a"] } },
+      { type: "data", name: "PredictState", data: '{"steps":["a","b"]}' },
+    ]);
+  });
 });

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

@@ -158,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({

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

@@ -186,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>,

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/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", () => {