@assistant-ui/core 0.3.17 → 0.3.19

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

@@ -1,8 +1,9 @@
 // @vitest-environment jsdom
 
-import { renderHook } from "@testing-library/react";
+import { renderHook, waitFor } from "@testing-library/react";
 import type { AssistantCloud } from "assistant-cloud";
-import { describe, expect, it, vi } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { ThreadAssistantMessage } from "../../../types/message";
 import { useAssistantCloudThreadHistoryAdapter } from "./AssistantCloudThreadHistoryAdapter";
 
 const mocks = vi.hoisted(() => {
@@ -23,8 +24,14 @@ const mocks = vi.hoisted(() => {
       threadListItem,
       threads: {
         item: vi.fn(() => threadListItem),
-        getState: () => ({ threadItems: [{ id, remoteId }] }),
+        getState: () => ({
+          mainThreadId: id,
+          threadItems: [{ id, remoteId }],
+        }),
       },
+      thread: { getState: () => ({ isEmpty: false, suggestions: [] }) },
+      on: () => () => {},
+      subscribe: () => () => {},
     } as unknown as import("@assistant-ui/store").AssistantClient;
   };
 
@@ -40,8 +47,14 @@ const mocks = vi.hoisted(() => {
       threadListItem: live,
       threads: {
         item: vi.fn(() => listItem),
-        getState: () => ({ threadItems: [{ id: remoteId, remoteId }] }),
+        getState: () => ({
+          mainThreadId: remoteId,
+          threadItems: [{ id: remoteId, remoteId }],
+        }),
       },
+      thread: { getState: () => ({ isEmpty: false, suggestions: [] }) },
+      on: () => () => {},
+      subscribe: () => () => {},
     } as unknown as import("@assistant-ui/store").AssistantClient;
   };
 
@@ -57,20 +70,223 @@ vi.mock("@assistant-ui/store", async (importOriginal) => ({
   useAui: () => mocks.aui,
 }));
 
-const makeCloud = () =>
+const makeCloud = (telemetry: Partial<AssistantCloud["telemetry"]> = {}) =>
   ({
     threads: {
       messages: {
         list: vi.fn().mockResolvedValue({ messages: [] }),
         create: vi.fn().mockResolvedValue({ message_id: "remote-message-1" }),
         update: vi.fn().mockResolvedValue(undefined),
+        feedback: vi.fn().mockResolvedValue({
+          feedback_id: "feedback-1",
+          type: "positive",
+        }),
       },
     },
-    telemetry: { enabled: true },
+    events: { track: vi.fn() },
+    telemetry: { enabled: true, ...telemetry },
     runs: { report: vi.fn().mockResolvedValue(undefined) },
   }) as unknown as AssistantCloud;
 
+const makeAssistantMessage = (id: string): ThreadAssistantMessage => ({
+  id,
+  role: "assistant",
+  content: [{ type: "text", text: "done" }],
+  status: { type: "complete", reason: "stop" },
+  createdAt: new Date(0),
+  metadata: {
+    unstable_state: null,
+    unstable_annotations: [],
+    unstable_data: [],
+    steps: [],
+    custom: {},
+  },
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
 describe("useAssistantCloudThreadHistoryAdapter", () => {
+  it("tracks cloud engagement events without message content", async () => {
+    const now = vi.spyOn(Date, "now").mockReturnValue(100);
+    const listeners = new Map<string, (payload: any) => void>();
+    let notify: (() => void) | undefined;
+    const threadState = {
+      isEmpty: false,
+      suggestions: [] as { prompt: string }[],
+    };
+    const threadListItem = {
+      source: "threads",
+      getState: () => ({ id: "thread-1", remoteId: "thread-1" }),
+      initialize: async () => ({ remoteId: "thread-1", externalId: undefined }),
+    };
+    mocks.aui = {
+      threadListItem,
+      threads: {
+        item: vi.fn(() => threadListItem),
+        getState: () => ({
+          mainThreadId: "thread-1",
+          threadItems: [{ id: "thread-1", remoteId: "thread-1" }],
+        }),
+      },
+      thread: { getState: () => threadState },
+      on: vi.fn((selector, callback) => {
+        listeners.set(selector.event, callback);
+        return () => listeners.delete(selector.event);
+      }),
+      subscribe: vi.fn((callback) => {
+        notify = callback;
+        return () => {};
+      }),
+    } as unknown as import("@assistant-ui/store").AssistantClient;
+    const cloud = makeCloud();
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter({ current: cloud }),
+    );
+    const message = makeAssistantMessage("local-message-1");
+
+    await result.current.append({ parentId: null, message });
+    await waitFor(() => expect(listeners.size).toBeGreaterThan(0));
+
+    listeners.get("thread.runEnd")!({ threadId: "thread-1" });
+    now.mockReturnValue(125);
+    listeners.get("composer.send")!({
+      threadId: "thread-1",
+      chars: 5,
+      attachments: 1,
+      suggestion: true,
+    });
+    listeners.get("composer.send")!({
+      threadId: "thread-1",
+      messageId: "local-message-1",
+      chars: 7,
+      attachments: 0,
+    });
+    listeners.get("thread.runStart")!({ threadId: "thread-1" });
+    now.mockReturnValue(150);
+    listeners.get("thread.cancelRun")!({ threadId: "thread-1" });
+    listeners.get("message.reload")!({
+      threadId: "thread-1",
+      messageId: "local-message-1",
+    });
+    listeners.get("message.branchSwitched")!({
+      threadId: "thread-1",
+      messageId: "local-message-1",
+    });
+    listeners.get("message.copied")!({
+      threadId: "thread-1",
+      messageId: "local-message-1",
+    });
+    listeners.get("thread.toolApprovalAnswered")!({
+      threadId: "thread-1",
+      messageId: "local-message-1",
+      toolCallId: "tool-approved",
+      toolName: "send_email",
+      approved: true,
+    });
+    listeners.get("thread.toolApprovalAnswered")!({
+      threadId: "thread-1",
+      messageId: "local-message-1",
+      toolCallId: "tool-rejected",
+      toolName: "delete_account",
+      approved: false,
+    });
+    listeners.get("composer.attachmentAdd")!({
+      threadId: "thread-1",
+      contentType: "image/png",
+    });
+    listeners.get("composer.attachmentAddError")!({
+      threadId: "thread-1",
+      reason: "adapter-error",
+      message: "not sent",
+      contentType: "application/pdf",
+    });
+    listeners.get("threads.selectionChanged")!({
+      threadId: "thread-1",
+      previousThreadId: "thread-0",
+    });
+    listeners.get("message.speak")!({
+      threadId: "thread-1",
+      messageId: "local-message-1",
+    });
+    listeners.get("thread.voiceStarted")!({ threadId: "thread-1" });
+    listeners.get("message.error")!({
+      threadId: "thread-1",
+      messageId: "local-message-1",
+      reason: "error",
+    });
+    listeners.get("message.error")!({
+      threadId: "thread-1",
+      messageId: "local-message-2",
+      reason: "error",
+    });
+    threadState.isEmpty = true;
+    threadState.suggestions = [{ prompt: "one" }, { prompt: "two" }];
+    notify!();
+    await waitFor(() =>
+      expect(vi.mocked(cloud.events.track).mock.calls.length).toBeGreaterThan(
+        12,
+      ),
+    );
+
+    expect(
+      vi.mocked(cloud.events.track).mock.calls.map(([event]) => event),
+    ).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          kind: "message_sent",
+          thread_id: "thread-1",
+          value: 25,
+          props: { chars: 5, attachments: 1 },
+        }),
+        expect.objectContaining({
+          kind: "message_edited",
+          thread_id: "thread-1",
+          message_id: "remote-message-1",
+          props: { chars: 7 },
+        }),
+        expect.objectContaining({ kind: "suggestion_clicked" }),
+        expect.objectContaining({ kind: "run_stopped", value: 25 }),
+        expect.objectContaining({ kind: "message_regenerated" }),
+        expect.objectContaining({ kind: "branch_switched" }),
+        expect.objectContaining({ kind: "message_copied" }),
+        expect.objectContaining({
+          kind: "tool_approved",
+          message_id: "remote-message-1",
+          props: { toolCallId: "tool-approved", toolName: "send_email" },
+        }),
+        expect.objectContaining({
+          kind: "tool_rejected",
+          message_id: "remote-message-1",
+          props: { toolCallId: "tool-rejected", toolName: "delete_account" },
+        }),
+        expect.objectContaining({
+          kind: "attachment_added",
+          props: { type: "image/png" },
+        }),
+        expect.objectContaining({
+          kind: "attachment_failed",
+          props: { type: "application/pdf" },
+        }),
+        expect.objectContaining({ kind: "thread_switched" }),
+        expect.objectContaining({ kind: "speech_started" }),
+        expect.objectContaining({ kind: "voice_started" }),
+        expect.objectContaining({
+          kind: "error_shown",
+          props: { reason: "error" },
+        }),
+        expect.objectContaining({ kind: "suggestions_shown", value: 2 }),
+      ]),
+    );
+    expect(
+      vi
+        .mocked(cloud.events.track)
+        .mock.calls.map(([event]) => event)
+        .filter((event) => event.kind === "error_shown"),
+    ).toHaveLength(1);
+  });
+
   it("refreshes formatted persistence when the Cloud client changes", async () => {
     mocks.aui = mocks.makeClient("thread-1");
     const firstCloud = makeCloud();
@@ -104,6 +320,7 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
     expect(secondCloud.threads.messages.list).toHaveBeenCalledOnce();
     expect(secondCloud.threads.messages.list).toHaveBeenCalledWith("thread-1", {
       format: "test",
+      limit: 200,
     });
   });
 
