@assistant-ui/core 0.3.17 → 0.3.19

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

@@ -7,19 +7,33 @@ import type {
   MessageFormatRepository,
 } from "../../../adapters/thread-history";
 import type { ExportedMessageRepositoryItem } from "../../../runtime/utils/message-repository";
+import type { ThreadMessage } from "../../../types";
 import {
   type AssistantCloud,
-  type AssistantCloudRunReportToolCall,
+  type AssistantCloudEvent,
+  CloudEngagementReporter,
   CloudMessagePersistence,
+  CloudRunReporter,
   createFormattedPersistence,
   createRunTelemetryToolCall,
+  deriveRunOutcome,
+  describeRunError,
+  extractRunTelemetryModelId,
   normalizeRunTelemetryUsage,
+  type RunMessageTelemetry,
+  type RunReportOutcome,
+  type RunReportStepInit,
   type RunTelemetryUsageInit,
   truncateRunTelemetryText,
 } from "assistant-cloud";
+import {
+  extractAISDKRunTelemetry,
+  type AISDKMessageLike,
+} from "assistant-cloud/ai-sdk";
 import { auiV0Decode, auiV0Encode } from "./auiV0";
 import { type AssistantClient, getClientId, useAui } from "@assistant-ui/store";
 import type { ThreadListItemMethods } from "../../../store/scopes/thread-list-item";
+import type { FeedbackAdapter } from "../../../adapters/feedback";
 
 type CloudThreadListItem = Pick<
   ThreadListItemMethods,
@@ -34,6 +48,8 @@ const globalPersistence = new WeakMap<
 class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
   private cloudRef: RefObject<AssistantCloud>;
   private getAui: () => AssistantClient;
+  private runReporter: CloudRunReporter;
+  public readonly engagementReporter: CloudEngagementReporter;
 
   constructor(
     cloudRef: RefObject<AssistantCloud>,
@@ -41,6 +57,12 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
   ) {
     this.cloudRef = cloudRef;
     this.getAui = getAui;
+    this.runReporter = new CloudRunReporter(() => this.cloudRef.current);
+    this.engagementReporter = new CloudEngagementReporter(
+      () => this.cloudRef.current,
+      (threadId, messageId, options) =>
+        this.resolveEngagementEventIds(threadId, messageId, options),
+    );
   }
 
   private get aui(): AssistantClient {
@@ -64,6 +86,72 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
     return this.getPersistence();
   }
 
+  /**
+   * A send is the moment the runtime creates the remote thread, so that one
+   * event waits for the id; every other event reads the id that already
+   * exists, because initializing a thread nobody has written to would create
+   * an empty remote thread just to attribute an event.
+   */
+  public async resolveEngagementEventIds(
+    threadId: string,
+    messageId?: string,
+    options?: { awaitThread?: boolean },
+  ): Promise<Pick<AssistantCloudEvent, "thread_id" | "message_id">> {
+    const threadListItem = this.getThreadListItem(threadId);
+    if (!threadListItem) return {};
+
+    let remoteThreadId = threadListItem.getState().remoteId;
+    if (!remoteThreadId && options?.awaitThread) {
+      remoteThreadId = await threadListItem
+        .initialize()
+        .then((result) => result.remoteId)
+        .catch(() => undefined);
+    }
+    const remoteMessageId = messageId
+      ? this.getPersistence(threadListItem).getResolvedRemoteId(messageId)
+      : undefined;
+    return {
+      ...(remoteThreadId ? { thread_id: remoteThreadId } : undefined),
+      ...(remoteMessageId ? { message_id: remoteMessageId } : undefined),
+    };
+  }
+
+  public readonly feedback: FeedbackAdapter = {
+    submit: ({ message, type }) => {
+      void (async () => {
+        const threadListItem = this.tryGetKeyedThreadListItem();
+        const remoteThreadId = threadListItem?.getState().remoteId;
+        if (!threadListItem || !remoteThreadId) {
+          console.warn(
+            `[assistant-ui] Skipping feedback for message ${message.id}: the thread has no remote id.`,
+          );
+          return;
+        }
+
+        const cloudMessageId = await this.getPersistence(
+          threadListItem,
+        ).getRemoteId(message.id);
+        if (!cloudMessageId) {
+          console.warn(
+            `[assistant-ui] Skipping feedback for message ${message.id}: no cloud message id is mapped.`,
+          );
+          return;
+        }
+
+        await this.cloudRef.current.threads.messages.feedback(
+          remoteThreadId,
+          cloudMessageId,
+          { type },
+        );
+      })().catch((error: unknown) => {
+        console.error(
+          "[assistant-ui] Cloud feedback submission failed:",
+          error,
+        );
+      });
+    },
+  };
+
   private tryGetKeyedThreadListItem(): CloudThreadListItem | undefined {
     const live = this.aui.threadListItem;
     if (!live.source) return undefined;
@@ -77,6 +165,21 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
     return listed ? this.aui.threads.item({ id }) : live;
   }
 
