@kognitivedev/voice-tracing 0.2.29

package/dist/reporter.js

@@ -0,0 +1,1249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVoiceTelemetryReporter = void 0;
+exports.createVoiceTracingReporter = createVoiceTracingReporter;
+const shared_1 = require("@kognitivedev/shared");
+const VOICE_MODEL_PRICING_OVERRIDES = {
+    // 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) {
+    return resourceId.userId ? String(resourceId.userId) : "system";
+}
+function logVoiceTracing(message, payload) {
+    console.log(`[VoiceTracing:reporter] ${message}`, payload);
+}
+function getSessionMetadata(config) {
+    var _a, _b;
+    return Object.assign({ kind: "voice", agentName: config.agentName, transport: (_a = config.transport) !== null && _a !== void 0 ? _a : "webrtc", callId: config.callId, modelId: config.modelId, transcriptionModelId: config.transcriptionModelId, voice: config.voice, sourceSessionId: config.resourceId.sessionId ? String(config.resourceId.sessionId) : undefined }, ((_b = config.metadata) !== null && _b !== void 0 ? _b : {}));
+}
+function extractReportingLinkage(value) {
+    if (!value || typeof value !== "object")
+        return {};
+    const record = value;
+    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, max = 240) {
+    return text.slice(0, max);
+}
+function roundCents(value) {
+    return Math.round(value * 1000000) / 1000000;
+}
+function toCostCents(tokens, dollarsPerMillion) {
+    if (!tokens || !dollarsPerMillion)
+        return 0;
+    return (tokens / 1000000) * dollarsPerMillion * 100;
+}
+function calculateVoiceUsageCostCents(usage, modelId) {
+    var _a, _b, _c, _d, _e, _f;
+    if (!usage || usage.type !== "tokens" || !modelId)
+        return undefined;
+    const pricing = VOICE_MODEL_PRICING_OVERRIDES[modelId];
+    if (!pricing)
+        return undefined;
+    const inputAudioTokens = (_a = usage.inputAudioTokens) !== null && _a !== void 0 ? _a : 0;
+    const inputTextTokens = (_b = usage.inputTextTokens) !== null && _b !== void 0 ? _b : 0;
+    const cachedAudioTokens = (_c = usage.cachedAudioTokens) !== null && _c !== void 0 ? _c : 0;
+    const cachedTextTokens = (_d = usage.cachedTextTokens) !== null && _d !== void 0 ? _d : 0;
+    const regularAudioTokens = Math.max(0, inputAudioTokens - cachedAudioTokens);
+    const regularTextTokens = Math.max(0, inputTextTokens - cachedTextTokens);
+    const outputAudioTokens = (_e = usage.outputAudioTokens) !== null && _e !== void 0 ? _e : 0;
+    const outputTextTokens = (_f = usage.outputTextTokens) !== null && _f !== void 0 ? _f : 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) {
+    var _a;
+    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: (_a = part.mediaType) !== null && _a !== void 0 ? _a : "image/png",
+            data: part.image,
+        },
+    };
+}
+function normalizeFilePart(part) {
+    var _a, _b, _c;
+    return {
+        type: "file",
+        file: {
+            url: typeof part.url === "string" ? part.url : undefined,
+            name: (_a = part.filename) !== null && _a !== void 0 ? _a : part.name,
+            mime_type: (_c = (_b = part.mediaType) !== null && _b !== void 0 ? _b : part.mimeType) !== null && _c !== void 0 ? _c : part.mime_type,
+        },
+    };
+}
+function normalizeDynamicToolPart(part) {
+    var _a;
+    const parts = [];
+    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(Object.assign({ type: "tool-result", toolCallId: part.toolCallId, toolName: part.toolName, result: (_a = part.output) !== null && _a !== void 0 ? _a : 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) {
+    const normalized = [];
+    const textBuffer = [];
+    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(Object.assign({ 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) {
+    return messages.reduce((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) {
+    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, role) {
+    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) {
+    return JSON.stringify(messages);
+}
+function getUiMessageText(message) {
+    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) {
+    var _a;
+    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:${(_a = event.outputText) !== null && _a !== void 0 ? _a : ""}`;
+}
+function buildTurnPreview(messages, role, maxLength) {
+    const text = messages
+        .filter((message) => message.role === role)
+        .map(getPersistedMessageText)
+        .filter(Boolean)
+        .join("\n")
+        .trim();
+    return preview(text, maxLength);
+}
+function extractSyntheticToolEvents(messages) {
+    var _a, _b, _c, _d, _e;
+    const events = [];
+    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((_a = part.input) !== null && _a !== void 0 ? _a : {}).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: Object.assign({ toolCallId: part.toolCallId, toolName: part.toolName }, (isError
+                        ? { errorMessage: JSON.stringify((_c = (_b = part.result) !== null && _b !== void 0 ? _b : part.output) !== null && _c !== void 0 ? _c : "Tool execution failed").slice(0, 220) }
+                        : { outputPreview: JSON.stringify((_e = (_d = part.result) !== null && _d !== void 0 ? _d : part.output) !== null && _e !== void 0 ? _e : {}).slice(0, 220) })),
+                });
+            }
+        }
+    }
+    return events;
+}
+function deriveSyntheticVoiceTurns(messages) {
+    const persistedMessages = toPersistedConversationMessages(messages);
+    if (persistedMessages.length === 0)
+        return [];
+    const turns = [];
+    let currentMessages = [];
+    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, usage, modelId) {
+    var _a, _b, _c;
+    if (!usage)
+        return undefined;
+    const costCentsOverride = calculateVoiceUsageCostCents(usage, modelId);
+    if (usage.type !== "tokens") {
+        return {
+            eventType,
+            modelId,
+            costCentsOverride,
+        };
+    }
+    return {
+        eventType,
+        modelId,
+        inputTokens: (_a = usage.inputTokens) !== null && _a !== void 0 ? _a : 0,
+        outputTokens: (_b = usage.outputTokens) !== null && _b !== void 0 ? _b : 0,
+        cachedInputTokens: (_c = usage.cachedInputTokens) !== null && _c !== void 0 ? _c : 0,
+        costCentsOverride,
+    };
+}
+function payloadForSessionEvent(event) {
+    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;
+    }
+}
+function createVoiceTracingReporter(config) {
+    var _a, _b;
+    const sink = config.adapter;
+    const sessionId = config.callId;
+    const userId = getUserId(config.resourceId);
+    const sessionMetadata = getSessionMetadata(config);
+    const pendingSessionEvents = [{
+            eventType: "voice.call.started",
+            payload: {
+                callId: config.callId,
+                modelId: config.modelId,
+                voice: config.voice,
+                transport: (_a = config.transport) !== null && _a !== void 0 ? _a : "webrtc",
+            },
+        }];
+    const connectionRun = (0, shared_1.createRemoteRunContext)({
+        agentName: config.agentName,
+        sessionId,
+        requestedRunScope: "session",
+    });
+    let activeTurn = null;
+    let turnCounter = -1;
+    let latestMessages = [];
+    const seenUserMessageIds = new Set();
+    const seenAssistantCompletionKeys = new Set();
+    let hasReportedRuns = false;
+    let reporterQueue = Promise.resolve();
+    let linkage = {};
+    let lastFlushedMessageSignature = null;
+    logVoiceTracing("initialized", {
+        sessionId,
+        agentName: config.agentName,
+        modelId: config.modelId,
+        transcriptionModelId: (_b = config.transcriptionModelId) !== null && _b !== void 0 ? _b : null,
+    });
+    const enqueueReporterTask = (task) => {
+        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((0, shared_1.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 = Object.assign(Object.assign({}, linkage), extractReportingLinkage(runResult));
+        await sink.reportConversationLog((0, shared_1.buildRemoteLogPayload)({
+            execution: (0, shared_1.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 = (payload) => (Object.assign(Object.assign(Object.assign({}, payload), (linkage.sessionDbId ? { sessionDbId: linkage.sessionDbId } : {})), (linkage.agentRunDbId ? { agentRunDbId: linkage.agentRunDbId } : {})));
+    const reportConnectionRunCompletion = async (reason) => {
+        await ensureSessionBootstrap();
+        await sink.reportAgentRun(withLinkage((0, shared_1.buildRemoteRunPayload)({
+            execution: connectionRun,
+            finalizeRun: true,
+            userId,
+            sessionId,
+            modelId: config.modelId,
+            status: "completed",
+            triggerType: "voice",
+            agentType: "voice",
+            messages: toPersistedConversationMessages(latestMessages),
+            metadata: Object.assign(Object.assign({}, sessionMetadata), { endReason: reason !== null && reason !== void 0 ? reason : "disconnect" }),
+            sessionMetadata,
+            skipConversationLog: true,
+            skipPipelines: true,
+            skipCostRecording: true,
+            incrementSessionMessageCount: false,
+            completedAt: new Date().toISOString(),
+        })));
+    };
+    const startTurn = async (transcript, usage, startMessageId) => {
+        var _a, _b, _c;
+        turnCounter += 1;
+        const turnId = (0, shared_1.generateId)();
+        const startedAt = new Date().toISOString();
+        const execution = (0, shared_1.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, (_a = config.transcriptionModelId) !== null && _a !== void 0 ? _a : 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 && startMessageId !== void 0 ? startMessageId : null,
+            hasUsage: !!usage,
+            transcriptionCostCentsOverride: (_c = (_b = activeTurn.transcriptionUsage) === null || _b === void 0 ? void 0 : _b.costCentsOverride) !== null && _c !== void 0 ? _c : null,
+        });
+        await ensureSessionBootstrap();
+        const traceStartPayload = (0, shared_1.buildRemoteTraceStartPayload)({
+            execution,
+            userId,
+            sessionId,
+            requestPreview: activeTurn.inputPreview,
+            modelId: config.modelId,
+            metadata: {
+                source: "voice",
+                callId: config.callId,
+            },
+            startedAt,
+        });
+        await sink.reportTraceEvents(withLinkage(Object.assign(Object.assign({}, traceStartPayload), { start: Object.assign(Object.assign(Object.assign({}, 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, nextUserMessageId) => {
+        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 = {}) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        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 = (_b = (_a = turn.outputPreview) !== null && _a !== void 0 ? _a : fallbackAssistantPreview) !== null && _b !== void 0 ? _b : undefined;
+        const completedAt = (_d = (_c = args.completedAt) !== null && _c !== void 0 ? _c : turn.completedAt) !== null && _d !== void 0 ? _d : new Date().toISOString();
+        const durationMs = Math.max(0, new Date(completedAt).getTime() - new Date(turn.startedAt).getTime());
+        const inferredStatus = args.forceInterrupt
+            ? "interrupted"
+            : (_f = (_e = args.responseStatus) !== null && _e !== void 0 ? _e : turn.completionStatus) !== null && _f !== void 0 ? _f : (outputPreview ? "completed" : "interrupted");
+        const finishState = inferredStatus === "completed" ? "completed" : "error";
+        logVoiceTracing("turn finalized", {
+            sessionId,
+            traceId: turn.execution.traceId,
+            runId: turn.execution.runId,
+            status: inferredStatus,
+            nextUserMessageId: (_g = args.nextUserMessageId) !== null && _g !== void 0 ? _g : null,
+            messageCount: persistedMessages.length,
+            outputPreview: outputPreview !== null && outputPreview !== void 0 ? outputPreview : null,
+        });
+        await ensureSessionBootstrap();
+        await sink.reportAgentRun(withLinkage((0, shared_1.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 === null || responseUsage === void 0 ? void 0 : responseUsage.inputTokens,
+            outputTokens: responseUsage === null || responseUsage === void 0 ? void 0 : responseUsage.outputTokens,
+            cachedInputTokens: responseUsage === null || responseUsage === void 0 ? void 0 : responseUsage.cachedInputTokens,
+            costCentsOverride: responseUsage === null || responseUsage === void 0 ? void 0 : responseUsage.costCentsOverride,
+            costEventType: responseUsage ? "voice_chat" : undefined,
+            additionalCostEvents: turn.transcriptionUsage ? [turn.transcriptionUsage] : [],
+            messages: persistedMessages,
+            metadata: Object.assign(Object.assign({}, sessionMetadata), { responseId: (_h = turn.responseId) !== null && _h !== void 0 ? _h : null, turnIndex: turn.turnIndex, responseStatus: inferredStatus, endReason: (_j = args.reason) !== null && _j !== void 0 ? _j : null }),
+        })));
+        hasReportedRuns = true;
+        await sink.reportTraceEvents(withLinkage((0, shared_1.buildRemoteTraceFinishPayload)({
+            execution: turn.execution,
+            state: finishState,
+            responsePreview: outputPreview !== null && outputPreview !== void 0 ? outputPreview : undefined,
+            durationMs,
+            usage: {
+                inputTokens: responseUsage === null || responseUsage === void 0 ? void 0 : responseUsage.inputTokens,
+                outputTokens: responseUsage === null || responseUsage === void 0 ? void 0 : responseUsage.outputTokens,
+                cachedInputTokens: responseUsage === null || responseUsage === void 0 ? void 0 : responseUsage.cachedInputTokens,
+            },
+            payload: {
+                responseStatus: inferredStatus,
+                responseId: (_k = turn.responseId) !== null && _k !== void 0 ? _k : null,
+                reason: (_l = args.reason) !== null && _l !== void 0 ? _l : null,
+            },
+            errorMessage: finishState === "error" ? inferredStatus : undefined,
+        })));
+        await flushConversationLog({
+            execution: turn.execution,
+            messages: persistedMessages,
+        });
+        activeTurn = null;
+        return true;
+    };
+    const syncTurnsFromState = async (usage) => {
+        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) => {
+        var _a, _b, _c;
+        return (Object.assign(Object.assign({}, event), { agentName: (_a = event.agentName) !== null && _a !== void 0 ? _a : config.agentName, traceId: (_b = event.traceId) !== null && _b !== void 0 ? _b : activeTurn === null || activeTurn === void 0 ? void 0 : activeTurn.execution.traceId, agentRunId: (_c = event.agentRunId) !== null && _c !== void 0 ? _c : activeTurn === null || activeTurn === void 0 ? void 0 : activeTurn.execution.runId }));
+    };
+    const flushConversationLog = async (args = {}) => {
+        var _a, _b;
+        await ensureSessionBootstrap();
+        const execution = (_a = args.execution) !== null && _a !== void 0 ? _a : (0, shared_1.createRemoteExecutionContext)({
+            agentName: config.agentName,
+            sessionId,
+            requestedRunScope: "session",
+            turnId: "voice-session-flush",
+            turnIndex: turnCounter >= 0 ? turnCounter : 0,
+        });
+        const messages = (_b = args.messages) !== null && _b !== void 0 ? _b : 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((0, shared_1.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 = {}) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (hasReportedRuns) {
+            logVoiceTracing("synthetic turn recovery skipped", {
+                sessionId,
+                reason: (_a = args.reason) !== null && _a !== void 0 ? _a : null,
+                hasReportedRuns,
+            });
+            return false;
+        }
+        const turns = deriveSyntheticVoiceTurns(latestMessages);
+        if (turns.length === 0) {
+            logVoiceTracing("synthetic turn recovery found no turns", {
+                sessionId,
+                reason: (_b = args.reason) !== null && _b !== void 0 ? _b : null,
+                messageCount: latestMessages.length,
+            });
+            return false;
+        }
+        const baseCompletedAt = args.responseAt ? new Date(args.responseAt).getTime() : Date.now();
+        logVoiceTracing("synthetic turns recovered", {
+            sessionId,
+            reason: (_c = args.reason) !== null && _c !== void 0 ? _c : null,
+            turnCount: turns.length,
+            messageCount: latestMessages.length,
+            responseStatus: (_d = args.responseStatus) !== null && _d !== void 0 ? _d : null,
+        });
+        let accumulatedSyntheticMessages = [];
+        for (const [index, turn] of turns.entries()) {
+            const syntheticTurnId = (0, shared_1.generateId)();
+            const execution = (0, shared_1.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((0, shared_1.buildRemoteRunPayload)({
+                execution,
+                userId,
+                sessionId,
+                modelId: config.modelId,
+                status,
+                inputPreview: turn.inputPreview,
+                outputPreview: (_e = turn.outputPreview) !== null && _e !== void 0 ? _e : undefined,
+                triggerType: "voice",
+                agentType: "voice",
+                startedAt: syntheticStartedAt,
+                completedAt: syntheticCompletedAt,
+                durationMs: 1000,
+                inputTokens: responseUsage === null || responseUsage === void 0 ? void 0 : responseUsage.inputTokens,
+                outputTokens: responseUsage === null || responseUsage === void 0 ? void 0 : responseUsage.outputTokens,
+                cachedInputTokens: responseUsage === null || responseUsage === void 0 ? void 0 : responseUsage.cachedInputTokens,
+                costCentsOverride: responseUsage === null || responseUsage === void 0 ? void 0 : responseUsage.costCentsOverride,
+                costEventType: "voice_chat",
+                messages: accumulatedSyntheticMessages,
+                incrementSessionMessageCount: false,
+                skipConversationLog: true,
+                skipPipelines: true,
+                metadata: Object.assign(Object.assign({}, sessionMetadata), { responseId: isLastTurn ? (_f = args.responseId) !== null && _f !== void 0 ? _f : null : null, turnIndex: turn.turnIndex, responseStatus: status, recovery: "conversation_fallback", recoveryReason: (_g = args.reason) !== null && _g !== void 0 ? _g : null }),
+            })));
+            hasReportedRuns = true;
+            const traceStartPayload = (0, shared_1.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(Object.assign(Object.assign({}, traceStartPayload), { start: Object.assign(Object.assign(Object.assign({}, traceStartPayload.start), (linkage.sessionDbId ? { sessionDbId: linkage.sessionDbId } : {})), (linkage.agentRunDbId ? { agentRunDbId: linkage.agentRunDbId } : {})), events: turn.toolEvents, finish: (0, shared_1.buildRemoteTraceFinishPayload)({
+                    execution,
+                    state: finishState,
+                    responsePreview: (_h = turn.outputPreview) !== null && _h !== void 0 ? _h : undefined,
+                    durationMs: 1000,
+                    usage: {
+                        inputTokens: responseUsage === null || responseUsage === void 0 ? void 0 : responseUsage.inputTokens,
+                        outputTokens: responseUsage === null || responseUsage === void 0 ? void 0 : responseUsage.outputTokens,
+                        cachedInputTokens: responseUsage === null || responseUsage === void 0 ? void 0 : responseUsage.cachedInputTokens,
+                    },
+                    errorMessage: finishState === "error" ? status : undefined,
+                }).finish })));
+        }
+        return true;
+    };
+    return {
+        handleSessionEvent(event) {
+            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) {
+            return enqueueReporterTask(async () => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+                logVoiceTracing("telemetry received", {
+                    sessionId,
+                    type: event.type,
+                    responseId: "responseId" in event ? (_a = event.responseId) !== null && _a !== void 0 ? _a : null : null,
+                    itemId: "itemId" in event ? (_b = event.itemId) !== null && _b !== void 0 ? _b : null : null,
+                    toolCallId: "toolCallId" in event ? (_c = event.toolCallId) !== null && _c !== void 0 ? _c : 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: (_d = event.responseId) !== null && _d !== void 0 ? _d : null,
+                            itemId: (_e = event.itemId) !== null && _e !== void 0 ? _e : null,
+                        });
+                        return;
+                    }
+                    seenAssistantCompletionKeys.add(completionKey);
+                    activeTurn.responseId = (_f = event.responseId) !== null && _f !== void 0 ? _f : activeTurn.responseId;
+                    activeTurn.outputPreview = event.outputText
+                        ? preview(event.outputText, 240)
+                        : (_g = findLatestMessageText(toPersistedConversationMessages(latestMessages), "assistant")) !== null && _g !== void 0 ? _g : activeTurn.outputPreview;
+                    activeTurn.completedAt = event.at;
+                    activeTurn.completionStatus = (_h = event.status) !== null && _h !== void 0 ? _h : "completed";
+                    logVoiceTracing("assistant output completed", {
+                        sessionId,
+                        traceId: activeTurn.execution.traceId,
+                        runId: activeTurn.execution.runId,
+                        responseId: (_j = activeTurn.responseId) !== null && _j !== void 0 ? _j : null,
+                        itemId: (_k = event.itemId) !== null && _k !== void 0 ? _k : null,
+                        outputPreview: (_l = activeTurn.outputPreview) !== null && _l !== void 0 ? _l : null,
+                    });
+                    await ensureSessionBootstrap();
+                    await sink.reportTraceEvents(withLinkage({
+                        traceId: activeTurn.execution.traceId,
+                        events: [{
+                                eventType: "assistant.completed",
+                                status: "completed",
+                                payload: {
+                                    preview: (_m = activeTurn.outputPreview) !== null && _m !== void 0 ? _m : null,
+                                    responseId: (_o = activeTurn.responseId) !== null && _o !== void 0 ? _o : null,
+                                    itemId: (_p = event.itemId) !== null && _p !== void 0 ? _p : 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((_q = event.input) !== null && _q !== void 0 ? _q : {}).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((_r = event.output) !== null && _r !== void 0 ? _r : {}).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 ((_s = event.rawEvent) === null || _s === void 0 ? void 0 : _s.response) === "object" && event.rawEvent.response !== null
+                        ? event.rawEvent.response
+                        : null;
+                    const rawOutputs = Array.isArray(rawResponse === null || rawResponse === void 0 ? void 0 : rawResponse.output) ? rawResponse.output : [];
+                    for (const output of rawOutputs) {
+                        if (typeof output === "object" && output !== null) {
+                            const item = output;
+                            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.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: (_t = activeTurn.outputPreview) !== null && _t !== void 0 ? _t : 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) {
+            void enqueueReporterTask(async () => {
+                var _a;
+                logVoiceTracing("flush call end", {
+                    sessionId,
+                    reason: reason !== null && reason !== void 0 ? reason : null,
+                    hasActiveTurn: !!activeTurn,
+                });
+                pendingSessionEvents.push({
+                    eventType: "voice.call.ended",
+                    payload: { callId: config.callId, reason },
+                });
+                if (activeTurn) {
+                    await finalizeActiveTurn({
+                        completedAt: (_a = activeTurn.completedAt) !== null && _a !== void 0 ? _a : new Date().toISOString(),
+                        responseStatus: activeTurn.completionStatus,
+                        forceInterrupt: !activeTurn.completedAt && !activeTurn.outputPreview,
+                        reason: reason !== null && reason !== void 0 ? reason : "disconnect",
+                    });
+                    await reportConnectionRunCompletion(reason);
+                    return;
+                }
+                await emitSyntheticTurnsFromConversation({
+                    reason: reason !== null && reason !== void 0 ? reason : "disconnect",
+                });
+                await flushConversationLog();
+                await reportConnectionRunCompletion(reason);
+            });
+        },
+    };
+}
+exports.createVoiceTelemetryReporter = createVoiceTracingReporter;