@truefoundry/ai-gateway-sdk 0.0.9 → 0.0.11

package/dist/services/buildExecutionReport.js

@@ -1,6 +1,15 @@
-import { resolveStreamEndReason } from '../stream/resolveStreamEndReason.js';
+/**
+ * Settle {@link ExecutionReport} for SDK execute (P7.1).
+ *
+ * Token facts: CLONE of live loggers (`*UsageFrom*`) + NEW routers (`liveUsageFrom*`).
+ * No USD / OTel / Model-span close — gateway egress owns that later.
+ */
+import { VERTEX_MODALITY } from '../providers/google-vertex-ai/types.js';
+import { isStreamingTerminatedError, resolveStreamEndReason } from '../stream/resolveStreamEndReason.js';
 import { billedUsageFromRequestResponse, extractSpeechToTextBilledSeconds, } from '../utils/billedUsage.js';
 import { asNumber, asRecord, nestedRecord, usageRecord } from '../utils/jsonValue.js';
+import { providerReportedCostInUsd } from '../utils/providerReportedCost.js';
+import { getSseDataLines, parseSseDataJson } from '../utils/sseUtils.js';
 export function usageFromJson(json) {
     const usage = usageRecord(json);
     if (!usage)
@@ -182,15 +191,33 @@ export function createStreamingReportDeferred(args) {
     return {
         promise,
         settle(pumpResult, extra) {
+            const pumpError = pumpResult.error;
+            let endError;
+            if (pumpError) {
+                const socket = new TypeError(pumpError.message || 'terminated', { cause: pumpError.cause });
+                if (isStreamingTerminatedError(socket)) {
+                    socket.status = pumpError.status ?? 500;
+                    endError = socket;
+                }
+                else {
+                    endError = new Error(String(pumpError.message ?? 'stream error'));
+                }
+            }
             finish({
                 ...args,
                 streaming: true,
                 usage: extra?.usage,
                 iterations: extra?.iterations,
+                tokensEstimated: extra?.tokensEstimated,
+                serviceTier: extra?.serviceTier,
+                toolUsage: extra?.toolUsage,
+                providerReportedCostInUsd: extra?.providerReportedCostInUsd, // NEW report field (live usage.cost)
+                streamFrames: pumpResult.frames, // NEW: same single buffer live keeps as chunks[]
+                streamEventCounts: pumpResult.eventCounts,
                 endReason: resolveStreamEndReason({
                     truncated: pumpResult.truncated,
                     finishReason: extra?.finishReason,
-                    error: pumpResult.error ? new Error(String(pumpResult.error.message ?? 'stream error')) : undefined,
+                    error: endError,
                 }),
             });
         },
@@ -203,4 +230,851 @@ export function createStreamingReportDeferred(args) {
         },
     };
 }
+/** CLONE: live `estimateTokenCountFromText` (~3.5 chars/token). */
+function createTokenEstimator() {
+    const estimator = {
+        used: false,
+        fromText(text) {
+            estimator.used = true;
+            if (!text || typeof text !== 'string')
+                return 0;
+            return Math.ceil(text.length / 3.5);
+        },
+    };
+    return estimator;
+}
+/** CLONE: live `getCacheWriteTokens`. */
+function getCacheWriteTokens(usage) {
+    return (usage?.cache_creation_input_tokens ??
+        usage?.prompt_tokens_details?.cache_write_tokens ??
+        usage?.input_tokens_details?.cache_write_tokens ??
+        0);
+}
+/** CLONE: live `getCacheReadImageTokens`. */
+function getCacheReadImageTokens(usage) {
+    return (usage?.prompt_tokens_details?.cached_tokens_details?.image_tokens ??
+        usage?.input_tokens_details?.cached_tokens_details?.image_tokens ??
+        0);
+}
+/** CLONE: live `getToolUsageFromResponsesOutput` (completed search web_search_call). */
+function getToolUsageFromResponsesOutput(output) {
+    if (!Array.isArray(output))
+        return {};
+    let webSearchCount = 0;
+    for (const outputItem of output) {
+        if (outputItem?.type !== 'web_search_call' || outputItem?.status !== 'completed')
+            continue;
+        const action = outputItem?.action?.type;
+        if (action && action !== 'search')
+            continue;
+        webSearchCount += 1;
+    }
+    return webSearchCount > 0 ? { web_search: webSearchCount } : {};
+}
+/** CLONE: live `logChatCompleteResponse` (non-stream chat + estimate fallback). */
+function chatUsageFromResponse(response, request, est) {
+    if ('error' in response)
+        return { usage: {} };
+    const usage = response.usage;
+    let promptTokenCount = usage?.prompt_tokens || 0;
+    let completionTokenCount = usage?.completion_tokens || 0;
+    const cacheReadTokenCount = usage?.cache_read_input_tokens || usage?.prompt_tokens_details?.cached_tokens || 0;
+    if (!promptTokenCount) {
+        // CLONE: live pushes tool_call functions into request.functions before estimating.
+        const toolCallFunctions = [];
+        request.messages?.forEach((message) => {
+            message.tool_calls?.forEach((toolCall) => {
+                if (toolCall.function)
+                    toolCallFunctions.push(toolCall.function);
+            });
+        });
+        for (const message of request.messages ?? []) {
+            if (typeof message.content === 'string') {
+                promptTokenCount += est.fromText(message.content);
+            }
+            else if (message.content && typeof message.content === 'object' && 'type' in message.content) {
+                promptTokenCount += est.fromText(JSON.stringify(message.content));
+            }
+            promptTokenCount += 5;
+        }
+        if (request.functions) {
+            promptTokenCount += est.fromText(JSON.stringify([...request.functions, ...toolCallFunctions])) + 10;
+        }
+        if (request.function_call) {
+            promptTokenCount += est.fromText(JSON.stringify(request.function_call)) + 5;
+        }
+        completionTokenCount = est.fromText(response.choices?.map((choice) => choice.message.content)?.join('') || '');
+    }
+    return {
+        usage: {
+            input: promptTokenCount,
+            output: completionTokenCount,
+            cache_read: cacheReadTokenCount,
+            cache_write: getCacheWriteTokens(usage),
+            cache_write_1h: usage?.cache_creation?.ephemeral_1h_input_tokens || 0,
+            input_image: usage?.prompt_tokens_details?.image_tokens ?? 0,
+            cache_read_image: getCacheReadImageTokens(usage),
+            output_image: usage?.completion_tokens_details?.image_tokens ?? 0,
+        },
+        tokensEstimated: est.used,
+        finishReason: response.choices?.[0]?.finish_reason,
+        serviceTier: response.service_tier,
+        providerReportedCostInUsd: providerReportedCostInUsd(usage),
+    };
+}
+/** CLONE: live `estimateTokenCounts` (streaming chat fallback). */
+function estimateChatTokenCounts(request, messages, est) {
+    let promptTokenCount = 0;
+    for (const message of request.messages ?? []) {
+        if (typeof message.content === 'string') {
+            promptTokenCount += est.fromText(message.content);
+        }
+        else if (Array.isArray(message.content)) {
+            for (const part of message.content) {
+                if (part && typeof part === 'object' && 'text' in part && typeof part.text === 'string') {
+                    promptTokenCount += est.fromText(part.text);
+                }
+            }
+        }
+        else if (message.content && typeof message.content === 'object' && 'type' in message.content) {
+            promptTokenCount += est.fromText(JSON.stringify(message.content));
+        }
+        promptTokenCount += 5;
+    }
+    if (request.functions) {
+        promptTokenCount += est.fromText(JSON.stringify(request.functions)) + 10;
+    }
+    if (request.function_call) {
+        promptTokenCount += est.fromText(JSON.stringify(request.function_call)) + 5;
+    }
+    const completionText = messages
+        ?.map(message => {
+        if (typeof message.content === 'string')
+            return message.content;
+        if (Array.isArray(message.content)) {
+            return message.content
+                .map((part) => (part && typeof part === 'object' && 'text' in part ? (part.text ?? '') : ''))
+                .join('');
+        }
+        return '';
+    })
+        .join('') || '';
+    return { promptTokenCount, completionTokenCount: est.fromText(completionText) };
+}
+/** CLONE: live `logChatCompleteResponseForStreaming` + `parseChunksAndExtractData`. */
+function chatUsageFromStream(chunks, request, streamState, est) {
+    const messages = [];
+    const extracted = {};
+    let finishReason;
+    let serviceTier;
+    let reportedCostInUsd;
+    chunks.forEach(chunk => {
+        const parsedChunk = parseSseDataJson(chunk);
+        if (!parsedChunk)
+            return;
+        for (const choice of parsedChunk.choices ?? []) {
+            if (choice.finish_reason)
+                finishReason = choice.finish_reason;
+            messages.push(choice.delta);
+        }
+        if (parsedChunk.service_tier)
+            serviceTier = parsedChunk.service_tier;
+        const usage = parsedChunk.usage;
+        if (usage) {
+            if (usage.prompt_tokens)
+                extracted.prompt_tokens = usage.prompt_tokens;
+            if (usage.completion_tokens)
+                extracted.completion_tokens = usage.completion_tokens;
+            if (usage.cache_read_input_tokens)
+                extracted.cache_read_input_tokens = usage.cache_read_input_tokens;
+            const cacheWriteTokens = getCacheWriteTokens(usage);
+            if (cacheWriteTokens)
+                extracted.cache_creation_input_tokens = cacheWriteTokens;
+            if (usage.cache_creation?.ephemeral_1h_input_tokens) {
+                extracted.cache_creation_input_tokens_1h = usage.cache_creation.ephemeral_1h_input_tokens;
+            }
+            if (usage.prompt_tokens_details?.cached_tokens) {
+                extracted.cache_read_input_tokens = usage.prompt_tokens_details.cached_tokens;
+            }
+            if (usage.prompt_tokens_details?.image_tokens !== undefined) {
+                extracted.input_image_tokens = usage.prompt_tokens_details.image_tokens;
+            }
+            const cacheReadImageTokens = getCacheReadImageTokens(usage);
+            if (cacheReadImageTokens)
+                extracted.cache_read_image_tokens = cacheReadImageTokens;
+            if (usage.completion_tokens_details?.image_tokens !== undefined) {
+                extracted.output_image_tokens = usage.completion_tokens_details.image_tokens;
+            }
+            const reported = providerReportedCostInUsd(usage);
+            if (reported !== undefined)
+                reportedCostInUsd = reported;
+        }
+    });
+    let promptTokenCount;
+    let completionTokenCount;
+    let cacheReadTokenCount;
+    let cacheWriteTokenCount;
+    if (extracted.prompt_tokens !== undefined && extracted.completion_tokens !== undefined) {
+        promptTokenCount = extracted.prompt_tokens;
+        completionTokenCount = extracted.completion_tokens;
+        cacheReadTokenCount = extracted.cache_read_input_tokens ?? 0;
+        cacheWriteTokenCount = extracted.cache_creation_input_tokens ?? 0;
+    }
+    else {
+        const estimated = estimateChatTokenCounts(request, messages, est);
+        promptTokenCount = extracted.prompt_tokens ?? streamState?.promptTokensWithCache ?? estimated.promptTokenCount;
+        completionTokenCount = extracted.completion_tokens ?? estimated.completionTokenCount;
+        cacheReadTokenCount = extracted.cache_read_input_tokens ?? streamState?.usage?.cache_read_input_tokens ?? 0;
+        cacheWriteTokenCount =
+            extracted.cache_creation_input_tokens ?? streamState?.usage?.cache_creation_input_tokens ?? 0;
+    }
+    return {
+        usage: {
+            input: promptTokenCount,
+            output: completionTokenCount,
+            cache_read: cacheReadTokenCount,
+            cache_write: cacheWriteTokenCount,
+            cache_write_1h: extracted.cache_creation_input_tokens_1h ?? 0,
+            input_image: extracted.input_image_tokens ?? 0,
+            cache_read_image: extracted.cache_read_image_tokens ?? 0,
+            output_image: extracted.output_image_tokens ?? 0,
+        },
+        tokensEstimated: est.used,
+        finishReason,
+        serviceTier,
+        providerReportedCostInUsd: reportedCostInUsd,
+    };
+}
+/** CLONE: live `logCompleteResponse` (non-stream completions). */
+function completeUsageFromResponse(response, request, est) {
+    if ('error' in response)
+        return { usage: {} };
+    const concatenatedPrompt = Array.isArray(request.prompt) ? request.prompt.join('\n\n') : request.prompt;
+    const usage = response.usage;
+    let promptTokenCount = usage?.prompt_tokens || 0;
+    let completionTokenCount = usage?.completion_tokens || 0;
+    if (!promptTokenCount) {
+        promptTokenCount = est.fromText(concatenatedPrompt || '');
+        completionTokenCount = est.fromText(response.choices?.map((choice) => choice.text)?.join('\n\n') || '');
+    }
+    return {
+        usage: {
+            input: promptTokenCount,
+            output: completionTokenCount,
+            cache_read: usage?.cache_read_input_tokens || usage?.prompt_tokens_details?.cached_tokens || 0,
+            cache_write: getCacheWriteTokens(usage),
+        },
+        tokensEstimated: est.used,
+    };
+}
+/** CLONE: live `logCompleteResponseForStreaming` / assembleStreamingCompletion token half. */
+function completeUsageFromStream(chunks, request, est) {
+    const concatenatedPrompt = Array.isArray(request.prompt) ? request.prompt.join('\n\n') : request.prompt;
+    let completeResponse = '';
+    const extracted = {};
+    chunks.forEach(chunk => {
+        const parsedChunk = parseSseDataJson(chunk);
+        if (!parsedChunk)
+            return;
+        parsedChunk.choices?.forEach((choice) => {
+            completeResponse += choice.text;
+        });
+        const usage = parsedChunk.usage;
+        if (usage) {
+            if (usage.prompt_tokens)
+                extracted.prompt_tokens = usage.prompt_tokens;
+            if (usage.completion_tokens)
+                extracted.completion_tokens = usage.completion_tokens;
+            if (usage.cache_read_input_tokens)
+                extracted.cache_read_input_tokens = usage.cache_read_input_tokens;
+            const cacheWriteTokens = getCacheWriteTokens(usage);
+            if (cacheWriteTokens)
+                extracted.cache_creation_input_tokens = cacheWriteTokens;
+            if (usage.prompt_tokens_details?.cached_tokens)
+                extracted.prompt_tokens_details = usage.prompt_tokens_details;
+        }
+    });
+    let promptTokenCount;
+    let completionTokenCount;
+    if (extracted.prompt_tokens !== undefined && extracted.completion_tokens !== undefined) {
+        promptTokenCount = extracted.prompt_tokens;
+        completionTokenCount = extracted.completion_tokens;
+    }
+    else {
+        promptTokenCount = extracted.prompt_tokens ?? est.fromText(concatenatedPrompt || '');
+        completionTokenCount = extracted.completion_tokens ?? est.fromText(completeResponse);
+    }
+    return {
+        usage: {
+            input: promptTokenCount,
+            output: completionTokenCount,
+            cache_read: extracted.cache_read_input_tokens || extracted.prompt_tokens_details?.cached_tokens || 0,
+            cache_write: extracted.cache_creation_input_tokens || 0,
+        },
+        tokensEstimated: est.used,
+    };
+}
+/** CLONE: live `numTokensInEmbeddingInput` (always flags estimation). */
+function numTokensInEmbeddingInput(embeddingInput, est) {
+    est.used = true;
+    if (typeof embeddingInput === 'string')
+        return est.fromText(embeddingInput);
+    if (Array.isArray(embeddingInput) && embeddingInput.length > 0) {
+        if (typeof embeddingInput[0] === 'string') {
+            return embeddingInput.reduce((acc, inp) => acc + est.fromText(inp), 0);
+        }
+        if (typeof embeddingInput[0] === 'number')
+            return embeddingInput.length;
+        if (Array.isArray(embeddingInput[0])) {
+            return embeddingInput.reduce((acc, inp) => acc + inp.length, 0);
+        }
+    }
+    return 0;
+}
+/** CLONE: live `logEmbedResponse` (input tokens; estimate from request.input when missing). */
+function embedUsageFromResponse(response, request, est) {
+    if ('error' in response)
+        return { usage: {} };
+    const promptTokenCount = response.usage?.prompt_tokens || numTokensInEmbeddingInput(request.input, est);
+    return { usage: { input: promptTokenCount }, tokensEstimated: est.used };
+}
+/** CLONE: live `logRerankResponse` (`isError` true for /ranking proxy detail→error). */
+function rerankUsageFromResponse(response, request, est, isError) {
+    if (isError)
+        return { usage: {} };
+    let promptTokenCount = response.usage?.prompt_tokens || 0;
+    let completionTokenCount = 0;
+    if (!promptTokenCount) {
+        promptTokenCount = est.fromText(JSON.stringify(request.documents) || '');
+        completionTokenCount = est.fromText(response.results?.map((result) => result.document ?? '').join('\n\n'));
+    }
+    return { usage: { input: promptTokenCount, output: completionTokenCount }, tokensEstimated: est.used };
+}
+/** CLONE: live `logDecisionResponse` (estimate from evidence + questions when usage missing). */
+function decisionUsageFromResponse(response, request, est) {
+    if ('error' in response)
+        return { usage: {} };
+    const usage = response.usage;
+    let promptTokenCount = usage?.prompt_tokens ?? usage?.input_tokens ?? 0;
+    let completionTokenCount = usage?.completion_tokens ?? usage?.output_tokens ?? 0;
+    if (!promptTokenCount) {
+        const evidence = request.input ?? request.state;
+        promptTokenCount = est.fromText(`${JSON.stringify(evidence ?? '')}${JSON.stringify(request.questions ?? '')}`);
+        completionTokenCount = est.fromText(JSON.stringify(response.answers ?? ''));
+    }
+    return { usage: { input: promptTokenCount, output: completionTokenCount }, tokensEstimated: est.used };
+}
+/** CLONE: live `logResponsesApi` (non-stream; error:null = success). */
+function responsesUsageFromResponse(response) {
+    if (response.error !== null && response.error !== undefined)
+        return { usage: {} };
+    const usage = response.usage;
+    return {
+        usage: {
+            input: usage?.input_tokens || 0,
+            output: usage?.output_tokens || 0,
+            cache_read: usage?.input_tokens_details?.cached_tokens || 0,
+            cache_write: getCacheWriteTokens(usage),
+        },
+        toolUsage: getToolUsageFromResponsesOutput(response.output),
+        providerReportedCostInUsd: providerReportedCostInUsd(usage),
+    };
+}
+/** CLONE: live `logResponsesApiForStreaming` (usage/tools from response.completed only). */
+function responsesUsageFromStream(chunks) {
+    let completeResponse = {};
+    // Per data: line — completed + [DONE] in one frame must not be joined (parseSseDataJson would).
+    for (const chunk of chunks) {
+        for (const dataLine of getSseDataLines(chunk)) {
+            if (dataLine === '[DONE]')
+                continue;
+            let parsedChunk;
+            try {
+                parsedChunk = JSON.parse(dataLine);
+            }
+            catch {
+                continue;
+            }
+            if (parsedChunk.type === 'response.completed' && parsedChunk.response) {
+                completeResponse = parsedChunk.response;
+            }
+        }
+    }
+    const usage = completeResponse.usage;
+    return {
+        usage: {
+            input: usage?.input_tokens || 0,
+            output: usage?.output_tokens || 0,
+            cache_read: usage?.input_tokens_details?.cached_tokens || 0,
+            cache_write: getCacheWriteTokens(usage),
+        },
+        toolUsage: getToolUsageFromResponsesOutput(completeResponse.output),
+        providerReportedCostInUsd: providerReportedCostInUsd(usage),
+    };
+}
+/** CLONE: live `logCreateModelResponseCompactResponse`. */
+function compactUsageFromResponse(response) {
+    if ('error' in response && response.error != null)
+        return { usage: {} };
+    const usage = response.usage;
+    return {
+        usage: {
+            input: usage?.input_tokens ?? 0,
+            output: usage?.output_tokens ?? 0,
+            cache_read: usage?.input_tokens_details?.cached_tokens ?? 0,
+            cache_write: getCacheWriteTokens(usage),
+        },
+    };
+}
+/** CLONE: live `logAnthropicMessageResponse` (input = base + cache read + cache write). */
+function anthropicUsageFromResponse(response) {
+    if ('error' in response)
+        return { usage: {} };
+    const cacheReadTokenCount = response.usage?.cache_read_input_tokens || 0;
+    const cacheWriteTokenCount = response.usage?.cache_creation_input_tokens || 0;
+    return {
+        usage: {
+            input: (response.usage?.input_tokens || 0) + cacheReadTokenCount + cacheWriteTokenCount,
+            output: response.usage?.output_tokens || 0,
+            cache_read: cacheReadTokenCount,
+            cache_write: cacheWriteTokenCount,
+            cache_write_1h: response.usage?.cache_creation?.ephemeral_1h_input_tokens || 0,
+        },
+        finishReason: response.stop_reason ?? undefined,
+    };
+}
+/** CLONE: live Anthropic stream token half (message_start input / message_delta output). */
+function anthropicUsageFromStream(chunks, cancelledMidwayByClient, est) {
+    let promptTokenCount = 0;
+    let completionTokenCount = 0;
+    let cacheReadTokenCount = 0;
+    let cacheWriteTokenCount = 0;
+    let cacheWrite1hTokenCount = 0;
+    let stopReason;
+    const generatedTextByIndex = new Map();
+    for (const chunk of chunks) {
+        const parsedData = parseSseDataJson(chunk);
+        if (!parsedData || parsedData.type === 'ping')
+            continue;
+        if (parsedData.type === 'message_start' && parsedData.message) {
+            const usage = parsedData.message.usage;
+            if (usage?.input_tokens)
+                promptTokenCount = usage.input_tokens;
+            if (usage?.cache_read_input_tokens)
+                cacheReadTokenCount = usage.cache_read_input_tokens;
+            if (usage?.cache_creation_input_tokens)
+                cacheWriteTokenCount = usage.cache_creation_input_tokens;
+            if (usage?.cache_creation?.ephemeral_1h_input_tokens) {
+                cacheWrite1hTokenCount = usage.cache_creation.ephemeral_1h_input_tokens;
+            }
+        }
+        if (parsedData.type === 'content_block_start' && parsedData.content_block) {
+            const block = parsedData.content_block;
+            if (block.type === 'text') {
+                generatedTextByIndex.set(parsedData.index, { kind: 'text', text: block.text ?? '' });
+            }
+            else if (block.type === 'tool_use' || block.type === 'server_tool_use') {
+                generatedTextByIndex.set(parsedData.index, { kind: 'tool', text: '' });
+            }
+            else if (block.type === 'thinking') {
+                generatedTextByIndex.set(parsedData.index, { kind: 'thinking', text: block.thinking ?? '' });
+            }
+        }
+        if (parsedData.type === 'content_block_delta' && parsedData.delta) {
+            const state = generatedTextByIndex.get(parsedData.index);
+            if (state?.kind === 'text' && parsedData.delta.type === 'text_delta') {
+                state.text += parsedData.delta.text || '';
+            }
+            else if (state?.kind === 'thinking' && parsedData.delta.type === 'thinking_delta') {
+                state.text += parsedData.delta.thinking || '';
+            }
+            else if (state?.kind === 'tool' && parsedData.delta.type === 'input_json_delta') {
+                state.text += parsedData.delta.partial_json ?? '';
+            }
+        }
+        if (parsedData.type === 'message_delta') {
+            if (parsedData.delta?.stop_reason)
+                stopReason = parsedData.delta.stop_reason;
+            const usage = parsedData.usage;
+            if (usage?.output_tokens)
+                completionTokenCount = usage.output_tokens;
+            if (usage?.input_tokens)
+                promptTokenCount = usage.input_tokens;
+            if (usage?.cache_creation?.ephemeral_1h_input_tokens) {
+                cacheWrite1hTokenCount = usage.cache_creation.ephemeral_1h_input_tokens;
+            }
+        }
+    }
+    if (completionTokenCount === 0 && cancelledMidwayByClient) {
+        const streamedText = [...generatedTextByIndex.values()].map(state => state.text).join('');
+        if (streamedText.length > 0)
+            completionTokenCount = est.fromText(streamedText);
+    }
+    return {
+        usage: {
+            input: promptTokenCount + cacheReadTokenCount + cacheWriteTokenCount,
+            output: completionTokenCount,
+            cache_read: cacheReadTokenCount,
+            cache_write: cacheWriteTokenCount,
+            cache_write_1h: cacheWrite1hTokenCount,
+        },
+        tokensEstimated: est.used,
+        finishReason: stopReason,
+    };
+}
+/** CLONE: live `parseGeminiUsageMetadata` (output = candidates + thoughts). */
+function geminiUsageFromMetadata(metadata) {
+    const imageTokens = (details) => (details ?? []).reduce((acc, curr) => (curr.modality === VERTEX_MODALITY.IMAGE ? acc + curr.tokenCount : acc), 0);
+    const cachedContentTokenCount = typeof metadata.cachedContentTokenCount === 'number' ? metadata.cachedContentTokenCount : 0;
+    const usage = {
+        input: typeof metadata.promptTokenCount === 'number' ? metadata.promptTokenCount : 0,
+        output: (typeof metadata.candidatesTokenCount === 'number' ? metadata.candidatesTokenCount : 0) +
+            (typeof metadata.thoughtsTokenCount === 'number' ? metadata.thoughtsTokenCount : 0),
+        input_image: imageTokens(metadata.promptTokensDetails),
+        output_image: imageTokens(metadata.candidatesTokensDetails),
+    };
+    if (cachedContentTokenCount > 0)
+        usage.cache_read = cachedContentTokenCount;
+    return usage;
+}
+/** CLONE: live `logGeminiProxyResponse` (no usageMetadata → empty usage). */
+function geminiUsageFromResponse(response) {
+    if (response.error)
+        return { usage: {} };
+    const metadata = response.usageMetadata;
+    return { usage: metadata && typeof metadata === 'object' ? geminiUsageFromMetadata(metadata) : {} };
+}
+/** CLONE: live `parseUsageFromGeminiStreamChunks` (last usageMetadata wins). */
+function geminiUsageFromStream(chunks) {
+    let usage = {};
+    chunks.forEach(chunk => {
+        if (!chunk)
+            return;
+        const trimmed = chunk
+            .trim()
+            .replace(/\r\n+$/, '')
+            .trim();
+        if (!trimmed)
+            return;
+        const dataMatch = trimmed.match(/^data:\s*(.+)$/m);
+        const raw = dataMatch ? dataMatch[1].trim() : trimmed;
+        if (!raw || raw === '[DONE]')
+            return;
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed?.usageMetadata && typeof parsed.usageMetadata === 'object') {
+                usage = geminiUsageFromMetadata(parsed.usageMetadata);
+            }
+        }
+        catch {
+            return;
+        }
+    });
+    return { usage };
+}
+/** CLONE helper: BedrockCounts → TokenUsage (prompt already includes cache when live does). */
+function bedrockCountsToUsage(counts) {
+    if (!counts)
+        return { input: 0, output: 0 };
+    const usage = { input: counts.promptTokenCount, output: counts.completionTokenCount };
+    if (counts.cacheReadTokenCount !== undefined)
+        usage.cache_read = counts.cacheReadTokenCount;
+    if (counts.cacheWriteTokenCount !== undefined)
+        usage.cache_write = counts.cacheWriteTokenCount;
+    if (counts.cacheWrite1hTokenCount !== undefined)
+        usage.cache_write_1h = counts.cacheWrite1hTokenCount;
+    return usage;
+}
+/** CLONE: live `sumConverseCacheDetails1h`. */
+function sumConverseCacheDetails1h(cacheDetails) {
+    if (!Array.isArray(cacheDetails) || cacheDetails.length === 0)
+        return undefined;
+    let total = 0;
+    let saw1h = false;
+    for (const entry of cacheDetails) {
+        if (entry?.ttl === '1h') {
+            saw1h = true;
+            total += entry.inputTokens ?? 0;
+        }
+    }
+    return saw1h ? total : 0;
+}
+/** CLONE: live `logBedrockProxyResponse` (Invoke headers / Converse camelCase usage). */
+function bedrockUsageFromResponse(response, headers) {
+    if (typeof response.message === 'string')
+        return { usage: {} };
+    const isInvokeBody = Array.isArray(response.generations) || Array.isArray(response.completions);
+    if (isInvokeBody) {
+        return {
+            usage: bedrockCountsToUsage({
+                promptTokenCount: Number(headers.get('x-amzn-bedrock-input-token-count')) || 0,
+                completionTokenCount: Number(headers.get('x-amzn-bedrock-output-token-count')) || 0,
+            }),
+        };
+    }
+    if (!('output' in response && 'usage' in response))
+        return { usage: {} };
+    const u = response.usage;
+    const cacheRead = u.cacheReadInputTokens ?? 0;
+    const cacheWrite = u.cacheWriteInputTokens ?? 0;
+    return {
+        usage: bedrockCountsToUsage({
+            promptTokenCount: u.inputTokens + cacheRead + cacheWrite,
+            completionTokenCount: u.outputTokens,
+            cacheReadTokenCount: u.cacheReadInputTokens,
+            cacheWriteTokenCount: u.cacheWriteInputTokens,
+            cacheWrite1hTokenCount: sumConverseCacheDetails1h(u.cacheDetails),
+        }),
+    };
+}
+/** CLONE: live bedrock `parseChunkJson` (raw JSON or AWS bytes envelope). */
+function parseBedrockChunkJson(chunk) {
+    if (!chunk?.trim())
+        return null;
+    // SSE frames via parseSseDataJson (data:/event: order-safe); else raw JSON (AWS event stream).
+    let parsed = parseSseDataJson(chunk);
+    if (parsed === undefined) {
+        const raw = chunk.trim();
+        if (!raw || raw === '[DONE]')
+            return null;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (parsed && typeof parsed === 'object' && typeof parsed.bytes === 'string') {
+        try {
+            const inner = Buffer.from(parsed.bytes, 'base64').toString('utf8');
+            if (inner)
+                parsed = JSON.parse(inner);
+        }
+        catch {
+            // keep outer
+        }
+    }
+    return parsed && typeof parsed === 'object' ? parsed : null;
+}
+/** CLONE: live bedrock flat `usage` block (camelCase + cache tokens). */
+function bedrockCountsFromFlatUsage(u) {
+    if (!u || typeof u !== 'object')
+        return null;
+    const inN = typeof u.inputTokens === 'number' ? u.inputTokens : typeof u.inputTokenCount === 'number' ? u.inputTokenCount : 0;
+    const outN = typeof u.outputTokens === 'number'
+        ? u.outputTokens
+        : typeof u.outputTokenCount === 'number'
+            ? u.outputTokenCount
+            : 0;
+    if (!(inN > 0 || outN > 0))
+        return null;
+    const cacheRead = typeof u.cacheReadInputTokens === 'number' ? u.cacheReadInputTokens : 0;
+    const cacheWrite = typeof u.cacheWriteInputTokens === 'number' ? u.cacheWriteInputTokens : 0;
+    return {
+        promptTokenCount: inN + cacheRead + cacheWrite,
+        completionTokenCount: outN,
+        cacheReadTokenCount: cacheRead || undefined,
+        cacheWriteTokenCount: cacheWrite || undefined,
+        cacheWrite1hTokenCount: sumConverseCacheDetails1h(u.cacheDetails),
+    };
+}
+/** CLONE: live `parseUsageFromConverseChunks`. */
+function bedrockCountsFromConverseChunks(chunks) {
+    for (const chunk of chunks) {
+        const p = parseBedrockChunkJson(chunk);
+        if (!p)
+            continue;
+        const flat = bedrockCountsFromFlatUsage(p.usage);
+        if (flat)
+            return flat;
+        const m = p.metrics;
+        if (m && (typeof m.inputTokenCount === 'number' || typeof m.outputTokenCount === 'number')) {
+            const cacheRead = m.cacheReadInputTokens ?? 0;
+            const cacheWrite = m.cacheWriteInputTokens ?? 0;
+            return {
+                promptTokenCount: (m.inputTokenCount ?? 0) + cacheRead + cacheWrite,
+                completionTokenCount: m.outputTokenCount ?? 0,
+                cacheReadTokenCount: m.cacheReadInputTokens,
+                cacheWriteTokenCount: m.cacheWriteInputTokens,
+                cacheWrite1hTokenCount: sumConverseCacheDetails1h(m.cacheDetails),
+            };
+        }
+    }
+    return null;
+}
+/** CLONE: live `parseUsageFromInvokeChunks`. */
+function bedrockCountsFromInvokeChunks(chunks) {
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadTokens;
+    let cacheWriteTokens;
+    let cacheWrite1hTokens;
+    for (const chunk of chunks) {
+        const p = parseBedrockChunkJson(chunk);
+        if (!p)
+            continue;
+        const flat = bedrockCountsFromFlatUsage(p.usage);
+        if (flat)
+            return flat;
+        const m = p.metrics;
+        if (m && (typeof m.inputTokenCount === 'number' || typeof m.outputTokenCount === 'number')) {
+            inputTokens = m.inputTokenCount ?? inputTokens;
+            outputTokens = m.outputTokenCount ?? outputTokens;
+            if (typeof m.cacheReadInputTokens === 'number')
+                cacheReadTokens = m.cacheReadInputTokens;
+            if (typeof m.cacheWriteInputTokens === 'number')
+                cacheWriteTokens = m.cacheWriteInputTokens;
+            continue;
+        }
+        const metaUsage = p.metadata?.usage;
+        if (metaUsage && (typeof metaUsage.inputTokens === 'number' || typeof metaUsage.outputTokens === 'number')) {
+            const cacheRead = metaUsage.cacheReadInputTokens ?? 0;
+            const cacheWrite = metaUsage.cacheWriteInputTokens ?? 0;
+            return {
+                promptTokenCount: (metaUsage.inputTokens ?? 0) + cacheRead + cacheWrite,
+                completionTokenCount: metaUsage.outputTokens ?? 0,
+                cacheReadTokenCount: metaUsage.cacheReadInputTokens,
+                cacheWriteTokenCount: metaUsage.cacheWriteInputTokens,
+                cacheWrite1hTokenCount: sumConverseCacheDetails1h(metaUsage.cacheDetails),
+            };
+        }
+        const topMetrics = p['amazon-bedrock-invocationMetrics'];
+        if (topMetrics &&
+            (typeof topMetrics.inputTokenCount === 'number' || typeof topMetrics.outputTokenCount === 'number')) {
+            const cacheRead = topMetrics.cacheReadInputTokens ?? 0;
+            const cacheWrite = topMetrics.cacheWriteInputTokens ?? 0;
+            return {
+                promptTokenCount: (topMetrics.inputTokenCount ?? 0) + cacheRead + cacheWrite,
+                completionTokenCount: topMetrics.outputTokenCount ?? 0,
+                cacheReadTokenCount: topMetrics.cacheReadInputTokens,
+                cacheWriteTokenCount: topMetrics.cacheWriteInputTokens,
+                cacheWrite1hTokenCount: cacheWrite1hTokens,
+            };
+        }
+        const nestedMetrics = p.metadata?.['amazon-bedrock-invocationMetrics'];
+        if (nestedMetrics &&
+            (typeof nestedMetrics.inputTokenCount === 'number' || typeof nestedMetrics.outputTokenCount === 'number')) {
+            inputTokens = nestedMetrics.inputTokenCount ?? inputTokens;
+            outputTokens = nestedMetrics.outputTokenCount ?? outputTokens;
+            if (typeof nestedMetrics.cacheReadInputTokens === 'number')
+                cacheReadTokens = nestedMetrics.cacheReadInputTokens;
+            if (typeof nestedMetrics.cacheWriteInputTokens === 'number') {
+                cacheWriteTokens = nestedMetrics.cacheWriteInputTokens;
+            }
+            continue;
+        }
+        const msgStart = p.messageStart ?? p.message;
+        if (msgStart?.usage && typeof msgStart.usage.input_tokens === 'number') {
+            inputTokens = msgStart.usage.input_tokens;
+            if (typeof msgStart.usage.cache_read_input_tokens === 'number') {
+                cacheReadTokens = msgStart.usage.cache_read_input_tokens;
+            }
+            if (typeof msgStart.usage.cache_creation_input_tokens === 'number') {
+                cacheWriteTokens = msgStart.usage.cache_creation_input_tokens;
+            }
+            if (typeof msgStart.usage.cache_creation?.ephemeral_1h_input_tokens === 'number') {
+                cacheWrite1hTokens = msgStart.usage.cache_creation.ephemeral_1h_input_tokens;
+            }
+        }
+        const deltaUsage = (p.messageDelta ?? p)?.usage;
+        if (deltaUsage) {
+            if (typeof deltaUsage.output_tokens === 'number')
+                outputTokens = deltaUsage.output_tokens;
+            if (typeof deltaUsage.input_tokens === 'number')
+                inputTokens = deltaUsage.input_tokens;
+            if (typeof deltaUsage.cache_creation?.ephemeral_1h_input_tokens === 'number') {
+                cacheWrite1hTokens = deltaUsage.cache_creation.ephemeral_1h_input_tokens;
+            }
+        }
+    }
+    return inputTokens > 0 || outputTokens > 0
+        ? {
+            promptTokenCount: inputTokens + (cacheReadTokens ?? 0) + (cacheWriteTokens ?? 0),
+            completionTokenCount: outputTokens,
+            cacheReadTokenCount: cacheReadTokens,
+            cacheWriteTokenCount: cacheWriteTokens,
+            cacheWrite1hTokenCount: cacheWrite1hTokens,
+        }
+        : null;
+}
+function isAnthropicMessagesProxy(scope) {
+    return scope.endpoint === 'proxy' && scope.inboundPath.includes('/v1/messages');
+}
+/**
+ * NEW router over CLONE parsers: non-stream counts live `handleNonStreamingMode` would price.
+ * `undefined` = no live token logger (caller keeps usageFromJson).
+ */
+export function liveUsageFromResponse(scope, json, headers) {
+    const response = asRecord(json);
+    if (!response)
+        return undefined;
+    const { endpoint, request } = scope;
+    const est = createTokenEstimator();
+    if (endpoint === 'chatComplete')
+        return chatUsageFromResponse(response, request, est);
+    if (endpoint === 'complete')
+        return completeUsageFromResponse(response, request, est);
+    if (endpoint === 'embed')
+        return embedUsageFromResponse(response, request, est);
+    if (endpoint === 'rerank')
+        return rerankUsageFromResponse(response, request, est, 'error' in response);
+    if (endpoint === 'decision')
+        return decisionUsageFromResponse(response, request, est);
+    if (endpoint === 'createModelResponse')
+        return responsesUsageFromResponse(response);
+    if (endpoint === 'createModelResponseCompact')
+        return compactUsageFromResponse(response);
+    if (endpoint === 'messages' || isAnthropicMessagesProxy(scope))
+        return anthropicUsageFromResponse(response);
+    if (endpoint === 'proxy' && scope.inboundPath.includes('/ranking')) {
+        return rerankUsageFromResponse(response, request, est, Boolean(response.detail) || 'error' in response);
+    }
+    if (endpoint === 'generateContent')
+        return geminiUsageFromResponse(response);
+    if (endpoint === 'bedrockConverse')
+        return bedrockUsageFromResponse(response, headers);
+    if (endpoint === 'proxy' || endpoint === 'tts-proxy' || endpoint === 'stt-proxy') {
+        if (scope.isGeminiRouter)
+            return geminiUsageFromResponse(response);
+        if (scope.isBedrockRouter)
+            return bedrockUsageFromResponse(response, headers);
+        // CLONE: live generic proxy spans carry no token counts.
+        return { usage: {} };
+    }
+    return undefined;
+}
+/**
+ * NEW router over CLONE parsers: stream counts live `logStreamingResponse` would price from frames.
+ * `undefined` = no live stream logger for this endpoint.
+ */
+export function liveUsageFromStreamFrames(scope, frames, streamState, cancelledMidwayByClient) {
+    const { endpoint, inboundPath, request } = scope;
+    const est = createTokenEstimator();
+    if (endpoint === 'chatComplete')
+        return chatUsageFromStream(frames, request, streamState, est);
+    if (endpoint === 'complete')
+        return completeUsageFromStream(frames, request, est);
+    if (endpoint === 'createModelResponse')
+        return responsesUsageFromStream(frames);
+    if (endpoint === 'messages' ||
+        isAnthropicMessagesProxy(scope) ||
+        (endpoint === 'proxy' &&
+            inboundPath.includes('/publishers/anthropic/models/') &&
+            inboundPath.includes(':streamRawPredict'))) {
+        return anthropicUsageFromStream(frames, cancelledMidwayByClient, est);
+    }
+    if (endpoint === 'generateContent' || (endpoint === 'proxy' && scope.isGeminiRouter)) {
+        return geminiUsageFromStream(frames);
+    }
+    if (endpoint === 'bedrockConverse' || (endpoint === 'proxy' && scope.isBedrockRouter)) {
+        const counts = inboundPath.includes('converse-stream')
+            ? bedrockCountsFromConverseChunks(frames)
+            : bedrockCountsFromInvokeChunks(frames);
+        return { usage: bedrockCountsToUsage(counts) };
+    }
+    // CLONE: live logs no tokens for other proxy streams.
+    if (endpoint === 'proxy')
+        return { usage: {} };
+    return undefined;
+}
 //# sourceMappingURL=buildExecutionReport.js.map