@assistant-ui/core 0.3.16 → 0.3.18

package/dist/react/runtimes/cloud/AssistantCloudThreadHistoryAdapter.js

@@ -1,7 +1,8 @@
 import { auiV0Decode, auiV0Encode } from "./auiV0.js";
+import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 import { useEffect, useRef, useState } from "@assistant-ui/tap/react-shim";
 import { getClientId, useAui } from "@assistant-ui/store";
-import { CloudMessagePersistence, createFormattedPersistence, createRunTelemetryToolCall, normalizeRunTelemetryUsage, truncateRunTelemetryText } from "assistant-cloud";
+import { CloudMessagePersistence, createFormattedPersistence, createRunReport, createRunTelemetryToolCall, deriveRunOutcome, describeRunError, extractRunTelemetryModelId, normalizeRunTelemetryUsage, truncateRunTelemetryText } from "assistant-cloud";
 //#region src/react/runtimes/cloud/AssistantCloudThreadHistoryAdapter.ts
 const globalPersistence = /* @__PURE__ */ new WeakMap();
 var AssistantCloudThreadHistoryAdapter = class {
@@ -22,12 +23,54 @@ var AssistantCloudThreadHistoryAdapter = class {
 	get _persistence() {
 		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.
+	*/
+	async resolveEngagementEventIds(threadId, messageId, options) {
+		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(() => void 0);
+		const remoteMessageId = messageId ? this.getPersistence(threadListItem).getResolvedRemoteId(messageId) : void 0;
+		return {
+			...remoteThreadId ? { thread_id: remoteThreadId } : void 0,
+			...remoteMessageId ? { message_id: remoteMessageId } : void 0
+		};
+	}
+	feedback = { submit: ({ message, type }) => {
+		(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) => {
+			console.error("[assistant-ui] Cloud feedback submission failed:", error);
+		});
+	} };
 	tryGetKeyedThreadListItem() {
 		const live = this.aui.threadListItem;
 		if (!live.source) return void 0;
 		const id = live.getState().id;
 		if (id === void 0) return void 0;
-		return this.aui.threads.item({ id });
+		return this.aui.threads.getState().threadItems.some((item) => item.id === id || item.remoteId === id) ? this.aui.threads.item({ id }) : live;
+	}
+	getThreadListItem(threadId) {
+		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 }) : void 0;
 	}
 	withFormat(formatAdapter) {
 		const adapter = this;
@@ -38,7 +81,6 @@ var AssistantCloudThreadHistoryAdapter = class {
 			return threadListItem;
 		};
 		const resolvePinned = () => threadListItem ?? pinCurrent();
-		const getFormatted = () => createFormattedPersistence(adapter._persistence, formatAdapter);
 		const getTargetFormatted = (item) => createFormattedPersistence(adapter.getPersistence(item), formatAdapter);
 		return {
 			pin() {
@@ -61,14 +103,14 @@ var AssistantCloudThreadHistoryAdapter = class {
 			},
 			reportTelemetry(items, options) {
 				const encodedRunMessages = items.map((item) => formatAdapter.encode(item));
-				adapter._reportRunTelemetry(formatAdapter.format, encodedRunMessages, options, resolvePinned());
+				adapter._reportRunTelemetry(formatAdapter.format, encodedRunMessages, options, resolvePinned(), extractLastRunMessageInfo(items, formatAdapter));
 			},
 			async load() {
-				pinCurrent();
+				const pinned = pinCurrent();
 				const live = adapter.aui.threadListItem;
 				const remoteId = live.source ? live.getState().remoteId : void 0;
 				if (!remoteId) return { messages: [] };
-				return getFormatted().load(remoteId);
+				return getTargetFormatted(pinned ?? live).load(remoteId);
 			}
 		};
 	}
@@ -76,7 +118,7 @@ var AssistantCloudThreadHistoryAdapter = class {
 		const { remoteId } = await this.aui.threadListItem.initialize();
 		const encoded = auiV0Encode(message);
 		await this._persistence.append(remoteId, message.id, parentId, "aui/v0", encoded);
-		if (this.cloudRef.current.telemetry.enabled) this._maybeReportRun(remoteId, "aui/v0", encoded);
+		if (this.cloudRef.current.telemetry.enabled) this._maybeReportRun(remoteId, "aui/v0", encoded, extractRunMessageInfo(message, "aui/v0"));
 	}
 	async update(item) {
 		if (!this._persistence.isPersisted(item.message.id)) return this.append(item);
@@ -85,7 +127,7 @@ var AssistantCloudThreadHistoryAdapter = class {
 		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);
+		if (this.cloudRef.current.telemetry.enabled) this._maybeReportRun(remoteId, "aui/v0", encoded, extractRunMessageInfo(message, "aui/v0"));
 	}
 	async delete() {
 		throw new Error("Assistant Cloud does not support deleting thread messages yet.");
@@ -95,42 +137,68 @@ var AssistantCloudThreadHistoryAdapter = class {
 		if (!remoteId) return { messages: [] };
 		return { messages: (await this._persistence.load(remoteId, "aui/v0")).filter((m) => m.format === "aui/v0").map(auiV0Decode).reverse() };
 	}
-	_reportRunTelemetry(format, runMessages, options, threadListItem) {
+	_reportRunTelemetry(format, runMessages, options, threadListItem, messageInfo) {
 		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);
 		if (!extracted) return;
-		this._sendReport(remoteId, extracted, options?.durationMs, options?.stepTimestamps);
+		this._sendReport(remoteId, extracted, options?.durationMs, options?.stepTimestamps, messageInfo, this.getPersistence(item));
 	}
-	_maybeReportRun(remoteId, format, content) {
+	_maybeReportRun(remoteId, format, content, messageInfo) {
 		const extracted = extractTelemetry(format, content);
 		if (!extracted) return;
-		this._sendReport(remoteId, extracted);
+		this._sendReport(remoteId, extracted, void 0, void 0, messageInfo);
 	}
-	_sendReport(remoteId, data, durationMs, stepTimestamps) {
+	_sendReport(remoteId, data, durationMs, stepTimestamps, messageInfo, persistence = this._persistence) {
 		const mergedSteps = mergeStepTimestamps(data.steps, stepTimestamps);
-		const initial = {
-			thread_id: remoteId,
-			status: data.status,
-			...data.totalSteps != null ? { total_steps: data.totalSteps } : void 0,
-			...data.toolCalls ? { tool_calls: data.toolCalls } : void 0,
-			...mergedSteps ? { steps: mergedSteps } : void 0,
-			...data.inputTokens != null ? { input_tokens: data.inputTokens } : void 0,
-			...data.outputTokens != null ? { output_tokens: data.outputTokens } : void 0,
-			...data.reasoningTokens != null ? { reasoning_tokens: data.reasoningTokens } : void 0,
-			...data.cachedInputTokens != null ? { cached_input_tokens: data.cachedInputTokens } : void 0,
-			...durationMs != null ? { duration_ms: durationMs } : void 0,
-			...data.outputText != null ? { output_text: data.outputText } : void 0,
-			...data.metadata ? { metadata: data.metadata } : void 0,
-			...data.modelId ? { model_id: data.modelId } : void 0
-		};
+		const messageId = messageInfo?.localMessageId ? persistence.getResolvedRemoteId(messageInfo.localMessageId) : void 0;
+		const initial = createRunReport({
+			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: {
+				inputTokens: data.inputTokens,
+				outputTokens: data.outputTokens,
+				reasoningTokens: data.reasoningTokens,
+				cachedInputTokens: data.cachedInputTokens
+			},
+			steps: toRunReportSteps(mergedSteps),
+			totalSteps: data.totalSteps,
+			toolCalls: data.toolCalls,
+			durationMs,
+			firstTokenMs: messageInfo?.firstTokenMs,
+			outputText: data.outputText,
+			metadata: data.metadata,
+			telemetry: this.cloudRef.current.telemetry
+		});
 		const { beforeReport } = this.cloudRef.current.telemetry;
 		const report = beforeReport ? beforeReport(initial) : initial;
 		if (!report) return;
 		this.cloudRef.current.runs.report(report).catch(() => {});
 	}
 };
+function toRunReportSteps(steps) {
+	if (!steps) return void 0;
+	return steps.map((step) => ({
+		usage: {
+			inputTokens: step.input_tokens,
+			outputTokens: step.output_tokens,
+			reasoningTokens: step.reasoning_tokens,
+			cachedInputTokens: step.cached_input_tokens
+		},
+		toolCalls: step.tool_calls,
+		startMs: step.start_ms,
+		endMs: step.end_ms
+	}));
+}
 function mergeStepTimestamps(steps, timestamps) {
 	if (!timestamps) return steps;
 	if (!steps) return timestamps.map((t) => ({ ...t }));
@@ -140,6 +208,46 @@ function mergeStepTimestamps(steps, timestamps) {
 		...i < len ? timestamps[i] : void 0
 	}));
 }
+function extractLastRunMessageInfo(items, formatAdapter) {
+	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;
+	}
+}
+function extractRunMessageInfo(message, format, localMessageId) {
+	if (!isRecord(message) || message.role !== "assistant") return void 0;
+	const status = isRecord(message.status) ? message.status : void 0;
+	const metadata = isRecord(message.metadata) ? message.metadata : void 0;
+	const custom = isRecord(metadata?.custom) ? metadata.custom : void 0;
+	const timing = isRecord(metadata?.timing) ? metadata.timing : void 0;
+	const streamStartTime = timing?.streamStartTime;
+	const firstTokenTime = timing?.firstTokenTime;
+	const firstTokenMs = typeof streamStartTime === "number" && Number.isFinite(streamStartTime) && typeof firstTokenTime === "number" && Number.isFinite(firstTokenTime) ? Math.round(firstTokenTime - streamStartTime) : void 0;
+	const finishReason = status?.type === "incomplete" ? status.reason : typeof metadata?.finishReason === "string" ? metadata.finishReason : void 0;
+	const failed = status?.type === "incomplete" && status.reason === "error";
+	const outcome = deriveRunOutcome({
+		finishReason: typeof finishReason === "string" ? finishReason : void 0,
+		isError: failed
+	});
+	const outcomeType = outcome.outcome;
+	const failure = failed ? describeRunError(status.error) : {};
+	const messageId = localMessageId ?? (typeof message.id === "string" ? message.id : void 0);
+	const traceId = format === "aui/v0" ? custom?.traceId : format === "ai-sdk/v6" ? metadata?.traceId : void 0;
+	const provider = typeof custom?.provider === "string" ? custom.provider : typeof metadata?.provider === "string" ? metadata.provider : void 0;
+	return {
+		...messageId ? { localMessageId: messageId } : void 0,
+		...outcome.status === "error" ? { status: "error" } : void 0,
+		...outcomeType ? { outcomeType } : void 0,
+		...failure,
+		...firstTokenMs != null && firstTokenMs >= 0 ? { firstTokenMs } : void 0,
+		...typeof traceId === "string" ? { traceId } : void 0,
+		...provider !== void 0 ? { provider } : void 0
+	};
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object";
+}
 function extractTelemetry(format, content) {
 	switch (format) {
 		case "aui/v0": return extractAuiV0(content);
@@ -187,20 +295,23 @@ function extractAuiV0(content) {
 		let hasReasoning = false;
 		let hasCachedInput = false;
 		for (const step of steps) {
-			if (step.usage?.inputTokens != null) {
-				totalInput += step.usage.inputTokens;
+			if (!step.usage) continue;
+			const usage = normalizeRunTelemetryUsage(step.usage);
+			if (!usage) continue;
+			if (usage.inputTokens != null) {
+				totalInput += usage.inputTokens;
 				hasInput = true;
 			}
-			if (step.usage?.outputTokens != null) {
-				totalOutput += step.usage.outputTokens;
+			if (usage.outputTokens != null) {
+				totalOutput += usage.outputTokens;
 				hasOutput = true;
 			}
-			if (step.usage?.reasoningTokens != null) {
-				totalReasoning += step.usage.reasoningTokens;
+			if (usage.reasoningTokens != null) {
+				totalReasoning += usage.reasoningTokens;
 				hasReasoning = true;
 			}
-			if (step.usage?.cachedInputTokens != null) {
-				totalCachedInput += step.usage.cachedInputTokens;
+			if (usage.cachedInputTokens != null) {
+				totalCachedInput += usage.cachedInputTokens;
 				hasCachedInput = true;
 			}
 		}
@@ -210,15 +321,18 @@ function extractAuiV0(content) {
 		cachedInputTokens = hasCachedInput ? totalCachedInput : void 0;
 	}
 	const statusType = msg.status?.type;
-	const status = statusType && AUI_STATUS_MAP[statusType] || "completed";
+	const status = statusType === "incomplete" && msg.status?.reason === "error" ? "error" : statusType && AUI_STATUS_MAP[statusType] || "completed";
 	const metadata = msg.metadata?.custom;
-	const modelId = msg.metadata?.modelId ?? (typeof msg.metadata?.custom?.modelId === "string" ? msg.metadata.custom.modelId : void 0);
-	const telemetrySteps = steps && steps.length > 1 ? steps.map((s) => ({
-		...s.usage?.inputTokens != null ? { input_tokens: s.usage.inputTokens } : void 0,
-		...s.usage?.outputTokens != null ? { output_tokens: s.usage.outputTokens } : void 0,
-		...s.usage?.reasoningTokens != null ? { reasoning_tokens: s.usage.reasoningTokens } : void 0,
-		...s.usage?.cachedInputTokens != null ? { cached_input_tokens: s.usage.cachedInputTokens } : void 0
-	})) : void 0;
+	const modelId = extractRunTelemetryModelId(msg.metadata);
+	const telemetrySteps = steps && steps.length > 1 ? steps.map((s) => {
+		const usage = s.usage ? normalizeRunTelemetryUsage(s.usage) : void 0;
+		return {
+			...usage?.inputTokens != null ? { input_tokens: usage.inputTokens } : void 0,
+			...usage?.outputTokens != null ? { output_tokens: usage.outputTokens } : void 0,
+			...usage?.reasoningTokens != null ? { reasoning_tokens: usage.reasoningTokens } : void 0,
+			...usage?.cachedInputTokens != null ? { cached_input_tokens: usage.cachedInputTokens } : void 0
+		};
+	}) : void 0;
 	return {
 		status,
 		...toolCalls && toolCalls.length > 0 ? { toolCalls } : void 0,
@@ -272,16 +386,10 @@ function collectAiSdkV6Parts(parts) {
 		stepsData
 	};
 }
-function extractModelId(metadata) {
-	if (!metadata) return void 0;
-	if (typeof metadata.modelId === "string") return metadata.modelId;
-	const custom = metadata.custom;
-	if (typeof custom?.modelId === "string") return custom.modelId;
-}
 function buildAiSdkV6Result(textParts, toolCalls, totalSteps, metadata, stepsData, usage) {
 	const hasText = textParts.length > 0;
 	const outputText = hasText ? truncateRunTelemetryText(textParts.join("")) : void 0;
-	const modelId = extractModelId(metadata);
+	const modelId = extractRunTelemetryModelId(metadata);
 	const steps = stepsData && stepsData.length > 1 ? stepsData.map((s) => ({ ...s.tool_calls.length > 0 ? { tool_calls: s.tool_calls } : void 0 })) : void 0;
 	return {
 		status: hasText ? "completed" : "incomplete",
@@ -409,8 +517,272 @@ function useAssistantCloudThreadHistoryAdapter(cloudRef) {
 		auiRef.current = aui;
 	});
 	const [adapter] = useState(() => new AssistantCloudThreadHistoryAdapter(cloudRef, () => auiRef.current));
+	useAssistantCloudEngagementEvents(cloudRef, adapter, aui);
 	return adapter;
 }
+const rootEngagementTrackers = /* @__PURE__ */ new WeakMap();
+/**
+* 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 = (cloudRef, adapter, aui) => {
+	const $ = c(5);
+	let t0;
+	let t1;
+	if ($[0] !== adapter || $[1] !== aui || $[2] !== cloudRef) {
+		t0 = () => {
+			let tracker = rootEngagementTrackers.get(aui);
+			if (!tracker) {
+				const created = {
+					count: 0,
+					adapter,
+					cloudRef,
+					dispose: _temp
+				};
+				created.dispose = aui.on({
+					scope: "*",
+					event: "threads.selectionChanged"
+				}, (payload) => {
+					created.adapter.resolveEngagementEventIds(payload.threadId).then((ids) => {
+						if (!ids.thread_id) return;
+						created.cloudRef.current.events?.track({
+							kind: "thread_switched",
+							...ids
+						});
+					}).catch(_temp2);
+				});
+				rootEngagementTrackers.set(aui, created);
+				tracker = created;
+			}
+			const active = tracker;
+			active.adapter = adapter;
+			active.cloudRef = cloudRef;
+			active.count = active.count + 1;
+			return () => {
+				active.count = active.count - 1;
+				if (active.count === 0) {
+					active.dispose();
+					rootEngagementTrackers.delete(aui);
+				}
+			};
+		};
+		t1 = [
+			adapter,
+			aui,
+			cloudRef
+		];
+		$[0] = adapter;
+		$[1] = aui;
+		$[2] = cloudRef;
+		$[3] = t0;
+		$[4] = t1;
+	} else {
+		t0 = $[3];
+		t1 = $[4];
+	}
+	useEffect(t0, t1);
+};
+const useAssistantCloudEngagementEvents = (cloudRef, adapter, aui) => {
+	const $ = c(13);
+	useRootEngagementEvents(cloudRef, adapter, aui);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = /* @__PURE__ */ new Map();
+		$[0] = t0;
+	} else t0 = $[0];
+	const runStartedAt = useRef(t0);
+	let t1;
+	if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+		t1 = /* @__PURE__ */ new Map();
+		$[1] = t1;
+	} else t1 = $[1];
+	const runEndedAt = useRef(t1);
+	let t2;
+	if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+		t2 = /* @__PURE__ */ new Set();
+		$[2] = t2;
+	} else t2 = $[2];
+	const shownSuggestions = useRef(t2);
+	let t3;
+	let t4;
+	if ($[3] !== adapter || $[4] !== aui || $[5] !== cloudRef) {
+		t3 = () => {
+			const track = (event, threadId, messageId, options) => {
+				adapter.resolveEngagementEventIds(threadId, messageId, options).then((ids) => {
+					cloudRef.current.events?.track({
+						...event,
+						...ids
+					});
+				}).catch(_temp3);
+			};
+			const trackRunStopped = (threadId_0) => {
+				const startedAt = runStartedAt.current.get(threadId_0);
+				if (startedAt === void 0) return;
+				runStartedAt.current.delete(threadId_0);
+				track({
+					kind: "run_stopped",
+					value: Math.max(0, Date.now() - startedAt)
+				}, threadId_0);
+			};
+			const unsubscribers = [
+				aui.on({
+					scope: "thread",
+					event: "composer.send"
+				}, (payload) => {
+					const previousRunEndedAt = runEndedAt.current.get(payload.threadId);
+					track({
+						kind: payload.messageId ? "message_edited" : "message_sent",
+						...payload.messageId ? { props: { chars: payload.chars } } : { props: {
+							chars: payload.chars,
+							attachments: payload.attachments
+						} },
+						...!payload.messageId && previousRunEndedAt !== void 0 ? { value: Math.max(0, Date.now() - previousRunEndedAt) } : void 0
+					}, payload.threadId, payload.messageId, { awaitThread: !payload.messageId });
+					if (payload.suggestion) track({ kind: "suggestion_clicked" }, payload.threadId);
+				}),
+				aui.on({
+					scope: "thread",
+					event: "composer.attachmentAdd"
+				}, (payload_0) => {
+					track({
+						kind: "attachment_added",
+						...payload_0.contentType ? { props: { type: payload_0.contentType } } : void 0
+					}, payload_0.threadId, payload_0.messageId);
+				}),
+				aui.on({
+					scope: "thread",
+					event: "composer.attachmentAddError"
+				}, (payload_1) => {
+					track({
+						kind: "attachment_failed",
+						...payload_1.contentType ? { props: { type: payload_1.contentType } } : void 0
+					}, payload_1.threadId, payload_1.messageId);
+				}),
+				aui.on({
+					scope: "thread",
+					event: "composer.cancel"
+				}, (payload_2) => {
+					trackRunStopped(payload_2.threadId);
+				}),
+				aui.on({
+					scope: "thread",
+					event: "thread.runStart"
+				}, (payload_3) => {
+					runStartedAt.current.set(payload_3.threadId, Date.now());
+				}),
+				aui.on({
+					scope: "thread",
+					event: "thread.runEnd"
+				}, (payload_4) => {
+					runStartedAt.current.delete(payload_4.threadId);
+					runEndedAt.current.set(payload_4.threadId, Date.now());
+				}),
+				aui.on({
+					scope: "thread",
+					event: "thread.cancelRun"
+				}, (payload_5) => {
+					trackRunStopped(payload_5.threadId);
+				}),
+				aui.on({
+					scope: "thread",
+					event: "thread.voiceStarted"
+				}, (payload_6) => {
+					track({ kind: "voice_started" }, payload_6.threadId);
+				}),
+				aui.on({
+					scope: "thread",
+					event: "message.reload"
+				}, (payload_7) => {
+					track({ kind: "message_regenerated" }, payload_7.threadId, payload_7.messageId);
+				}),
+				aui.on({
+					scope: "thread",
+					event: "message.branchSwitched"
+				}, (payload_8) => {
+					track({ kind: "branch_switched" }, payload_8.threadId, payload_8.messageId);
+				}),
+				aui.on({
+					scope: "thread",
+					event: "message.copied"
+				}, (payload_9) => {
+					track({ kind: "message_copied" }, payload_9.threadId, payload_9.messageId);
+				}),
+				aui.on({
+					scope: "thread",
+					event: "message.speak"
+				}, (payload_10) => {
+					track({ kind: "speech_started" }, payload_10.threadId, payload_10.messageId);
+				}),
+				aui.on({
+					scope: "thread",
+					event: "message.error"
+				}, (payload_11) => {
+					track({
+						kind: "error_shown",
+						props: { reason: payload_11.reason }
+					}, payload_11.threadId, payload_11.messageId);
+				})
+			];
+			return () => {
+				for (const unsubscribe of unsubscribers) unsubscribe();
+			};
+		};
+		t4 = [
+			adapter,
+			aui,
+			cloudRef
+		];
+		$[3] = adapter;
+		$[4] = aui;
+		$[5] = cloudRef;
+		$[6] = t3;
+		$[7] = t4;
+	} else {
+		t3 = $[6];
+		t4 = $[7];
+	}
+	useEffect(t3, t4);
+	let t5;
+	let t6;
+	if ($[8] !== adapter || $[9] !== aui || $[10] !== cloudRef) {
+		t5 = () => {
+			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 || shownSuggestions.current.has(mainThreadId)) return;
+				shownSuggestions.current.add(mainThreadId);
+				adapter.resolveEngagementEventIds(mainThreadId).then((ids_0) => {
+					cloudRef.current.events?.track({
+						kind: "suggestions_shown",
+						value: suggestions.length,
+						...ids_0
+					});
+				});
+			};
+			reportSuggestions();
+			return aui.subscribe(reportSuggestions);
+		};
+		t6 = [
+			adapter,
+			aui,
+			cloudRef
+		];
+		$[8] = adapter;
+		$[9] = aui;
+		$[10] = cloudRef;
+		$[11] = t5;
+		$[12] = t6;
+	} else {
+		t5 = $[11];
+		t6 = $[12];
+	}
+	useEffect(t5, t6);
+};
+function _temp() {}
+function _temp2() {}
+function _temp3() {}
 //#endregion
 export { extractAuiV0, useAssistantCloudThreadHistoryAdapter };