+  private getThreadListItem(threadId: string): CloudThreadListItem | undefined {
+    const current = this.aui.threadListItem;
+    const currentState = current.getState();
+    if (currentState.id === threadId || currentState.remoteId === threadId) {
+      return current;
+    }
+
+    const listed = this.aui.threads
+      .getState()
+      .threadItems.find(
+        (item) => item.id === threadId || item.remoteId === threadId,
+      );
+    return listed ? this.aui.threads.item({ id: listed.id }) : undefined;
+  }
+
   withFormat<TMessage, TStorageFormat extends Record<string, unknown>>(
     formatAdapter: MessageFormatAdapter<TMessage, TStorageFormat>,
   ): GenericThreadHistoryAdapter<TMessage> {
@@ -125,6 +228,7 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
         options?: {
           durationMs?: number;
           stepTimestamps?: StepTimestamp[];
+          message?: ThreadMessage;
         },
       ) {
         const encodedRunMessages = items.map((item) =>
@@ -135,6 +239,12 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
           encodedRunMessages,
           options,
           resolvePinned(),
+          mergeRunMessageInfo(
+            extractLastRunMessageInfo(items, formatAdapter),
+            options?.message
+              ? extractRunMessageInfo(options.message, "aui/v0")
+              : undefined,
+          ),
         );
       },
       async load(): Promise<MessageFormatRepository<TMessage>> {
@@ -162,7 +272,12 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
     );
 
     if (this.cloudRef.current.telemetry.enabled) {
-      this._maybeReportRun(remoteId, "aui/v0", encoded);
+      this._maybeReportRun(
+        remoteId,
+        "aui/v0",
+        encoded,
+        extractRunMessageInfo(message, "aui/v0"),
+      );
     }
   }
 
@@ -177,7 +292,12 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
     await this._persistence.update(remoteId, message.id, "aui/v0", encoded);
 
     if (this.cloudRef.current.telemetry.enabled) {
-      this._maybeReportRun(remoteId, "aui/v0", encoded);
+      this._maybeReportRun(
+        remoteId,
+        "aui/v0",
+        encoded,
+        extractRunMessageInfo(message, "aui/v0"),
+      );
     }
   }
 
@@ -209,14 +329,17 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
       stepTimestamps?: StepTimestamp[];
     },
     threadListItem?: CloudThreadListItem,
+    messageInfo?: RunMessageInfo,
   ) {
-    if (!this.cloudRef.current.telemetry.enabled) return;
-
-    const remoteId = (threadListItem ?? this.aui.threadListItem).getState()
-      .remoteId;
+    const item = threadListItem ?? this.aui.threadListItem;
+    const remoteId = item.getState().remoteId;
     if (!remoteId) return;
 
-    const extracted = extractRunTelemetry(format, runMessages);
+    const extracted =
+      extractRunTelemetry(format, runMessages) ??
+      (messageInfo?.status !== undefined
+        ? { status: "incomplete" as const }
+        : undefined);
     if (!extracted) return;
 
     this._sendReport(
@@ -224,107 +347,199 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
       extracted,
       options?.durationMs,
       options?.stepTimestamps,
+      messageInfo,
+      this.getPersistence(item),
     );
   }
 
