@assistant-ui/core 0.3.19 → 0.3.20

package/src/react/runtimes/RemoteThreadListHookInstanceManager.tsx

@@ -10,7 +10,7 @@ import {
   type ComponentType,
   Fragment,
 } from "react";
-import { useResources, withKey } from "@assistant-ui/tap";
+import { useResources, useTapHost, withKey } from "@assistant-ui/tap";
 import type { AssistantClient } from "@assistant-ui/store";
 import { ThreadListItemRuntimeProvider } from "../providers/ThreadListItemRuntimeProvider";
 import type {
@@ -329,30 +329,37 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     });
   }
 
+  private _threadElements(
+    parentClient: AssistantClient,
+    { threads, hookEpoch }: HostSnapshot,
+    adapters: AdapterSnapshot,
+  ) {
+    const runtimeHook = this.runtimeHook;
+    return threads.map(({ id, generation, destroySignal }) => {
+      const threadAdapters = this.pendingThreadAdapters.has(id)
+        ? this.pendingThreadAdapters.get(id)!
+        : (adapters.threadAdapters.get(id) ?? adapters.defaultAdapters);
+      return withKey(
+        `${id}:${generation}:${hookEpoch}`,
+        RemoteThreadResource({
+          threadId: id,
+          generation,
+          parentList: this.parent,
+          runtimeHook,
+          parentClient,
+          adapters: threadAdapters,
+          publish: this._publish,
+          destroySignal,
+        }),
+      );
+    });
+  }
+
+  /** @deprecated Commits the hosted threads after descendant layout effects; render `__internal_Host` instead. */
   public __internal_useHost(parentClient: AssistantClient) {
-    const { threads, hookEpoch } = useSubscribable(this.hostStore);
+    const host = useSubscribable(this.hostStore);
     const adapters = useSubscribable(this.adapterStore);
-    const runtimeHook = this.runtimeHook;
-    return useResources(
-      threads.map(({ id, generation, destroySignal }) => {
-        const threadAdapters = this.pendingThreadAdapters.has(id)
-          ? this.pendingThreadAdapters.get(id)!
-          : (adapters.threadAdapters.get(id) ?? adapters.defaultAdapters);
-        return withKey(
-          `${id}:${generation}:${hookEpoch}`,
-          RemoteThreadResource({
-            threadId: id,
-            generation,
-            parentList: this.parent,
-            runtimeHook,
-            parentClient,
-            adapters: threadAdapters,
-            publish: this._publish,
-            destroySignal,
-          }),
-        );
-      }),
-    );
+    return useResources(this._threadElements(parentClient, host, adapters));
   }
 
   public __internal_RenderThreadRuntimes: FC<{
@@ -374,7 +381,15 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
   public __internal_Host: FC<{ parentClient: AssistantClient }> = ({
     parentClient,
   }) => {
-    this.__internal_useHost(parentClient);
+    const host = useSubscribable(this.hostStore);
+    const adapters = useSubscribable(this.adapterStore);
+    const elements = this._threadElements(parentClient, host, adapters);
+    const { effects } = useTapHost(function RemoteThreadResources() {
+      return useResources(elements);
+    });
+    // Descendant layout effects may already dispatch to the thread resources,
+    // and tap commits a hosted resource only when its host effects run.
+    useLayoutEffect(effects);
     return null;
   };
 

package/src/react/runtimes/assistant-transport/transport-scheduling.test.ts

@@ -1,8 +1,15 @@
 // @vitest-environment jsdom
 
-import { act, render, renderHook, waitFor } from "@testing-library/react";
+import { act, renderHook, waitFor } from "@testing-library/react";
 import { describe, expect, it, vi } from "vitest";
-import { createElement, StrictMode, useLayoutEffect, useRef } from "react";
+import {
+  createElement,
+  StrictMode,
+  useEffect,
+  useLayoutEffect,
+  useRef,
+} from "react";
+import { createRoot } from "react-dom/client";
 import { useCommandQueue } from "./commandQueue";
 import { useRunManager } from "./runManager";
 import type { AssistantTransportCommand } from "./types";
@@ -85,52 +92,70 @@ const useTransportSchedulingHarness = (
 };
 
 describe("assistant transport scheduling contracts", () => {
-  it("uses current callbacks when scheduled by a descendant layout effect", async () => {
-    const onRunA = vi.fn(async () => {});
-    const onRunB = vi.fn(async () => {});
-    // act flushes passive effects before real microtasks, so preserve the
-    // browser's microtask-before-passive-effect ordering at the layout boundary.
-    const queueMicrotaskSpy = vi
-      .spyOn(globalThis, "queueMicrotask")
-      .mockImplementation((callback) => callback());
-
-    const Scheduler = ({
-      schedule,
-      enabled,
-    }: {
-      schedule: () => void;
-      enabled: boolean;
-    }) => {
-      useLayoutEffect(() => {
-        if (enabled) schedule();
-      }, [enabled, schedule]);
-      return null;
-    };
-    const Probe = ({
-      enabled,
-      onRun,
-    }: {
-      enabled: boolean;
-      onRun: (signal: AbortSignal) => Promise<void>;
-    }) => {
-      const runManager = useRunManager({ onRun });
-      return createElement(Scheduler, {
-        enabled,
-        schedule: runManager.schedule,
-      });
-    };
-
+  it("reads the committed callbacks when a run settles inside a yielded commit", 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 view = render(
-        createElement(Probe, { enabled: false, onRun: onRunA }),
+      const events: string[] = [];
+      const pendingRuns: (() => void)[] = [];
+      let schedule!: () => void;
+      const settleRun = () => {
+        pendingRuns.shift()?.();
+        schedule();
+      };
+
+      const Settle = ({ onLayout }: { onLayout: (() => void) | undefined }) => {
+        useLayoutEffect(() => {
+          onLayout?.();
+        }, [onLayout]);
+        return null;
+      };
+      const Probe = ({
+        label,
+        renderMs,
+        onLayout,
+      }: {
+        label: string;
+        renderMs: number;
+        onLayout?: () => void;
+      }) => {
+        const runManager = useRunManager({
+          onRun: () => {
+            events.push(`run:${label}`);
+            return new Promise<void>((resolve) => pendingRuns.push(resolve));
+          },
+          onFinish: () => events.push(`finish:${label}`),
+        });
+        schedule = runManager.schedule;
+        useEffect(() => {
+          events.push(`passive:${label}`);
+        }, [label]);
+        const renderEnd = performance.now() + renderMs;
+        while (performance.now() < renderEnd) {}
+        return createElement(Settle, { onLayout });
+      };
+
+      const root = createRoot(document.createElement("div"));
+      root.render(createElement(Probe, { label: "A", renderMs: 0 }));
+      await vi.waitFor(() => expect(events).toEqual(["passive:A"]));
+      schedule();
+      await vi.waitFor(() => expect(events).toEqual(["passive:A", "run:A"]));
+      root.render(
+        createElement(Probe, { label: "B", renderMs: 30, onLayout: settleRun }),
       );
-      view.rerender(createElement(Probe, { enabled: true, onRun: onRunB }));
-      await act(async () => {});
-
-      expect(onRunB).toHaveBeenCalledTimes(1);
-      expect(onRunA).not.toHaveBeenCalled();
+      await vi.waitFor(() => expect(events).toContain("passive:B"));
+      root.unmount();
+
+      expect(events).toEqual([
+        "passive:A",
+        "run:A",
+        "finish:B",
+        "run:B",
+        "passive:B",
+      ]);
     } finally {
-      queueMicrotaskSpy.mockRestore();
+      vi.unstubAllGlobals();
     }
   });
 
@@ -196,7 +221,9 @@ describe("assistant transport scheduling contracts", () => {
         onRun: () => {
           throw new Error("network error");
         },
-        onError: (commands) => seen.push(commands),
+        onError: (commands) => {
+          seen.push(commands);
+        },
       }),
     );
 

package/src/react/runtimes/assistant-transport/useAssistantTransportRuntime.test.tsx

@@ -167,7 +167,13 @@ describe("useAssistantTransportRuntime", () => {
               ],
               createdAt: new Date(0),
               status: { type: "requires-action", reason: "tool-calls" },
-              metadata: { custom: {} },
+              metadata: {
+                unstable_state: {},
+                unstable_annotations: [],
+                unstable_data: [],
+                steps: [],
+                custom: {},
+              },
             },
           ],
           isRunning: meta.isSending,
@@ -203,6 +209,65 @@ describe("useAssistantTransportRuntime", () => {
     },
   );
 
+  it("forwards a tool response's modelContent to the outbound command", async () => {
+    const fetchMock = installFetch();
+    const { aui } = mountRuntime({
+      converter: (_state, meta) => ({
+        messages: [
+          {
+            id: "a1",
+            role: "assistant",
+            content: [
+              {
+                type: "tool-call",
+                toolCallId: "tc1",
+                toolName: "probe",
+                args: {},
+                argsText: "{}",
+              },
+            ],
+            createdAt: new Date(0),
+            status: { type: "requires-action", reason: "tool-calls" },
+            metadata: {
+              unstable_state: {},
+              unstable_annotations: [],
+              unstable_data: [],
+              steps: [],
+              custom: {},
+            },
+          },
+        ],
+        isRunning: meta.isSending,
+      }),
+    });
+
+    await waitFor(() =>
+      expect(
+        aui()
+          .thread.message({ id: "a1" })
+          .part({ toolCallId: "tc1" })
+          .getState().type,
+      ).toBe("tool-call"),
+    );
+
+    const modelContent = [{ type: "text" as const, text: "done" }];
+    act(() => {
+      aui()
+        .thread.message({ id: "a1" })
+        .part({ toolCallId: "tc1" })
+        .addToolResult(new ToolResponse({ result: "ok", modelContent }));
+    });
+
+    await waitFor(() => expect(fetchMock.requests).toHaveLength(1));
+    expect(fetchMock.requests[0]!.body["commands"][0]).toHaveProperty(
+      "modelContent",
+      modelContent,
+    );
+
+    act(() => fetchMock.servers[0]!.close());
+    await waitFor(() => expect(aui().thread.getState().isRunning).toBe(false));
+  });
+
   it.each(["throws", "rejects"] as const)(
     "cancels the response body when onResponse %s",
     async (failureMode) => {

package/src/react/runtimes/cloud/AssistantCloudThreadHistoryAdapter.test.tsx

@@ -404,6 +404,31 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
     });
   });
 