@@ -130,6 +347,7 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
     await formatted.load();
     expect(cloud.threads.messages.list).toHaveBeenCalledWith("thread-1", {
       format: "test",
+      limit: 200,
     });
 
     mocks.aui = mocks.makeClient("thread-2");
@@ -137,6 +355,7 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
     await formatted.load();
     expect(cloud.threads.messages.list).toHaveBeenCalledWith("thread-2", {
       format: "test",
+      limit: 200,
     });
   });
 
@@ -151,6 +370,7 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
     await result.current.load();
     expect(cloud.threads.messages.list).toHaveBeenCalledWith("thread-1", {
       format: "aui/v0",
+      limit: 200,
     });
 
     mocks.aui = mocks.makeClient("thread-2");
@@ -159,6 +379,92 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
     await result.current.load();
     expect(cloud.threads.messages.list).toHaveBeenCalledWith("thread-2", {
       format: "aui/v0",
+      limit: 200,
+    });
+  });
+
+  it("submits feedback with the mapped cloud message ID", 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: "positive" });
+
+    await waitFor(() => {
+      expect(cloud.threads.messages.feedback).toHaveBeenCalledWith(
+        "thread-1",
+        "remote-message-1",
+        { type: "positive" },
+      );
+    });
+  });
+
+  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();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter({ current: cloud }),
+    );
+    const message = makeAssistantMessage("local-message-1");
+
+    result.current.feedback.submit({ message, type: "negative" });
+
+    await waitFor(() => {
+      expect(warn).toHaveBeenCalledWith(
+        "[assistant-ui] Skipping feedback for message local-message-1: the thread has no remote id.",
+      );
+    });
+    expect(cloud.threads.messages.feedback).not.toHaveBeenCalled();
+  });
+
+  it("warns and skips feedback before the message has a cloud ID", async () => {
+    mocks.aui = mocks.makeClient("thread-1");
+    const cloud = makeCloud();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter({ current: cloud }),
+    );
+    const message = makeAssistantMessage("local-message-1");
+
+    result.current.feedback.submit({ message, type: "negative" });
+
+    await waitFor(() => {
+      expect(warn).toHaveBeenCalledWith(
+        "[assistant-ui] Skipping feedback for message local-message-1: no cloud message id is mapped.",
+      );
+    });
+    expect(cloud.threads.messages.feedback).not.toHaveBeenCalled();
+  });
+
+  it("reports cloud feedback errors without throwing them into the UI", async () => {
+    mocks.aui = mocks.makeClient("thread-1");
+    const cloud = makeCloud();
+    const error = new Error("feedback unavailable");
+    vi.mocked(cloud.threads.messages.feedback).mockRejectedValue(error);
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter({ current: cloud }),
+    );
+    const message = makeAssistantMessage("local-message-1");
+
+    await result.current.append({ parentId: null, message });
+    expect(() =>
+      result.current.feedback.submit({ message, type: "positive" }),
+    ).not.toThrow();
+
+    await waitFor(() => {
+      expect(consoleError).toHaveBeenCalledWith(
+        "[assistant-ui] Cloud feedback submission failed:",
+        error,
+      );
     });
   });
 