-  private _maybeReportRun<T>(remoteId: string, format: string, content: T) {
+  private _maybeReportRun<T>(
+    remoteId: string,
+    format: string,
+    content: T,
+    messageInfo?: RunMessageInfo,
+  ) {
     const extracted = extractTelemetry(format, content);
     if (!extracted) return;
 
-    this._sendReport(remoteId, extracted);
+    this._sendReport(remoteId, extracted, undefined, undefined, messageInfo);
   }
 
   private _sendReport(
     remoteId: string,
-    data: TelemetryData,
+    data: RunMessageTelemetry,
     durationMs?: number,
     stepTimestamps?: StepTimestamp[],
+    messageInfo?: RunMessageInfo,
+    persistence = this._persistence,
   ) {
     const mergedSteps = mergeStepTimestamps(data.steps, stepTimestamps);
-    // Keep in sync with assistant-cloud createRunSchema
-    // (apps/aui-cloud-api/src/endpoints/runs/create.ts).
-    const initial: Parameters<typeof this.cloudRef.current.runs.report>[0] = {
-      thread_id: remoteId,
-      status: data.status,
-      ...(data.totalSteps != null
-        ? { total_steps: data.totalSteps }
-        : undefined),
-      ...(data.toolCalls ? { tool_calls: data.toolCalls } : undefined),
-      ...(mergedSteps ? { steps: mergedSteps } : undefined),
-      ...(data.inputTokens != null
-        ? { input_tokens: data.inputTokens }
-        : undefined),
-      ...(data.outputTokens != null
-        ? { output_tokens: data.outputTokens }
-        : undefined),
-      ...(data.reasoningTokens != null
-        ? { reasoning_tokens: data.reasoningTokens }
-        : undefined),
-      ...(data.cachedInputTokens != null
-        ? { cached_input_tokens: data.cachedInputTokens }
-        : undefined),
-      ...(durationMs != null ? { duration_ms: durationMs } : undefined),
-      ...(data.outputText != null
-        ? { output_text: data.outputText }
-        : undefined),
-      ...(data.metadata ? { metadata: data.metadata } : undefined),
-      ...(data.modelId ? { model_id: data.modelId } : undefined),
-    };
-
-    const { beforeReport } = this.cloudRef.current.telemetry;
-    const report = beforeReport ? beforeReport(initial) : initial;
-    if (!report) return;
-
-    this.cloudRef.current.runs.report(report).catch(() => {});
+    const messageId = messageInfo?.localMessageId
+      ? persistence.getResolvedRemoteId(messageInfo.localMessageId)
+      : undefined;
+    void this.runReporter.report({
+      threadId: remoteId,
+      status: messageInfo?.status ?? data.status,
+      outcome: messageInfo?.outcomeType,
+      error: messageInfo?.error,
+      errorCode: messageInfo?.errorCode,
+      messageId,
+      traceId: messageInfo?.traceId,
+      modelId: data.modelId,
+      provider: messageInfo?.provider,
+      usage: data.usage,
+      steps: mergedSteps,
+      totalSteps: data.totalSteps,
+      toolCalls: data.toolCalls,
+      durationMs,
+      firstTokenMs: messageInfo?.firstTokenMs,
+      outputText: data.outputText,
+      metadata: data.metadata,
+    });
   }
 }
 
