@kognitivedev/voice-tracing 0.2.29

package/src/reporter.ts

@@ -0,0 +1,1492 @@
+import {
+    buildRemoteLogPayload,
+    buildRemoteRunPayload,
+    buildRemoteTraceFinishPayload,
+    buildRemoteTraceStartPayload,
+    createRemoteExecutionContext,
+    createRemoteRunContext,
+    generateId,
+} from "@kognitivedev/shared";
+import type { KognitiveContentPart, KognitiveUIMessage, Metadata, ResourceId } from "@kognitivedev/shared";
+import type {
+    PersistedConversationMessage,
+    PersistedConversationPart,
+    VoiceTracingAdapter,
+    VoiceTracingReporterConfig,
+    VoiceTracingSessionEvent,
+    VoiceTracingTelemetryEvent,
+    VoiceTracingUsageSnapshot,
+} from "./types";
+
+type UsageEventInput = {
+    eventType: string;
+    modelId?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedInputTokens?: number;
+    costCentsOverride?: number;
+};
+
+type SessionEventInput = {
+    eventType: string;
+    payload: Record<string, unknown>;
+    agentName?: string;
+    traceId?: string;
+    agentRunId?: string;
+};
+
+type ActiveTurn = {
+    execution: ReturnType<typeof createRemoteExecutionContext>;
+    turnIndex: number;
+    startedAt: string;
+    inputPreview: string;
+    startMessageId?: string;
+    transcriptionUsage?: UsageEventInput;
+    responseId?: string;
+    outputPreview?: string;
+    completedAt?: string;
+    completionStatus?: string;
+    pendingToolCallIds: Set<string>;
+};
+
+type SyntheticTraceEvent = {
+    eventType: string;
+    spanKey?: string;
+    status?: string;
+    payload?: Record<string, unknown>;
+};
+
+type SyntheticVoiceTurn = {
+    turnIndex: number;
+    messages: PersistedConversationMessage[];
+    inputPreview: string;
+    outputPreview: string | null;
+    toolEvents: SyntheticTraceEvent[];
+    hasAssistantOutput: boolean;
+};
+
+type ReportingLinkage = {
+    sessionDbId?: string | null;
+    agentRunDbId?: string | null;
+};
+
+type VoiceModelPricingOverride = {
+    textInputPerMillion?: number;
+    textOutputPerMillion?: number;
+    textCachedInputPerMillion?: number;
+    audioInputPerMillion?: number;
+    audioOutputPerMillion?: number;
+    audioCachedInputPerMillion?: number;
+};
+
+const VOICE_MODEL_PRICING_OVERRIDES: Record<string, VoiceModelPricingOverride> = {
+    // Official OpenAI model docs as of 2026-04-06:
+    // gpt-realtime: $4/$16 text input/output per 1M, $32/$64 audio input/output per 1M, $0.40 cached input per 1M.
+    "gpt-realtime": {
+        textInputPerMillion: 4,
+        textOutputPerMillion: 16,
+        textCachedInputPerMillion: 0.4,
+        audioInputPerMillion: 32,
+        audioOutputPerMillion: 64,
+        audioCachedInputPerMillion: 0.4,
+    },
+    "gpt-realtime-1.5": {
+        textInputPerMillion: 4,
+        textOutputPerMillion: 16,
+        textCachedInputPerMillion: 0.4,
+        audioInputPerMillion: 32,
+        audioOutputPerMillion: 64,
+        audioCachedInputPerMillion: 0.4,
+    },
+    // GPT-4o Transcribe: $2.50 audio input and $10 text output per 1M.
+    "gpt-4o-transcribe": {
+        audioInputPerMillion: 2.5,
+        textOutputPerMillion: 10,
+    },
+    "gpt-4o-mini-transcribe": {
+        audioInputPerMillion: 1.25,
+        textOutputPerMillion: 5,
+    },
+};
+
+function getUserId(resourceId: ResourceId): string {
+    return resourceId.userId ? String(resourceId.userId) : "system";
+}
+
+function logVoiceTracing(message: string, payload: Record<string, unknown>) {
+    console.log(`[VoiceTracing:reporter] ${message}`, payload);
+}
+
+function getSessionMetadata(config: VoiceTelemetryReporterConfig) {
+    return {
+        kind: "voice",
+        agentName: config.agentName,
+        transport: config.transport ?? "webrtc",
+        callId: config.callId,
+        modelId: config.modelId,
+        transcriptionModelId: config.transcriptionModelId,
+        voice: config.voice,
+        sourceSessionId: config.resourceId.sessionId ? String(config.resourceId.sessionId) : undefined,
+        ...(config.metadata ?? {}),
+    };
+}
+
+function extractReportingLinkage(value: unknown): ReportingLinkage {
+    if (!value || typeof value !== "object") return {};
+    const record = value as Record<string, unknown>;
+    return {
+        sessionDbId: typeof record.sessionDbId === "string" ? record.sessionDbId : null,
+        agentRunDbId: typeof record.runDbId === "string"
+            ? record.runDbId
+            : typeof record.agentRunDbId === "string"
+                ? record.agentRunDbId
+                : null,
+    };
+}
+
+function preview(text: string, max = 240): string {
+    return text.slice(0, max);
+}
+
+function roundCents(value: number): number {
+    return Math.round(value * 1_000_000) / 1_000_000;
+}
+
+function toCostCents(tokens: number | undefined, dollarsPerMillion: number | undefined): number {
+    if (!tokens || !dollarsPerMillion) return 0;
+    return (tokens / 1_000_000) * dollarsPerMillion * 100;
+}
+
+function calculateVoiceUsageCostCents(usage: VoiceTracingUsageSnapshot | undefined, modelId: string | undefined): number | undefined {
+    if (!usage || usage.type !== "tokens" || !modelId) return undefined;
+
+    const pricing = VOICE_MODEL_PRICING_OVERRIDES[modelId];
+    if (!pricing) return undefined;
+
+    const inputAudioTokens = usage.inputAudioTokens ?? 0;
+    const inputTextTokens = usage.inputTextTokens ?? 0;
+    const cachedAudioTokens = usage.cachedAudioTokens ?? 0;
+    const cachedTextTokens = usage.cachedTextTokens ?? 0;
+    const regularAudioTokens = Math.max(0, inputAudioTokens - cachedAudioTokens);
+    const regularTextTokens = Math.max(0, inputTextTokens - cachedTextTokens);
+
+    const outputAudioTokens = usage.outputAudioTokens ?? 0;
+    const outputTextTokens = usage.outputTextTokens ?? 0;
+
+    const detailedTokenCount =
+        inputAudioTokens
+        + inputTextTokens
+        + outputAudioTokens
+        + outputTextTokens
+        + cachedAudioTokens
+        + cachedTextTokens;
+
+    if (detailedTokenCount === 0) {
+        return undefined;
+    }
+
+    const totalCostCents =
+        toCostCents(regularAudioTokens, pricing.audioInputPerMillion)
+        + toCostCents(regularTextTokens, pricing.textInputPerMillion)
+        + toCostCents(cachedAudioTokens, pricing.audioCachedInputPerMillion)
+        + toCostCents(cachedTextTokens, pricing.textCachedInputPerMillion)
+        + toCostCents(outputAudioTokens, pricing.audioOutputPerMillion)
+        + toCostCents(outputTextTokens, pricing.textOutputPerMillion);
+
+    return roundCents(totalCostCents);
+}
+
+function normalizeImagePart(part: Extract<KognitiveContentPart, { type: "image" }>): PersistedConversationPart | null {
+    if (typeof part.url === "string" && part.url.length > 0) {
+        return {
+            type: "image",
+            source: {
+                type: "url",
+                url: part.url,
+            },
+        };
+    }
+
+    if (typeof part.image !== "string" || part.image.length === 0) {
+        return null;
+    }
+
+    const dataUrlMatch = part.image.match(/^data:([^;,]+);base64,(.+)$/);
+    if (dataUrlMatch) {
+        return {
+            type: "image",
+            source: {
+                type: "base64",
+                media_type: dataUrlMatch[1],
+                data: dataUrlMatch[2],
+            },
+        };
+    }
+
+    return {
+        type: "image",
+        source: {
+            type: "base64",
+            media_type: part.mediaType ?? "image/png",
+            data: part.image,
+        },
+    };
+}
+
+function normalizeFilePart(part: Extract<KognitiveContentPart, { type: "file" }>): PersistedConversationPart {
+    return {
+        type: "file",
+        file: {
+            url: typeof part.url === "string" ? part.url : undefined,
+            name: part.filename ?? part.name,
+            mime_type: part.mediaType ?? part.mimeType ?? part.mime_type,
+        },
+    };
+}
+
+function normalizeDynamicToolPart(part: Extract<KognitiveContentPart, { type: "dynamic-tool" }>): PersistedConversationPart[] {
+    const parts: PersistedConversationPart[] = [];
+
+    if (part.input !== undefined) {
+        parts.push({
+            type: "tool-call",
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            input: part.input,
+        });
+    }
+
+    if (part.output !== undefined || part.errorText) {
+        parts.push({
+            type: "tool-result",
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            result: part.output ?? part.errorText,
+            ...(part.state === "error" || part.errorText ? { isError: true } : {}),
+        });
+    }
+
+    if (parts.length === 0) {
+        parts.push({
+            type: "text",
+            text: `${part.toolName} ${part.state}`,
+        });
+    }
+
+    return parts;
+}
+
+function normalizeConversationParts(parts: KognitiveContentPart[]): PersistedConversationPart[] {
+    const normalized: PersistedConversationPart[] = [];
+    const textBuffer: string[] = [];
+
+    const flushText = () => {
+        const text = textBuffer.join(" ").trim();
+        if (!text) return;
+        normalized.push({ type: "text", text });
+        textBuffer.length = 0;
+    };
+
+    for (const part of parts) {
+        switch (part.type) {
+            case "text":
+            case "reasoning":
+                if (part.text.trim()) textBuffer.push(part.text.trim());
+                break;
+            case "tool-call":
+                flushText();
+                normalized.push({
+                    type: "tool-call",
+                    toolCallId: part.toolCallId,
+                    toolName: part.toolName,
+                    input: part.input,
+                });
+                break;
+            case "tool-result":
+                flushText();
+                normalized.push({
+                    type: "tool-result",
+                    toolCallId: part.toolCallId,
+                    toolName: part.toolName,
+                    output: part.output,
+                    result: part.result,
+                    ...(part.isError ? { isError: true } : {}),
+                });
+                break;
+            case "image": {
+                flushText();
+                const imagePart = normalizeImagePart(part);
+                if (imagePart) normalized.push(imagePart);
+                break;
+            }
+            case "file":
+                flushText();
+                normalized.push(normalizeFilePart(part));
+                break;
+            case "dynamic-tool":
+                flushText();
+                normalized.push(...normalizeDynamicToolPart(part));
+                break;
+            case "data":
+                flushText();
+                normalized.push({
+                    type: "text",
+                    text: typeof part.data === "string" ? part.data : JSON.stringify(part.data, null, 2),
+                });
+                break;
+            default:
+                break;
+        }
+    }
+
+    flushText();
+    return normalized;
+}
+
+function toPersistedConversationMessages(messages: KognitiveUIMessage[]): PersistedConversationMessage[] {
+    return messages.reduce<PersistedConversationMessage[]>((acc, message) => {
+        const normalizedParts = normalizeConversationParts(message.parts);
+        if (normalizedParts.length === 0) return acc;
+
+        if (normalizedParts.length === 1 && normalizedParts[0].type === "text" && typeof normalizedParts[0].text === "string") {
+            acc.push({
+                role: message.role,
+                content: normalizedParts[0].text,
+                metadata: message.metadata,
+            });
+            return acc;
+        }
+
+        acc.push({
+            role: message.role,
+            content: normalizedParts,
+            metadata: message.metadata,
+        });
+        return acc;
+    }, []);
+}
+
+function getPersistedMessageText(message: PersistedConversationMessage): string {
+    if (typeof message.content === "string") return message.content;
+
+    return message.content
+        .map((part) => {
+            if (part.type === "text" && typeof part.text === "string") return part.text;
+            if (part.type === "tool-call" && typeof part.toolName === "string") return `Called ${part.toolName}`;
+            if (part.type === "tool-result" && typeof part.toolName === "string") return `Received ${part.toolName} result`;
+            return "";
+        })
+        .filter(Boolean)
+        .join(" ")
+        .trim();
+}
+
+function findLatestMessageText(messages: PersistedConversationMessage[], role: PersistedConversationMessage["role"]): string | null {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message.role !== role) continue;
+        const text = getPersistedMessageText(message);
+        if (text) return text;
+    }
+
+    return null;
+}
+
+function buildPersistedMessageSignature(messages: PersistedConversationMessage[]): string {
+    return JSON.stringify(messages);
+}
+
+function getUiMessageText(message: KognitiveUIMessage): string {
+    return message.parts
+        .flatMap((part) => {
+            if (part.type === "text" || part.type === "reasoning") {
+                return part.text.trim() ? [part.text.trim()] : [];
+            }
+            return [];
+        })
+        .join(" ")
+        .trim();
+}
+
+function buildAssistantCompletionKey(event: Extract<VoiceTelemetryEvent, { type: "voice.response.output.completed" }>): string {
+    if (event.itemId) {
+        return `item:${event.itemId}`;
+    }
+
+    if (event.responseId && event.outputText) {
+        return `response:${event.responseId}:${event.outputText}`;
+    }
+
+    if (event.responseId) {
+        return `response:${event.responseId}`;
+    }
+
+    return `text:${event.outputText ?? ""}`;
+}
+
+function buildTurnPreview(messages: PersistedConversationMessage[], role: PersistedConversationMessage["role"], maxLength: number): string {
+    const text = messages
+        .filter((message) => message.role === role)
+        .map(getPersistedMessageText)
+        .filter(Boolean)
+        .join("\n")
+        .trim();
+
+    return preview(text, maxLength);
+}
+
+function extractSyntheticToolEvents(messages: PersistedConversationMessage[]): SyntheticTraceEvent[] {
+    const events: SyntheticTraceEvent[] = [];
+
+    for (const message of messages) {
+        if (!Array.isArray(message.content)) continue;
+
+        for (const part of message.content) {
+            if (part.type === "tool-call" && typeof part.toolCallId === "string" && typeof part.toolName === "string") {
+                events.push({
+                    eventType: "tool.started",
+                    spanKey: part.toolCallId,
+                    status: "active",
+                    payload: {
+                        toolCallId: part.toolCallId,
+                        toolName: part.toolName,
+                        inputPreview: JSON.stringify(part.input ?? {}).slice(0, 220),
+                    },
+                });
+                continue;
+            }
+
+            if (part.type === "tool-result" && typeof part.toolCallId === "string" && typeof part.toolName === "string") {
+                const isError = part.isError === true;
+                events.push({
+                    eventType: isError ? "tool.failed" : "tool.completed",
+                    spanKey: part.toolCallId,
+                    status: isError ? "error" : "completed",
+                    payload: {
+                        toolCallId: part.toolCallId,
+                        toolName: part.toolName,
+                        ...(isError
+                            ? { errorMessage: JSON.stringify(part.result ?? part.output ?? "Tool execution failed").slice(0, 220) }
+                            : { outputPreview: JSON.stringify(part.result ?? part.output ?? {}).slice(0, 220) }),
+                    },
+                });
+            }
+        }
+    }
+
+    return events;
+}
+
+function deriveSyntheticVoiceTurns(messages: KognitiveUIMessage[]): SyntheticVoiceTurn[] {
+    const persistedMessages = toPersistedConversationMessages(messages);
+    if (persistedMessages.length === 0) return [];
+
+    const turns: SyntheticVoiceTurn[] = [];
+    let currentMessages: PersistedConversationMessage[] = [];
+    let turnIndex = -1;
+
+    const finalizeCurrentTurn = () => {
+        if (currentMessages.length === 0) return;
+
+        const inputPreview = buildTurnPreview(currentMessages, "user", 220);
+        const outputPreview = buildTurnPreview(currentMessages, "assistant", 240) || null;
+        const hasAssistantOutput = currentMessages.some((message) => message.role === "assistant");
+
+        if (!inputPreview && !hasAssistantOutput) {
+            currentMessages = [];
+            return;
+        }
+
+        turnIndex += 1;
+        turns.push({
+            turnIndex,
+            messages: currentMessages,
+            inputPreview,
+            outputPreview,
+            toolEvents: extractSyntheticToolEvents(currentMessages),
+            hasAssistantOutput,
+        });
+        currentMessages = [];
+    };
+
+    for (const message of persistedMessages) {
+        if (message.role === "user" && currentMessages.some((current) => current.role !== "user")) {
+            finalizeCurrentTurn();
+        }
+
+        currentMessages.push(message);
+    }
+
+    finalizeCurrentTurn();
+    return turns;
+}
+
+function usageToCostEvent(eventType: string, usage?: VoiceTracingUsageSnapshot, modelId?: string): UsageEventInput | undefined {
+    if (!usage) return undefined;
+    const costCentsOverride = calculateVoiceUsageCostCents(usage, modelId);
+    if (usage.type !== "tokens") {
+        return {
+            eventType,
+            modelId,
+            costCentsOverride,
+        };
+    }
+    return {
+        eventType,
+        modelId,
+        inputTokens: usage.inputTokens ?? 0,
+        outputTokens: usage.outputTokens ?? 0,
+        cachedInputTokens: usage.cachedInputTokens ?? 0,
+        costCentsOverride,
+    };
+}
+
+function payloadForSessionEvent(event: VoiceTracingTelemetryEvent): SessionEventInput | null {
+    switch (event.type) {
+        case "voice.user.transcribed":
+            return {
+                eventType: "voice.user.transcribed",
+                payload: {
+                    transcript: event.transcript,
+                    itemId: event.itemId,
+                },
+            };
+        case "voice.assistant.started":
+            return {
+                eventType: "voice.assistant.started",
+                payload: {
+                    responseId: event.responseId,
+                },
+            };
+        case "voice.assistant.stopped":
+            return {
+                eventType: "voice.assistant.stopped",
+                payload: {
+                    responseId: event.responseId,
+                },
+            };
+        case "voice.tool.started":
+            return {
+                eventType: "tool.started",
+                payload: {
+                    toolCallId: event.toolCallId,
+                    toolName: event.toolName,
+                    input: event.input,
+                },
+            };
+        case "voice.tool.completed":
+            return {
+                eventType: "tool.completed",
+                payload: {
+                    toolCallId: event.toolCallId,
+                    toolName: event.toolName,
+                    output: event.output,
+                },
+            };
+        case "voice.tool.failed":
+            return {
+                eventType: "tool.failed",
+                payload: {
+                    toolCallId: event.toolCallId,
+                    toolName: event.toolName,
+                    error: event.error,
+                },
+            };
+        case "voice.interrupted":
+            return {
+                eventType: "voice.turn.interrupted",
+                payload: {
+                    responseId: event.responseId,
+                    reason: event.reason,
+                },
+            };
+        case "voice.response.done":
+            return {
+                eventType: "voice.turn.completed",
+                payload: {
+                    responseId: event.responseId,
+                    status: event.status,
+                    outputText: event.outputText,
+                },
+            };
+        case "voice.response.output.completed":
+            return {
+                eventType: "voice.assistant.output.completed",
+                payload: {
+                    responseId: event.responseId,
+                    itemId: event.itemId,
+                    status: event.status,
+                    outputText: event.outputText,
+                },
+            };
+        default:
+            return null;
+    }
+}
+
+export function createVoiceTracingReporter(config: VoiceTracingReporterConfig) {
+    const sink = config.adapter;
+    const sessionId = config.callId;
+    const userId = getUserId(config.resourceId);
+    const sessionMetadata = getSessionMetadata(config);
+    const pendingSessionEvents: SessionEventInput[] = [{
+        eventType: "voice.call.started",
+        payload: {
+            callId: config.callId,
+            modelId: config.modelId,
+            voice: config.voice,
+            transport: config.transport ?? "webrtc",
+        },
+    }];
+    const connectionRun = createRemoteRunContext({
+        agentName: config.agentName,
+        sessionId,
+        requestedRunScope: "session",
+    });
+    let activeTurn: ActiveTurn | null = null;
+    let turnCounter = -1;
+    let latestMessages: KognitiveUIMessage[] = [];
+    const seenUserMessageIds = new Set<string>();
+    const seenAssistantCompletionKeys = new Set<string>();
+    let hasReportedRuns = false;
+    let reporterQueue = Promise.resolve();
+    let linkage: ReportingLinkage = {};
+    let lastFlushedMessageSignature: string | null = null;
+    logVoiceTracing("initialized", {
+        sessionId,
+        agentName: config.agentName,
+        modelId: config.modelId,
+        transcriptionModelId: config.transcriptionModelId ?? null,
+    });
+
+    const enqueueReporterTask = <T>(task: () => Promise<T> | T) => {
+        const nextTask = reporterQueue.then(task, task);
+        reporterQueue = nextTask.then(() => undefined, () => undefined);
+        return nextTask;
+    };
+
+    const ensureSessionBootstrap = async () => {
+        if (linkage.sessionDbId || linkage.agentRunDbId) {
+            return linkage;
+        }
+
+        const runResult = await sink.reportAgentRun(buildRemoteRunPayload({
+            execution: connectionRun,
+            userId,
+            sessionId,
+            modelId: config.modelId,
+            status: "running",
+            inputPreview: "",
+            triggerType: "voice",
+            agentType: "voice",
+            metadata: sessionMetadata,
+            sessionMetadata,
+            skipConversationLog: true,
+            skipPipelines: true,
+            skipCostRecording: true,
+        }));
+        linkage = {
+            ...linkage,
+            ...extractReportingLinkage(runResult),
+        };
+
+        await sink.reportConversationLog(buildRemoteLogPayload({
+            execution: createRemoteExecutionContext({
+                agentName: config.agentName,
+                sessionId,
+                requestedRunScope: "session",
+                turnId: "voice-call-start",
+                turnIndex: 0,
+            }),
+            userId,
+            sessionId,
+            messages: [],
+            modelId: config.modelId,
+            sessionMetadata,
+            incrementMessageCount: false,
+            skipPipelines: true,
+            skipTraceTracking: true,
+            sessionEvents: pendingSessionEvents.splice(0, pendingSessionEvents.length),
+            metadata: { source: "voice", phase: "call-start" },
+        }));
+
+        return linkage;
+    };
+
+    const withLinkage = <T extends Record<string, unknown>>(payload: T): T & ReportingLinkage => ({
+        ...payload,
+        ...(linkage.sessionDbId ? { sessionDbId: linkage.sessionDbId } : {}),
+        ...(linkage.agentRunDbId ? { agentRunDbId: linkage.agentRunDbId } : {}),
+    });
+
+    const reportConnectionRunCompletion = async (reason?: string) => {
+        await ensureSessionBootstrap();
+        await sink.reportAgentRun(withLinkage(buildRemoteRunPayload({
+            execution: connectionRun,
+            finalizeRun: true,
+            userId,
+            sessionId,
+            modelId: config.modelId,
+            status: "completed",
+            triggerType: "voice",
+            agentType: "voice",
+            messages: toPersistedConversationMessages(latestMessages),
+            metadata: { ...sessionMetadata, endReason: reason ?? "disconnect" },
+            sessionMetadata,
+            skipConversationLog: true,
+            skipPipelines: true,
+            skipCostRecording: true,
+            incrementSessionMessageCount: false,
+            completedAt: new Date().toISOString(),
+        })));
+    };
+
+    const startTurn = async (transcript: string, usage?: VoiceTracingUsageSnapshot, startMessageId?: string) => {
+        turnCounter += 1;
+        const turnId = generateId();
+        const startedAt = new Date().toISOString();
+        const execution = createRemoteExecutionContext({
+            agentName: config.agentName,
+            sessionId,
+            requestedRunScope: "session",
+            turnId,
+            turnIndex: turnCounter,
+        });
+
+        activeTurn = {
+            execution,
+            turnIndex: turnCounter,
+            startedAt,
+            inputPreview: preview(transcript, 220),
+            startMessageId,
+            transcriptionUsage: usageToCostEvent("voice_transcription", usage, config.transcriptionModelId ?? config.modelId),
+            pendingToolCallIds: new Set(),
+        };
+        if (startMessageId) {
+            seenUserMessageIds.add(startMessageId);
+        }
+        logVoiceTracing("turn started", {
+            sessionId,
+            runId: execution.runId,
+            turnId,
+            traceId: execution.traceId,
+            turnIndex: activeTurn.turnIndex,
+            transcriptPreview: activeTurn.inputPreview,
+            startMessageId: startMessageId ?? null,
+            hasUsage: !!usage,
+            transcriptionCostCentsOverride: activeTurn.transcriptionUsage?.costCentsOverride ?? null,
+        });
+
+        await ensureSessionBootstrap();
+        const traceStartPayload = buildRemoteTraceStartPayload({
+            execution,
+            userId,
+            sessionId,
+            requestPreview: activeTurn.inputPreview,
+            modelId: config.modelId,
+            metadata: {
+                source: "voice",
+                callId: config.callId,
+            },
+            startedAt,
+        });
+        await sink.reportTraceEvents(withLinkage({
+            ...traceStartPayload,
+            start: {
+                ...traceStartPayload.start,
+                ...(linkage.sessionDbId ? { sessionDbId: linkage.sessionDbId } : {}),
+                ...(linkage.agentRunDbId ? { agentRunDbId: linkage.agentRunDbId } : {}),
+            },
+        }));
+    };
+
+    const getPendingUserMessagesFromState = () => latestMessages
+        .filter((message) => message.role === "user" && !seenUserMessageIds.has(message.id))
+        .map((message) => ({
+            id: message.id,
+            transcript: getUiMessageText(message),
+        }))
+        .filter((message) => message.transcript.length > 0);
+
+    const getTurnMessages = (turn: ActiveTurn, nextUserMessageId?: string) => {
+        const startIndex = turn.startMessageId
+            ? latestMessages.findIndex((message) => message.id === turn.startMessageId)
+            : -1;
+        const nextUserIndex = nextUserMessageId
+            ? latestMessages.findIndex((message) => message.id === nextUserMessageId)
+            : -1;
+
+        const sliceStart = startIndex >= 0 ? startIndex : 0;
+        const sliceEnd = nextUserIndex > sliceStart ? nextUserIndex : latestMessages.length;
+        return latestMessages.slice(sliceStart, sliceEnd);
+    };
+
+    const finalizeActiveTurn = async (args: {
+        completedAt?: string;
+        responseStatus?: string;
+        usage?: VoiceTracingUsageSnapshot;
+        nextUserMessageId?: string;
+        forceInterrupt?: boolean;
+        reason?: string;
+    } = {}) => {
+        if (!activeTurn) return false;
+
+        const turn = activeTurn;
+        const turnMessages = getTurnMessages(turn, args.nextUserMessageId);
+        const responseUsage = usageToCostEvent("voice_chat", args.usage, config.modelId);
+        const fallbackAssistantPreview = findLatestMessageText(toPersistedConversationMessages(turnMessages), "assistant");
+        // Send cumulative messages up to the end of this turn (not beyond the next user turn's start).
+        const nextUserIndex = args.nextUserMessageId
+            ? latestMessages.findIndex((message) => message.id === args.nextUserMessageId)
+            : -1;
+        const turnEndIndex = nextUserIndex > 0 ? nextUserIndex : latestMessages.length;
+        const persistedMessages = toPersistedConversationMessages(latestMessages.slice(0, turnEndIndex));
+        const outputPreview = turn.outputPreview ?? fallbackAssistantPreview ?? undefined;
+        const completedAt = args.completedAt ?? turn.completedAt ?? new Date().toISOString();
+        const durationMs = Math.max(0, new Date(completedAt).getTime() - new Date(turn.startedAt).getTime());
+        const inferredStatus = args.forceInterrupt
+            ? "interrupted"
+            : args.responseStatus
+              ?? turn.completionStatus
+              ?? (outputPreview ? "completed" : "interrupted");
+        const finishState = inferredStatus === "completed" ? "completed" : "error";
+
+        logVoiceTracing("turn finalized", {
+            sessionId,
+            traceId: turn.execution.traceId,
+            runId: turn.execution.runId,
+            status: inferredStatus,
+            nextUserMessageId: args.nextUserMessageId ?? null,
+            messageCount: persistedMessages.length,
+            outputPreview: outputPreview ?? null,
+        });
+
+        await ensureSessionBootstrap();
+        await sink.reportAgentRun(withLinkage(buildRemoteRunPayload({
+            execution: turn.execution,
+            userId,
+            sessionId,
+            modelId: config.modelId,
+            status: inferredStatus,
+            inputPreview: turn.inputPreview,
+            outputPreview,
+            triggerType: "voice",
+            agentType: "voice",
+            durationMs,
+            startedAt: turn.startedAt,
+            completedAt,
+            inputTokens: responseUsage?.inputTokens,
+            outputTokens: responseUsage?.outputTokens,
+            cachedInputTokens: responseUsage?.cachedInputTokens,
+            costCentsOverride: responseUsage?.costCentsOverride,
+            costEventType: responseUsage ? "voice_chat" : undefined,
+            additionalCostEvents: turn.transcriptionUsage ? [turn.transcriptionUsage] : [],
+            messages: persistedMessages,
+            metadata: {
+                ...sessionMetadata,
+                responseId: turn.responseId ?? null,
+                turnIndex: turn.turnIndex,
+                responseStatus: inferredStatus,
+                endReason: args.reason ?? null,
+            },
+        })));
+        hasReportedRuns = true;
+
+        await sink.reportTraceEvents(withLinkage(buildRemoteTraceFinishPayload({
+            execution: turn.execution,
+            state: finishState,
+            responsePreview: outputPreview ?? undefined,
+            durationMs,
+            usage: {
+                inputTokens: responseUsage?.inputTokens,
+                outputTokens: responseUsage?.outputTokens,
+                cachedInputTokens: responseUsage?.cachedInputTokens,
+            },
+            payload: {
+                responseStatus: inferredStatus,
+                responseId: turn.responseId ?? null,
+                reason: args.reason ?? null,
+            },
+            errorMessage: finishState === "error" ? inferredStatus : undefined,
+        })));
+
+        await flushConversationLog({
+            execution: turn.execution,
+            messages: persistedMessages,
+        });
+
+        activeTurn = null;
+        return true;
+    };
+
+    const syncTurnsFromState = async (usage?: VoiceTracingUsageSnapshot) => {
+        const pending = getPendingUserMessagesFromState();
+        if (pending.length === 0) {
+            logVoiceTracing("no active turn found from state", {
+                sessionId,
+                latestMessageCount: latestMessages.length,
+                seenUserMessageCount: seenUserMessageIds.size,
+            });
+            return;
+        }
+
+        for (const pendingUser of pending) {
+            if (activeTurn) {
+                await finalizeActiveTurn({
+                    nextUserMessageId: pendingUser.id,
+                    forceInterrupt: !activeTurn.completedAt && !activeTurn.outputPreview,
+                    reason: "next_user_turn",
+                });
+            }
+
+            logVoiceTracing("turn recovered from state", {
+                sessionId,
+                messageId: pendingUser.id,
+                transcriptPreview: preview(pendingUser.transcript, 120),
+            });
+            await startTurn(pendingUser.transcript, usage, pendingUser.id);
+        }
+    };
+
+    const enrichSessionEvent = (event: SessionEventInput): SessionEventInput => ({
+        ...event,
+        agentName: event.agentName ?? config.agentName,
+        traceId: event.traceId ?? activeTurn?.execution.traceId,
+        agentRunId: event.agentRunId ?? activeTurn?.execution.runId,
+    });
+
+    const flushConversationLog = async (args: {
+        execution?: ReturnType<typeof createRemoteExecutionContext>;
+        messages?: PersistedConversationMessage[];
+    } = {}) => {
+        await ensureSessionBootstrap();
+        const execution = args.execution ?? createRemoteExecutionContext({
+            agentName: config.agentName,
+            sessionId,
+            requestedRunScope: "session",
+            turnId: "voice-session-flush",
+            turnIndex: turnCounter >= 0 ? turnCounter : 0,
+        });
+        const messages = args.messages ?? toPersistedConversationMessages(latestMessages);
+        const messageSignature = buildPersistedMessageSignature(messages);
+        const hasPendingSessionEvents = pendingSessionEvents.length > 0;
+        const shouldSkipReplayMessages = messageSignature === lastFlushedMessageSignature;
+        if (shouldSkipReplayMessages && !hasPendingSessionEvents) {
+            logVoiceTracing("conversation flush skipped", {
+                sessionId,
+                traceId: execution.traceId,
+                agentRunId: execution.runId,
+                reason: "duplicate_messages",
+            });
+            return;
+        }
+
+        const messagesToPersist = shouldSkipReplayMessages ? [] : messages;
+        await sink.reportConversationLog(withLinkage(buildRemoteLogPayload({
+            execution,
+            userId,
+            sessionId,
+            messages: messagesToPersist,
+            modelId: config.modelId,
+            incrementMessageCount: false,
+            skipPipelines: true,
+            skipTraceTracking: true,
+            sessionMetadata,
+            sessionEvents: pendingSessionEvents.splice(0, pendingSessionEvents.length),
+            metadata: { source: "voice", phase: "session-flush" },
+        })));
+        if (!shouldSkipReplayMessages) {
+            lastFlushedMessageSignature = messageSignature;
+        }
+        logVoiceTracing("conversation flushed", {
+            sessionId,
+            traceId: execution.traceId,
+            agentRunId: execution.runId,
+            messageCount: messagesToPersist.length,
+            replaySkipped: shouldSkipReplayMessages,
+        });
+    };
+
+    const emitSyntheticTurnsFromConversation = async (args: {
+        reason?: string;
+        responseAt?: string;
+        responseId?: string;
+        responseStatus?: string;
+        usage?: VoiceTracingUsageSnapshot;
+    } = {}) => {
+        if (hasReportedRuns) {
+            logVoiceTracing("synthetic turn recovery skipped", {
+                sessionId,
+                reason: args.reason ?? null,
+                hasReportedRuns,
+            });
+            return false;
+        }
+
+        const turns = deriveSyntheticVoiceTurns(latestMessages);
+        if (turns.length === 0) {
+            logVoiceTracing("synthetic turn recovery found no turns", {
+                sessionId,
+                reason: args.reason ?? null,
+                messageCount: latestMessages.length,
+            });
+            return false;
+        }
+
+        const baseCompletedAt = args.responseAt ? new Date(args.responseAt).getTime() : Date.now();
+        logVoiceTracing("synthetic turns recovered", {
+            sessionId,
+            reason: args.reason ?? null,
+            turnCount: turns.length,
+            messageCount: latestMessages.length,
+            responseStatus: args.responseStatus ?? null,
+        });
+
+        let accumulatedSyntheticMessages: PersistedConversationMessage[] = [];
+        for (const [index, turn] of turns.entries()) {
+            const syntheticTurnId = generateId();
+            const execution = createRemoteExecutionContext({
+                agentName: config.agentName,
+                sessionId,
+                requestedRunScope: "session",
+                turnId: syntheticTurnId,
+                turnIndex: turn.turnIndex,
+            });
+            const syntheticCompletedAt = new Date(baseCompletedAt - Math.max(0, turns.length - index - 1) * 1000).toISOString();
+            const syntheticStartedAt = new Date(new Date(syntheticCompletedAt).getTime() - 1000).toISOString();
+            const isLastTurn = index === turns.length - 1;
+            const responseUsage = isLastTurn ? usageToCostEvent("voice_chat", args.usage, config.modelId) : undefined;
+            const status = isLastTurn && args.responseStatus
+                ? (args.responseStatus === "cancelled" || args.responseStatus === "incomplete"
+                    ? "interrupted"
+                    : args.responseStatus === "failed"
+                      ? "failed"
+                      : "completed")
+                : turn.hasAssistantOutput
+                  ? "completed"
+                  : "interrupted";
+            const finishState = status === "completed" ? "completed" : "error";
+            accumulatedSyntheticMessages = [...accumulatedSyntheticMessages, ...turn.messages];
+
+            await ensureSessionBootstrap();
+            await sink.reportAgentRun(withLinkage(buildRemoteRunPayload({
+                execution,
+                userId,
+                sessionId,
+                modelId: config.modelId,
+                status,
+                inputPreview: turn.inputPreview,
+                outputPreview: turn.outputPreview ?? undefined,
+                triggerType: "voice",
+                agentType: "voice",
+                startedAt: syntheticStartedAt,
+                completedAt: syntheticCompletedAt,
+                durationMs: 1000,
+                inputTokens: responseUsage?.inputTokens,
+                outputTokens: responseUsage?.outputTokens,
+                cachedInputTokens: responseUsage?.cachedInputTokens,
+                costCentsOverride: responseUsage?.costCentsOverride,
+                costEventType: "voice_chat",
+                messages: accumulatedSyntheticMessages,
+                incrementSessionMessageCount: false,
+                skipConversationLog: true,
+                skipPipelines: true,
+                metadata: {
+                    ...sessionMetadata,
+                    responseId: isLastTurn ? args.responseId ?? null : null,
+                    turnIndex: turn.turnIndex,
+                    responseStatus: status,
+                    recovery: "conversation_fallback",
+                    recoveryReason: args.reason ?? null,
+                },
+            })));
+            hasReportedRuns = true;
+
+            const traceStartPayload = buildRemoteTraceStartPayload({
+                execution,
+                userId,
+                sessionId,
+                requestPreview: turn.inputPreview,
+                modelId: config.modelId,
+                metadata: {
+                    source: "voice",
+                    callId: config.callId,
+                    synthetic: true,
+                    recovery: "conversation_fallback",
+                },
+                startedAt: syntheticStartedAt,
+            });
+            await sink.reportTraceEvents(withLinkage({
+                ...traceStartPayload,
+                start: {
+                    ...traceStartPayload.start,
+                    ...(linkage.sessionDbId ? { sessionDbId: linkage.sessionDbId } : {}),
+                    ...(linkage.agentRunDbId ? { agentRunDbId: linkage.agentRunDbId } : {}),
+                },
+                events: turn.toolEvents,
+                finish: buildRemoteTraceFinishPayload({
+                    execution,
+                    state: finishState,
+                    responsePreview: turn.outputPreview ?? undefined,
+                    durationMs: 1000,
+                    usage: {
+                        inputTokens: responseUsage?.inputTokens,
+                        outputTokens: responseUsage?.outputTokens,
+                        cachedInputTokens: responseUsage?.cachedInputTokens,
+                    },
+                    errorMessage: finishState === "error" ? status : undefined,
+                }).finish,
+            }));
+        }
+
+        return true;
+    };
+
+    return {
+        handleSessionEvent(event: VoiceTracingSessionEvent) {
+            void enqueueReporterTask(async () => {
+                latestMessages = event.state.messages;
+                logVoiceTracing("session state updated", {
+                    sessionId,
+                    messageCount: latestMessages.length,
+                    toolInvocationCount: event.state.toolInvocations.length,
+                    connectionStatus: event.state.connectionStatus,
+                    agentState: event.state.agentState,
+                    speechState: event.state.speechState,
+                    transcriptionStatus: event.state.transcriptionStatus,
+                    hasActiveTurn: !!activeTurn,
+                });
+                await syncTurnsFromState();
+            });
+        },
+        async handleTelemetry(event: VoiceTracingTelemetryEvent) {
+            return enqueueReporterTask(async () => {
+                logVoiceTracing("telemetry received", {
+                    sessionId,
+                    type: event.type,
+                    responseId: "responseId" in event ? event.responseId ?? null : null,
+                    itemId: "itemId" in event ? event.itemId ?? null : null,
+                    toolCallId: "toolCallId" in event ? event.toolCallId ?? null : null,
+                    hasActiveTurn: !!activeTurn,
+                });
+                if (event.type === "voice.user.transcribed") {
+                    if (event.itemId && seenUserMessageIds.has(event.itemId)) {
+                        logVoiceTracing("duplicate user turn ignored", {
+                            sessionId,
+                            itemId: event.itemId,
+                        });
+                        return;
+                    }
+
+                    await syncTurnsFromState(event.usage);
+                    if (!activeTurn) {
+                        await startTurn(event.transcript, event.usage, event.itemId);
+                    }
+                    const sessionEvent = payloadForSessionEvent(event);
+                    if (sessionEvent) pendingSessionEvents.push(enrichSessionEvent(sessionEvent));
+                    return;
+                }
+
+                await syncTurnsFromState();
+
+                const sessionEvent = payloadForSessionEvent(event);
+                if (sessionEvent) pendingSessionEvents.push(enrichSessionEvent(sessionEvent));
+
+                if (event.type === "voice.response.created" && activeTurn) {
+                    activeTurn.responseId = event.responseId;
+                    logVoiceTracing("response linked to turn", {
+                        sessionId,
+                        traceId: activeTurn.execution.traceId,
+                        runId: activeTurn.execution.runId,
+                        responseId: event.responseId,
+                    });
+                    return;
+                }
+
+                if (event.type === "voice.response.output.completed" && activeTurn) {
+                    const completionKey = buildAssistantCompletionKey(event);
+                    if (seenAssistantCompletionKeys.has(completionKey)) {
+                        logVoiceTracing("duplicate assistant completion ignored", {
+                            sessionId,
+                            responseId: event.responseId ?? null,
+                            itemId: event.itemId ?? null,
+                        });
+                        return;
+                    }
+                    seenAssistantCompletionKeys.add(completionKey);
+                    activeTurn.responseId = event.responseId ?? activeTurn.responseId;
+                    activeTurn.outputPreview = event.outputText
+                        ? preview(event.outputText, 240)
+                        : findLatestMessageText(toPersistedConversationMessages(latestMessages), "assistant") ?? activeTurn.outputPreview;
+                    activeTurn.completedAt = event.at;
+                    activeTurn.completionStatus = event.status ?? "completed";
+                    logVoiceTracing("assistant output completed", {
+                        sessionId,
+                        traceId: activeTurn.execution.traceId,
+                        runId: activeTurn.execution.runId,
+                        responseId: activeTurn.responseId ?? null,
+                        itemId: event.itemId ?? null,
+                        outputPreview: activeTurn.outputPreview ?? null,
+                    });
+                    await ensureSessionBootstrap();
+                    await sink.reportTraceEvents(withLinkage({
+                        traceId: activeTurn.execution.traceId,
+                        events: [{
+                            eventType: "assistant.completed",
+                            status: "completed",
+                            payload: {
+                                preview: activeTurn.outputPreview ?? null,
+                                responseId: activeTurn.responseId ?? null,
+                                itemId: event.itemId ?? null,
+                            },
+                        }],
+                    }));
+                    return;
+                }
+
+                if (event.type === "voice.tool.started" && activeTurn) {
+                    activeTurn.pendingToolCallIds.add(event.toolCallId);
+                    logVoiceTracing("tool started", {
+                        sessionId,
+                        traceId: activeTurn.execution.traceId,
+                        toolCallId: event.toolCallId,
+                        toolName: event.toolName,
+                        pendingCount: activeTurn.pendingToolCallIds.size,
+                    });
+                    await ensureSessionBootstrap();
+                    await sink.reportTraceEvents(withLinkage({
+                        traceId: activeTurn.execution.traceId,
+                        events: [{
+                            eventType: "tool.started",
+                            spanKey: event.toolCallId,
+                            status: "active",
+                            payload: {
+                                toolCallId: event.toolCallId,
+                                toolName: event.toolName,
+                                inputPreview: JSON.stringify(event.input ?? {}).slice(0, 220),
+                            },
+                        }],
+                    }));
+                    return;
+                }
+
+                if (event.type === "voice.tool.completed" && activeTurn) {
+                    activeTurn.pendingToolCallIds.delete(event.toolCallId);
+                    logVoiceTracing("tool completed", {
+                        sessionId,
+                        traceId: activeTurn.execution.traceId,
+                        toolCallId: event.toolCallId,
+                        toolName: event.toolName,
+                        pendingCount: activeTurn.pendingToolCallIds.size,
+                        hasCompletedAt: !!activeTurn.completedAt,
+                    });
+                    await ensureSessionBootstrap();
+                    await sink.reportTraceEvents(withLinkage({
+                        traceId: activeTurn.execution.traceId,
+                        events: [{
+                            eventType: "tool.completed",
+                            spanKey: event.toolCallId,
+                            status: "completed",
+                            payload: {
+                                toolCallId: event.toolCallId,
+                                toolName: event.toolName,
+                                outputPreview: JSON.stringify(event.output ?? {}).slice(0, 220),
+                            },
+                        }],
+                    }));
+                    // All tool calls done and response.done already fired — finalize the turn now.
+                    // This handles the case where there is no second response.done (single-response turns).
+                    if (activeTurn.pendingToolCallIds.size === 0 && activeTurn.completedAt) {
+                        logVoiceTracing("finalizing after last tool completed", {
+                            sessionId,
+                            traceId: activeTurn.execution.traceId,
+                            runId: activeTurn.execution.runId,
+                        });
+                        await finalizeActiveTurn({
+                            completedAt: activeTurn.completedAt,
+                            responseStatus: activeTurn.completionStatus,
+                        });
+                    }
+                    return;
+                }
+
+                if (event.type === "voice.tool.failed" && activeTurn) {
+                    activeTurn.pendingToolCallIds.delete(event.toolCallId);
+                    await ensureSessionBootstrap();
+                    await sink.reportTraceEvents(withLinkage({
+                        traceId: activeTurn.execution.traceId,
+                        events: [{
+                            eventType: "tool.failed",
+                            spanKey: event.toolCallId,
+                            status: "error",
+                            payload: {
+                                toolCallId: event.toolCallId,
+                                toolName: event.toolName,
+                                errorMessage: event.error,
+                            },
+                        }],
+                    }));
+                    if (activeTurn.pendingToolCallIds.size === 0 && activeTurn.completedAt) {
+                        await finalizeActiveTurn({
+                            completedAt: activeTurn.completedAt,
+                            responseStatus: activeTurn.completionStatus,
+                        });
+                    }
+                    return;
+                }
+
+                if ((event.type === "voice.assistant.started" || event.type === "voice.assistant.stopped") && activeTurn) {
+                    await ensureSessionBootstrap();
+                    await sink.reportTraceEvents(withLinkage({
+                        traceId: activeTurn.execution.traceId,
+                        events: [{
+                            eventType: event.type,
+                            status: "completed",
+                            payload: {
+                                responseId: event.responseId,
+                            },
+                        }],
+                    }));
+                    return;
+                }
+
+                if (event.type === "voice.interrupted" && activeTurn) {
+                    await ensureSessionBootstrap();
+                    await sink.reportTraceEvents(withLinkage({
+                        traceId: activeTurn.execution.traceId,
+                        events: [{
+                            eventType: "trace.interrupted",
+                            status: "cancelled",
+                            payload: {
+                                reason: event.reason,
+                                responseId: event.responseId,
+                            },
+                        }],
+                    }));
+                    return;
+                }
+
+                if (event.type === "voice.response.done" && activeTurn) {
+                    activeTurn.responseId = event.responseId;
+                    activeTurn.outputPreview = event.outputText
+                        ? preview(event.outputText, 240)
+                        : activeTurn.outputPreview;
+                    activeTurn.completedAt = event.at;
+                    activeTurn.completionStatus = event.status === "cancelled" || event.status === "incomplete"
+                        ? "interrupted"
+                        : event.status === "failed"
+                          ? "failed"
+                          : "completed";
+
+                    // The browser-session SDK fires agent_tool_start AFTER response.done, so
+                    // pendingToolCallIds may not yet be populated via voice.tool.started.
+                    // Pre-populate from rawEvent output items so we can defer finalization.
+                    // Use call_id first (matches voice.tool.completed.toolCallId), fall back to id.
+                    const rawResponse = typeof event.rawEvent?.response === "object" && event.rawEvent.response !== null
+                        ? event.rawEvent.response as Record<string, unknown>
+                        : null;
+                    const rawOutputs = Array.isArray(rawResponse?.output) ? rawResponse.output as unknown[] : [];
+                    for (const output of rawOutputs) {
+                        if (typeof output === "object" && output !== null) {
+                            const item = output as Record<string, unknown>;
+                            if (item.type === "function_call") {
+                                if (typeof item.call_id === "string") activeTurn.pendingToolCallIds.add(item.call_id);
+                                else if (typeof item.id === "string") activeTurn.pendingToolCallIds.add(item.id);
+                            }
+                        }
+                    }
+                    logVoiceTracing("response done rawEvent check", {
+                        sessionId,
+                        traceId: activeTurn.execution.traceId,
+                        hasRawResponse: !!rawResponse,
+                        rawOutputCount: rawOutputs.length,
+                        functionCallCount: rawOutputs.filter((o) => typeof o === "object" && o !== null && (o as Record<string, unknown>).type === "function_call").length,
+                        pendingCount: activeTurn.pendingToolCallIds.size,
+                    });
+
+                    if (activeTurn.pendingToolCallIds.size > 0) {
+                        // Tool calls detected — keep activeTurn alive so voice.tool.started and
+                        // voice.tool.completed can be properly traced against this turn.
+                        logVoiceTracing("response done deferred — tool calls in output", {
+                            sessionId,
+                            traceId: activeTurn.execution.traceId,
+                            runId: activeTurn.execution.runId,
+                            status: event.status,
+                            pendingCount: activeTurn.pendingToolCallIds.size,
+                        });
+                        return;
+                    }
+
+                    logVoiceTracing("response completed", {
+                        sessionId,
+                        traceId: activeTurn.execution.traceId,
+                        runId: activeTurn.execution.runId,
+                        status: event.status,
+                        outputPreview: activeTurn.outputPreview ?? null,
+                    });
+                    await finalizeActiveTurn({
+                        completedAt: event.at,
+                        responseStatus: activeTurn.completionStatus,
+                        usage: event.usage,
+                    });
+                    return;
+                }
+
+                if (event.type === "voice.response.done" && !activeTurn) {
+                    logVoiceTracing("response completed without active turn", {
+                        sessionId,
+                        responseId: event.responseId,
+                        status: event.status,
+                        latestMessageCount: latestMessages.length,
+                    });
+                    await emitSyntheticTurnsFromConversation({
+                        reason: "response.done_without_active_turn",
+                        responseAt: event.at,
+                        responseId: event.responseId,
+                        responseStatus: event.status,
+                        usage: event.usage,
+                    });
+                }
+            });
+        },
+        flushCallEnd(reason?: string) {
+            void enqueueReporterTask(async () => {
+                logVoiceTracing("flush call end", {
+                    sessionId,
+                    reason: reason ?? null,
+                    hasActiveTurn: !!activeTurn,
+                });
+                pendingSessionEvents.push({
+                    eventType: "voice.call.ended",
+                    payload: { callId: config.callId, reason },
+                });
+
+                if (activeTurn) {
+                    await finalizeActiveTurn({
+                        completedAt: activeTurn.completedAt ?? new Date().toISOString(),
+                        responseStatus: activeTurn.completionStatus,
+                        forceInterrupt: !activeTurn.completedAt && !activeTurn.outputPreview,
+                        reason: reason ?? "disconnect",
+                    });
+                    await reportConnectionRunCompletion(reason);
+                    return;
+                }
+
+                await emitSyntheticTurnsFromConversation({
+                    reason: reason ?? "disconnect",
+                });
+
+                await flushConversationLog();
+
+                await reportConnectionRunCompletion(reason);
+            });
+        },
+    };
+}
+
+export const createVoiceTelemetryReporter = createVoiceTracingReporter;
+export type VoiceReportingSink = VoiceTracingAdapter;
+export type VoiceTelemetryReporterConfig = VoiceTracingReporterConfig;
+export type VoiceSessionEvent = VoiceTracingSessionEvent;
+export type VoiceTelemetryEvent = VoiceTracingTelemetryEvent;
+export type VoiceUsageSnapshot = VoiceTracingUsageSnapshot;