@assistant-ui/core 0.3.20 → 0.3.21

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

@@ -8,9 +8,16 @@ import type {
 } from "../../../adapters/thread-history";
 import type { ExportedMessageRepositoryItem } from "../../../runtime/utils/message-repository";
 import type { ThreadMessage } from "../../../types";
+import type { Unstable_ToolInteractionLog } from "../../../types/message";
+import {
+  appendToolInteraction,
+  readToolInteractionLog,
+} from "../../../runtime/utils/tool-interactions";
+import { isJSONValueEqual } from "../../../utils/json/is-json-equal";
 import {
   type AssistantCloud,
   type AssistantCloudEvent,
+  CloudAPIError,
   CloudEngagementReporter,
   CloudMessagePersistence,
   CloudRunReporter,
@@ -34,6 +41,11 @@ import { auiV0DecodeSafely, 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";
+import {
+  isStoredMessageStatus,
+  parseStoredThreadSteps,
+} from "../../../runtime/utils/stored-message-parts";
+import { runCleanups } from "../../../subscribable/subscribable";
 
 type CloudThreadListItem = Pick<
   ThreadListItemMethods,
@@ -45,11 +57,76 @@ const globalPersistence = new WeakMap<
   CloudMessagePersistence
 >();
 
+// Kept per persistence so they share the id mapping's lifetime: ids whose stored aui/v0 entry is settled, and ids whose run a write has reported.
+const runLedgers = new WeakMap<
+  CloudMessagePersistence,
+  { settled: Set<string>; reported: Set<string> }
+>();
+
+const runLedgerOf = (persistence: CloudMessagePersistence) => {
+  let ledger = runLedgers.get(persistence);
+  if (!ledger) {
+    ledger = { settled: new Set<string>(), reported: new Set<string>() };
+    runLedgers.set(persistence, ledger);
+  }
+  return ledger;
+};
+
+const isSettledMessage = (message: ThreadMessage) =>
+  message.role === "assistant" &&
+  (message.status.type === "complete" || message.status.type === "incomplete");
+
+const mergeInteractionLogs = (
+  stored: Unstable_ToolInteractionLog | undefined,
+  current: Unstable_ToolInteractionLog | undefined,
+): Unstable_ToolInteractionLog | undefined => {
+  const incoming = readToolInteractionLog(current);
+  if (!stored) return incoming;
+  if (!incoming) return stored;
+  const omitted = Math.max(stored.omitted ?? 0, incoming.omitted ?? 0);
+  let merged: Unstable_ToolInteractionLog = {
+    entries: stored.entries,
+    ...(omitted ? { omitted } : undefined),
+  };
+  for (const entry of incoming.entries) {
+    if (
+      merged.entries.some(
+        (existing) =>
+          existing.type === entry.type &&
+          existing.occurredAt === entry.occurredAt &&
+          isJSONValueEqual(existing.payload, entry.payload),
+      )
+    ) {
+      continue;
+    }
+    merged = appendToolInteraction(merged, entry);
+  }
+  return merged;
+};
+
+type CopiedThread = {
+  stored: Set<string>;
+  refused: Set<string>;
+  closed: boolean;
+  interactions: Map<string, Unstable_ToolInteractionLog>;
+};
+
+const RETRIED_COPY_STATUSES = new Set([401, 403, 408, 429]);
+// The thread is gone, or its end user may not write this month.
+const THREAD_REFUSAL_STATUSES = new Set([402, 404]);
+
+const isRefusedCopy = (error: unknown): error is CloudAPIError =>
+  error instanceof CloudAPIError &&
+  error.status >= 400 &&
+  error.status < 500 &&
+  !RETRIED_COPY_STATUSES.has(error.status);
+
 class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
   private cloudRef: RefObject<AssistantCloud>;
   private getAui: () => AssistantClient;
   private runReporter: CloudRunReporter;
-  public readonly engagementReporter: CloudEngagementReporter;
+  private copiedThreads = new Map<string, Promise<CopiedThread>>();
+  private copyQueues = new Map<string, Promise<void>>();
 
   constructor(
     cloudRef: RefObject<AssistantCloud>,
@@ -58,17 +135,23 @@ 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 {
     return this.getAui();
   }
 
+  public getCloud(): AssistantCloud {
+    return this.cloudRef.current;
+  }
+
+  public ownsThread(threadId: string): boolean {
+    const live = this.aui.threadListItem;
+    if (!live.source) return false;
+    const { id, remoteId } = live.getState();
+    return id === threadId || remoteId === threadId;
+  }
+
   private getPersistence(
     threadListItem: CloudThreadListItem = this.aui.threadListItem,
   ): CloudMessagePersistence {
@@ -90,15 +173,18 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
    * 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.
+   * an empty remote thread just to attribute an event. A thread the list does
+   * not know resolves to nothing, which declines the event.
    */
   public async resolveEngagementEventIds(
     threadId: string,
     messageId?: string,
     options?: { awaitThread?: boolean },
-  ): Promise<Pick<AssistantCloudEvent, "thread_id" | "message_id">> {
+  ): Promise<
+    Pick<AssistantCloudEvent, "thread_id" | "message_id"> | undefined
+  > {
     const threadListItem = this.getThreadListItem(threadId);
-    if (!threadListItem) return {};
+    if (!threadListItem) return undefined;
 
     let remoteThreadId = threadListItem.getState().remoteId;
     if (!remoteThreadId && options?.awaitThread) {
@@ -167,9 +253,11 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
 
   private getThreadListItem(threadId: string): CloudThreadListItem | undefined {
     const current = this.aui.threadListItem;
-    const currentState = current.getState();
-    if (currentState.id === threadId || currentState.remoteId === threadId) {
-      return current;
+    if (current.source) {
+      const currentState = current.getState();
+      if (currentState.id === threadId || currentState.remoteId === threadId) {
+        return current;
+      }
     }
 
     const listed = this.aui.threads
@@ -262,45 +350,234 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
 
   async append({ parentId, message }: ExportedMessageRepositoryItem) {
     const { remoteId } = await this.aui.threadListItem.initialize();
-    const encoded = auiV0Encode(message);
-    await this._persistence.append(
-      remoteId,
-      message.id,
-      parentId,
-      "aui/v0",
-      encoded,
+    const persistence = this._persistence;
+    await this._writeMessage(persistence, remoteId, message, (encoded) =>
+      persistence.append(remoteId, message.id, parentId, "aui/v0", encoded),
     );
-
-    if (this.cloudRef.current.telemetry.enabled) {
-      this._maybeReportRun(
-        remoteId,
-        "aui/v0",
-        encoded,
-        extractRunMessageInfo(message, "aui/v0"),
-      );
-    }
   }
 
   async update(item: ExportedMessageRepositoryItem) {
-    if (!this._persistence.isPersisted(item.message.id)) {
+    const persistence = this._persistence;
+    if (!persistence.isPersisted(item.message.id)) {
       return this.append(item);
     }
     const { message } = item;
     const remoteId = this.aui.threadListItem.getState().remoteId;
     if (!remoteId) return;
-    const encoded = auiV0Encode(message);
-    await this._persistence.update(remoteId, message.id, "aui/v0", encoded);
-
-    if (this.cloudRef.current.telemetry.enabled) {
-      this._maybeReportRun(
-        remoteId,
-        "aui/v0",
-        encoded,
-        extractRunMessageInfo(message, "aui/v0"),
+    await this._writeMessage(persistence, remoteId, message, (encoded) =>
+      persistence.update(remoteId, message.id, "aui/v0", encoded),
+    );
+  }
+
+  get unstable_copy() {
+    const telemetry = this.cloudRef.current?.telemetry;
+    return telemetry?.enabled === false || telemetry?.messages === false
+      ? undefined
+      : this.copy;
+  }
+
+  private copy = async (
+    branch: readonly ThreadMessage[],
+    messageIds: readonly string[],
+  ): Promise<void> => {
+    const cloud = this.cloudRef.current;
+    if (messageIds.length === 0) return;
+
+    const threadListItem = this.tryGetKeyedThreadListItem();
+    if (!threadListItem) {
+      throw new Error("Cannot copy cloud history without a thread list item.");
+    }
+    const remoteId = (await threadListItem.initialize()).remoteId;
+    const persistence = this.getPersistence(threadListItem);
+    const previous = this.copyQueues.get(remoteId);
+    const task = (previous ?? Promise.resolve())
+      .catch(() => undefined)
+      .then(() =>
+        this.copyBranch(cloud, remoteId, persistence, branch, messageIds),
       );
+    this.copyQueues.set(remoteId, task);
+    try {
+      await task;
+    } finally {
+      if (this.copyQueues.get(remoteId) === task) {
+        this.copyQueues.delete(remoteId);
+      }
+    }
+  };
+
+  private async copyBranch(
+    cloud: AssistantCloud,
+    remoteId: string,
+    persistence: CloudMessagePersistence,
+    branch: readonly ThreadMessage[],
+    messageIds: readonly string[],
+  ): Promise<void> {
+    let inventory = this.copiedThreads.get(remoteId);
+    if (!inventory) {
+      inventory = (async (): Promise<CopiedThread> => {
+        const copied: CopiedThread = {
+          stored: new Set(),
+          refused: new Set(),
+          closed: false,
+          interactions: new Map(),
+        };
+        const seen = new Set<string>();
+        let after: string | undefined;
+        while (true) {
+          const page = await cloud.threads.messages.list(remoteId, {
+            limit: 200,
+            ...(after ? { after } : undefined),
+          });
+          // A cursor the server cannot resolve drops the keyset filter and replays
+          // an earlier page, so already-seen rows end the walk instead of repeating.
+          const fresh = page.messages.filter((row) => !seen.has(row.id));
+          for (const row of fresh) {
+            seen.add(row.id);
+            if (!row.external_id || row.format !== "aui/v0") continue;
+            copied.stored.add(row.external_id);
+            persistence.record(row.external_id, row.id);
+            const decoded = auiV0DecodeSafely(
+              row as typeof row & { format: "aui/v0" },
+            );
+            for (const part of decoded?.message.content ?? []) {
+              if (part.type !== "tool-call") continue;
+              const merged = mergeInteractionLogs(
+                copied.interactions.get(part.toolCallId),
+                part.unstable_interactions,
+              );
+              if (merged) copied.interactions.set(part.toolCallId, merged);
+            }
+          }
+          const last = page.messages.at(-1);
+          if (fresh.length === 0 || page.messages.length < 200 || !last) break;
+          after = last.id;
+        }
+        return copied;
+      })();
+      this.copiedThreads.set(remoteId, inventory);
+    }
+
+    let copied: CopiedThread;
+    try {
+      copied = await inventory;
+    } catch (error) {
+      if (this.copiedThreads.get(remoteId) === inventory) {
+        this.copiedThreads.delete(remoteId);
+      }
+      throw error;
+    }
+    if (copied.closed) return;
+
+    const eligible = branch.filter(
+      (message) => message.id.length > 0 && message.id.length <= 255,
+    );
+    const changed = new Set(messageIds);
+    let next = 0;
+    let parent: string | undefined;
+    for (let index = 0; index < eligible.length; index++) {
+      if (!changed.has(eligible[index]!.id)) continue;
+      for (; next <= index; next++) {
+        const message = eligible[next]!;
+        if (
+          next !== index &&
+          (copied.stored.has(message.id) || copied.refused.has(message.id))
+        ) {
+          if (copied.stored.has(message.id)) parent = message.id;
+          continue;
+        }
+        const encoded = auiV0Encode(message);
+        const content = {
+          ...encoded,
+          content: encoded.content.map((part) => {
+            if (part.type !== "tool-call") return part;
+            const interactions = mergeInteractionLogs(
+              copied.interactions.get(part.toolCallId),
+              part.unstable_interactions,
+            );
+            return {
+              ...part,
+              ...(interactions
+                ? { unstable_interactions: interactions }
+                : undefined),
+            };
+          }),
+        };
+        let message_id: string;
+        try {
+          ({ message_id } = await cloud.threads.messages.create(remoteId, {
+            parent_id: null,
+            format: "aui/v0",
+            content,
+            external_id: message.id,
+            ...(parent ? { parent_external_id: parent } : undefined),
+          }));
+        } catch (error) {
+          if (!isRefusedCopy(error)) throw error;
+          // Two refusals before any accepted message mean the cloud takes none of the thread, as a server without external ids does; one alone may be an oversized first message.
+          if (
+            THREAD_REFUSAL_STATUSES.has(error.status) ||
+            (copied.stored.size === 0 && copied.refused.size > 0)
+          ) {
+            copied.closed = true;
+            console.warn(
+              `[assistant-ui] The cloud refused copies to thread ${remoteId}; the dashboard shows the conversation as far as it was copied.`,
+              error,
+            );
+            return;
+          }
+          copied.refused.add(message.id);
+          console.warn(
+            `[assistant-ui] The cloud refused the copy of message ${message.id}; the dashboard shows the conversation without it.`,
+            error,
+          );
+          continue;
+        }
+        copied.stored.add(message.id);
+        copied.refused.delete(message.id);
+        parent = message.id;
+        persistence.record(message.id, message_id);
+        for (const part of content.content) {
+          if (part.type === "tool-call" && part.unstable_interactions) {
+            copied.interactions.set(
+              part.toolCallId,
+              part.unstable_interactions,
+            );
+          }
+        }
+      }
     }
   }
 
+  // A run is reported once, by the write that first stores its message as settled; rewriting that entry later, as a late tool result does, is not a new run. Eligibility is read before the write, so a load that reads the write back cannot take the report, and the report is claimed after it, so overlapping writes of one message report once.
+  private async _writeMessage(
+    persistence: CloudMessagePersistence,
+    remoteId: string,
+    message: ThreadMessage,
+    write: (encoded: ReturnType<typeof auiV0Encode>) => Promise<void>,
+  ) {
+    const encoded = auiV0Encode(message);
+    const ledger = runLedgerOf(persistence);
+    const firstSettle =
+      isSettledMessage(message) && !ledger.settled.has(message.id);
+    await write(encoded);
+    if (!firstSettle) return;
+    ledger.settled.add(message.id);
+    if (ledger.reported.has(message.id)) return;
+
+    if (!this.cloudRef.current.telemetry.enabled) return;
+    const extracted = extractTelemetry("aui/v0", encoded);
+    if (!extracted) return;
+    ledger.reported.add(message.id);
+    this._sendReport(
+      remoteId,
+      extracted,
+      undefined,
+      undefined,
+      extractRunMessageInfo(message, "aui/v0"),
+      persistence,
+    );
+  }
+
   async delete() {
     throw new Error(
       "Assistant Cloud does not support deleting thread messages yet.",
@@ -310,7 +587,8 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
   async load() {
     const remoteId = this.aui.threadListItem.getState().remoteId;
     if (!remoteId) return { messages: [] };
-    const messages = await this._persistence.load(remoteId, "aui/v0");
+    const persistence = this._persistence;
+    const messages = await persistence.load(remoteId, "aui/v0");
     // The cloud lists rows newest first, so walking them oldest first puts a
     // parent ahead of its children and a row orphaned by an unreadable parent
     // can be dropped in the same pass; MessageRepository.import throws on a
@@ -323,11 +601,13 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
 
     const loaded: ExportedMessageRepositoryItem[] = [];
     const loadedIds = new Set<string>();
+    const { settled } = runLedgerOf(persistence);
     for (const row of rows) {
       const item = auiV0DecodeSafely(row);
       if (!item) continue;
       if (item.parentId && !loadedIds.has(item.parentId)) continue;
       loadedIds.add(item.message.id);
+      if (isSettledMessage(item.message)) settled.add(item.message.id);
       loaded.push(item);
     }
 
@@ -365,18 +645,6 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
     );
   }
 
-  private _maybeReportRun<T>(
-    remoteId: string,
-    format: string,
-    content: T,
-    messageInfo?: RunMessageInfo,
-  ) {
-    const extracted = extractTelemetry(format, content);
-    if (!extracted) return;
-
-    this._sendReport(remoteId, extracted, undefined, undefined, messageInfo);
-  }
-
   private _sendReport(
     remoteId: string,
     data: RunMessageTelemetry,
@@ -544,6 +812,63 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === "object";
 }
 
+const usageTokenKeys = [
+  "inputTokens",
+  "outputTokens",
+  "reasoningTokens",
+  "cachedInputTokens",
+  "promptTokens",
+  "completionTokens",
+] as const;
+
+const readTokenCount = (value: unknown): number | undefined =>
+  typeof value === "number" && Number.isFinite(value) && value >= 0
+    ? value
+    : undefined;
+
+const readStoredTelemetryUsage = (
+  value: unknown,
+): RunTelemetryUsageInit | undefined => {
+  if (!isRecord(value) || Array.isArray(value)) return undefined;
+
+  const usage: Record<string, unknown> = {};
+  for (const key of usageTokenKeys) {
+    const count = readTokenCount(value[key]);
+    if (count !== undefined) usage[key] = count;
+  }
+
+  const cacheReadTokens =
+    isRecord(value.inputTokenDetails) && !Array.isArray(value.inputTokenDetails)
+      ? readTokenCount(value.inputTokenDetails.cacheReadTokens)
+      : undefined;
+  if (cacheReadTokens !== undefined) {
+    usage.inputTokenDetails = { cacheReadTokens };
+  }
+
+  const reasoningTokens =
+    isRecord(value.outputTokenDetails) &&
+    !Array.isArray(value.outputTokenDetails)
+      ? readTokenCount(value.outputTokenDetails.reasoningTokens)
+      : undefined;
+  if (reasoningTokens !== undefined) {
+    usage.outputTokenDetails = { reasoningTokens };
+  }
+
+  return Object.keys(usage).length > 0
+    ? (usage as RunTelemetryUsageInit)
+    : undefined;
+};
+
+const parseStoredTelemetrySteps = (
+  value: unknown,
+): { usage?: RunTelemetryUsageInit }[] =>
+  parseStoredThreadSteps(value).map((step) => {
+    const usage = readStoredTelemetryUsage(
+      (step as Record<string, unknown>).usage,
+    );
+    return usage ? { usage } : {};
+  });
+
 function extractTelemetry<T>(
   format: string,
   content: T,
@@ -575,7 +900,7 @@ function extractRunTelemetry<T>(
 export function extractAuiV0<T>(content: T): RunMessageTelemetry | null {
   const msg = content as {
     role?: string;
-    status?: { type: string; reason?: string };
+    status?: unknown;
     content?: readonly {
       type: string;
       text?: string;
@@ -587,15 +912,25 @@ export function extractAuiV0<T>(content: T): RunMessageTelemetry | null {
     }[];
     metadata?: {
       modelId?: string;
-      steps?: readonly { usage?: RunTelemetryUsageInit }[];
+      steps?: unknown;
       custom?: Record<string, unknown> & { modelId?: string };
     };
   };
 
   if (msg.role !== "assistant") return null;
-  // A paused (requires-action) write is not a finished run; reporting it would
-  // mislabel it "completed" and double-count steps once the terminal write reports.
-  if (msg.status?.type === "requires-action") return null;
+  // A status the persistence boundary rejects carries no verdict, so reporting
+  // one would label the run from a value the thread itself never restores.
+  if (msg.status !== undefined && !isStoredMessageStatus(msg.status))
+    return null;
+  const statusType =
+    isRecord(msg.status) && typeof msg.status.type === "string"
+      ? msg.status.type
+      : undefined;
+  // A non-terminal write is not a finished run; reporting it would mislabel it
+  // "completed" and double-count steps once the terminal write reports.
+  if (statusType === "running" || statusType === "requires-action") {
+    return null;
+  }
 
   const toolCalls = msg.content
     ?.filter((p) => p.type === "tool-call" && p.toolName && p.toolCallId)
@@ -615,7 +950,7 @@ export function extractAuiV0<T>(content: T): RunMessageTelemetry | null {
       ? truncateRunTelemetryText(textParts.map((p) => p.text).join(""))
       : undefined;
 
-  const steps = msg.metadata?.steps;
+  const steps = parseStoredTelemetrySteps(msg.metadata?.steps);
   let inputTokens: number | undefined;
   let outputTokens: number | undefined;
   let reasoningTokens: number | undefined;
@@ -656,7 +991,7 @@ export function extractAuiV0<T>(content: T): RunMessageTelemetry | null {
     cachedInputTokens = hasCachedInput ? totalCachedInput : undefined;
   }
 
-  const status = msg.status?.type === "incomplete" ? "incomplete" : "completed";
+  const status = statusType === "incomplete" ? "incomplete" : "completed";
 
   const metadata = msg.metadata?.custom as Record<string, unknown> | undefined;
   const modelId = extractRunTelemetryModelId(
@@ -664,9 +999,7 @@ export function extractAuiV0<T>(content: T): RunMessageTelemetry | null {
   );
 
   const telemetrySteps: RunReportStepInit[] | undefined =
-    steps && steps.length > 0
-      ? steps.map((step) => (step.usage ? { usage: step.usage } : {}))
-      : undefined;
+    steps.length > 0 ? steps : undefined;
 
   return {
     status,
@@ -709,176 +1042,198 @@ export function useAssistantCloudThreadHistoryAdapter(
   return adapter;
 }
 
-type RootEngagementTracker = {
-  count: number;
-  engagementReporter: CloudEngagementReporter;
-  dispose: () => void;
+type EngagementTracker = {
+  mounted: Map<AssistantCloudThreadHistoryAdapter, AssistantClient>;
+  lastMounted: AssistantCloudThreadHistoryAdapter;
+  reporter: CloudEngagementReporter;
+  host: AssistantClient | undefined;
+  dispose: (() => void) | undefined;
 };
 
-const rootEngagementTrackers = new WeakMap<
-  AssistantClient,
-  RootEngagementTracker
+const engagementTrackers = new WeakMap<
+  getClientId.ClientId,
+  EngagementTracker
 >();
 
-/**
- * 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 = (
+const mountedAdapter = (
+  tracker: EngagementTracker,
+  threadId?: string,
+): AssistantCloudThreadHistoryAdapter => {
+  let fallback: AssistantCloudThreadHistoryAdapter | undefined;
+  for (const adapter of tracker.mounted.keys()) {
+    if (threadId !== undefined && adapter.ownsThread(threadId)) return adapter;
+    fallback ??= adapter;
+  }
+  return fallback ?? tracker.lastMounted;
+};
+
+const createEngagementTracker = (
   adapter: AssistantCloudThreadHistoryAdapter,
+): EngagementTracker => {
+  const tracker: EngagementTracker = {
+    mounted: new Map(),
+    lastMounted: adapter,
+    reporter: new CloudEngagementReporter(
+      () => mountedAdapter(tracker).getCloud(),
+      (threadId, messageId, options) =>
+        mountedAdapter(tracker, threadId).resolveEngagementEventIds(
+          threadId,
+          messageId,
+          options,
+        ),
+    ),
+    host: undefined,
+    dispose: undefined,
+  };
+  return tracker;
+};
+
+const subscribeEngagementEvents = (
   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);
+  reporter: CloudEngagementReporter,
+): (() => void) => {
+  const reportSuggestions = () => {
+    const { mainThreadId } = aui.threads.getState();
+    const { isEmpty, suggestions } = aui.thread.getState();
+    if (!isEmpty || suggestions.length === 0) return;
+    reporter.suggestionsShown(mainThreadId, suggestions.length);
+  };
+
+  const unsubscribers = [
+    aui.on({ scope: "*", event: "threads.selectionChanged" }, (payload) => {
+      reporter.threadSwitched(payload.threadId);
+    }),
+    aui.on({ scope: "*", 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,
+        });
       }
-    };
-  }, [adapter, aui]);
+      if (payload.suggestion) {
+        reporter.suggestionClicked(payload.threadId);
+      }
+    }),
+    aui.on({ scope: "*", event: "composer.attachmentAdd" }, (payload) => {
+      reporter.attachmentAdded(payload.threadId, {
+        messageId: payload.messageId,
+        contentType: payload.contentType,
+      });
+    }),
+    aui.on({ scope: "*", event: "composer.attachmentAddError" }, (payload) => {
+      reporter.attachmentFailed(payload.threadId, {
+        messageId: payload.messageId,
+        contentType: payload.contentType,
+      });
+    }),
+    aui.on({ scope: "*", event: "composer.cancel" }, (payload) => {
+      reporter.runStopped(payload.threadId);
+    }),
+    aui.on({ scope: "*", event: "thread.runStart" }, (payload) => {
+      reporter.runStarted(payload.threadId);
+    }),
+    aui.on({ scope: "*", event: "thread.runEnd" }, (payload) => {
+      reporter.runEnded(payload.threadId);
+    }),
+    aui.on({ scope: "*", event: "thread.cancelRun" }, (payload) => {
+      reporter.runStopped(payload.threadId);
+    }),
+    aui.on({ scope: "*", event: "thread.voiceStarted" }, (payload) => {
+      reporter.voiceStarted(payload.threadId);
+    }),
+    aui.on({ scope: "*", event: "message.reload" }, (payload) => {
+      reporter.messageRegenerated(payload.threadId, payload.messageId);
+    }),
+    aui.on({ scope: "*", event: "message.branchSwitched" }, (payload) => {
+      reporter.branchSwitched(payload.threadId, payload.messageId);
+    }),
+    aui.on({ scope: "*", event: "message.copied" }, (payload) => {
+      reporter.messageCopied(payload.threadId, payload.messageId);
+    }),
+    aui.on({ scope: "*", 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: "*", event: "message.speak" }, (payload) => {
+      reporter.speechStarted(payload.threadId, payload.messageId);
+    }),
+    aui.on({ scope: "*", event: "message.error" }, (payload) => {
+      reporter.errorShown(payload.threadId, {
+        messageId: payload.messageId,
+        reason: payload.reason,
+      });
+    }),
+    aui.subscribe(reportSuggestions),
+  ];
+
+  reportSuggestions();
+  return () => runCleanups(unsubscribers);
+};
+
+const installEngagementEvents = (
+  tracker: EngagementTracker,
+  host: AssistantClient,
+) => {
+  tracker.host = host;
+  tracker.dispose = subscribeEngagementEvents(host, tracker.reporter);
+};
+
+const uninstallEngagementEvents = (tracker: EngagementTracker) => {
+  const dispose = tracker.dispose;
+  tracker.host = undefined;
+  tracker.dispose = undefined;
+  dispose?.();
 };
 
+/**
+ * The client delivers an event to every listener once per emission, and a
+ * thread runtime, with this adapter inside it, mounts once per visited
+ * thread. One subscription set per thread list therefore reports each event
+ * once, attributed by the thread id the event carries, and the reporter that
+ * keeps run timing per thread lives as long as the list. The subscriptions
+ * ride on one mounted thread's client, because a thread's own client stops
+ * forwarding state notifications once its runtime unmounts, so they move to
+ * another mounted thread when their host leaves.
+ */
 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,
-        });
-      }),
-    ];
-
+    const key = getClientId(aui.threads);
+    let tracker = engagementTrackers.get(key);
+    if (!tracker) {
+      tracker = createEngagementTracker(adapter);
+      engagementTrackers.set(key, tracker);
+    }
+    const active = tracker;
+    active.mounted.set(adapter, aui);
+    active.lastMounted = adapter;
+    if (active.host === undefined) installEngagementEvents(active, aui);
     return () => {
-      for (const unsubscribe of unsubscribers) unsubscribe();
+      active.mounted.delete(adapter);
+      if (active.host !== aui) return;
+      uninstallEngagementEvents(active);
+      const next = active.mounted.values().next();
+      if (!next.done) installEngagementEvents(active, next.value);
     };
   }, [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]);
 };