-type TelemetryStepData = {
-  input_tokens?: number;
-  output_tokens?: number;
-  reasoning_tokens?: number;
-  cached_input_tokens?: number;
-  tool_calls?: AssistantCloudRunReportToolCall[];
-  start_ms?: number;
-  end_ms?: number;
-};
-
 type StepTimestamp = { start_ms: number; end_ms: number };
 
 function mergeStepTimestamps(
-  steps: TelemetryStepData[] | undefined,
+  steps: RunReportStepInit[] | undefined,
   timestamps: StepTimestamp[] | undefined,
-): TelemetryStepData[] | undefined {
+): RunReportStepInit[] | undefined {
   if (!timestamps) return steps;
-  if (!steps) return timestamps.map((t) => ({ ...t }));
+  if (!steps) {
+    return timestamps.map(({ start_ms, end_ms }) => ({
+      startMs: start_ms,
+      endMs: end_ms,
+    }));
+  }
 
   const len = Math.min(steps.length, timestamps.length);
-  return steps.map((s, i) => ({
-    ...s,
-    ...(i < len ? timestamps[i] : undefined),
+  return steps.map((step, index) => ({
+    ...step,
+    ...(index < len
+      ? {
+          startMs: timestamps[index]!.start_ms,
+          endMs: timestamps[index]!.end_ms,
+        }
+      : undefined),
   }));
 }
 
-type TelemetryData = {
-  status: "completed" | "incomplete" | "error";
-  toolCalls?: AssistantCloudRunReportToolCall[];
-  totalSteps?: number;
-  inputTokens?: number;
-  outputTokens?: number;
-  reasoningTokens?: number;
-  cachedInputTokens?: number;
-  outputText?: string;
-  metadata?: Record<string, unknown>;
-  steps?: TelemetryStepData[];
-  modelId?: string;
+type RunMessageInfo = {
+  localMessageId?: string;
+  status?: "completed" | "incomplete" | "error";
+  outcomeType?: RunReportOutcome;
+  error?: string;
+  errorCode?: string;
+  firstTokenMs?: number;
+  traceId?: string;
+  provider?: string;
 };
 
-function extractTelemetry<T>(format: string, content: T): TelemetryData | null {
+function extractLastRunMessageInfo<
+  TMessage,
+  TStorageFormat extends Record<string, unknown>,
+>(
+  items: MessageFormatItem<TMessage>[],
+  formatAdapter: MessageFormatAdapter<TMessage, TStorageFormat>,
+): RunMessageInfo | undefined {
+  for (let i = items.length - 1; i >= 0; i--) {
+    const item = items[i]!;
+    const info = extractRunMessageInfo(
+      item.message,
+      formatAdapter.format,
+      formatAdapter.getId(item.message),
+    );
+    if (info) return info;
+  }
+  return undefined;
+}
+
+function mergeRunMessageInfo(
+  stored: RunMessageInfo | undefined,
+  observed: RunMessageInfo | undefined,
+): RunMessageInfo | undefined {
+  if (!observed) return stored;
+  const { localMessageId: _observedId, ...outcome } = observed;
+  return { ...stored, ...outcome };
+}
+
+function extractRunMessageInfo(
+  message: unknown,
+  format: string,
+  localMessageId?: string,
+): RunMessageInfo | undefined {
+  if (!isRecord(message) || message.role !== "assistant") return undefined;
+
+  const status = isRecord(message.status) ? message.status : undefined;
+  const metadata = isRecord(message.metadata) ? message.metadata : undefined;
+  const custom = isRecord(metadata?.custom) ? metadata.custom : undefined;
+  const timing = isRecord(metadata?.timing) ? metadata.timing : undefined;
+  const firstTokenTime = timing?.firstTokenTime;
+  const firstTokenMs =
+    typeof firstTokenTime === "number" && Number.isFinite(firstTokenTime)
+      ? Math.round(firstTokenTime)
+      : undefined;
+  const finishReason =
+    status?.type === "incomplete"
+      ? typeof status.reason === "string"
+        ? status.reason
+        : undefined
+      : typeof metadata?.finishReason === "string"
+        ? metadata.finishReason
+        : undefined;
+  const failed = status?.type === "incomplete" && status.reason === "error";
+  const outcome = deriveRunOutcome({ finishReason, isError: failed });
+  const outcomeType = outcome.outcome;
+  const runStatus =
+    outcome.status === "error"
+      ? "error"
+      : status?.type === "incomplete"
+        ? "incomplete"
+        : finishReason !== undefined
+          ? outcome.status
+          : undefined;
+  const failure = failed ? describeRunError(status.error) : {};
+  const messageId =
+    localMessageId ?? (typeof message.id === "string" ? message.id : undefined);
+  const traceId =
+    format === "aui/v0"
+      ? custom?.traceId
+      : format === "ai-sdk/v6"
+        ? metadata?.traceId
+        : undefined;
+  const provider =
+    typeof custom?.provider === "string"
+      ? custom.provider
+      : typeof metadata?.provider === "string"
+        ? metadata.provider
+        : undefined;
+
+  return {
+    ...(messageId ? { localMessageId: messageId } : undefined),
+    ...(runStatus !== undefined ? { status: runStatus } : undefined),
+    ...(outcomeType ? { outcomeType } : undefined),
+    ...failure,
+    ...(firstTokenMs != null && firstTokenMs >= 0
+      ? { firstTokenMs }
+      : undefined),
+    ...(typeof traceId === "string" ? { traceId } : undefined),
+    ...(provider !== undefined ? { provider } : undefined),
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object";
+}
+
+function extractTelemetry<T>(
+  format: string,
+  content: T,
+): RunMessageTelemetry | null {
   switch (format) {
     case "aui/v0":
       return extractAuiV0(content);
     case "ai-sdk/v6":
-      return extractAiSdkV6(content);
+      return extractAISDKRunTelemetry([content as AISDKMessageLike]);
     default:
       return null;
   }
@@ -333,9 +548,9 @@ function extractTelemetry<T>(format: string, content: T): TelemetryData | null {
 function extractRunTelemetry<T>(
   format: string,
   runMessages: T[],
-): TelemetryData | null {
+): RunMessageTelemetry | null {
   if (format === "ai-sdk/v6") {
-    return aggregateAiSdkV6RunSteps(runMessages);
+    return extractAISDKRunTelemetry(runMessages as AISDKMessageLike[]);
   }
   for (let i = runMessages.length - 1; i >= 0; i--) {
     const result = extractTelemetry(format, runMessages[i]!);
@@ -344,15 +559,10 @@ function extractRunTelemetry<T>(
   return null;
 }
 
-const AUI_STATUS_MAP: Record<string, TelemetryData["status"]> = {
-  error: "error",
-  incomplete: "incomplete",
-};
-
-export function extractAuiV0<T>(content: T): TelemetryData | null {
+export function extractAuiV0<T>(content: T): RunMessageTelemetry | null {
   const msg = content as {
     role?: string;
-    status?: { type: string };
+    status?: { type: string; reason?: string };
     content?: readonly {
       type: string;
       text?: string;
@@ -433,340 +643,45 @@ export function extractAuiV0<T>(content: T): TelemetryData | null {
     cachedInputTokens = hasCachedInput ? totalCachedInput : undefined;
   }
 
-  const statusType = msg.status?.type;
-  const status: TelemetryData["status"] =
-    (statusType && AUI_STATUS_MAP[statusType]) || "completed";
+  const status = msg.status?.type === "incomplete" ? "incomplete" : "completed";
 
   const metadata = msg.metadata?.custom as Record<string, unknown> | undefined;
-  const modelId =
-    msg.metadata?.modelId ??
-    (typeof msg.metadata?.custom?.modelId === "string"
-      ? msg.metadata.custom.modelId
-      : undefined);
-
-  const telemetrySteps: TelemetryStepData[] | undefined =
-    steps && steps.length > 1
-      ? steps.map((s) => {
-          const usage = s.usage
-            ? normalizeRunTelemetryUsage(s.usage)
-            : undefined;
-          return {
-            ...(usage?.inputTokens != null
-              ? { input_tokens: usage.inputTokens }
-              : undefined),
-            ...(usage?.outputTokens != null
-              ? { output_tokens: usage.outputTokens }
-              : undefined),
-            ...(usage?.reasoningTokens != null
-              ? { reasoning_tokens: usage.reasoningTokens }
-              : undefined),
-            ...(usage?.cachedInputTokens != null
-              ? { cached_input_tokens: usage.cachedInputTokens }
-              : undefined),
-          };
-        })
+  const modelId = extractRunTelemetryModelId(
+    msg.metadata as Record<string, unknown> | undefined,
+  );
+
+  const telemetrySteps: RunReportStepInit[] | undefined =
+    steps && steps.length > 0
+      ? steps.map((step) => (step.usage ? { usage: step.usage } : {}))
       : undefined;
 
   return {
     status,
     ...(toolCalls && toolCalls.length > 0 ? { toolCalls } : undefined),
     ...(steps?.length ? { totalSteps: steps.length } : undefined),
-    ...(inputTokens != null ? { inputTokens } : undefined),
-    ...(outputTokens != null ? { outputTokens } : undefined),
-    ...(reasoningTokens != null ? { reasoningTokens } : undefined),
-    ...(cachedInputTokens != null ? { cachedInputTokens } : undefined),
-    ...(outputText != null ? { outputText } : undefined),
-    ...(metadata ? { metadata } : undefined),
-    ...(telemetrySteps ? { steps: telemetrySteps } : undefined),
-    ...(modelId ? { modelId } : undefined),
-  };
-}
-
-type AiSdkV6Part = {
-  type: string;
-  text?: string;
-  toolName?: string;
-  toolCallId?: string;
-  args?: unknown;
-  result?: unknown;
-  input?: unknown;
-  output?: unknown;
-};
-
-type AiSdkV6Message = {
-  role?: string;
-  parts?: readonly AiSdkV6Part[];
-  metadata?: Record<string, unknown>;
-};
-
-function isToolCallPart(p: AiSdkV6Part): boolean {
-  if (!p.toolCallId) return false;
-  if (p.type === "tool-call" || p.type === "dynamic-tool") return !!p.toolName;
-  return p.type.startsWith("tool-") || p.type.startsWith("dynamic-tool-");
-}
-
-function isDynamicToolPart(p: AiSdkV6Part): boolean {
-  return p.type === "dynamic-tool" || p.type.startsWith("dynamic-tool-");
-}
-
-function partToToolCall(p: AiSdkV6Part): AssistantCloudRunReportToolCall {
-  const toolSource: "mcp" | "frontend" = isDynamicToolPart(p)
-    ? "mcp"
-    : "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: AssistantCloudRunReportToolCall[];
-  stepsData: { tool_calls: AssistantCloudRunReportToolCall[] }[];
-} {
-  const textParts: string[] = [];
-  const toolCalls: AssistantCloudRunReportToolCall[] = [];
-  const stepsData: { tool_calls: AssistantCloudRunReportToolCall[] }[] = [];
-  let currentStepToolCalls: AssistantCloudRunReportToolCall[] | null = null;
-
-  for (const p of parts) {
-    if (p.type === "step-start") {
-      if (currentStepToolCalls !== null) {
-        stepsData.push({ tool_calls: currentStepToolCalls });
-      }
-      currentStepToolCalls = [];
-    } else if (p.type === "text" && p.text) {
-      textParts.push(p.text);
-    } else if (isToolCallPart(p)) {
-      const tc = partToToolCall(p);
-      toolCalls.push(tc);
-      if (currentStepToolCalls !== null) {
-        currentStepToolCalls.push(tc);
-      }
-    }
-  }
-
-  if (currentStepToolCalls !== null) {
-    stepsData.push({ tool_calls: currentStepToolCalls });
-  }
-
-  return { textParts, toolCalls, stepsData };
-}
-
-function extractModelId(
-  metadata?: Record<string, unknown>,
-): string | undefined {
-  if (!metadata) return undefined;
-  if (typeof metadata.modelId === "string") return metadata.modelId;
-  const custom = metadata.custom as Record<string, unknown> | undefined;
-  if (typeof custom?.modelId === "string") return custom.modelId;
-  return undefined;
-}
-
-function buildAiSdkV6Result(
-  textParts: string[],
-  toolCalls: AssistantCloudRunReportToolCall[],
-  totalSteps: number,
-  metadata?: Record<string, unknown>,
-  stepsData?: { tool_calls: AssistantCloudRunReportToolCall[] }[],
-  usage?: {
-    inputTokens?: number;
-    outputTokens?: number;
-    reasoningTokens?: number;
-    cachedInputTokens?: number;
-  },
-): TelemetryData {
-  const hasText = textParts.length > 0;
-  const outputText = hasText
-    ? truncateRunTelemetryText(textParts.join(""))
-    : undefined;
-  const modelId = extractModelId(metadata);
-
-  const steps: TelemetryStepData[] | undefined =
-    stepsData && stepsData.length > 1
-      ? stepsData.map((s) => ({
-          ...(s.tool_calls.length > 0
-            ? { tool_calls: s.tool_calls }
-            : undefined),
-        }))
-      : undefined;
-
-  return {
-    status: hasText ? "completed" : "incomplete",
-    ...(toolCalls.length > 0 ? { toolCalls } : undefined),
-    ...(totalSteps > 0 ? { totalSteps } : undefined),
-    ...(usage?.inputTokens != null
-      ? { inputTokens: usage.inputTokens }
-      : undefined),
-    ...(usage?.outputTokens != null
-      ? { outputTokens: usage.outputTokens }
-      : undefined),
-    ...(usage?.reasoningTokens != null
-      ? { reasoningTokens: usage.reasoningTokens }
-      : undefined),
-    ...(usage?.cachedInputTokens != null
-      ? { cachedInputTokens: usage.cachedInputTokens }
+    ...(inputTokens != null ||
+    outputTokens != null ||
+    reasoningTokens != null ||
+    cachedInputTokens != null
+      ? {
+          usage: {
+            ...(inputTokens != null ? { inputTokens } : undefined),
+            ...(outputTokens != null ? { outputTokens } : undefined),
+            ...(reasoningTokens != null ? { reasoningTokens } : undefined),
+            ...(cachedInputTokens != null ? { cachedInputTokens } : undefined),
+          },
+        }
       : undefined),
     ...(outputText != null ? { outputText } : undefined),
     ...(metadata ? { metadata } : undefined),
-    ...(steps ? { steps } : undefined),
+    ...(telemetrySteps ? { steps: telemetrySteps } : undefined),
     ...(modelId ? { modelId } : undefined),
   };
 }
 
-function extractAiSdkV6Usage(metadata?: Record<string, unknown>):
-  | {
-      inputTokens?: number;
-      outputTokens?: number;
-      reasoningTokens?: number;
-      cachedInputTokens?: number;
-    }
-  | undefined {
-  // Try top-level metadata.usage
-  const usage = metadata?.usage as RunTelemetryUsageInit | undefined;
-  if (usage) {
-    const normalized = normalizeRunTelemetryUsage(usage);
-    if (normalized) return normalized;
-  }
-
-  // Try aggregating from metadata.steps[].usage
-  const steps = metadata?.steps as
-    | readonly { usage?: RunTelemetryUsageInit }[]
-    | undefined;
-  if (steps && steps.length > 0) {
-    let inputTokens = 0;
-    let outputTokens = 0;
-    let reasoningTokens = 0;
-    let cachedInputTokens = 0;
-    let hasInput = false;
-    let hasOutput = false;
-    let hasReasoning = false;
-    let hasCachedInput = false;
-    let hasAny = false;
-    for (const s of steps) {
-      if (!s.usage) continue;
-      const n = normalizeRunTelemetryUsage(s.usage);
-      if (n) {
-        if (n.inputTokens != null) {
-          inputTokens += n.inputTokens;
-          hasInput = true;
-        }
-        if (n.outputTokens != null) {
-          outputTokens += n.outputTokens;
-          hasOutput = true;
-        }
-        if (n.reasoningTokens != null) {
-          reasoningTokens += n.reasoningTokens;
-          hasReasoning = true;
-        }
-        if (n.cachedInputTokens != null) {
-          cachedInputTokens += n.cachedInputTokens;
-          hasCachedInput = true;
-        }
-        hasAny = true;
-      }
-    }
-    if (hasAny) {
-      return {
-        ...(hasInput ? { inputTokens } : undefined),
-        ...(hasOutput ? { outputTokens } : undefined),
-        ...(hasReasoning ? { reasoningTokens } : undefined),
-        ...(hasCachedInput ? { cachedInputTokens } : undefined),
-      };
-    }
-  }
-
-  return undefined;
-}
-
-function extractAiSdkV6<T>(content: T): TelemetryData | null {
-  const msg = content as AiSdkV6Message;
-  if (msg.role !== "assistant") return null;
-
-  const { textParts, toolCalls, stepsData } = collectAiSdkV6Parts(
-    msg.parts ?? [],
-  );
-  return buildAiSdkV6Result(
-    textParts,
-    toolCalls,
-    stepsData.length,
-    msg.metadata,
-    stepsData,
-    extractAiSdkV6Usage(msg.metadata),
-  );
-}
-
-function aggregateAiSdkV6RunSteps<T>(stepMessages: T[]): TelemetryData | null {
-  const allTextParts: string[] = [];
-  const allToolCalls: AssistantCloudRunReportToolCall[] = [];
-  const allStepsData: { tool_calls: AssistantCloudRunReportToolCall[] }[] = [];
-  let hasAssistant = false;
-  let metadata: Record<string, unknown> | undefined;
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let reasoningTokens = 0;
-  let cachedInputTokens = 0;
-  let hasInput = false;
-  let hasOutput = false;
-  let hasReasoning = false;
-  let hasCachedInput = false;
-
-  for (const content of stepMessages) {
-    const msg = content as AiSdkV6Message;
-    if (msg.role !== "assistant") continue;
-    hasAssistant = true;
-
-    const { textParts, toolCalls, stepsData } = collectAiSdkV6Parts(
-      msg.parts ?? [],
-    );
-    allTextParts.push(...textParts);
-    allToolCalls.push(...toolCalls);
-    allStepsData.push(...stepsData);
-    if (msg.metadata) metadata = msg.metadata;
-
-    const usage = extractAiSdkV6Usage(msg.metadata);
-    if (usage) {
-      if (usage.inputTokens != null) {
-        inputTokens += usage.inputTokens;
-        hasInput = true;
-      }
-      if (usage.outputTokens != null) {
-        outputTokens += usage.outputTokens;
-        hasOutput = true;
-      }
-      if (usage.reasoningTokens != null) {
-        reasoningTokens += usage.reasoningTokens;
-        hasReasoning = true;
-      }
-      if (usage.cachedInputTokens != null) {
-        cachedInputTokens += usage.cachedInputTokens;
-        hasCachedInput = true;
-      }
-    }
-  }
-
-  if (!hasAssistant) return null;
-  return buildAiSdkV6Result(
-    allTextParts,
-    allToolCalls,
-    allStepsData.length,
-    metadata,
-    allStepsData,
-    {
-      ...(hasInput ? { inputTokens } : undefined),
-      ...(hasOutput ? { outputTokens } : undefined),
-      ...(hasReasoning ? { reasoningTokens } : undefined),
-      ...(hasCachedInput ? { cachedInputTokens } : undefined),
-    },
-  );
-}
-
 export function useAssistantCloudThreadHistoryAdapter(
   cloudRef: RefObject<AssistantCloud>,
-): ThreadHistoryAdapter {
+): ThreadHistoryAdapter & { readonly feedback: FeedbackAdapter } {
   const aui = useAui();
   // Not useEffectEvent: history adapter methods run during render (SSR load).
   const auiRef = useRef(aui);
@@ -777,5 +692,180 @@ export function useAssistantCloudThreadHistoryAdapter(
     () =>
       new AssistantCloudThreadHistoryAdapter(cloudRef, () => auiRef.current),
   );
+  useAssistantCloudEngagementEvents(adapter, aui);
   return adapter;
 }
+
+type RootEngagementTracker = {
+  count: number;
+  engagementReporter: CloudEngagementReporter;
+  dispose: () => void;
+};
+
+const rootEngagementTrackers = new WeakMap<
+  AssistantClient,
+  RootEngagementTracker
+>();
+
+/**
+ * Thread switches are a thread list event, so one subscription per assistant
+ * client reports them; every thread runtime mounted under it shares the
+ * subscription and the last one to unmount removes it.
+ */
+const useRootEngagementEvents = (
+  adapter: AssistantCloudThreadHistoryAdapter,
+  aui: AssistantClient,
+) => {
+  useEffect(() => {
+    let tracker = rootEngagementTrackers.get(aui);
+    if (!tracker) {
+      const created: RootEngagementTracker = {
+        count: 0,
+        engagementReporter: adapter.engagementReporter,
+        dispose: () => {},
+      };
+      created.dispose = aui.on(
+        { scope: "*", event: "threads.selectionChanged" },
+        (payload) => {
+          created.engagementReporter.threadSwitched(payload.threadId);
+        },
+      );
+      rootEngagementTrackers.set(aui, created);
+      tracker = created;
+    }
+    const active = tracker;
+    active.engagementReporter = adapter.engagementReporter;
+    active.count += 1;
+    return () => {
+      active.count -= 1;
+      if (active.count === 0) {
+        active.dispose();
+        rootEngagementTrackers.delete(aui);
+      }
+    };
+  }, [adapter, aui]);
+};
+
+const useAssistantCloudEngagementEvents = (
+  adapter: AssistantCloudThreadHistoryAdapter,
+  aui: AssistantClient,
+) => {
+  useRootEngagementEvents(adapter, aui);
+
+  useEffect(() => {
+    const reporter = adapter.engagementReporter;
+
+    const unsubscribers = [
+      aui.on({ scope: "thread", event: "composer.send" }, (payload) => {
+        if (payload.messageId) {
+          reporter.messageEdited(payload.threadId, {
+            messageId: payload.messageId,
+            chars: payload.chars,
+          });
+        } else {
+          reporter.messageSent(payload.threadId, {
+            chars: payload.chars,
+            attachments: payload.attachments,
+          });
+        }
+        if (payload.suggestion) {
+          reporter.suggestionClicked(payload.threadId);
+        }
+      }),
+      aui.on(
+        { scope: "thread", event: "composer.attachmentAdd" },
+        (payload) => {
+          reporter.attachmentAdded(payload.threadId, {
+            messageId: payload.messageId,
+            contentType: payload.contentType,
+          });
+        },
+      ),
+      aui.on(
+        { scope: "thread", event: "composer.attachmentAddError" },
+        (payload) => {
+          reporter.attachmentFailed(payload.threadId, {
+            messageId: payload.messageId,
+            contentType: payload.contentType,
+          });
+        },
+      ),
+      aui.on({ scope: "thread", event: "composer.cancel" }, (payload) => {
+        reporter.runStopped(payload.threadId);
+      }),
+      aui.on({ scope: "thread", event: "thread.runStart" }, (payload) => {
+        reporter.runStarted(payload.threadId);
+      }),
+      aui.on({ scope: "thread", event: "thread.runEnd" }, (payload) => {
+        reporter.runEnded(payload.threadId);
+      }),
+      aui.on({ scope: "thread", event: "thread.cancelRun" }, (payload) => {
+        reporter.runStopped(payload.threadId);
+      }),
+      aui.on({ scope: "thread", event: "thread.voiceStarted" }, (payload) => {
+        reporter.voiceStarted(payload.threadId);
+      }),
+      aui.on({ scope: "thread", event: "message.reload" }, (payload) => {
+        reporter.messageRegenerated(payload.threadId, payload.messageId);
+      }),
+      aui.on(
+        { scope: "thread", event: "message.branchSwitched" },
+        (payload) => {
+          reporter.branchSwitched(payload.threadId, payload.messageId);
+        },
+      ),
+      aui.on({ scope: "thread", event: "message.copied" }, (payload) => {
+        reporter.messageCopied(payload.threadId, payload.messageId);
+      }),
+      aui.on(
+        { scope: "thread", event: "thread.toolApprovalAnswered" },
+        (payload) => {
+          if (payload.approved) {
+            reporter.toolApproved(
+              payload.threadId,
+              payload.messageId,
+              payload.toolCallId,
+              payload.toolName,
+            );
+          } else {
+            reporter.toolRejected(
+              payload.threadId,
+              payload.messageId,
+              payload.toolCallId,
+              payload.toolName,
+            );
+          }
+        },
+      ),
+      aui.on({ scope: "thread", event: "message.speak" }, (payload) => {
+        reporter.speechStarted(payload.threadId, payload.messageId);
+      }),
+      aui.on({ scope: "thread", event: "message.error" }, (payload) => {
+        reporter.errorShown(payload.threadId, {
+          messageId: payload.messageId,
+          reason: payload.reason,
+        });
+      }),
+    ];
+
+    return () => {
+      for (const unsubscribe of unsubscribers) unsubscribe();
+    };
+  }, [adapter, aui]);
+
+  useEffect(() => {
+    const reportSuggestions = () => {
+      const { mainThreadId } = aui.threads.getState();
+      if (aui.threadListItem.getState().id !== mainThreadId) return;
+      const { isEmpty, suggestions } = aui.thread.getState();
+      if (!isEmpty || suggestions.length === 0) return;
+      adapter.engagementReporter.suggestionsShown(
+        mainThreadId,
+        suggestions.length,
+      );
+    };
+
+    reportSuggestions();
+    return aui.subscribe(reportSuggestions);
+  }, [adapter, aui]);
+};