@@ -209,6 +515,132 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
     );
   });
 
+  it("reports persisted assistant telemetry dimensions", async () => {
+    mocks.aui = mocks.makeClient("thread-1");
+    const cloud = makeCloud({
+      release: "web-2026.09.08",
+      environment: "production",
+      tags: ["region:sg", "tier:paid"],
+    });
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter({ current: cloud }),
+    );
+    const message: ThreadAssistantMessage = {
+      ...makeAssistantMessage("local-message-1"),
+      status: { type: "incomplete", reason: "length" },
+      metadata: {
+        ...makeAssistantMessage("local-message-1").metadata,
+        custom: {
+          traceId: "AABBCCDDEEFF00112233445566778899",
+          provider: "openai",
+        },
+        timing: {
+          streamStartTime: 100,
+          firstTokenTime: 55.6,
+          totalChunks: 1,
+          toolCallCount: 0,
+        },
+      },
+    };
+
+    await result.current.append({ parentId: null, message });
+
+    expect(cloud.runs.report).toHaveBeenCalledWith(
+      expect.objectContaining({
+        thread_id: "thread-1",
+        status: "incomplete",
+        outcome_type: "length",
+        message_id: "remote-message-1",
+        first_token_ms: 56,
+        trace_id: "aabbccddeeff00112233445566778899",
+        provider: "openai",
+        provider_type: "openai",
+        release: "web-2026.09.08",
+        environment: "production",
+        tags: ["region:sg", "tier:paid"],
+      }),
+    );
+  });
+
+  it("reports the error message and code of a failed run", async () => {
+    mocks.aui = mocks.makeClient("thread-1");
+    const cloud = makeCloud();
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter({ current: cloud }),
+    );
+    const error = new Error("Rate limited");
+    error.name = "AI_APICallError";
+    const message: ThreadAssistantMessage = {
+      ...makeAssistantMessage("local-message-1"),
+      status: { type: "incomplete", reason: "error", error },
+    };
+
+    await result.current.append({ parentId: null, message });
+
+    expect(cloud.runs.report).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: "error",
+        error: "Rate limited",
+        error_code: "AI_APICallError",
+      }),
+    );
+  });
+
+  it.each([
+    ["cancelled", "aborted"],
+    ["length", "length"],
+    ["content-filter", "content_filter"],
+  ] as const)("maps incomplete %s to outcome %s", async (reason, outcome) => {
+    mocks.aui = mocks.makeClient("thread-1");
+    const cloud = makeCloud();
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter({ current: cloud }),
+    );
+    const message: ThreadAssistantMessage = {
+      ...makeAssistantMessage("local-message-1"),
+      status: { type: "incomplete", reason },
+    };
+
+    await result.current.append({ parentId: null, message });
+
+    expect(cloud.runs.report).toHaveBeenCalledWith(
+      expect.objectContaining({ outcome_type: outcome }),
+    );
+  });
+
+  it("omits a clean outcome and an unknown cloud message ID", () => {
+    mocks.aui = mocks.makeClient("thread-1");
+    const cloud = makeCloud();
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter({ current: cloud }),
+    );
+    const formatted = result.current.withFormat({
+      format: "aui/v0",
+      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: "local-message-1",
+          role: "assistant",
+          content: [{ type: "text", text: "done" }],
+          status: { type: "complete", reason: "stop" },
+        },
+      },
+    ]);
+
+    const report = vi.mocked(cloud.runs.report).mock.calls[0]![0]!;
+    expect(report).not.toHaveProperty("outcome_type");
+    expect(report).not.toHaveProperty("message_id");
+  });
+
   it("reports frontend and MCP sources for ai-sdk/v6 tool calls", () => {
     mocks.aui = mocks.makeClient("thread-1");
     const cloud = makeCloud();
@@ -255,6 +687,10 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
               output: { result: "ok" },
             },
           ],
