@assistant-ui/core 0.3.19 → 0.3.20

package/src/react/runtimes/useRemoteThreadListRuntime.concurrent.test.tsx

@@ -1,10 +1,18 @@
 // @vitest-environment jsdom
 
 import { act, render } from "@testing-library/react";
-import { startTransition, Suspense, type ReactNode } from "react";
+import {
+  startTransition,
+  Suspense,
+  useInsertionEffect,
+  useLayoutEffect,
+  useRef,
+  type ReactNode,
+} from "react";
+import { createRoot } from "react-dom/client";
 import { describe, expect, it, vi } from "vitest";
 import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
-import type { AppendMessage } from "../../types/message";
+import type { AppendMessage, ThreadMessage } from "../../types/message";
 import { makeAdapter } from "../../tests/remote-thread-list-test-helpers";
 import { AssistantRuntimeProvider } from "../AssistantRuntimeProvider";
 import { useExternalStoreRuntime } from "./useExternalStoreRuntime";
@@ -51,7 +59,7 @@ const createHarness = ({ stableHook = false } = {}) => {
   // variant is the only way to exercise an unchanged published hook.
   const useHoistedThreadRuntime = () => {
     renderThreadRuntime();
-    return useExternalStoreRuntime({
+    return useExternalStoreRuntime<ThreadMessage>({
       messages: EMPTY_MESSAGES,
       onNew: onNewA,
     });
@@ -68,7 +76,10 @@ const createHarness = ({ stableHook = false } = {}) => {
       ? useHoistedThreadRuntime
       : () => {
           renderThreadRuntime();
-          return useExternalStoreRuntime({ messages: EMPTY_MESSAGES, onNew });
+          return useExternalStoreRuntime<ThreadMessage>({
+            messages: EMPTY_MESSAGES,
+            onNew,
+          });
         };
     const runtime = useRemoteThreadListRuntime({
       adapter,
@@ -214,3 +225,72 @@ describe("useRemoteThreadListRuntime concurrent options", () => {
     expect(onNewA).not.toHaveBeenCalled();
   });
 });
+
+describe("useRemoteThreadListRuntime commit phase", () => {
+  const LayoutProbe = ({
+    onLayout,
+  }: {
+    onLayout: (() => void) | undefined;
+  }) => {
+    useLayoutEffect(() => {
+      onLayout?.();
+    }, [onLayout]);
+    return null;
+  };
+
+  it("hands a hosted hook its committed options before a yielded commit settles work", async () => {
+    // A render past the scheduler's 5 ms frame budget yields before passive
+    // effects, and act would drain them first, so this renders outside act.
+    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", false);
+    try {
+      const adapter = makeAdapter();
+      const settled: string[] = [];
+      let readLabel: (() => string) | undefined;
+      const App = ({
+        label,
+        renderMs,
+        onLayout,
+      }: {
+        label: string;
+        renderMs: number;
+        onLayout?: () => void;
+      }) => {
+        const runtime = useRemoteThreadListRuntime({
+          adapter,
+          runtimeHook: function useLabelThreadRuntime() {
+            const labelRef = useRef(label);
+            useInsertionEffect(() => {
+              labelRef.current = label;
+              readLabel = () => labelRef.current;
+            });
+            return useExternalStoreRuntime<ThreadMessage>({
+              messages: EMPTY_MESSAGES,
+              onNew: async () => {},
+            });
+          },
+        });
+        const renderEnd = performance.now() + renderMs;
+        while (performance.now() < renderEnd) {}
+        return (
+          <AssistantRuntimeProvider runtime={runtime}>
+            <LayoutProbe onLayout={onLayout} />
+          </AssistantRuntimeProvider>
+        );
+      };
+      const settleInMicrotask = () => {
+        queueMicrotask(() => settled.push(readLabel!()));
+      };
+
+      const root = createRoot(document.createElement("div"));
+      root.render(<App label="A" renderMs={0} />);
+      await vi.waitFor(() => expect(readLabel?.()).toBe("A"));
+      root.render(<App label="B" renderMs={30} onLayout={settleInMicrotask} />);
+      await vi.waitFor(() => expect(settled).toHaveLength(1));
+      root.unmount();
+
+      expect(settled).toEqual(["B"]);
+    } finally {
+      vi.unstubAllGlobals();
+    }
+  });
+});

package/src/react/runtimes/useRemoteThreadListRuntime.ts

@@ -2,6 +2,7 @@ import {
   useState,
   useEffect,
   useInsertionEffect,
+  useLayoutEffect,
   useMemo,
   useRef,
   useCallback,
@@ -86,7 +87,10 @@ export const useRemoteThreadListRuntime = (
   const [runtimeHookStore] = useState(
     () => new WritableSubscribable(options.runtimeHook),
   );
-  useEffect(() => {
+  // The layout phase re-renders hosted threads before this commit yields. An
+  // insertion effect cannot notify subscribers, so descendant layout effects
+  // of the same commit still see the previous hook.
+  useLayoutEffect(() => {
     runtimeHookStore.setState(options.runtimeHook);
   }, [runtimeHookStore, options.runtimeHook]);
 

package/src/runtime/api/message-part-runtime.ts

@@ -92,8 +92,11 @@ export class MessagePartRuntimeImpl implements MessagePartRuntime {
       toolName,
       toolCallId,
       result: response.result,
-      artifact: response.artifact,
       isError: response.isError,
+      ...(response.artifact !== undefined && { artifact: response.artifact }),
+      ...(response.modelContent !== undefined && {
+        modelContent: response.modelContent,
+      }),
     });
   }
 

package/src/runtime/api/message-runtime.ts

@@ -83,7 +83,13 @@ export type MessageRuntime = {
    * @deprecated This API is still under active development and might change without notice.
    */
   stopSpeaking(): void;
-  submitFeedback({ type }: { type: "positive" | "negative" }): void;
+  submitFeedback({
+    type,
+    comment,
+  }: {
+    type: "positive" | "negative";
+    comment?: string;
+  }): void;
   switchToBranch({
     position,
     branchId,
@@ -197,11 +203,18 @@ export class MessageRuntimeImpl implements MessageRuntime {
     }
   }
 
-  public submitFeedback({ type }: { type: "positive" | "negative" }) {
+  public submitFeedback({
+    type,
+    comment,
+  }: {
+    type: "positive" | "negative";
+    comment?: string;
+  }) {
     const state = this._core.getState();
     this._threadBinding.getState().submitFeedback({
       messageId: state.id,
       type,
+      ...(comment !== undefined ? { comment } : undefined),
     });
   }