@assistant-ui/core 0.3.16 → 0.3.17

package/src/react/runtimes/RemoteThreadResource.ts

@@ -22,6 +22,7 @@ import {
   type RuntimeAdapters,
 } from "./RuntimeAdapterProvider";
 import { isSilentRuntimeAction } from "../../utils/silent-runtime-action";
+import { isTitleSourceMessage } from "../../runtimes/remote-thread-list/title";
 
 export type RemoteThreadListHook = () => AssistantRuntime;
 
@@ -39,10 +40,6 @@ export type RemoteThreadResourceProps = {
   ) => void;
 };
 
-export const isTitleSourceMessage = (message: {
-  status?: { type: string } | undefined;
-}) => message.status?.type !== "running";
-
 export const subscribeToTitleGeneration = (
   threadRuntime: AssistantRuntime["thread"],
   itemRuntime: ThreadListItemRuntime,

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

@@ -1,8 +1,8 @@
 // @vitest-environment jsdom
 
-import { act, renderHook, waitFor } from "@testing-library/react";
+import { act, render, renderHook, waitFor } from "@testing-library/react";
 import { describe, expect, it, vi } from "vitest";
-import { createElement, StrictMode, useRef } from "react";
+import { createElement, StrictMode, useLayoutEffect, useRef } from "react";
 import { useCommandQueue } from "./commandQueue";
 import { useRunManager } from "./runManager";
 import type { AssistantTransportCommand } from "./types";
@@ -85,6 +85,55 @@ 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,
+      });
+    };
+
+    try {
+      const view = render(
+        createElement(Probe, { enabled: false, onRun: onRunA }),
+      );
+      view.rerender(createElement(Probe, { enabled: true, onRun: onRunB }));
+      await act(async () => {});
+
+      expect(onRunB).toHaveBeenCalledTimes(1);
+      expect(onRunA).not.toHaveBeenCalled();
+    } finally {
+      queueMicrotaskSpy.mockRestore();
+    }
+  });
+
   it("runs in single-flight mode and schedules exactly one follow-up run", async () => {
     const gate = createDeferred();
     const { result } = renderHook(() =>

package/src/react/runtimes/assistant-transport/useLatestRef.ts

@@ -1,8 +1,8 @@
-import { useEffect, useRef } from "react";
+import { useInsertionEffect, useRef } from "react";
 
 export function useLatestRef<T>(value: T) {
   const ref = useRef(value);
-  useEffect(() => {
+  useInsertionEffect(() => {
     ref.current = value;
   }, [value]);
   return ref as { current: T };

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

@@ -31,4 +31,49 @@ describe("extractAuiV0", () => {
     expect(result?.inputTokens).toBe(1);
     expect(result?.outputTokens).toBe(2);
   });
+
+  it("sums step usage reported under the AI SDK v7 token details", () => {
+    const result = extractAuiV0({
+      ...auiV0Message({ type: "complete" }),
+      metadata: {
+        steps: [
+          {
+            usage: {
+              inputTokens: 10,
+              outputTokens: 4,
+              inputTokenDetails: { cacheReadTokens: 6 },
+              outputTokenDetails: { reasoningTokens: 1 },
+            },
+          },
+          {
+            usage: {
+              inputTokens: 5,
+              outputTokens: 2,
+              inputTokenDetails: { cacheReadTokens: 3 },
+              outputTokenDetails: { reasoningTokens: 1 },
+            },
+          },
+        ],
+      },
+    });
+
+    expect(result?.inputTokens).toBe(15);
+    expect(result?.outputTokens).toBe(6);
+    expect(result?.cachedInputTokens).toBe(9);
+    expect(result?.reasoningTokens).toBe(2);
+    expect(result?.steps).toEqual([
+      {
+        input_tokens: 10,
+        output_tokens: 4,
+        reasoning_tokens: 1,
+        cached_input_tokens: 6,
+      },
+      {
+        input_tokens: 5,
+        output_tokens: 2,
+        reasoning_tokens: 1,
+        cached_input_tokens: 3,
+      },
+    ]);
+  });
 });

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

@@ -21,12 +21,33 @@ const mocks = vi.hoisted(() => {
     };
     return {
       threadListItem,
-      threads: { item: vi.fn(() => threadListItem) },
+      threads: {
+        item: vi.fn(() => threadListItem),
+        getState: () => ({ threadItems: [{ id, remoteId }] }),
+      },
+    } as unknown as import("@assistant-ui/store").AssistantClient;
+  };
+
+  const makeSplitClient = (remoteId: string) => {
+    const itemShape = () => ({
+      source: "threads",
+      getState: () => ({ id: remoteId, remoteId }),
+      initialize: async () => ({ remoteId, externalId: undefined }),
+    });
+    const live = itemShape();
+    const listItem = itemShape();
+    return {
+      threadListItem: live,
+      threads: {
+        item: vi.fn(() => listItem),
+        getState: () => ({ threadItems: [{ id: remoteId, remoteId }] }),
+      },
     } as unknown as import("@assistant-ui/store").AssistantClient;
   };
 
   return {
     makeClient,
+    makeSplitClient,
     aui: makeClient("thread-1"),
   };
 });
@@ -308,4 +329,47 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
       expect.anything(),
     );
   });
