@assistant-ui/react 0.15.8 → 0.15.10

package/src/client/ExternalThread.ts

@@ -33,6 +33,9 @@ import type {
   ExternalThreadQueueAdapter,
   ExternalThreadBranchAdapter,
   QueuePlacement,
+  FeedbackAdapter,
+  SpeechState,
+  SpeechSynthesisAdapter,
 } from "@assistant-ui/core";
 import { ToolResponse } from "assistant-stream";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
@@ -97,6 +100,8 @@ export type ExternalThreadProps = {
   onResumeToolCall?: ((options: ResumeToolCallOptions) => void) | undefined;
   onLoadExternalState?: ((state: unknown) => void) | undefined;
   attachmentAdapter?: AttachmentAdapter | undefined;
+  feedbackAdapter?: FeedbackAdapter | undefined;
+  speechAdapter?: SpeechSynthesisAdapter | undefined;
   /** Queue adapter for runtimes that support message queuing and steering. */
   queue?: ExternalThreadQueueAdapter;
   /** Branch adapter for runtimes that track sibling variants of messages. */
@@ -119,6 +124,11 @@ type MessageClientProps = {
   onAddToolResult?: ((options: AddToolResultOptions) => void) | undefined;
   onResumeToolCall?: ((options: ResumeToolCallOptions) => void) | undefined;
   attachmentAdapter?: AttachmentAdapter | undefined;
+  submittedFeedback: "positive" | "negative" | undefined;
+  onSubmitFeedback: (feedback: { type: "positive" | "negative" }) => void;
+  speech: SpeechState | undefined;
+  onSpeak: () => void;
+  onStopSpeaking: () => void;
 };
 
 // Message Client - minimal implementation
@@ -134,6 +144,11 @@ const useMessageClient = ({
   onAddToolResult,
   onResumeToolCall,
   attachmentAdapter,
+  submittedFeedback,
+  onSubmitFeedback,
+  speech,
+  onSpeak,
+  onStopSpeaking,
 }: MessageClientProps): ClientOutput<"message"> => {
   const [isCopied, setIsCopied] = useState(false);
   const [isHovering, setIsHovering] = useState(false);
@@ -168,6 +183,7 @@ const useMessageClient = ({
   );
 
   const handleBeginEdit = () => {
+    if (!onEdit) throw new Error("Runtime does not support editing.");
     setIsEditing(true);
   };
 
@@ -176,7 +192,8 @@ const useMessageClient = ({
   };
 
   const handleSendEdit = (msg: AppendMessage) => {
-    onEdit?.({
+    if (!onEdit) throw new Error("Runtime does not support editing.");
+    onEdit({
       ...msg,
       parentId,
       sourceId: message.id,
@@ -204,14 +221,24 @@ const useMessageClient = ({
   const branchCount = branchIndex === -1 ? 1 : branchIds.length;
 
   const state = useMemo(() => {
+    const messageWithFeedback: ExternalThreadMessage =
+      submittedFeedback && message.role === "assistant"
+        ? {
+            ...message,
+            metadata: {
+              ...message.metadata,
+              submittedFeedback: { type: submittedFeedback },
+            },
+          }
+        : message;
     return {
-      ...message,
+      ...messageWithFeedback,
       attachments: message.attachments ?? [],
       parentId,
       isLast: false, // Will be set by thread
       branchNumber,
       branchCount,
-      speech: undefined,
+      speech,
       parts: partClients.state,
       isCopied,
       isHovering,
@@ -228,6 +255,8 @@ const useMessageClient = ({
     partClients.state,
     branchNumber,
     branchCount,
+    submittedFeedback,
+    speech,
   ]);
 
   return {
@@ -237,9 +266,9 @@ const useMessageClient = ({
     reload: () => {
       onReload?.();
     },
-    speak: () => {},
-    stopSpeaking: () => {},
-    submitFeedback: () => {},
+    speak: onSpeak,
+    stopSpeaking: onStopSpeaking,
+    submitFeedback: onSubmitFeedback,
     switchToBranch: ({ position, branchId }) => {
       if (!branches) return;
       const target =
@@ -721,6 +750,65 @@ const useComposerClientResource = ({
 
 const ComposerClientResource = resource(useComposerClientResource);
 
+const createSpeechController = (
+  notify: (speech: SpeechState | undefined) => void,
+) => {
+  let session: { messageId: string; cancel: () => void } | undefined;
+
+  const clear = () => {
+    if (!session) return;
+    session.cancel();
+    session = undefined;
+    notify(undefined);
+  };
+
+  return {
+    speak: (
+      adapter: SpeechSynthesisAdapter,
+      message: ExternalThreadMessage,
+    ) => {
+      clear();
+
+      const utterance = adapter.speak(getThreadMessageText(message));
+      let unsub: (() => void) | undefined;
+      unsub = utterance.subscribe(() => {
+        if (utterance.status.type === "ended") {
+          unsub?.();
+          session = undefined;
+          notify(undefined);
+        } else {
+          notify({ messageId: message.id, status: utterance.status });
+        }
+      });
+
+      if (utterance.status.type === "ended") {
+        unsub();
+        notify(undefined);
+        return;
+      }
+
+      session = {
+        messageId: message.id,
+        cancel: () => {
+          unsub!();
+          utterance.cancel();
+        },
+      };
+      notify({ messageId: message.id, status: utterance.status });
+    },
+    stop: () => {
+      if (!session) throw new Error("No message is being spoken");
+      clear();
+    },
+    stopMessage: (messageId: string) => {
+      if (session?.messageId !== messageId)
+        throw new Error("Message is not being spoken");
+      clear();
+    },
+    dispose: clear,
+  };
+};
+
 const dedupeMessagesById = (messages: readonly ExternalThreadMessage[]) => {
   const seenIds = new Set<string>();
   const deduped: ExternalThreadMessage[] = [];
@@ -756,6 +844,8 @@ const useExternalThread = ({
   onResumeToolCall,
   onLoadExternalState,
   attachmentAdapter,
+  feedbackAdapter,
+  speechAdapter,
   queue,
   branches,
   onRespondToToolApproval,
@@ -765,6 +855,71 @@ const useExternalThread = ({
     [messagesProp],
   );
 
+  // Local entries are optimistic: they apply only while the message's
+  // external submittedFeedback still equals the value seen at click time.
+  const [submittedFeedback, setSubmittedFeedback] = useState<
+    Record<
+      string,
+      {
+        type: "positive" | "negative";
+        external: "positive" | "negative" | undefined;
+      }
+    >
+  >({});
+
+  const feedbackFor = (msg: ExternalThreadMessage) => {
+    const entry = submittedFeedback[msg.id];
+    return entry && msg.metadata.submittedFeedback?.type === entry.external
+      ? entry.type
+      : undefined;
+  };
+
+  useEffect(() => {
+    setSubmittedFeedback((prev) => {
+      const live = Object.entries(prev).filter(([id, entry]) => {
+        const msg = messages.find((m) => m.id === id);
+        return !!msg && msg.metadata.submittedFeedback?.type === entry.external;
+      });
+      return live.length === Object.keys(prev).length
+        ? prev
+        : Object.fromEntries(live);
+    });
+  }, [messages]);
+
+  const handleSubmitFeedback = (
+    message: ExternalThreadMessage,
+    { type }: { type: "positive" | "negative" },
+  ) => {
+    if (!feedbackAdapter) throw new Error("Feedback adapter not configured");
+    feedbackAdapter.submit({ message, type });
+
+    if (message.role === "assistant") {
+      setSubmittedFeedback((prev) => ({
+        ...prev,
+        [message.id]: {
+          type,
+          external: message.metadata.submittedFeedback?.type,
+        },
+      }));
+    }
+  };
+
+  const [speechState, setSpeech] = useState<SpeechState | undefined>(undefined);
+  const [speechController] = useState(() => createSpeechController(setSpeech));
+
+  const hasSpeechAdapter = !!speechAdapter;
+  const speech = hasSpeechAdapter ? speechState : undefined;
+  useEffect(() => {
+    if (!hasSpeechAdapter) speechController.dispose();
+  }, [hasSpeechAdapter, speechController]);
+
+  useEffect(() => () => speechController.dispose(), [speechController]);
+
+  const handleSpeak = (message: ExternalThreadMessage) => {
+    if (!speechAdapter) throw new Error("Speech adapter not configured");
+    speechController.speak(speechAdapter, message);
+  };
+
   const handleReload = (messageId: string) => {
     const messageIndex = messages.findIndex((m) => m.id === messageId);
     if (messageIndex === -1) return;
@@ -786,6 +941,11 @@ const useExternalThread = ({
         onAddToolResult,
         onResumeToolCall,
         attachmentAdapter,
+        submittedFeedback: feedbackFor(msg),
+        onSubmitFeedback: (feedback) => handleSubmitFeedback(msg, feedback),
+        speech: speech?.messageId === msg.id ? speech : undefined,
+        onSpeak: () => handleSpeak(msg),
+        onStopSpeaking: () => speechController.stopMessage(msg.id),
       };
       if (onEdit) props.onEdit = onEdit;
       return withKey(msg.id, MessageClient(props));
@@ -833,6 +993,8 @@ const useExternalThread = ({
   const hasEdit = !!onEdit;
   const hasReload = !!onReload;
   const hasAttachments = !!attachmentAdapter;
+  const hasFeedback = !!feedbackAdapter;
+  const hasSpeech = !!speechAdapter;
   const state = useMemo(() => {
     const messageStates = messageClients.state.map((s, idx, arr) => ({
       ...s,
@@ -850,9 +1012,9 @@ const useExternalThread = ({
         reload: hasReload,
         refetchThread: false,
         cancel: isRunning,
-        speech: false,
+        speech: hasSpeech,
         attachments: hasAttachments,
-        feedback: false,
+        feedback: hasFeedback,
         voice: false,
         switchToBranch: hasBranches,
         switchBranchDuringRun: false,
@@ -864,7 +1026,7 @@ const useExternalThread = ({
       state: threadState ?? {},
       suggestions: [],
       extras,
-      speech: undefined,
+      speech,
       voice: undefined,
       composer: composerClient.state,
     };
@@ -879,6 +1041,9 @@ const useExternalThread = ({
     hasEdit,
     hasReload,
     hasAttachments,
+    hasFeedback,
+    hasSpeech,
+    speech,
     messageClients.state,
     composerClient.state,
   ]);
@@ -945,7 +1110,7 @@ const useExternalThread = ({
       }
       return messageClients.get(selector);
     },
-    stopSpeaking: () => {},
+    stopSpeaking: speechController.stop,
     connectVoice: () => {},
     disconnectVoice: () => {},
     getVoiceVolume: () => 0,

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-parity.test.tsx

@@ -322,6 +322,35 @@ describe("ExternalThread composer", () => {
     expect(steer).not.toHaveBeenCalled();
   });
 
+  it("throws on beginEdit when the runtime has no edit handler", () => {
+    const { aui } = renderThread({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      isRunning: false,
+      queue: {
+        items: [],
+        steerItems: [],
+        enqueue: vi.fn(),
+        steer: vi.fn(),
+        move: vi.fn(),
+        edit: vi.fn(),
+        remove: vi.fn(),
+      },
+    });
+
+    expect(() =>
+      aui().thread.message({ id: "u1" }).composer().beginEdit(),
+    ).toThrow("Runtime does not support editing.");
+  });
+
   it("still refuses to send an empty composer synchronously after a send", async () => {
     const onNew = vi.fn();
     const { aui } = renderThread({ messages: [], isRunning: false, onNew });