+          metadata: {
+            traceId: "00112233445566778899AABBCCDDEEFF",
+            provider: "anthropic",
+          },
         },
       },
     ]);
@@ -287,6 +723,7 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
                 tool_source: "mcp",
               }),
             ],
+            finish_reason: "tool-calls",
           },
           {
             tool_calls: [
@@ -295,12 +732,272 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
                 tool_source: "frontend",
               }),
             ],
+            finish_reason: "tool-calls",
           },
         ],
+        trace_id: "00112233445566778899aabbccddeeff",
+        provider: "anthropic",
+        provider_type: "anthropic",
       }),
     );
   });
 
+  it("reports a single ai-sdk/v6 step with its tool calls", () => {
+    mocks.aui = mocks.makeClient("thread-1");
+    const cloud = makeCloud();
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter({ current: cloud }),
+    );
+    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: "search-1",
+              input: { query: "test" },
+              output: { result: "ok" },
+            },
+          ],
+        },
+      },
+    ]);
+
+    expect(cloud.runs.report).toHaveBeenCalledWith(
+      expect.objectContaining({
+        total_steps: 1,
+        steps: [
+          {
+            tool_calls: [
+              expect.objectContaining({
+                tool_call_id: "search-1",
+                tool_source: "frontend",
+              }),
+            ],
+            finish_reason: "tool-calls",
+          },
+        ],
+      }),
+    );
+  });
+
+  it("reads the status of an ai-sdk/v6 run from its finish reason", () => {
+    mocks.aui = mocks.makeClient("thread-1");
+    const cloud = makeCloud();
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter({ current: cloud }),
+    );
+    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: "text", text: "cut" }],
+          metadata: { finishReason: "length" },
+        },
+      },
+    ]);
+
+    expect(cloud.runs.report).toHaveBeenCalledWith(
+      expect.objectContaining({ status: "incomplete", outcome_type: "length" }),
+    );
+  });
+
+  it("reads the error and timing of an ai-sdk/v6 run from the thread message", () => {
+    mocks.aui = mocks.makeClient("thread-1");
+    const cloud = makeCloud();
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter({ current: cloud }),
+    );
+    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,
+    });
+    const base = makeAssistantMessage("assistant-1");
+    const message: ThreadAssistantMessage = {
+      ...base,
+      status: {
+        type: "incomplete",
+        reason: "error",
+        error: Object.assign(new Error("model unavailable"), {
+          code: "model_unavailable",
+        }),
+      },
+      metadata: {
+        ...base.metadata,
+        timing: {
+          streamStartTime: 100,
+          firstTokenTime: 240,
+          totalChunks: 3,
+          toolCallCount: 0,
+        },
+      },
+    };
+
+    formatted.reportTelemetry(
+      [
+        {
+          parentId: null,
+          message: {
+            id: "message-1",
+            role: "assistant",
+            parts: [{ type: "text", text: "partial" }],
+          },
+        },
+      ],
+      { message },
+    );
+
+    expect(cloud.runs.report).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: "error",
+        error: "model unavailable",
+        error_code: "model_unavailable",
+        first_token_ms: 240,
+      }),
+    );
+  });
+
+  it("reports a run that failed before any assistant message was stored", () => {
+    mocks.aui = mocks.makeClient("thread-1");
+    const cloud = makeCloud();
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter({ current: cloud }),
+    );
+    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,
+    });
+    const message: ThreadAssistantMessage = {
+      ...makeAssistantMessage("assistant-1"),
+      content: [],
+      status: {
+        type: "incomplete",
+        reason: "error",
+        error: { code: "AI_APICallError", message: "upstream failed" },
+      },
+    };
+
+    formatted.reportTelemetry([], { message, durationMs: 120 });
+
+    expect(cloud.runs.report).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: "error",
+        error: "upstream failed",
+        error_code: "AI_APICallError",
+        duration_ms: 120,
+      }),
+    );
+  });
+
+  it("reports the model ID carried by aui/v0 step metadata", () => {
+    mocks.aui = mocks.makeClient("thread-1");
+    const cloud = makeCloud();
+    const cloudRef = { current: cloud };
+    const { result } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter(cloudRef),
+    );
+    const formatted = result.current.withFormat({
+      format: "aui/v0",
+      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",
+          content: [{ type: "text", text: "done" }],
+          status: { type: "complete" },
+          metadata: {
+            steps: [{ response: { modelId: "provider/model-1" } }],
+          },
+        },
+      },
+    ]);
+
+    expect(cloud.runs.report).toHaveBeenCalledWith(
+      expect.objectContaining({ model_id: "provider/model-1" }),
+    );
+  });
+
+  it("reports the model ID carried by ai-sdk/v6 step metadata", () => {
+    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: "text", text: "done" }],
+          metadata: {
+            steps: [{ response: { modelId: "provider/model-1" } }],
+          },
+        },
+      },
+    ]);
+
+    expect(cloud.runs.report).toHaveBeenCalledWith(
+      expect.objectContaining({ model_id: "provider/model-1" }),
+    );
+  });
+
   it("initializes the pinned item instead of the new main thread", async () => {
     mocks.aui = mocks.makeClient(undefined, "new-thread", "thread-1");
     const cloud = makeCloud();