@assistant-ui/core 0.3.19 → 0.3.20

package/src/store/primitive-predicates.ts

@@ -20,11 +20,14 @@ export const composerInputDisabled = (s: AssistantState): boolean =>
   s.thread.isDisabled || s.composer.dictation?.inputDisabled === true;
 
 export const actionBarEditDisabled = (s: AssistantState): boolean =>
-  s.composer.isEditing || s.optional.thread?.capabilities.edit === false;
+  s.composer.isEditing ||
+  s.optional.thread?.voice !== undefined ||
+  s.optional.thread?.capabilities.edit === false;
 
 export const actionBarReloadDisabled = (s: AssistantState): boolean =>
   s.thread.isRunning ||
   s.thread.isDisabled ||
+  s.thread.voice !== undefined ||
   s.message.role !== "assistant" ||
   !s.thread.capabilities.reload;
 

package/src/store/runtime-clients/thread-runtime-client.test.tsx

@@ -0,0 +1,110 @@
+// @vitest-environment jsdom
+
+import { act, cleanup, render } from "@testing-library/react";
+import {
+  AuiConfig,
+  AuiProvider,
+  type AssistantClient,
+} from "@assistant-ui/store";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { ThreadListItemState } from "../../runtime/api/bindings";
+import { ThreadRuntimeImpl } from "../../runtime/api/thread-runtime";
+import type { ExternalStoreAdapter } from "../../runtimes/external-store/external-store-adapter";
+import { ExternalStoreThreadRuntimeCore } from "../../runtimes/external-store/external-store-thread-runtime-core";
+import type { ThreadMessage } from "../../types/message";
+import { ThreadClient } from "./thread-runtime-client";
+
+const path = {
+  ref: "threads.main",
+  threadSelector: { type: "main" as const },
+};
+
+const threadListItem: ThreadListItemState = {
+  id: "thread-1",
+  remoteId: undefined,
+  externalId: undefined,
+  isMain: true,
+  isRunning: false,
+  status: "regular",
+};
+
+const userMessage = {
+  id: "u1",
+  role: "user",
+  content: [{ type: "text", text: "Hello" }],
+  createdAt: new Date(0),
+  attachments: [],
+  metadata: { custom: {} },
+} as ThreadMessage;
+
+const renderThreadClient = (core: ExternalStoreThreadRuntimeCore) => {
+  const runtime = new ThreadRuntimeImpl(
+    {
+      path,
+      getState: () => core,
+      subscribe: (callback) => core.subscribe(callback),
+      outerSubscribe: (callback) => core.subscribe(callback),
+    },
+    {
+      path,
+      getState: () => threadListItem,
+      subscribe: () => () => {},
+    },
+  );
+  const captured: { current: AssistantClient | null } = { current: null };
+  const App = () => (
+    <AuiProvider
+      config={AuiConfig({ thread: ThreadClient({ runtime }) })}
+      ref={(client: AssistantClient | null) => {
+        captured.current = client;
+      }}
+    >
+      {null}
+    </AuiProvider>
+  );
+  act(() => {
+    render(<App />);
+  });
+  if (!captured.current) throw new Error("Expected the client to mount.");
+  return { runtime, client: captured.current };
+};
+
+describe("ThreadClient", () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  it("renders a run cancelled before its placeholder reached the client", async () => {
+    const adapter = (
+      overrides: Partial<ExternalStoreAdapter<ThreadMessage>>,
+    ): ExternalStoreAdapter<ThreadMessage> => ({
+      messages: [],
+      onNew: vi.fn(),
+      onCancel: vi.fn(),
+      ...overrides,
+    });
+    const core = new ExternalStoreThreadRuntimeCore(
+      { getModelContext: () => ({}) },
+      adapter({}),
+    );
+    const { runtime, client } = renderThreadClient(core);
+
+    act(() => {
+      core.__internal_setAdapter(
+        adapter({ messages: [userMessage], isRunning: true }),
+      );
+      expect(core.messages).toHaveLength(2);
+      runtime.cancelRun();
+    });
+
+    expect(client.thread.getState().messages.map(({ id }) => id)).toEqual([
+      "u1",
+    ]);
+
+    await act(() => new Promise((resolve) => setTimeout(resolve, 0)));
+
+    expect(client.thread.getState().messages.map(({ id }) => id)).toEqual([
+      "u1",
+    ]);
+  });
+});