+
+  it("updates a history-loaded message when the list item identity differs from the live item", async () => {
+    mocks.aui = mocks.makeSplitClient("thread-split");
+    const cloud = makeCloud();
+    (cloud.threads.messages.list as ReturnType<typeof vi.fn>).mockResolvedValue(
+      {
+        messages: [
+          {
+            id: "m1",
+            parent_id: null,
+            format: "test",
+            content: { id: "m1" },
+          },
+        ],
+      },
+    );
+    const cloudRef = { current: cloud };
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter(cloudRef),
+    );
+    const formatted = result.current.withFormat<
+      { id: string },
+      Record<string, unknown>
+    >({
+      format: "test",
+      encode: ({ message }) => message,
+      decode: ({ parent_id, content }) => ({
+        parentId: parent_id,
+        message: content as { id: string },
+      }),
+      getId: (message) => message.id,
+    });
+
+    formatted.pin!();
+    await formatted.load();
+    await formatted.update!({ parentId: null, message: { id: "m1" } }, "m1");
+
+    expect(cloud.threads.messages.update).toHaveBeenCalledWith(
+      "thread-split",
+      "m1",
+      expect.anything(),
+    );
+  });
 });

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

@@ -69,7 +69,12 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
     if (!live.source) return undefined;
     const id = live.getState().id;
     if (id === undefined) return undefined;
-    return this.aui.threads.item({ id });
+    // A body can resolve before the list's committed items include its
+    // thread; the live item is already the per-thread anchor in that window.
+    const listed = this.aui.threads
+      .getState()
+      .threadItems.some((item) => item.id === id || item.remoteId === id);
+    return listed ? this.aui.threads.item({ id }) : live;
   }
 
   withFormat<TMessage, TStorageFormat extends Record<string, unknown>>(
@@ -83,8 +88,6 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
       return threadListItem;
     };
     const resolvePinned = () => threadListItem ?? pinCurrent();
-    const getFormatted = () =>
-      createFormattedPersistence(adapter._persistence, formatAdapter);
     const getTargetFormatted = (item: CloudThreadListItem) =>
       createFormattedPersistence(adapter.getPersistence(item), formatAdapter);
     return {
@@ -135,11 +138,14 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
         );
       },
       async load(): Promise<MessageFormatRepository<TMessage>> {
-        pinCurrent();
+        // Loads re-pin and resolve through the pinned item, so the id mapping
+        // they populate lives on the same persistence instance later writes
+        // resolve, whichever of the list item or the live graft won the pin.
+        const pinned = pinCurrent();
         const live = adapter.aui.threadListItem;
         const remoteId = live.source ? live.getState().remoteId : undefined;
         if (!remoteId) return { messages: [] };
-        return getFormatted().load(remoteId);
+        return getTargetFormatted(pinned ?? live).load(remoteId);
       },
     };
   }
