@assistant-ui/core 0.3.15 → 0.3.16

package/src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx

@@ -1,5 +1,4 @@
 import type { ThreadListRuntimeCore } from "../../runtime/interfaces/thread-list-runtime-core";
-import { generateId } from "../../utils/id";
 import { BaseSubscribable } from "../../subscribable/subscribable";
 import { OptimisticState } from "../../runtimes/remote-thread-list/optimistic-state";
 import { EMPTY_THREAD_CORE } from "../../runtimes/remote-thread-list/empty-thread-core";
@@ -9,10 +8,14 @@ import type {
 } from "../../runtimes/remote-thread-list/remote-thread-state";
 import {
   classifyThreads,
+  createEmptyRemoteThreadState,
   createThreadMappingId,
   getThreadData,
   normalizeCursor,
   updateStatusReducer,
+  preserveMidLoadTransitions,
+  seedNewThread,
+  statusSnapshot,
 } from "../../runtimes/remote-thread-list/remote-thread-state";
 import type {
   RemoteThreadListAdapter,
@@ -49,47 +52,7 @@ const threadStatusError = (
     `Thread "${threadIdOrRemoteId}" has status "${status}", so it cannot ${action}.`,
   );
 
-const EMPTY_REMOTE_STATE: RemoteThreadState = {
-  isLoading: true,
-  isLoadingMore: false,
-  cursor: undefined,
-  newThreadId: undefined,
-  threadIds: [],
-  archivedThreadIds: [],
-  threadIdMap: {},
-  threadData: {},
-};
-
-const addNewThread = (state: RemoteThreadState) => {
-  let id: string;
-  do {
-    id = `__LOCALID_${generateId()}`;
-  } while (state.threadIdMap[id]);
-
-  const mappingId = createThreadMappingId(id);
-  return {
-    id,
-    state: {
-      ...state,
-      newThreadId: id,
-      threadIdMap: {
-        ...state.threadIdMap,
-        [id]: mappingId,
-      },
-      threadData: {
-        ...state.threadData,
-        [mappingId]: {
-          status: "new",
-          id,
-          remoteId: undefined,
-          externalId: undefined,
-          title: undefined,
-          custom: undefined,
-        } satisfies RemoteThreadData,
-      },
-    },
-  };
-};
+const EMPTY_REMOTE_STATE = createEmptyRemoteThreadState();
 
 export class RemoteThreadListThreadListRuntimeCore
   extends BaseSubscribable
@@ -158,6 +121,7 @@ export class RemoteThreadListThreadListRuntimeCore
     if (!this._loadThreadsPromise) {
       const generation = this._loadGeneration;
       let replacedList = false;
+      const statusAtRequest = statusSnapshot(this._state.baseValue);
       this._loadThreadsPromise = this._state
         .optimisticUpdate({
           execute: () => this._options.adapter.list(),
@@ -186,7 +150,7 @@ export class RemoteThreadListThreadListRuntimeCore
               threadIdMap: {},
               threadData: {},
             });
-            return {
+            const merged = {
               ...state,
               isLoading: false,
               cursor: normalizeCursor(l.nextCursor),
@@ -195,6 +159,7 @@ export class RemoteThreadListThreadListRuntimeCore
               threadIdMap: { ...state.threadIdMap, ...fresh.threadIdMap },
               threadData: { ...state.threadData, ...fresh.threadData },
             };
+            return preserveMidLoadTransitions(merged, state, statusAtRequest);
           },
         })
         .catch((error: unknown) => {
@@ -437,7 +402,7 @@ export class RemoteThreadListThreadListRuntimeCore
       if (preservedDraft !== undefined) {
         this._mainThreadId = preservedDraft;
       } else {
-        const seeded = addNewThread(nextState);
+        const seeded = seedNewThread(nextState);
         this._mainThreadId = seeded.id;
         nextState = seeded.state;
       }
@@ -762,7 +727,7 @@ export class RemoteThreadListThreadListRuntimeCore
     const state = this._state.baseValue;
     let id: string | undefined = this._state.value.newThreadId;
     if (id === undefined) {
-      const next = addNewThread(state);
+      const next = seedNewThread(state);
       id = next.id;
       this._state.update(next.state);
     }
@@ -857,17 +822,22 @@ export class RemoteThreadListThreadListRuntimeCore
     for await (const result of messageStream) {
       if (adapterGeneration !== this._adapterGeneration) return;
       const newTitle = result.parts.filter((c) => c.type === "text")[0]?.text;
-      const state = this._state.baseValue;
-      const currentData = getThreadData(state, data.id);
-      if (!currentData) continue;
-      this._state.update({
-        ...state,
-        threadData: {
-          ...state.threadData,
-          [currentData.id]: {
-            ...currentData,
-            title: newTitle,
-          },
+      await this._state.optimisticUpdate({
+        execute: async () => {},
+        optimistic: (state) => {
+          if (adapterGeneration !== this._adapterGeneration) return state;
+          const currentData = getThreadData(state, data.id);
+          if (!currentData) return state;
+          return {
+            ...state,
+            threadData: {
+              ...state.threadData,
+              [currentData.id]: {
+                ...currentData,
+                title: newTitle,
+              },
+            },
+          };
         },
       });
     }

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

@@ -1,4 +1,5 @@
 import { useCallback, useEffect, useRef, useState } from "react";
+import { invokeUserCallback } from "../../../utils/invoke-user-callback";
 import { useLatestRef } from "./useLatestRef";
 
 export type RunManager = Readonly<{
@@ -11,25 +12,11 @@ const disposeReason = Symbol("assistant-transport-dispose");
 
 type LifecycleCallbackName = "onCancel" | "onError" | "onFinish";
 
-const reportCallbackError = (name: LifecycleCallbackName, error: unknown) => {
-  console.error(
-    `[assistant-ui] Assistant transport ${name} callback threw an error`,
-    error,
-  );
-};
-
-const invokeCallback = async (
+const invokeCallback = (
   name: LifecycleCallbackName,
   callback: (() => unknown) | undefined,
-): Promise<void> => {
-  try {
-    await callback?.();
-  } catch (error) {
-    try {
-      reportCallbackError(name, error);
-    } catch {}
-  }
-};
+) =>
+  invokeUserCallback("assistant-ui", `Assistant transport ${name}`, callback);
 
 export function useRunManager(config: {
   onRun: (signal: AbortSignal) => Promise<void>;

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

@@ -188,6 +188,98 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
     );
   });
 
+  it("reports frontend and MCP sources for ai-sdk/v6 tool calls", () => {
+    mocks.aui = mocks.makeClient("thread-1");
+    const cloud = makeCloud();
+    const cloudRef = { current: cloud };
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter(cloudRef),
+    );
+    const formatted = result.current.withFormat({
+      format: "ai-sdk/v6",
+      encode: ({ message }) => message,
+      decode: ({ parent_id, content }) => ({
+        parentId: parent_id,
+        message: content as { id: string },
+      }),
+      getId: (message: { id: string }) => message.id,
+    });
+
+    formatted.reportTelemetry([
+      {
+        parentId: null,
+        message: {
+          id: "message-1",
+          role: "assistant",
+          parts: [
+            { type: "step-start" },
+            {
+              type: "tool-search",
+              toolCallId: "static-1",
+              input: { query: "test" },
+              output: { result: "ok" },
+            },
+            {
+              type: "dynamic-tool",
+              toolName: "mcp-search",
+              toolCallId: "dynamic-1",
+              input: { query: "test" },
+              output: { result: "ok" },
+            },
+            { type: "step-start" },
+            {
+              type: "tool-search",
+              toolCallId: "static-2",
+              input: { query: "again" },
+              output: { result: "ok" },
+            },
+          ],
+        },
+      },
+    ]);
+
+    expect(cloud.runs.report).toHaveBeenCalledWith(
+      expect.objectContaining({
+        tool_calls: [
+          expect.objectContaining({
+            tool_call_id: "static-1",
+            tool_source: "frontend",
+          }),
+          expect.objectContaining({
+            tool_call_id: "dynamic-1",
+            tool_source: "mcp",
+          }),
+          expect.objectContaining({
+            tool_call_id: "static-2",
+            tool_source: "frontend",
+          }),
+        ],
+        steps: [
+          {
+            tool_calls: [
+              expect.objectContaining({
+                tool_call_id: "static-1",
+                tool_source: "frontend",
+              }),
+              expect.objectContaining({
+                tool_call_id: "dynamic-1",
+                tool_source: "mcp",
+              }),
+            ],
+          },
+          {
+            tool_calls: [
+              expect.objectContaining({
+                tool_call_id: "static-2",
+                tool_source: "frontend",
+              }),
+            ],
+          },
+        ],
+      }),
+    );
+  });
+
   it("initializes the pinned item instead of the new main thread", async () => {
     mocks.aui = mocks.makeClient(undefined, "new-thread", "thread-1");
     const cloud = makeCloud();

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

@@ -9,8 +9,13 @@ import type {
 import type { ExportedMessageRepositoryItem } from "../../../runtime/utils/message-repository";
 import {
   type AssistantCloud,
+  type AssistantCloudRunReportToolCall,
   CloudMessagePersistence,
   createFormattedPersistence,
+  createRunTelemetryToolCall,
+  normalizeRunTelemetryUsage,
+  type RunTelemetryUsageInit,
+  truncateRunTelemetryText,
 } from "assistant-cloud";
 import { auiV0Decode, auiV0Encode } from "./auiV0";
 import { type AssistantClient, getClientId, useAui } from "@assistant-ui/store";
@@ -268,85 +273,12 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
   }
 }
 
-const MAX_SPAN_CONTENT = 50_000;
-
-function truncateStr(value: string): string {
-  if (value.length <= MAX_SPAN_CONTENT) return value;
-  return value.slice(0, MAX_SPAN_CONTENT);
-}
-
-function safeStringify(value: unknown): string | undefined {
-  if (value == null) return undefined;
-  try {
-    return truncateStr(JSON.stringify(value));
-  } catch {
-    return undefined;
-  }
-}
-
-type TelemetryToolCall = {
-  tool_name: string;
-  tool_call_id: string;
-  tool_args?: string;
-  tool_result?: string;
-  tool_source?: "mcp" | "frontend" | "backend";
-};
-
-const BASE64_PATTERN = /^[A-Za-z0-9+/]{100,}={0,2}$/;
-
-function summarizeMcpResult(value: unknown): string | undefined {
-  if (value == null) return undefined;
-  try {
-    const parsed = typeof value === "string" ? JSON.parse(value) : value;
-    if (Array.isArray(parsed)) {
-      const summarized = parsed.map((item) => {
-        if (item && typeof item === "object" && item.type) {
-          if (
-            (item.type === "image" || item.type === "audio") &&
-            typeof item.data === "string" &&
-            BASE64_PATTERN.test(item.data.slice(0, 200))
-          ) {
-            const sizeKB = ((item.data.length * 3) / 4 / 1024).toFixed(1);
-            return { ...item, data: `[${item.type}: ${sizeKB}KB]` };
-          }
-        }
-        return item;
-      });
-      return truncateStr(JSON.stringify(summarized));
-    }
-  } catch {
-    // not JSON array, fall through
-  }
-  return safeStringify(value);
-}
-
-function buildToolCall(
-  toolName: string,
-  toolCallId: string,
-  args: unknown,
-  result: unknown,
-  argsText?: string,
-  toolSource?: "mcp" | "frontend" | "backend",
-): TelemetryToolCall {
-  const call: TelemetryToolCall = {
-    tool_name: toolName,
-    tool_call_id: toolCallId,
-  };
-  const toolArgs = argsText ?? safeStringify(args);
-  if (toolArgs !== undefined) call.tool_args = toolArgs;
-  const toolResult =
-    toolSource === "mcp" ? summarizeMcpResult(result) : safeStringify(result);
-  if (toolResult !== undefined) call.tool_result = toolResult;
-  if (toolSource) call.tool_source = toolSource;
-  return call;
-}
-
 type TelemetryStepData = {
   input_tokens?: number;
   output_tokens?: number;
   reasoning_tokens?: number;
   cached_input_tokens?: number;
-  tool_calls?: TelemetryToolCall[];
+  tool_calls?: AssistantCloudRunReportToolCall[];
   start_ms?: number;
   end_ms?: number;
 };
@@ -369,7 +301,7 @@ function mergeStepTimestamps(
 
 type TelemetryData = {
   status: "completed" | "incomplete" | "error";
-  toolCalls?: TelemetryToolCall[];
+  toolCalls?: AssistantCloudRunReportToolCall[];
   totalSteps?: number;
   inputTokens?: number;
   outputTokens?: number;
@@ -446,13 +378,19 @@ export function extractAuiV0<T>(content: T): TelemetryData | null {
   const toolCalls = msg.content
     ?.filter((p) => p.type === "tool-call" && p.toolName && p.toolCallId)
     .map((p) =>
-      buildToolCall(p.toolName!, p.toolCallId!, p.args, p.result, p.argsText),
+      createRunTelemetryToolCall({
+        toolName: p.toolName!,
+        toolCallId: p.toolCallId!,
+        args: p.args,
+        result: p.result,
+        argsText: p.argsText,
+      }),
     );
 
   const textParts = msg.content?.filter((p) => p.type === "text" && p.text);
   const outputText =
     textParts && textParts.length > 0
-      ? truncateStr(textParts.map((p) => p.text).join(""))
+      ? truncateRunTelemetryText(textParts.map((p) => p.text).join(""))
       : undefined;
 
   const steps = msg.metadata?.steps;
@@ -564,29 +502,28 @@ function isDynamicToolPart(p: AiSdkV6Part): boolean {
   return p.type === "dynamic-tool" || p.type.startsWith("dynamic-tool-");
 }
 
-function partToToolCall(p: AiSdkV6Part): TelemetryToolCall {
-  const toolSource: "mcp" | undefined = isDynamicToolPart(p)
+function partToToolCall(p: AiSdkV6Part): AssistantCloudRunReportToolCall {
+  const toolSource: "mcp" | "frontend" = isDynamicToolPart(p)
     ? "mcp"
-    : undefined;
-  return buildToolCall(
-    p.toolName ?? p.type.slice(5),
-    p.toolCallId!,
-    p.args ?? p.input,
-    p.result ?? p.output,
-    undefined,
+    : "frontend";
+  return createRunTelemetryToolCall({
+    toolName: p.toolName ?? p.type.slice(5),
+    toolCallId: p.toolCallId!,
+    args: p.args ?? p.input,
+    result: p.result ?? p.output,
     toolSource,
-  );
+  });
 }
 
 function collectAiSdkV6Parts(parts: readonly AiSdkV6Part[]): {
   textParts: string[];
-  toolCalls: TelemetryToolCall[];
-  stepsData: { tool_calls: TelemetryToolCall[] }[];
+  toolCalls: AssistantCloudRunReportToolCall[];
+  stepsData: { tool_calls: AssistantCloudRunReportToolCall[] }[];
 } {
   const textParts: string[] = [];
-  const toolCalls: TelemetryToolCall[] = [];
-  const stepsData: { tool_calls: TelemetryToolCall[] }[] = [];
-  let currentStepToolCalls: TelemetryToolCall[] | null = null;
+  const toolCalls: AssistantCloudRunReportToolCall[] = [];
+  const stepsData: { tool_calls: AssistantCloudRunReportToolCall[] }[] = [];
+  let currentStepToolCalls: AssistantCloudRunReportToolCall[] | null = null;
 
   for (const p of parts) {
     if (p.type === "step-start") {
@@ -624,10 +561,10 @@ function extractModelId(
 
 function buildAiSdkV6Result(
   textParts: string[],
-  toolCalls: TelemetryToolCall[],
+  toolCalls: AssistantCloudRunReportToolCall[],
   totalSteps: number,
   metadata?: Record<string, unknown>,
-  stepsData?: { tool_calls: TelemetryToolCall[] }[],
+  stepsData?: { tool_calls: AssistantCloudRunReportToolCall[] }[],
   usage?: {
     inputTokens?: number;
     outputTokens?: number;
@@ -636,7 +573,9 @@ function buildAiSdkV6Result(
   },
 ): TelemetryData {
   const hasText = textParts.length > 0;
-  const outputText = hasText ? truncateStr(textParts.join("")) : undefined;
+  const outputText = hasText
+    ? truncateRunTelemetryText(textParts.join(""))
+    : undefined;
   const modelId = extractModelId(metadata);
 
   const steps: TelemetryStepData[] | undefined =
@@ -671,46 +610,6 @@ function buildAiSdkV6Result(
   };
 }
 
-type UsageFields = {
-  inputTokens?: number;
-  outputTokens?: number;
-  promptTokens?: number;
-  completionTokens?: number;
-  reasoningTokens?: number;
-  cachedInputTokens?: number;
-};
-
-function normalizeUsage(u: UsageFields):
-  | {
-      inputTokens?: number;
-      outputTokens?: number;
-      reasoningTokens?: number;
-      cachedInputTokens?: number;
-    }
-  | undefined {
-  const input = u.inputTokens ?? u.promptTokens;
-  const output = u.outputTokens ?? u.completionTokens;
-  if (
-    input == null &&
-    output == null &&
-    u.reasoningTokens == null &&
-    u.cachedInputTokens == null
-  ) {
-    return undefined;
-  }
-
-  return {
-    ...(input != null ? { inputTokens: input } : undefined),
-    ...(output != null ? { outputTokens: output } : undefined),
-    ...(u.reasoningTokens != null
-      ? { reasoningTokens: u.reasoningTokens }
-      : undefined),
-    ...(u.cachedInputTokens != null
-      ? { cachedInputTokens: u.cachedInputTokens }
-      : undefined),
-  };
-}
-
 function extractAiSdkV6Usage(metadata?: Record<string, unknown>):
   | {
       inputTokens?: number;
@@ -720,15 +619,15 @@ function extractAiSdkV6Usage(metadata?: Record<string, unknown>):
     }
   | undefined {
   // Try top-level metadata.usage
-  const usage = metadata?.usage as UsageFields | undefined;
+  const usage = metadata?.usage as RunTelemetryUsageInit | undefined;
   if (usage) {
-    const normalized = normalizeUsage(usage);
+    const normalized = normalizeRunTelemetryUsage(usage);
     if (normalized) return normalized;
   }
 
   // Try aggregating from metadata.steps[].usage
   const steps = metadata?.steps as
-    | readonly { usage?: UsageFields }[]
+    | readonly { usage?: RunTelemetryUsageInit }[]
     | undefined;
   if (steps && steps.length > 0) {
     let inputTokens = 0;
@@ -742,7 +641,7 @@ function extractAiSdkV6Usage(metadata?: Record<string, unknown>):
     let hasAny = false;
     for (const s of steps) {
       if (!s.usage) continue;
-      const n = normalizeUsage(s.usage);
+      const n = normalizeRunTelemetryUsage(s.usage);
       if (n) {
         if (n.inputTokens != null) {
           inputTokens += n.inputTokens;
@@ -795,8 +694,8 @@ function extractAiSdkV6<T>(content: T): TelemetryData | null {
 
 function aggregateAiSdkV6RunSteps<T>(stepMessages: T[]): TelemetryData | null {
   const allTextParts: string[] = [];
-  const allToolCalls: TelemetryToolCall[] = [];
-  const allStepsData: { tool_calls: TelemetryToolCall[] }[] = [];
+  const allToolCalls: AssistantCloudRunReportToolCall[] = [];
+  const allStepsData: { tool_calls: AssistantCloudRunReportToolCall[] }[] = [];
   let hasAssistant = false;
   let metadata: Record<string, unknown> | undefined;
   let inputTokens = 0;

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

@@ -0,0 +1,37 @@
+import { describe, expect, it, vi } from "vitest";
+import { createCloudThreadListAdapterCreateFallback } from "./createCloudThreadListAdapterCreateFallback";
+
+describe("createCloudThreadListAdapterCreateFallback", () => {
+  it("prefers the custom create function", async () => {
+    const create = vi.fn().mockResolvedValue({ externalId: "custom" });
+    const initialize = vi.fn().mockResolvedValue({ externalId: "nested" });
+    const fallback = createCloudThreadListAdapterCreateFallback(create, {
+      source: {},
+      initialize,
+    });
+
+    await expect(fallback()).resolves.toEqual({ externalId: "custom" });
+    expect(initialize).not.toHaveBeenCalled();
+  });
+
+  it("initializes a sourced thread list item", async () => {
+    const result = { externalId: "nested" };
+    const fallback = createCloudThreadListAdapterCreateFallback(undefined, {
+      source: {},
+      initialize: vi.fn().mockResolvedValue(result),
+    });
+
+    await expect(fallback()).resolves.toBe(result);
+  });
+
+  it("falls back to an undefined external ID", async () => {
+    const initialize = vi.fn();
+    const fallback = createCloudThreadListAdapterCreateFallback(undefined, {
+      source: null,
+      initialize,
+    });
+
+    await expect(fallback()).resolves.toEqual({ externalId: undefined });
+    expect(initialize).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,18 @@
+type ThreadData = {
+  externalId: string | undefined;
+};
+
+type ThreadListItem = {
+  source: unknown;
+  initialize: () => Promise<ThreadData>;
+};
+
+export const createCloudThreadListAdapterCreateFallback = (
+  create: (() => Promise<ThreadData>) | undefined,
+  threadListItem: ThreadListItem,
+): (() => Promise<ThreadData>) =>
+  async function createThread() {
+    if (create) return create();
+    if (threadListItem.source) return threadListItem.initialize();
+    return { externalId: undefined };
+  };

package/src/react/runtimes/external-message-converter.test.ts

@@ -542,19 +542,5 @@ describe("convertExternalMessages", () => {
         convertExternalMessages(messages, callback, false, {}),
       ).toThrowError(/returned an invalid message \(\{"role":"user"\}\)/);
     });
-
-    it("tolerates a tool message without toolCallId as an orphaned tool result", () => {
-      const messages = [{ id: "m1", role: "user" as const, content: "hi" }];
-      const callback = ((msg: (typeof messages)[number]) => [
-        msg,
-        { role: "tool", result: "ok" },
-      ]) as unknown as useExternalMessageConverter.Callback<
-        (typeof messages)[number]
-      >;
-
-      const result = convertExternalMessages(messages, callback, false, {});
-      expect(result[0]!.role).toBe("user");
-      expect(result[1]!.content).toHaveLength(0);
-    });
   });
 });