package/src/store/scopes/message.ts

@@ -48,7 +48,10 @@ export type MessageMethods = {
   speak(): void;
   /** @deprecated This API is still under active development and might change without notice. */
   stopSpeaking(): void;
-  submitFeedback(feedback: { type: "positive" | "negative" }): void;
+  submitFeedback(feedback: {
+    type: "positive" | "negative";
+    comment?: string;
+  }): void;
   switchToBranch(options: {
     position?: "previous" | "next";
     branchId?: string;

package/src/subscribable/subscribable.test.ts

@@ -277,7 +277,7 @@ describe("nested subscription swaps", () => {
       return () => {};
     });
     const next = { subscribe: nextSubscribe };
-    let current = previous;
+    let current: { subscribe: (callback: () => void) => () => void } = previous;
     const subject = new NestedSubscriptionSubject({
       path: null,
       getState: () => current,
@@ -314,7 +314,12 @@ describe("nested subscription swaps", () => {
       },
     );
     const next = { unstable_on: nextSubscribe };
-    let current = previous;
+    let current: {
+      unstable_on: (
+        event: string,
+        callback: (payload?: unknown) => void,
+      ) => () => void;
+    } = previous;
     const subject = new EventSubscriptionSubject({
       event: "test",
       binding: {

package/src/tests/attachment-adapters.test.ts

@@ -63,7 +63,22 @@ describe("SimpleTextAttachmentAdapter", () => {
     expect(complete.content).toEqual([
       {
         type: "text",
-        text: "<attachment name=notes.md>\n- retry with backoff\n- cap attempts at 3\n</attachment>",
+        text: '<attachment name="notes.md">\n- retry with backoff\n- cap attempts at 3\n</attachment>',
+      },
+    ]);
+  });
+
+  it("quotes and escapes filenames in the attachment wrapper", async () => {
+    const adapter = new SimpleTextAttachmentAdapter();
+    const pending = (await adapter.add({
+      file: makeFile("hello", `my "notes" & <draft>'s.md`),
+    })) as PendingAttachment;
+    const complete = await adapter.send(pending);
+
+    expect(complete.content).toEqual([
+      {
+        type: "text",
+        text: '<attachment name="my &quot;notes&quot; &amp; &lt;draft&gt;\'s.md">\nhello\n</attachment>',
       },
     ]);
   });

package/src/tests/auiV0Encode.test.ts

@@ -820,9 +820,11 @@ describe("auiV0Decode", () => {
     const decoded = auiV0Decode({
       id: "cloud",
       parent_id: null,
+      height: 0,
       format: "aui/v0",
       content: content as never,
       created_at: new Date("2026-03-15T00:00:00.000Z"),
+      updated_at: new Date("2026-03-15T00:00:00.000Z"),
     });
 
     if (decoded.message.role !== "assistant")
@@ -928,9 +930,11 @@ describe("auiV0Decode", () => {
     const decoded = auiV0Decode({
       id: "cloud",
       parent_id: null,
+      height: 0,
       format: "aui/v0",
       content: content as never,
       created_at: new Date("2026-03-15T00:00:00.000Z"),
+      updated_at: new Date("2026-03-15T00:00:00.000Z"),
     });
 
     if (decoded.message.role !== "user") throw new Error("expected user");

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

@@ -451,12 +451,12 @@ describe("BaseComposerRuntimeCore.addAttachment error events", () => {
   it("uses the adapter for foreign files that expose content", async () => {
     const add = vi.fn(makeAdapter().add);
     const composer = makeComposer(makeAdapter({ add }));
-    const foreignFile = {
-      name: "photo.png",
-      type: "image/png",
-      lastModified: 0,
-      content: [{ type: "text", text: "implementation detail" }],
-    } as File;
+    const foreignFile = Object.assign(
+      new File([""], "photo.png", { type: "image/png" }),
+      {
+        content: [{ type: "text", text: "implementation detail" }],
+      },
+    );
 
     await composer.addAttachment(foreignFile);
 

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

@@ -3,7 +3,11 @@ import { BaseComposerRuntimeCore } from "../runtime/base/base-composer-runtime-c
 import type { AttachmentAdapter } from "../adapters/attachment";
 import type { DictationAdapter } from "../adapters/speech";
 import { WebSpeechDictationAdapter } from "../adapters/speech";
-import type { CreateAttachment, PendingAttachment } from "../types/attachment";
+import type {
+  Attachment,
+  CreateAttachment,
+  PendingAttachment,
+} from "../types/attachment";
 import type { AppendMessage } from "../types/message";
 import type { SendOptions } from "../runtime/interfaces/composer-runtime-core";
 
@@ -29,6 +33,10 @@ class TestComposerCore extends BaseComposerRuntimeCore {
     this._attachmentAdapter = adapter;
   }
 
+  setTestAttachments(attachments: readonly Attachment[]) {
+    this.setAttachments(attachments);
+  }
+
   get canCancel() {
     return false;
   }
@@ -194,7 +202,7 @@ describe("BaseComposerRuntimeCore", () => {
             send: vi.fn(),
             remove,
           });
-          composer.setAttachments([
+          composer.setTestAttachments([
             makePendingAttachment("one"),
             {
               id: "complete",
@@ -879,14 +887,17 @@ describe("BaseComposerRuntimeCore.retractDraft", () => {
 
   it("leaves a changed quote alone", () => {
     const composer = new TestComposerCore();
-    const draft = { text: "returned", quote: { text: "quoted" } };
+    const draft = {
+      text: "returned",
+      quote: { text: "quoted", messageId: "m-1" },
+    };
 
     expect(composer.restoreDraft(draft)).toBe(true);
-    composer.setQuote({ text: "other" });
+    composer.setQuote({ text: "other", messageId: "m-2" });
     composer.retractDraft(draft);
 
     expect(composer.text).toBe("returned");
-    expect(composer.quote).toEqual({ text: "other" });
+    expect(composer.quote).toEqual({ text: "other", messageId: "m-2" });
   });
 
   it("leaves changed attachments alone", () => {

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

@@ -1,12 +1,32 @@
 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";
+import type {
+  RuntimeCapabilities,
+  ThreadRuntimeCore,
+} from "../runtime/interfaces/thread-runtime-core";
+import type { ThreadAssistantMessage } from "../types/message";
 
 type ThreadRuntimeStub = Omit<ThreadRuntimeCore, "composer"> & {
   notify: () => void;
 };
 
+const DEFAULT_CAPABILITIES: RuntimeCapabilities = {
+  switchToBranch: false,
+  switchBranchDuringRun: false,
+  edit: false,
+  reload: false,
+  refetchThread: false,
+  delete: false,
+  cancel: true,
+  unstable_copy: false,
+  speech: false,
+  dictation: false,
+  voice: false,
+  attachments: false,
+  feedback: false,
+  queue: false,
+};
+
 const makeRuntimeStub = (
   overrides: Partial<ThreadRuntimeCore> = {},
 ): ThreadRuntimeStub => {
@@ -19,7 +39,7 @@ const makeRuntimeStub = (
       subscribers.add(cb);
       return () => subscribers.delete(cb);
     },
-    capabilities: { cancel: true },
+    capabilities: DEFAULT_CAPABILITIES,
     messages: [],
     isDisabled: false,
     isSendDisabled: false,
@@ -32,11 +52,20 @@ const makeRuntimeStub = (
   } as unknown as ThreadRuntimeStub;
 };
 
-const runningAssistant = {
+const runningAssistant: ThreadAssistantMessage = {
   id: "a1",
   role: "assistant",
   status: { type: "running" },
-} as ThreadMessage;
+  content: [],
+  createdAt: new Date(0),
+  metadata: {
+    unstable_state: null,
+    unstable_annotations: [],
+    unstable_data: [],
+    steps: [],
+    custom: {},
+  },
+};
 
 describe("DefaultThreadComposerRuntimeCore.canCancel", () => {
   it("is false when the runtime is idle even if cancel is supported", () => {
@@ -47,7 +76,7 @@ describe("DefaultThreadComposerRuntimeCore.canCancel", () => {
   it("is false when cancel is not a capability", () => {
     const composer = new DefaultThreadComposerRuntimeCore(
       makeRuntimeStub({
-        capabilities: { cancel: false },
+        capabilities: { ...DEFAULT_CAPABILITIES, cancel: false },
         isRunning: true,
       }),
     );

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

@@ -76,6 +76,28 @@ describe("DefaultThreadComposerRuntimeCore.canSend", () => {
     expect(onChange).toHaveBeenCalled();
     expect(composer.canSend).toBe(false);
   });
+
+  it("is false while a voice session is connected and true after disconnect", () => {
+    const stub = makeRuntimeStub({
+      voice: {
+        status: { type: "running" },
+        isMuted: false,
+        mode: "listening",
+      },
+    });
+    const composer = new DefaultThreadComposerRuntimeCore(stub);
+    composer.setText("hi");
+    const onChange = vi.fn();
+    composer.subscribe(onChange);
+
+    expect(composer.canSend).toBe(false);
+
+    (stub as { voice: undefined }).voice = undefined;
+    stub.notify();
+
+    expect(onChange).toHaveBeenCalled();
+    expect(composer.canSend).toBe(true);
+  });
 });
 
 describe("BaseComposerRuntimeCore.send", () => {

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

@@ -14,6 +14,8 @@ const makeRuntime = (
   const runtime = {
     append,
     composer: { runConfig: {} },
+    voice: undefined,
+    subscribe: () => () => {},
     messages: options?.messages ?? [],
     getModelContext: () => ({
       ...(options?.composerMetadata
@@ -50,6 +52,51 @@ const makeCompleteAttachment = (
 });
 
 describe("DefaultEditComposerRuntimeCore", () => {
+  it("disables send while a voice session is connected and re-notifies on the flip", () => {
+    const listeners = new Set<() => void>();
+    const { runtime } = makeRuntime();
+    const live = runtime as unknown as {
+      voice: unknown;
+      subscribe: (callback: () => void) => () => void;
+    };
+    live.voice = undefined;
+    live.subscribe = (callback) => {
+      listeners.add(callback);
+      return () => {
+        listeners.delete(callback);
+      };
+    };
+    const endEdit = vi.fn();
+    const composer = new DefaultEditComposerRuntimeCore(runtime, endEdit, {
+      parentId: null,
+      message: makeUserMessage(),
+    });
+    const notify = vi.fn();
+    composer.subscribe(notify);
+    expect(composer.canSend).toBe(true);
+
+    live.voice = {
+      status: { type: "running" },
+      isMuted: false,
+      mode: "listening",
+    };
+    for (const listener of listeners) listener();
+    expect(composer.canSend).toBe(false);
+    expect(notify).toHaveBeenCalledTimes(1);
+
+    for (const listener of listeners) listener();
+    expect(notify).toHaveBeenCalledTimes(1);
+
+    live.voice = undefined;
+    for (const listener of listeners) listener();
+    expect(composer.canSend).toBe(true);
+    expect(notify).toHaveBeenCalledTimes(2);
+
+    composer.cancel();
+    expect(endEdit).toHaveBeenCalledOnce();
+    expect(listeners.size).toBe(0);
+  });
+
   describe("construction", () => {
     it("seeds composer text from the edited message", () => {
       const { runtime } = makeRuntime();