@assistant-ui/react 0.15.8 → 0.15.9

package/src/legacy-runtime/cloud/auiV0.ts

@@ -32,6 +32,7 @@ type AuiV0MessagePart =
   | {
       readonly type: "reasoning";
       readonly text: string;
+      readonly unstable_summary?: string;
     }
   | {
       readonly type: "source";
@@ -226,7 +227,13 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
           return { type: "text", text: part.text };
 
         case "reasoning":
-          return { type: "reasoning", text: part.text };
+          return {
+            type: "reasoning",
+            text: part.text,
+            ...(part.unstable_summary !== undefined
+              ? { unstable_summary: part.unstable_summary }
+              : undefined),
+          };
 
         case "source":
           if (part.sourceType === "url") {

package/src/legacy-runtime/runtime-cores/assistant-transport/useAssistantTransport.spec.md

@@ -23,6 +23,7 @@ Resume State
 - The resume request carries `runId` and no `state`: the server replays from the snapshot it retained for that run, so neither `body` overrides nor a `prepareSendCommandsRequest` rebuild can substitute a different base. `runId` takes precedence over `body` fields and is re-attached after `prepareSendCommandsRequest` so a rebuilt body cannot drop it. The local base is replaced by the snapshot only after the resume stream responds OK, so a rejected resume keeps the local state.
 - A 204 response means no active run: the resume is skipped without error, and queued commands are flushed in a follow-up run.
 - A malformed snapshot response fails the resume before the replay request is sent.
+- If a pending resume is dropped by an error or cancellation, later commands start normal runs.
 - Runs execute on a `queueMicrotask`, so multiple synchronous enqueues coalesce into a single request: the first run's flush takes all of them, and the coalesced follow-up run no-ops.
 
 Command Queue

package/src/legacy-runtime/runtime-cores/assistant-transport/useAssistantTransportRuntime.test.tsx

@@ -75,6 +75,35 @@ const installFetch = () => {
   return { requests, servers };
 };
 
+const installPendingFetch = () => {
+  const requests: RecordedRequest[] = [];
+  const pending: {
+    resolve: (response: Response) => void;
+    reject: (reason: unknown) => void;
+  }[] = [];
+
+  vi.stubGlobal("fetch", (url: RequestInfo | URL, init: RequestInit = {}) => {
+    requests.push({
+      url: String(url),
+      init,
+      body: JSON.parse(init.body as string),
+    });
+
+    return new Promise<Response>((resolve, reject) => {
+      pending.push({ resolve, reject });
+      init.signal?.addEventListener(
+        "abort",
+        () => reject(init.signal?.reason),
+        {
+          once: true,
+        },
+      );
+    });
+  });
+
+  return { requests, pending };
+};
+
 const mountRuntime = (
   options?: Partial<AssistantTransportOptions<unknown>>,
 ) => {
@@ -216,6 +245,56 @@ describe("useAssistantTransportRuntime", () => {
     await waitFor(() => expect(aui().thread.getState().isRunning).toBe(false));
   });
 
+  it.each(["error", "cancellation"] as const)(
+    "does not apply a dropped resume after run %s",
+    async (settlement) => {
+      const fetchMock = installPendingFetch();
+      const onError = vi.fn();
+      const { aui, sendCommand } = mountRuntime({
+        resumeApi: "https://example.com/resume",
+        onError,
+      });
+      await waitFor(() =>
+        expect(
+          (aui().thread.getState().extras as { sendCommand?: unknown })
+            ?.sendCommand,
+        ).toBeTypeOf("function"),
+      );
+
+      act(() => sendCommand(createMessageCommand("a")));
+      await waitFor(() => expect(fetchMock.requests).toHaveLength(1));
+
+      await act(async () => {
+        await aui().thread.resumeRun({ parentId: null });
+      });
+      if (settlement === "cancellation") {
+        act(() => aui().thread.cancelRun());
+      } else {
+        await act(async () => {
+          fetchMock.pending[0]!.reject(new Error("request failed"));
+        });
+      }
+      await waitFor(() =>
+        expect(aui().thread.getState().isRunning).toBe(false),
+      );
+
+      act(() => sendCommand(createMessageCommand("b")));
+      await waitFor(() => expect(fetchMock.requests).toHaveLength(2));
+      expect(fetchMock.requests[1]!.url).toBe("https://example.com/api");
+      expect(fetchMock.requests[1]!.body["commands"]).toEqual([
+        createMessageCommand("b"),
+      ]);
+
+      await act(async () => {
+        fetchMock.pending[1]!.resolve(new Response("", { status: 200 }));
+      });
+      await waitFor(() =>
+        expect(aui().thread.getState().isRunning).toBe(false),
+      );
+      expect(onError).toHaveBeenCalledTimes(settlement === "error" ? 1 : 0);
+    },
+  );
+
   it("applies resumed operations to the retained initial state", async () => {
     const requests: RecordedRequest[] = [];
     vi.stubGlobal(

package/src/legacy-runtime/runtime-cores/assistant-transport/useAssistantTransportRuntime.ts

@@ -348,6 +348,7 @@ const useAssistantTransportThreadRuntime = <T>(
       });
     },
     onError: async (error) => {
+      resumeFlagRef.current = false;
       setIsReplaying(false);
       const inTransitCmds = [...commandQueue.state.inTransit];
       const queuedCmds = [...commandQueue.state.queued];
@@ -422,6 +423,7 @@ const useAssistantTransportThreadRuntime = <T>(
       },
     }),
     onCancel: async () => {
+      resumeFlagRef.current = false;
       runManager.cancel();
     },
     onResume: async () => {

package/src/tests/external-thread-feedback.test.tsx

@@ -0,0 +1,204 @@
+// @vitest-environment jsdom
+
+import { act, render, waitFor } from "@testing-library/react";
+import type { FC } from "react";
+import { describe, expect, it, vi } from "vitest";
+import { AuiProvider, useAui } from "@assistant-ui/store";
+import type { FeedbackAdapter } from "@assistant-ui/core";
+import type {
+  ExternalThreadMessage,
+  ExternalThreadProps,
+} from "../client/ExternalThread";
+import { ExternalThread } from "../client/ExternalThread";
+
+const MESSAGES = [
+  {
+    id: "u1",
+    role: "user",
+    content: [{ type: "text", text: "hi" }],
+    createdAt: new Date(0),
+    attachments: [],
+    metadata: { custom: {} },
+  },
+  {
+    id: "a1",
+    role: "assistant",
+    content: [{ type: "text", text: "hello there" }],
+    createdAt: new Date(0),
+    metadata: { custom: {} },
+  },
+] as unknown as readonly ExternalThreadMessage[];
+
+const createFakeAdapter = () => {
+  const submit = vi.fn();
+  const adapter: FeedbackAdapter = { submit };
+  return { adapter, submit };
+};
+
+const renderThreadWithProps = (props: Partial<ExternalThreadProps>) => {
+  const captured: { aui?: ReturnType<typeof useAui> } = {};
+  const Capture: FC = () => {
+    captured.aui = useAui();
+    return null;
+  };
+  const App: FC<{ props: Partial<ExternalThreadProps> }> = ({ props }) => {
+    const aui = useAui({
+      thread: ExternalThread({
+        messages: MESSAGES,
+        isRunning: false,
+        ...props,
+      }),
+    });
+    return (
+      <AuiProvider value={aui}>
+        <Capture />
+      </AuiProvider>
+    );
+  };
+
+  const view = render(<App props={props} />);
+  return {
+    aui: () => captured.aui!,
+    rerender: (nextProps: Partial<ExternalThreadProps>) =>
+      view.rerender(<App props={nextProps} />),
+  };
+};
+
+describe("ExternalThread feedback", () => {
+  it("reports the feedback capability based on adapter presence", () => {
+    const { aui: withoutAdapter } = renderThreadWithProps({});
+    expect(withoutAdapter().thread.getState().capabilities.feedback).toBe(
+      false,
+    );
+
+    const { adapter } = createFakeAdapter();
+    const { aui: withAdapter } = renderThreadWithProps({
+      feedbackAdapter: adapter,
+    });
+    expect(withAdapter().thread.getState().capabilities.feedback).toBe(true);
+  });
+
+  it("throws on submitFeedback when no adapter is configured", () => {
+    const { aui } = renderThreadWithProps({});
+    expect(() =>
+      aui().thread.message({ id: "a1" }).submitFeedback({ type: "positive" }),
+    ).toThrow("Feedback adapter not configured");
+  });
+
+  it("submits feedback to the adapter and marks the assistant message", async () => {
+    const { adapter, submit } = createFakeAdapter();
+    const { aui } = renderThreadWithProps({ feedbackAdapter: adapter });
+
+    await act(async () => {
+      aui().thread.message({ id: "a1" }).submitFeedback({ type: "positive" });
+    });
+
+    expect(submit).toHaveBeenCalledTimes(1);
+    expect(submit).toHaveBeenCalledWith({
+      message: MESSAGES[1],
+      type: "positive",
+    });
+    await waitFor(() => {
+      expect(
+        aui().thread.message({ id: "a1" }).getState().metadata
+          .submittedFeedback,
+      ).toEqual({ type: "positive" });
+    });
+
+    await act(async () => {
+      aui().thread.message({ id: "a1" }).submitFeedback({ type: "negative" });
+    });
+
+    expect(submit).toHaveBeenLastCalledWith({
+      message: MESSAGES[1],
+      type: "negative",
+    });
+    await waitFor(() => {
+      expect(
+        aui().thread.message({ id: "a1" }).getState().metadata
+          .submittedFeedback,
+      ).toEqual({ type: "negative" });
+    });
+  });
+
+  it("prefers owner-supplied submittedFeedback over the local overlay", async () => {
+    const { adapter } = createFakeAdapter();
+    const { aui, rerender } = renderThreadWithProps({
+      feedbackAdapter: adapter,
+    });
+
+    await act(async () => {
+      aui().thread.message({ id: "a1" }).submitFeedback({ type: "positive" });
+    });
+    await waitFor(() => {
+      expect(
+        aui().thread.message({ id: "a1" }).getState().metadata
+          .submittedFeedback,
+      ).toEqual({ type: "positive" });
+    });
+
+    const ownerMessages = [
+      MESSAGES[0]!,
+      {
+        ...MESSAGES[1]!,
+        metadata: { custom: {}, submittedFeedback: { type: "negative" } },
+      },
+    ] as unknown as readonly ExternalThreadMessage[];
+    await act(async () => {
+      rerender({ feedbackAdapter: adapter, messages: ownerMessages });
+    });
+
+    expect(
+      aui().thread.message({ id: "a1" }).getState().metadata.submittedFeedback,
+    ).toEqual({ type: "negative" });
+  });
+
+  it("re-rates an owner-marked message locally, then honors an owner clear", async () => {
+    const { adapter } = createFakeAdapter();
+    const ratedMessages = [
+      MESSAGES[0]!,
+      {
+        ...MESSAGES[1]!,
+        metadata: { custom: {}, submittedFeedback: { type: "positive" } },
+      },
+    ] as unknown as readonly ExternalThreadMessage[];
+    const { aui, rerender } = renderThreadWithProps({
+      feedbackAdapter: adapter,
+      messages: ratedMessages,
+    });
+
+    await act(async () => {
+      aui().thread.message({ id: "a1" }).submitFeedback({ type: "negative" });
+    });
+    await waitFor(() => {
+      expect(
+        aui().thread.message({ id: "a1" }).getState().metadata
+          .submittedFeedback,
+      ).toEqual({ type: "negative" });
+    });
+
+    await act(async () => {
+      rerender({ feedbackAdapter: adapter, messages: MESSAGES });
+    });
+    expect(
+      aui().thread.message({ id: "a1" }).getState().metadata.submittedFeedback,
+    ).toBeUndefined();
+  });
+
+  it("submits user message feedback without marking the message", async () => {
+    const { adapter, submit } = createFakeAdapter();
+    const { aui } = renderThreadWithProps({ feedbackAdapter: adapter });
+
+    await act(async () => {
+      aui().thread.message({ id: "u1" }).submitFeedback({ type: "negative" });
+    });
+
+    expect(submit).toHaveBeenCalledWith({
+      message: MESSAGES[0],
+      type: "negative",
+    });
+    expect(
+      aui().thread.message({ id: "u1" }).getState().metadata.submittedFeedback,
+    ).toBeUndefined();
+  });
+});

package/src/tests/external-thread-speech.test.tsx

@@ -0,0 +1,328 @@
+// @vitest-environment jsdom
+
+import { act, render, waitFor } from "@testing-library/react";
+import type { FC } from "react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { AuiProvider, useAui } from "@assistant-ui/store";
+import type { SpeechSynthesisAdapter } from "@assistant-ui/core";
+import type {
+  ExternalThreadMessage,
+  ExternalThreadProps,
+} from "../client/ExternalThread";
+import { ExternalThread } from "../client/ExternalThread";
+
+const MESSAGES = [
+  {
+    id: "u1",
+    role: "user",
+    content: [{ type: "text", text: "hi" }],
+    createdAt: new Date(0),
+    attachments: [],
+    metadata: { custom: {} },
+  },
+  {
+    id: "a1",
+    role: "assistant",
+    content: [{ type: "text", text: "hello there" }],
+    createdAt: new Date(0),
+    metadata: { custom: {} },
+  },
+] as unknown as readonly ExternalThreadMessage[];
+
+type FakeUtterance = {
+  text: string;
+  cancel: ReturnType<typeof vi.fn>;
+  emit: (status: SpeechSynthesisAdapter.Status) => void;
+};
+
+const createFakeAdapter = () => {
+  const utterances: FakeUtterance[] = [];
+  const adapter: SpeechSynthesisAdapter = {
+    speak: (text) => {
+      const subscribers = new Set<() => void>();
+      // mirror WebSpeechSynthesisAdapter: cancel transitions to ended and notifies synchronously
+      const cancel = vi.fn(() => {
+        if (utterance.status.type === "ended") return;
+        utterance.status = { type: "ended", reason: "cancelled" };
+        for (const subscriber of subscribers) subscriber();
+      });
+      const utterance: SpeechSynthesisAdapter.Utterance = {
+        status: { type: "starting" },
+        cancel,
+        subscribe: (callback) => {
+          subscribers.add(callback);
+          return () => subscribers.delete(callback);
+        },
+      };
+      utterances.push({
+        text,
+        cancel,
+        emit: (status) => {
+          utterance.status = status;
+          for (const subscriber of subscribers) subscriber();
+        },
+      });
+      return utterance;
+    },
+  };
+  return { adapter, utterances };
+};
+
+const renderThreadWithProps = (props: Partial<ExternalThreadProps>) => {
+  const captured: { aui?: ReturnType<typeof useAui> } = {};
+  const Capture: FC = () => {
+    captured.aui = useAui();
+    return null;
+  };
+  const App: FC<{ props: Partial<ExternalThreadProps> }> = ({ props }) => {
+    const aui = useAui({
+      thread: ExternalThread({
+        messages: MESSAGES,
+        isRunning: false,
+        ...props,
+      }),
+    });
+    return (
+      <AuiProvider value={aui}>
+        <Capture />
+      </AuiProvider>
+    );
+  };
+
+  const view = render(<App props={props} />);
+  const aui = () => captured.aui!;
+  aui.rerender = (nextProps: Partial<ExternalThreadProps>) =>
+    view.rerender(<App props={nextProps} />);
+  aui.unmount = () => view.unmount();
+  return aui;
+};
+
+describe("ExternalThread speech", () => {
+  it("reports the speech capability based on adapter presence", () => {
+    const withoutAdapter = renderThreadWithProps({});
+    expect(withoutAdapter().thread.getState().capabilities.speech).toBe(false);
+
+    const { adapter } = createFakeAdapter();
+    const withAdapter = renderThreadWithProps({ speechAdapter: adapter });
+    expect(withAdapter().thread.getState().capabilities.speech).toBe(true);
+  });
+
+  it("throws on speak when no adapter is configured", () => {
+    const aui = renderThreadWithProps({});
+    expect(() => aui().thread.message({ id: "a1" }).speak()).toThrow(
+      "Speech adapter not configured",
+    );
+  });
+
+  it("tracks utterance status in thread and message state", async () => {
+    const { adapter, utterances } = createFakeAdapter();
+    const aui = renderThreadWithProps({ speechAdapter: adapter });
+
+    await act(async () => {
+      aui().thread.message({ id: "a1" }).speak();
+    });
+
+    expect(utterances[0]!.text).toBe("hello there");
+    await waitFor(() => {
+      expect(aui().thread.getState().speech).toEqual({
+        messageId: "a1",
+        status: { type: "starting" },
+      });
+      expect(aui().thread.message({ id: "a1" }).getState().speech).toEqual({
+        messageId: "a1",
+        status: { type: "starting" },
+      });
+      expect(
+        aui().thread.message({ id: "u1" }).getState().speech,
+      ).toBeUndefined();
+    });
+
+    await act(async () => {
+      utterances[0]!.emit({ type: "running" });
+    });
+    await waitFor(() => {
+      expect(aui().thread.getState().speech).toEqual({
+        messageId: "a1",
+        status: { type: "running" },
+      });
+    });
+
+    await act(async () => {
+      utterances[0]!.emit({ type: "ended", reason: "finished" });
+    });
+    await waitFor(() => {
+      expect(aui().thread.getState().speech).toBeUndefined();
+      expect(
+        aui().thread.message({ id: "a1" }).getState().speech,
+      ).toBeUndefined();
+    });
+  });
+
+  it("cancels the previous utterance when a new speak starts", async () => {
+    const { adapter, utterances } = createFakeAdapter();
+    const aui = renderThreadWithProps({ speechAdapter: adapter });
+
+    await act(async () => {
+      aui().thread.message({ id: "a1" }).speak();
+    });
+    await act(async () => {
+      aui().thread.message({ id: "u1" }).speak();
+    });
+
+    expect(utterances).toHaveLength(2);
+    expect(utterances[0]!.cancel).toHaveBeenCalledTimes(1);
+    await waitFor(() => {
+      expect(aui().thread.getState().speech).toEqual({
+        messageId: "u1",
+        status: { type: "starting" },
+      });
+    });
+
+    await act(async () => {
+      utterances[0]!.emit({ type: "ended", reason: "cancelled" });
+    });
+    expect(aui().thread.getState().speech).toEqual({
+      messageId: "u1",
+      status: { type: "starting" },
+    });
+  });
+
+  it("stopSpeaking cancels the utterance and clears state", async () => {
+    const { adapter, utterances } = createFakeAdapter();
+    const aui = renderThreadWithProps({ speechAdapter: adapter });
+
+    await act(async () => {
+      aui().thread.message({ id: "a1" }).speak();
+    });
+    await act(async () => {
+      aui().thread.stopSpeaking();
+    });
+
+    expect(utterances[0]!.cancel).toHaveBeenCalledTimes(1);
+    await waitFor(() => {
+      expect(aui().thread.getState().speech).toBeUndefined();
+    });
+    expect(() => aui().thread.stopSpeaking()).toThrow(
+      "No message is being spoken",
+    );
+  });
+
+  it("message stopSpeaking throws unless that message is being spoken", async () => {
+    const { adapter, utterances } = createFakeAdapter();
+    const aui = renderThreadWithProps({ speechAdapter: adapter });
+
+    expect(() => aui().thread.message({ id: "a1" }).stopSpeaking()).toThrow(
+      "Message is not being spoken",
+    );
+
+    // speak and stopSpeaking in the same tick, before any re-render
+    await act(async () => {
+      aui().thread.message({ id: "a1" }).speak();
+      expect(() => aui().thread.message({ id: "u1" }).stopSpeaking()).toThrow(
+        "Message is not being spoken",
+      );
+      aui().thread.message({ id: "a1" }).stopSpeaking();
+    });
+
+    expect(utterances[0]!.cancel).toHaveBeenCalledTimes(1);
+    await waitFor(() => {
+      expect(aui().thread.getState().speech).toBeUndefined();
+    });
+  });
+
+  it("cancels the utterance when the adapter is removed", async () => {
+    const { adapter, utterances } = createFakeAdapter();
+    const aui = renderThreadWithProps({ speechAdapter: adapter });
+
+    await act(async () => {
+      aui().thread.message({ id: "a1" }).speak();
+    });
+    await act(async () => {
+      aui.rerender({});
+    });
+
+    expect(utterances[0]!.cancel).toHaveBeenCalledTimes(1);
+    expect(aui().thread.getState().capabilities.speech).toBe(false);
+    await waitFor(() => {
+      expect(aui().thread.getState().speech).toBeUndefined();
+    });
+
+    await act(async () => {
+      utterances[0]!.emit({ type: "running" });
+    });
+    expect(aui().thread.getState().speech).toBeUndefined();
+  });
+
+  it("keeps the utterance alive when the adapter identity changes", async () => {
+    const first = createFakeAdapter();
+    const second = createFakeAdapter();
+    const aui = renderThreadWithProps({ speechAdapter: first.adapter });
+
+    await act(async () => {
+      aui().thread.message({ id: "a1" }).speak();
+    });
+    await act(async () => {
+      aui.rerender({ speechAdapter: second.adapter });
+    });
+
+    expect(first.utterances[0]!.cancel).not.toHaveBeenCalled();
+    expect(aui().thread.getState().speech).toEqual({
+      messageId: "a1",
+      status: { type: "starting" },
+    });
+
+    await act(async () => {
+      aui().thread.message({ id: "u1" }).speak();
+    });
+    expect(first.utterances[0]!.cancel).toHaveBeenCalledTimes(1);
+    expect(second.utterances[0]!.text).toBe("hi");
+    await waitFor(() => {
+      expect(aui().thread.getState().speech).toEqual({
+        messageId: "u1",
+        status: { type: "starting" },
+      });
+    });
+  });
+
+  it("handles utterances that end synchronously on subscribe", async () => {
+    const cancel = vi.fn();
+    const adapter: SpeechSynthesisAdapter = {
+      speak: () => ({
+        status: { type: "ended", reason: "finished" },
+        cancel,
+        subscribe: (callback) => {
+          callback();
+          return () => {};
+        },
+      }),
+    };
+    const aui = renderThreadWithProps({ speechAdapter: adapter });
+
+    await act(async () => {
+      aui().thread.message({ id: "a1" }).speak();
+    });
+
+    expect(aui().thread.getState().speech).toBeUndefined();
+    expect(() => aui().thread.stopSpeaking()).toThrow(
+      "No message is being spoken",
+    );
+  });
+
+  it("cancels the utterance on unmount", async () => {
+    const { adapter, utterances } = createFakeAdapter();
+    const aui = renderThreadWithProps({ speechAdapter: adapter });
+
+    await act(async () => {
+      aui().thread.message({ id: "a1" }).speak();
+    });
+    await act(async () => {
+      aui.unmount();
+    });
+
+    expect(utterances[0]!.cancel).toHaveBeenCalledTimes(1);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+});