@@ -358,14 +364,7 @@ export function extractAuiV0<T>(content: T): TelemetryData | null {
     }[];
     metadata?: {
       modelId?: string;
-      steps?: readonly {
-        usage?: {
-          inputTokens?: number;
-          outputTokens?: number;
-          reasoningTokens?: number;
-          cachedInputTokens?: number;
-        };
-      }[];
+      steps?: readonly { usage?: RunTelemetryUsageInit }[];
       custom?: Record<string, unknown> & { modelId?: string };
     };
   };
@@ -408,20 +407,23 @@ export function extractAuiV0<T>(content: T): TelemetryData | null {
     let hasReasoning = false;
     let hasCachedInput = false;
     for (const step of steps) {
-      if (step.usage?.inputTokens != null) {
-        totalInput += step.usage.inputTokens;
+      if (!step.usage) continue;
+      const usage = normalizeRunTelemetryUsage(step.usage);
+      if (!usage) continue;
+      if (usage.inputTokens != null) {
+        totalInput += usage.inputTokens;
         hasInput = true;
       }
-      if (step.usage?.outputTokens != null) {
-        totalOutput += step.usage.outputTokens;
+      if (usage.outputTokens != null) {
+        totalOutput += usage.outputTokens;
         hasOutput = true;
       }
-      if (step.usage?.reasoningTokens != null) {
-        totalReasoning += step.usage.reasoningTokens;
+      if (usage.reasoningTokens != null) {
+        totalReasoning += usage.reasoningTokens;
         hasReasoning = true;
       }
-      if (step.usage?.cachedInputTokens != null) {
-        totalCachedInput += step.usage.cachedInputTokens;
+      if (usage.cachedInputTokens != null) {
+        totalCachedInput += usage.cachedInputTokens;
         hasCachedInput = true;
       }
     }
@@ -444,20 +446,25 @@ export function extractAuiV0<T>(content: T): TelemetryData | null {
 
   const telemetrySteps: TelemetryStepData[] | undefined =
     steps && steps.length > 1
-      ? steps.map((s) => ({
-          ...(s.usage?.inputTokens != null
-            ? { input_tokens: s.usage.inputTokens }
-            : undefined),
-          ...(s.usage?.outputTokens != null
-            ? { output_tokens: s.usage.outputTokens }
-            : undefined),
-          ...(s.usage?.reasoningTokens != null
-            ? { reasoning_tokens: s.usage.reasoningTokens }
-            : undefined),
-          ...(s.usage?.cachedInputTokens != null
-            ? { cached_input_tokens: s.usage.cachedInputTokens }
-            : undefined),
-        }))
+      ? steps.map((s) => {
+          const usage = s.usage
+            ? normalizeRunTelemetryUsage(s.usage)
+            : undefined;
+          return {
+            ...(usage?.inputTokens != null
+              ? { input_tokens: usage.inputTokens }
+              : undefined),
+            ...(usage?.outputTokens != null
+              ? { output_tokens: usage.outputTokens }
+              : undefined),
+            ...(usage?.reasoningTokens != null
+              ? { reasoning_tokens: usage.reasoningTokens }
+              : undefined),
+            ...(usage?.cachedInputTokens != null
+              ? { cached_input_tokens: usage.cachedInputTokens }
+              : undefined),
+          };
+        })
       : undefined;
 
   return {

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

@@ -2,6 +2,7 @@ import type {
   MessageStatus,
   SourceProviderMetadata,
   ThreadMessage,
+  ToolApprovalDisplay,
   ToolApprovalOption,
 } from "../../../types/message";
 import type { CompleteAttachment } from "../../../types/attachment";
@@ -16,11 +17,15 @@ import type { ExportedMessageRepositoryItem } from "../../../runtime/utils/messa
 
 type AuiV0ToolApproval = {
   readonly id: string;
+  readonly prompt?: string;
+  readonly display?: ToolApprovalDisplay;
+  readonly allowFreeform?: boolean;
   readonly approved?: boolean;
   readonly reason?: string;
   readonly isAutomatic?: boolean;
   readonly options?: readonly ToolApprovalOption[];
   readonly optionId?: string;
+  readonly text?: string;
   readonly resolution?: "cancelled" | "expired";
 };
 

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

@@ -0,0 +1,88 @@
+// @vitest-environment jsdom
+
+import { describe, expect, it, vi } from "vitest";
+import { renderHook } from "@testing-library/react";
+import type { AssistantCloud } from "assistant-cloud";
+import { createCloudThreadListAdapter } from "./createCloudThreadListAdapter";
+
+const makeCloud = () =>
+  ({
+    threads: {
+      list: vi.fn(async () => ({ threads: [] })),
+      create: vi.fn(async () => ({ thread_id: "remote-1" })),
+      update: vi.fn(async () => {}),
+      delete: vi.fn(async () => {}),
+      get: vi.fn(),
+    },
+    runs: { stream: vi.fn(async () => new ReadableStream()) },
+  }) as unknown as AssistantCloud;
+
+describe("createCloudThreadListAdapter", () => {
+  it("falls back to an in-memory list without a cloud instance", async () => {
+    const create = vi.fn(async () => ({ externalId: "ext-1" }));
+    const adapter = createCloudThreadListAdapter({ create });
+    expect(await adapter.list()).toEqual({ threads: [] });
+    expect(await adapter.initialize("local-1")).toEqual({
+      remoteId: "local-1",
+      externalId: "ext-1",
+    });
+    expect(create).toHaveBeenCalledOnce();
+  });
+
+  it("maps the cloud api and reads callbacks through the getter", async () => {
+    const cloud = makeCloud();
+    const options: {
+      cloud: AssistantCloud;
+      delete?: (threadId: string) => Promise<void>;
+    } = { cloud };
+    const adapter = createCloudThreadListAdapter(() => options);
+
+    await adapter.list();
+    expect(cloud.threads.list).toHaveBeenCalledTimes(2);
+
+    expect(await adapter.initialize("local-1")).toEqual({
+      remoteId: "remote-1",
+      externalId: undefined,
+    });
+
+    await adapter.rename("remote-1", "Renamed");
+    expect(cloud.threads.update).toHaveBeenCalledWith("remote-1", {
+      title: "Renamed",
+    });
+    await adapter.archive("remote-1");
+    expect(cloud.threads.update).toHaveBeenCalledWith("remote-1", {
+      is_archived: true,
+    });
+    await adapter.unarchive("remote-1");
+    expect(cloud.threads.update).toHaveBeenCalledWith("remote-1", {
+      is_archived: false,
+    });
+
+    const onDelete = vi.fn(async () => {});
+    options.delete = onDelete;
+    await adapter.delete("remote-1");
+    expect(onDelete).toHaveBeenCalledWith("remote-1");
+    expect(cloud.threads.delete).toHaveBeenCalledWith("remote-1");
+
+    expect(adapter.unstable_useAdapters).toBeTypeOf("function");
+    expect(adapter.unstable_Provider).toBeUndefined();
+  });
+
+  it("constructs stable history and attachment adapters when the hook runs", () => {
+    const cloud = makeCloud();
+    const adapter = createCloudThreadListAdapter({ cloud });
+    const { result, rerender } = renderHook(() =>
+      adapter.unstable_useAdapters!(),
+    );
+    const first = result.current!;
+    expect(first.history).toBeDefined();
+    expect((first.history as { withFormat?: unknown }).withFormat).toBeTypeOf(
+      "function",
+    );
+    expect(first.attachments).toBeDefined();
+
+    rerender();
+    expect(result.current!.history).toBe(first.history);
+    expect(result.current!.attachments).toBe(first.attachments);
+  });
+});