@assistant-ui/core 0.3.14 → 0.3.16

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

@@ -4,6 +4,7 @@ import { act, render, waitFor } from "@testing-library/react";
 import type { FC } from "react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { useAui } from "@assistant-ui/store";
+import { ToolResponse } from "assistant-stream";
 import { AssistantRuntimeProvider } from "../../AssistantRuntimeProvider";
 import {
   useAssistantTransportRuntime,
@@ -145,6 +146,63 @@ afterEach(() => {
 });
 
 describe("useAssistantTransportRuntime", () => {
+  it.each([false, 0, "", null])(
+    "preserves the falsy tool artifact %j",
+    async (artifact) => {
+      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: { custom: {} },
+            },
+          ],
+          isRunning: meta.isSending,
+        }),
+      });
+
+      await waitFor(() =>
+        expect(
+          aui()
+            .thread.message({ id: "a1" })
+            .part({ toolCallId: "tc1" })
+            .getState().type,
+        ).toBe("tool-call"),
+      );
+
+      act(() => {
+        aui()
+          .thread.message({ id: "a1" })
+          .part({ toolCallId: "tc1" })
+          .addToolResult(new ToolResponse({ result: "ok", artifact }));
+      });
+
+      await waitFor(() => expect(fetchMock.requests).toHaveLength(1));
+      expect(fetchMock.requests[0]!.body["commands"][0]).toHaveProperty(
+        "artifact",
+        artifact,
+      );
+
+      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/assistant-transport/useAssistantTransportRuntime.ts

@@ -447,7 +447,9 @@ const useAssistantTransportThreadRuntime = <T>(
         result: toolOptions.result as ReadonlyJSONObject,
         toolName: toolOptions.toolName,
         isError: toolOptions.isError,
-        ...(toolOptions.artifact && { artifact: toolOptions.artifact }),
+        ...(toolOptions.artifact !== undefined && {
+          artifact: toolOptions.artifact,
+        }),
         ...(toolOptions.modelContent !== undefined && {
           modelContent: toolOptions.modelContent,
         }),

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/cloud/useCloudThreadListAdapter.test.tsx

@@ -19,7 +19,38 @@ const makeThread = (id: string) => ({
 });
 
 describe("useCloudThreadListAdapter", () => {
-  it("exposes full Cloud pages through the remote thread cursor", async () => {
+  it("loads archived Cloud threads alongside regular threads", async () => {
+    const activeThreads = [makeThread("active-1")];
+    const archivedThreads = [
+      { ...makeThread("archived-1"), is_archived: true },
+    ];
+    const list = vi
+      .fn()
+      .mockResolvedValueOnce({ threads: activeThreads })
+      .mockResolvedValueOnce({ threads: archivedThreads });
+    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
+
+    const page = await result.current.list();
+
+    expect(list).toHaveBeenNthCalledWith(1, { limit: 20 });
+    expect(list).toHaveBeenNthCalledWith(2, {
+      is_archived: true,
+      limit: 20,
+    });
+    expect(page.threads.map((thread) => thread.remoteId)).toEqual([
+      "active-1",
+      "archived-1",
+    ]);
+    expect(
+      page.threads.find((thread) => thread.remoteId === "active-1")?.status,
+    ).toBe("regular");
+    expect(
+      page.threads.find((thread) => thread.remoteId === "archived-1")?.status,
+    ).toBe("archived");
+  });
+
+  it("continues the active list once the archived list is exhausted", async () => {
     const firstPage = Array.from({ length: 20 }, (_, index) =>
       makeThread(`thread-${index + 1}`),
     );
@@ -27,17 +58,20 @@ describe("useCloudThreadListAdapter", () => {
     const list = vi
       .fn()
       .mockResolvedValueOnce({ threads: firstPage })
+      .mockResolvedValueOnce({ threads: [] })
       .mockResolvedValueOnce({ threads: secondPage });
     const cloud = { threads: { list } } as unknown as AssistantCloud;
     const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
 
     const first = await result.current.list();
     expect(list).toHaveBeenNthCalledWith(1, { limit: 20 });
+    expect(list).toHaveBeenNthCalledWith(2, { is_archived: true, limit: 20 });
     expect(first.threads).toHaveLength(20);
-    expect(first.nextCursor).toBe("thread-20");
+    expect(JSON.parse(first.nextCursor!)).toEqual({ a: "thread-20", re: true });
 
     const second = await result.current.list({ after: first.nextCursor });
-    expect(list).toHaveBeenNthCalledWith(2, {
+    expect(list).toHaveBeenCalledTimes(3);
+    expect(list).toHaveBeenNthCalledWith(3, {
       limit: 20,
       after: "thread-20",
     });
@@ -46,4 +80,65 @@ describe("useCloudThreadListAdapter", () => {
     ]);
     expect(second.nextCursor).toBeUndefined();
   });
+
+  it("paginates both legs without dropping or duplicating items", async () => {
+    const activePage1 = Array.from({ length: 20 }, (_, index) =>
+      makeThread(`a-${index + 1}`),
+    );
+    const archivedPage1 = Array.from({ length: 20 }, (_, index) => ({
+      ...makeThread(`r-${index + 1}`),
+      is_archived: true,
+    }));
+    const activePage2 = [makeThread("a-21")];
+    const archivedPage2 = [{ ...makeThread("r-21"), is_archived: true }];
+    const list = vi
+      .fn()
+      .mockResolvedValueOnce({ threads: activePage1 })
+      .mockResolvedValueOnce({ threads: archivedPage1 })
+      .mockResolvedValueOnce({ threads: activePage2 })
+      .mockResolvedValueOnce({ threads: archivedPage2 });
+    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
+
+    const page1 = await result.current.list();
+    expect(page1.threads).toHaveLength(40);
+    expect(JSON.parse(page1.nextCursor!)).toEqual({ a: "a-20", r: "r-20" });
+
+    const page2 = await result.current.list({ after: page1.nextCursor });
+    expect(list).toHaveBeenNthCalledWith(3, { limit: 20, after: "a-20" });
+    expect(list).toHaveBeenNthCalledWith(4, {
+      is_archived: true,
+      limit: 20,
+      after: "r-20",
+    });
+    expect(page2.threads.map((thread) => thread.remoteId)).toEqual([
+      "a-21",
+      "r-21",
+    ]);
+    expect(page2.nextCursor).toBeUndefined();
+  });
+
+  it("accepts a legacy bare-id cursor for the active list", async () => {
+    const activeThreads = [makeThread("thread-21")];
+    const list = vi
+      .fn()
+      .mockResolvedValueOnce({ threads: activeThreads })
+      .mockResolvedValueOnce({ threads: [] });
+    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
+
+    const page = await result.current.list({ after: "thread-20" });
+
+    expect(list).toHaveBeenNthCalledWith(1, {
+      limit: 20,
+      after: "thread-20",
+    });
+    expect(list).toHaveBeenNthCalledWith(2, {
+      is_archived: true,
+      limit: 20,
+    });
+    expect(page.threads.map((thread) => thread.remoteId)).toEqual([
+      "thread-21",
+    ]);
+  });
 });