+  it("forwards a feedback comment to the cloud", async () => {
+    mocks.aui = mocks.makeClient("thread-1");
+    const cloud = makeCloud();
+    const cloudRef = { current: cloud };
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter(cloudRef),
+    );
+    const message = makeAssistantMessage("local-message-1");
+
+    await result.current.append({ parentId: null, message });
+    result.current.feedback.submit({
+      message,
+      type: "negative",
+      comment: "Quoted the wrong date",
+    });
+
+    await waitFor(() => {
+      expect(cloud.threads.messages.feedback).toHaveBeenCalledWith(
+        "thread-1",
+        "remote-message-1",
+        { type: "negative", comment: "Quoted the wrong date" },
+      );
+    });
+  });
+
   it("warns and skips feedback before the thread has a remote ID", async () => {
     mocks.aui = mocks.makeClient(undefined, "local-thread", "thread-1");
     const cloud = makeCloud();
@@ -1070,3 +1095,80 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
     );
   });
 });
+
+describe("useAssistantCloudThreadHistoryAdapter load recovery", () => {
+  const userRow = (id: string, parentId: string | null, text: string) => ({
+    id,
+    thread_id: "thread-1",
+    format: "aui/v0" as const,
+    parent_id: parentId,
+    created_at: new Date(0),
+    content: {
+      role: "user",
+      content: [{ type: "text", text }],
+      metadata: { custom: {} },
+    },
+  });
+
+  const loadHistory = async (messages: unknown[]) => {
+    mocks.aui = mocks.makeClient("thread-1");
+    const cloud = makeCloud();
+    cloud.threads.messages.list = vi.fn().mockResolvedValue({ messages });
+    const cloudRef = { current: cloud };
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter(cloudRef),
+    );
+    return (await result.current.load()).messages;
+  };
+
+  it("keeps a row whose stored part is malformed, and the thread below it", async () => {
+    // The cloud lists rows newest first.
+    const messages = await loadHistory([
+      userRow("msg-3", "msg-2", "after"),
+      {
+        ...userRow("msg-2", "msg-1", "ignored"),
+        content: { role: "assistant", content: [null] },
+      },
+      userRow("msg-1", null, "hello"),
+    ]);
+
+    expect(messages.map((item) => item.message.id)).toEqual([
+      "msg-1",
+      "msg-2",
+      "msg-3",
+    ]);
+    expect(messages[1]?.message.content).toEqual([]);
+  });
+
+  it("keeps a row whose stored attachment is malformed", async () => {
+    const messages = await loadHistory([
+      {
+        ...userRow("msg-1", null, "look"),
+        content: {
+          role: "user",
+          content: [{ type: "text", text: "look" }],
+          attachments: [null],
+          metadata: { custom: {} },
+        },
+      },
+    ]);
+
+    expect(messages).toHaveLength(1);
+    expect(messages[0]?.message.content).toEqual([
+      { type: "text", text: "look" },
+    ]);
+  });
+
+  it("drops an unreadable row together with the subtree below it", async () => {
+    const messages = await loadHistory([
+      userRow("msg-3", "msg-2", "orphaned"),
+      {
+        ...userRow("msg-2", "msg-1", "ignored"),
+        content: { role: "assistant", content: null },
+      },
+      userRow("msg-1", null, "hello"),
+    ]);
+
+    expect(messages.map((item) => item.message.id)).toEqual(["msg-1"]);
+  });
+});

