@assistant-ui/core 0.3.16 → 0.3.18

package/src/react/runtimes/RemoteThreadResource.ts

@@ -3,6 +3,7 @@ import { resource } from "@assistant-ui/tap";
 import {
   useAssistantContextProvider,
   useConfiguredAui,
+  useDestroySignalProvider,
 } from "@assistant-ui/store/client";
 import { ThreadListItemClient } from "../../store/internal";
 import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
@@ -22,6 +23,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;
 
@@ -37,21 +39,20 @@ export type RemoteThreadResourceProps = {
     runtime: ThreadRuntimeCore,
     generation: number,
   ) => void;
+  destroySignal: AbortSignal;
 };
 
-export const isTitleSourceMessage = (message: {
-  status?: { type: string } | undefined;
-}) => message.status?.type !== "running";
-
 export const subscribeToTitleGeneration = (
   threadRuntime: AssistantRuntime["thread"],
   itemRuntime: ThreadListItemRuntime,
 ) => {
   const generate = () =>
-    void itemRuntime.generateTitle().catch((error: unknown) => {
-      if (isSilentRuntimeAction(error)) return;
-      console.error("[assistant-ui] Thread title generation failed", error);
-    });
+    void itemRuntime
+      .generateTitle({ automatic: true })
+      .catch((error: unknown) => {
+        if (isSilentRuntimeAction(error)) return;
+        console.error("[assistant-ui] Thread title generation failed", error);
+      });
 
   const hasTitleSource = () =>
     threadRuntime.getState().messages.some(isTitleSourceMessage);
@@ -181,6 +182,7 @@ const useRemoteThreadResource = ({
   parentClient,
   adapters,
   publish,
+  destroySignal,
 }: RemoteThreadResourceProps) => {
   const itemRuntime = useMemo(
     () =>
@@ -217,14 +219,16 @@ const useRemoteThreadResource = ({
     threadListItem: ThreadListItemClient({ runtime: itemRuntime }),
   });
 
-  return useAssistantContextProvider(client, function useThreadClient() {
-    return useRuntimeAdaptersProvider(adapters, function useBoundRuntime() {
-      return useRemoteThreadBinder({
-        threadId,
-        generation,
-        runtimeHook,
-        publish,
-        itemRuntime,
+  return useDestroySignalProvider(destroySignal, function useOwnedThread() {
+    return useAssistantContextProvider(client, function useThreadClient() {
+      return useRuntimeAdaptersProvider(adapters, function useBoundRuntime() {
+        return useRemoteThreadBinder({
+          threadId,
+          generation,
+          runtimeHook,
+          publish,
+          itemRuntime,
+        });
       });
     });
   });

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,
+      },
+    ]);
+  });
 });