@assistant-ui/core 0.3.16 → 0.3.18

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(() => {
@@ -21,12 +22,45 @@ const mocks = vi.hoisted(() => {
     };
     return {
       threadListItem,
-      threads: { item: vi.fn(() => threadListItem) },
+      threads: {
+        item: vi.fn(() => threadListItem),
+        getState: () => ({
+          mainThreadId: id,
+          threadItems: [{ id, remoteId }],
+        }),
+      },
+      thread: { getState: () => ({ isEmpty: false, suggestions: [] }) },
+      on: () => () => {},
+      subscribe: () => () => {},
+    } 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: () => ({
+          mainThreadId: remoteId,
+          threadItems: [{ id: remoteId, remoteId }],
+        }),
+      },
+      thread: { getState: () => ({ isEmpty: false, suggestions: [] }) },
+      on: () => () => {},
+      subscribe: () => () => {},
     } as unknown as import("@assistant-ui/store").AssistantClient;
   };
 
   return {
     makeClient,
+    makeSplitClient,
     aui: makeClient("thread-1"),
   };
 });
@@ -36,20 +70,188 @@ 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("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",
+    });
+    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: "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 }),
+      ]),
+    );
+  });
+
   it("refreshes formatted persistence when the Cloud client changes", async () => {
     mocks.aui = mocks.makeClient("thread-1");
     const firstCloud = makeCloud();
@@ -83,6 +285,7 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
     expect(secondCloud.threads.messages.list).toHaveBeenCalledOnce();
     expect(secondCloud.threads.messages.list).toHaveBeenCalledWith("thread-1", {
       format: "test",
+      limit: 200,
     });
   });
 
@@ -109,6 +312,7 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
     await formatted.load();
     expect(cloud.threads.messages.list).toHaveBeenCalledWith("thread-1", {
       format: "test",
+      limit: 200,
     });
 
     mocks.aui = mocks.makeClient("thread-2");
@@ -116,6 +320,7 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
     await formatted.load();
     expect(cloud.threads.messages.list).toHaveBeenCalledWith("thread-2", {
       format: "test",
+      limit: 200,
     });
   });
 
@@ -130,6 +335,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");
@@ -138,6 +344,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,
+      );
     });
   });
 
@@ -188,6 +480,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: 155.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();
@@ -234,6 +652,10 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
               output: { result: "ok" },
             },
           ],
+          metadata: {
+            traceId: "00112233445566778899AABBCCDDEEFF",
+            provider: "anthropic",
+          },
         },
       },
     ]);
@@ -276,7 +698,83 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
             ],
           },
         ],
+        trace_id: "00112233445566778899aabbccddeeff",
+        provider: "anthropic",
+        provider_type: "anthropic",
+      }),
+    );
+  });
+
+  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" }),
     );
   });
 
@@ -308,4 +806,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(),
+    );
+  });
 });