package/src/react/runtimes/cloud/AssistantCloudThreadHistoryAdapter.ts

@@ -30,7 +30,7 @@ import {
   extractAISDKRunTelemetry,
   type AISDKMessageLike,
 } from "assistant-cloud/ai-sdk";
-import { auiV0Decode, auiV0Encode } from "./auiV0";
+import { auiV0DecodeSafely, auiV0Encode } from "./auiV0";
 import { type AssistantClient, getClientId, useAui } from "@assistant-ui/store";
 import type { ThreadListItemMethods } from "../../../store/scopes/thread-list-item";
 import type { FeedbackAdapter } from "../../../adapters/feedback";
@@ -117,7 +117,7 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
   }
 
   public readonly feedback: FeedbackAdapter = {
-    submit: ({ message, type }) => {
+    submit: ({ message, type, comment }) => {
       void (async () => {
         const threadListItem = this.tryGetKeyedThreadListItem();
         const remoteThreadId = threadListItem?.getState().remoteId;
@@ -141,7 +141,7 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
         await this.cloudRef.current.threads.messages.feedback(
           remoteThreadId,
           cloudMessageId,
-          { type },
+          { type, ...(comment ? { comment } : undefined) },
         );
       })().catch((error: unknown) => {
         console.error(
@@ -311,14 +311,27 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
     const remoteId = this.aui.threadListItem.getState().remoteId;
     if (!remoteId) return { messages: [] };
     const messages = await this._persistence.load(remoteId, "aui/v0");
-    return {
-      messages: messages
-        .filter(
-          (m): m is typeof m & { format: "aui/v0" } => m.format === "aui/v0",
-        )
-        .map(auiV0Decode)
-        .reverse(),
-    };
+    // The cloud lists rows newest first, so walking them oldest first puts a
+    // parent ahead of its children and a row orphaned by an unreadable parent
+    // can be dropped in the same pass; MessageRepository.import throws on a
+    // message whose parent is missing.
+    const rows = messages
+      .filter(
+        (m): m is typeof m & { format: "aui/v0" } => m.format === "aui/v0",
+      )
+      .reverse();
+
+    const loaded: ExportedMessageRepositoryItem[] = [];
+    const loadedIds = new Set<string>();
+    for (const row of rows) {
+      const item = auiV0DecodeSafely(row);
+      if (!item) continue;
+      if (item.parentId && !loadedIds.has(item.parentId)) continue;
+      loadedIds.add(item.message.id);
+      loaded.push(item);
+    }
+
+    return { messages: loaded };
   }
 
   private _reportRunTelemetry<T>(

package/src/react/runtimes/cloud/CloudFileAttachmentAdapter.test.ts

@@ -134,10 +134,12 @@ describe("CloudFileAttachmentAdapter", () => {
   });
 
   it("does not finish an upload removed while requesting its URL", async () => {
-    const presigned = deferred<{
-      signedUrl: string;
-      publicUrl: string;
-    }>();
+    const presigned =
+      deferred<
+        Awaited<
+          ReturnType<AssistantCloud["files"]["generatePresignedUploadUrl"]>
+        >
+      >();
     const cloud = makeCloud();
     vi.mocked(cloud.files.generatePresignedUploadUrl).mockReturnValue(
       presigned.promise,
@@ -155,7 +157,9 @@ describe("CloudFileAttachmentAdapter", () => {
 
     await adapter.remove(running.value!);
     presigned.resolve({
+      success: true,
       signedUrl: "https://storage.example/upload",
+      expiresAt: "2026-09-16T00:00:00.000Z",
       publicUrl: "https://cdn.example/file.png",
     });
 

package/src/react/runtimes/cloud/auiV0.ts

@@ -14,7 +14,14 @@ import {
   type ThreadMessageLike,
 } from "../../../runtime/utils/thread-message-like";
 import type { CloudMessage } from "assistant-cloud";
-import { isJSONValue } from "../../../utils/json/is-json";
+import { isJSONValue, isRecord } from "../../../utils/json/is-json";
+import {
+  MAX_STORED_MESSAGE_DEPTH,
+  isStoredAuiV0RolePart,
+  isStoredMessageRole,
+  parseStoredAttachment,
+  parseStoredDate,
+} from "../../../runtime/utils/stored-message-parts";
 import type {
   ReadonlyJSONObject,
   ReadonlyJSONValue,
@@ -427,6 +434,119 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
   };
 }
 
+const readableAuiV0Parts = (
+  role: AuiV0Message["role"],
+  content: readonly unknown[],
+  depth: number,
+): AuiV0MessagePart[] =>
+  content.flatMap((part) => {
+    if (!isStoredAuiV0RolePart(role, part)) return [];
+    if (part.type !== "tool-call" || part.messages === undefined)
+      return [part as unknown as AuiV0MessagePart];
+
+    const { messages, ...toolCall } = part;
+    if (!Array.isArray(messages) || depth >= MAX_STORED_MESSAGE_DEPTH)
+      return [toolCall as unknown as AuiV0MessagePart];
+    return [
+      {
+        ...toolCall,
+        messages: messages.flatMap((message) => {
+          const nested = readableAuiV0Message(message, depth + 1);
+          return nested ? [nested] : [];
+        }),
+      } as unknown as AuiV0MessagePart,
+    ];
+  });
+
+const readableAuiV0Attachments = (
+  attachments: readonly unknown[],
+): AuiV0Attachment[] =>
+  attachments.flatMap((attachment) => {
+    const parsed = parseStoredAttachment(attachment, (value) =>
+      isStoredAuiV0RolePart("user", value),
+    );
+    return parsed ? [parsed as unknown as AuiV0Attachment] : [];
+  });
+
+const readableAuiV0Message = (
+  value: unknown,
+  depth: number,
+): AuiV0Message | null => {
+  if (
+    !isRecord(value) ||
+    !isStoredMessageRole(value.role) ||
+    !Array.isArray(value.content)
+  ) {
+    return null;
+  }
+
+  const { role } = value;
+  const content = readableAuiV0Parts(role, value.content, depth);
+  // fromThreadMessageLike takes a system row only with exactly one text part,
+  // so one that no longer matches after filtering is dropped here rather than
+  // costing the row or the tool call that carries it.
+  if (role === "system" && content.length !== 1) return null;
+
+  const { attachments, createdAt, status, metadata, ...rest } = value;
+  // decodeAuiV0Message turns a nested createdAt into a Date without checking
+  // it, and encodeNestedMessage later calls toISOString on the result, so an
+  // unparseable one would reject the next write to the message that holds it.
+  // Dropping the field falls back to the parent's timestamp.
+  const storedCreatedAt = parseStoredDate(createdAt);
+  const readableMetadata =
+    role === "assistant" || !isRecord(metadata)
+      ? metadata
+      : { ...metadata, steps: undefined };
+
+  return {
+    ...rest,
+    ...(storedCreatedAt ? { createdAt } : undefined),
+    // fromThreadMessageLike throws on a status, a metadata.steps or an
+    // attachments list carried by a row whose role cannot hold one, and
+    // auiV0Encode only ever writes each onto the role that can, so dropping a
+    // misplaced field costs no valid data and saves the row.
+    ...(role === "assistant" && status !== undefined ? { status } : undefined),
+    ...(metadata !== undefined ? { metadata: readableMetadata } : undefined),
+    content,
+    ...(role === "user" && Array.isArray(attachments)
+      ? { attachments: readableAuiV0Attachments(attachments) }
+      : undefined),
+  } as unknown as AuiV0Message;
+};
+
+/**
+ * Decodes a stored row, dropping the parts, attachments and nested messages
+ * that cannot be read back instead of rejecting the row, and returning null
+ * when the row itself is unreadable. Loading a thread must not fail because a
+ * single stored row is malformed.
+ */
+export function auiV0DecodeSafely(
+  cloudMessage: CloudMessage & { format: "aui/v0" },
+): ExportedMessageRepositoryItem | null {
+  try {
+    const payload = readableAuiV0Message(cloudMessage.content, 0);
+    if (!payload) throw new Error("stored row is not an aui/v0 message");
+
+    return {
+      parentId: cloudMessage.parent_id,
+      message: decodeAuiV0Message(
+        {
+          ...payload,
+          id: cloudMessage.id,
+          createdAt: cloudMessage.created_at,
+        },
+        cloudMessage.id,
+      ),
+    };
+  } catch (error) {
+    console.warn(
+      `aui/v0: dropping unreadable message ${cloudMessage.id}`,
+      error,
+    );
+    return null;
+  }
+}
+
 export function auiV0Decode(
   cloudMessage: CloudMessage & { format: "aui/v0" },
 ): ExportedMessageRepositoryItem {