elasticdash-sdk 0.2.8 → 0.2.9

package/dist/interceptors/ai-interceptor.js

@@ -51,7 +51,7 @@ function extractPromptSnippet(body) {
     }
     return undefined;
 }
-function extractUsage(provider, body) {
+function extractUsage(provider, body, url) {
     if (provider === 'openai' || provider === 'grok' || provider === 'kimi') {
         const u = body.usage;
         if (!u)
@@ -70,9 +70,26 @@ function extractUsage(provider, body) {
             return undefined;
         return { inputTokens: u.promptTokenCount, outputTokens: u.candidatesTokenCount, totalTokens: u.totalTokenCount };
     }
+    if (provider === 'bedrock') {
+        const kind = url ? bedrockApiKind(url) : undefined;
+        const vendor = url ? bedrockVendor(extractBedrockModelId(url)) : 'unknown';
+        if (kind === 'converse' || kind === 'converse-stream') {
+            const u = body.usage;
+            if (!u)
+                return undefined;
+            return { inputTokens: u.inputTokens, outputTokens: u.outputTokens, totalTokens: u.totalTokens ?? (u.inputTokens ?? 0) + (u.outputTokens ?? 0) };
+        }
+        if (vendor === 'anthropic') {
+            const u = body.usage;
+            if (!u)
+                return undefined;
+            return { inputTokens: u.input_tokens, outputTokens: u.output_tokens, totalTokens: (u.input_tokens ?? 0) + (u.output_tokens ?? 0) };
+        }
+        return undefined;
+    }
     return undefined;
 }
-function extractAssistantMessage(provider, body) {
+function extractAssistantMessage(provider, body, url) {
     if (provider === 'openai' || provider === 'grok' || provider === 'kimi') {
         const choices = body.choices;
         if (Array.isArray(choices) && choices.length > 0) {
@@ -95,6 +112,19 @@ function extractAssistantMessage(provider, body) {
                 return content;
         }
     }
+    if (provider === 'bedrock') {
+        const kind = url ? bedrockApiKind(url) : undefined;
+        const vendor = url ? bedrockVendor(extractBedrockModelId(url)) : 'unknown';
+        if (kind === 'converse' || kind === 'converse-stream') {
+            const output = body.output;
+            const msg = output?.message;
+            if (msg && typeof msg === 'object')
+                return msg;
+        }
+        else if (vendor === 'anthropic' && Array.isArray(body.content)) {
+            return { role: 'assistant', content: body.content };
+        }
+    }
     return null;
 }
 /** URL patterns for known AI providers */
@@ -104,6 +134,7 @@ const AI_PATTERNS = {
     gemini: /https?:\/\/generativelanguage\.googleapis\.com\/.*\/models\/[^\/:]+:(generateContent|streamGenerateContent)/,
     grok: /https?:\/\/api\.x\.ai\/v1\/(chat\/)?completions/,
     kimi: /https?:\/\/api\.moonshot\.ai\/v1\/(chat\/)?completions/,
+    bedrock: /https?:\/\/bedrock-runtime\.[^./]+\.amazonaws\.com\/model\/[^/]+\/(invoke|invoke-with-response-stream|converse|converse-stream)/,
 };
 /** Detect which provider (if any) a URL belongs to */
 function detectProvider(url) {
@@ -113,17 +144,118 @@ function detectProvider(url) {
     }
     return null;
 }
-/** Extract model name from request body or URL (for Gemini) */
+/** @internal — exported for tests only */
+export function bedrockApiKind(url) {
+    if (/\/converse-stream(\?|$)/.test(url))
+        return 'converse-stream';
+    if (/\/converse(\?|$)/.test(url))
+        return 'converse';
+    if (/\/invoke-with-response-stream(\?|$)/.test(url))
+        return 'invoke-stream';
+    if (/\/invoke(\?|$)/.test(url))
+        return 'invoke';
+    return undefined;
+}
+/** @internal — exported for tests only */
+export function extractBedrockModelId(url) {
+    const m = /\/model\/([^/]+)\//.exec(url);
+    if (!m)
+        return 'unknown';
+    try {
+        return decodeURIComponent(m[1]);
+    }
+    catch {
+        return m[1];
+    }
+}
+/** @internal — exported for tests only */
+export function bedrockVendor(modelId) {
+    // Strip cross-region inference profile prefixes (us., eu., apac., au., etc.)
+    const stripped = modelId.replace(/^(us|eu|apac|au|ap)\./, '');
+    const vendor = stripped.split('.')[0];
+    switch (vendor) {
+        case 'anthropic': return 'anthropic';
+        case 'amazon': return 'amazon';
+        case 'cohere': return 'cohere';
+        case 'meta': return 'meta';
+        case 'mistral': return 'mistral';
+        case 'ai21': return 'ai21';
+        case 'stability': return 'stability';
+        default: return 'unknown';
+    }
+}
+/** Extract model name from request body or URL (for Gemini/Bedrock) */
 function extractModel(provider, body, url) {
     if (provider === 'gemini') {
         // URL shape: .../models/gemini-1.5-pro:generateContent
         const match = /\/models\/([^/:]+):/.exec(url);
         return match ? match[1] : 'unknown';
     }
+    if (provider === 'bedrock') {
+        return extractBedrockModelId(url);
+    }
     return typeof body.model === 'string' ? body.model : 'unknown';
 }
 /** Extract prompt text from request body */
-function extractPrompt(provider, body) {
+function extractPrompt(provider, body, url) {
+    if (provider === 'bedrock') {
+        const kind = url ? bedrockApiKind(url) : undefined;
+        const vendor = url ? bedrockVendor(extractBedrockModelId(url)) : 'unknown';
+        if (kind === 'converse' || kind === 'converse-stream') {
+            let systemPrefix = '';
+            if (Array.isArray(body.system)) {
+                systemPrefix = body.system
+                    .map((b) => (b && typeof b === 'object' ? String(b.text ?? '') : String(b)))
+                    .filter(Boolean)
+                    .map((t) => `system: ${t}`)
+                    .join('\n');
+                if (systemPrefix)
+                    systemPrefix += '\n';
+            }
+            const messages = body.messages;
+            if (Array.isArray(messages)) {
+                const msgText = messages
+                    .map((m) => {
+                    if (!m || typeof m !== 'object')
+                        return String(m);
+                    const msg = m;
+                    let content = msg.content;
+                    if (Array.isArray(content)) {
+                        content = content
+                            .map((b) => (b && typeof b === 'object' ? String(b.text ?? '') : String(b)))
+                            .filter(Boolean)
+                            .join('');
+                    }
+                    return `${msg.role}: ${content}`;
+                })
+                    .join('\n');
+                return systemPrefix + msgText;
+            }
+            return systemPrefix;
+        }
+        if (vendor === 'anthropic') {
+            // Same body shape as anthropic — fall through to the anthropic branch below.
+            provider = 'anthropic';
+        }
+        else {
+            // Best-effort for other vendors
+            if (typeof body.prompt === 'string')
+                return body.prompt;
+            if (typeof body.inputText === 'string')
+                return body.inputText;
+            if (Array.isArray(body.messages)) {
+                return body.messages
+                    .map((m) => {
+                    if (!m || typeof m !== 'object')
+                        return String(m);
+                    const msg = m;
+                    return `${msg.role ?? 'user'}: ${String(msg.content ?? '')}`;
+                })
+                    .join('\n');
+            }
+            return '';
+        }
+    }
     if (provider === 'openai' || provider === 'anthropic' || provider === 'grok' || provider === 'kimi') {
         let systemPrefix = '';
         // Anthropic supports a top-level `system` parameter
@@ -203,11 +335,65 @@ function extractPrompt(provider, body) {
     return '';
 }
 /** Extract completion text from response body */
-function extractCompletion(provider, responseBody) {
+function extractCompletion(provider, responseBody, url) {
     // Handle buffered streaming format
     if (responseBody.streamed === true && typeof responseBody.completion === 'string') {
         return responseBody.completion;
     }
+    if (provider === 'bedrock') {
+        const kind = url ? bedrockApiKind(url) : undefined;
+        const vendor = url ? bedrockVendor(extractBedrockModelId(url)) : 'unknown';
+        if (kind === 'converse' || kind === 'converse-stream') {
+            const output = responseBody.output;
+            const msg = output?.message;
+            if (msg && Array.isArray(msg.content)) {
+                return msg.content
+                    .map((b) => (b && typeof b === 'object' ? String(b.text ?? '') : ''))
+                    .filter(Boolean)
+                    .join('');
+            }
+            return '';
+        }
+        if (vendor === 'anthropic') {
+            const content = responseBody.content;
+            if (Array.isArray(content)) {
+                return content
+                    .map((block) => {
+                    if (block && typeof block === 'object') {
+                        const b = block;
+                        if (b.type === 'text' && typeof b.text === 'string')
+                            return b.text;
+                    }
+                    return '';
+                })
+                    .filter(Boolean)
+                    .join('');
+            }
+            return '';
+        }
+        // Other vendors — best-effort
+        if (typeof responseBody.completion === 'string')
+            return responseBody.completion; // legacy Claude
+        if (typeof responseBody.outputText === 'string')
+            return responseBody.outputText; // Titan
+        if (typeof responseBody.generation === 'string')
+            return responseBody.generation; // Llama
+        if (Array.isArray(responseBody.results)) {
+            // Titan / Cohere results array
+            return responseBody.results
+                .map((r) => (r && typeof r === 'object' ? String(r.outputText ?? r.text ?? '') : ''))
+                .filter(Boolean)
+                .join('');
+        }
+        if (Array.isArray(responseBody.choices)) {
+            // Mistral
+            const first = responseBody.choices[0];
+            const msg = first?.message;
+            if (msg && typeof msg.content === 'string')
+                return msg.content;
+        }
+        return '';
+    }
     if (provider === 'openai' || provider === 'grok' || provider === 'kimi') {
         const choices = responseBody.choices;
         if (Array.isArray(choices) && choices.length > 0) {
@@ -265,6 +451,226 @@ function extractCompletion(provider, responseBody) {
     }
     return '';
 }
+// ---------------------------------------------------------------------------
+// Bedrock binary eventstream support (application/vnd.amazon.eventstream)
+// ---------------------------------------------------------------------------
+//
+// Wire format: 12-byte prelude (total_length | headers_length | prelude_crc),
+// headers TLV block, JSON payload, 4-byte message CRC. We ignore CRCs on read
+// (we are observing, not validating). On write we compute CRC-32 so that the
+// synthesized stream is acceptable to strict consumers like the AWS SDK.
+function crc32(bytes, init = 0xFFFFFFFF) {
+    let crc = init;
+    for (let i = 0; i < bytes.length; i++) {
+        crc = crc ^ bytes[i];
+        for (let j = 0; j < 8; j++) {
+            crc = (crc >>> 1) ^ (0xEDB88320 & -(crc & 1));
+        }
+    }
+    return (crc ^ 0xFFFFFFFF) >>> 0;
+}
+function concatChunks(chunks) {
+    let len = 0;
+    for (const c of chunks)
+        len += c.length;
+    const out = new Uint8Array(len);
+    let offset = 0;
+    for (const c of chunks) {
+        out.set(c, offset);
+        offset += c.length;
+    }
+    return out;
+}
+/** @internal — exported for tests only */
+export function parseBedrockEventStream(buf) {
+    const frames = [];
+    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    const decoder = new TextDecoder();
+    let offset = 0;
+    while (offset + 12 <= buf.length) {
+        const totalLen = view.getUint32(offset, false);
+        const headersLen = view.getUint32(offset + 4, false);
+        if (totalLen < 16 || totalLen > buf.length - offset)
+            break;
+        const headers = {};
+        let h = offset + 12;
+        const hEnd = h + headersLen;
+        while (h < hEnd) {
+            const nameLen = buf[h];
+            h += 1;
+            if (h + nameLen > hEnd)
+                break;
+            const name = decoder.decode(buf.subarray(h, h + nameLen));
+            h += nameLen;
+            const type = buf[h];
+            h += 1;
+            if (type === 7) {
+                // string
+                const valueLen = view.getUint16(h, false);
+                h += 2;
+                headers[name] = decoder.decode(buf.subarray(h, h + valueLen));
+                h += valueLen;
+            }
+            else {
+                // Other header types (bool, byte, short, int, long, byte_array, timestamp, uuid) — skip
+                const lenByType = { 0: 0, 1: 0, 2: 1, 3: 2, 4: 4, 5: 8, 8: 8, 9: 16 };
+                const skipLen = lenByType[type];
+                if (skipLen === undefined)
+                    break;
+                h += skipLen;
+            }
+        }
+        const payloadStart = offset + 12 + headersLen;
+        const payloadEnd = offset + totalLen - 4;
+        if (payloadEnd >= payloadStart) {
+            frames.push({ headers, payload: buf.subarray(payloadStart, payloadEnd) });
+        }
+        offset += totalLen;
+    }
+    return frames;
+}
+/** @internal — exported for tests only */
+export function encodeBedrockFrame(eventType, payloadObj) {
+    const encoder = new TextEncoder();
+    const payload = encoder.encode(JSON.stringify(payloadObj));
+    const writeHeader = (name, value) => {
+        const nameBytes = encoder.encode(name);
+        const valueBytes = encoder.encode(value);
+        const out = new Uint8Array(1 + nameBytes.length + 1 + 2 + valueBytes.length);
+        const dv = new DataView(out.buffer);
+        let p = 0;
+        out[p++] = nameBytes.length;
+        out.set(nameBytes, p);
+        p += nameBytes.length;
+        out[p++] = 7;
+        dv.setUint16(p, valueBytes.length, false);
+        p += 2;
+        out.set(valueBytes, p);
+        return out;
+    };
+    const headers = concatChunks([
+        writeHeader(':event-type', eventType),
+        writeHeader(':content-type', 'application/json'),
+        writeHeader(':message-type', 'event'),
+    ]);
+    const totalLen = 12 + headers.length + payload.length + 4;
+    const out = new Uint8Array(totalLen);
+    const dv = new DataView(out.buffer);
+    dv.setUint32(0, totalLen, false);
+    dv.setUint32(4, headers.length, false);
+    const preludeCrc = crc32(out.subarray(0, 8));
+    dv.setUint32(8, preludeCrc, false);
+    out.set(headers, 12);
+    out.set(payload, 12 + headers.length);
+    const msgCrc = crc32(out.subarray(0, totalLen - 4));
+    dv.setUint32(totalLen - 4, msgCrc, false);
+    return out;
+}
+/** @internal — exported for tests only */
+export async function bufferBedrockEventStream(url, stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const buf = concatChunks(chunks);
+    const frames = parseBedrockEventStream(buf);
+    const kind = bedrockApiKind(url);
+    const vendor = bedrockVendor(extractBedrockModelId(url));
+    const isInvoke = kind === 'invoke-stream';
+    const decoder = new TextDecoder();
+    let completion = '';
+    let usage;
+    for (const frame of frames) {
+        let obj;
+        try {
+            obj = JSON.parse(decoder.decode(frame.payload));
+        }
+        catch {
+            continue;
+        }
+        const eventType = frame.headers[':event-type'];
+        if (isInvoke && typeof obj.bytes === 'string') {
+            // InvokeModelWithResponseStream wraps the underlying model's SSE-equivalent
+            // JSON event in a base64 'bytes' field per frame.
+            try {
+                const innerJson = typeof atob === 'function'
+                    ? atob(obj.bytes)
+                    : Buffer.from(obj.bytes, 'base64').toString('utf8');
+                const decoded = JSON.parse(innerJson);
+                if (vendor === 'anthropic') {
+                    if (decoded.type === 'content_block_delta') {
+                        const d = decoded.delta;
+                        if (d?.type === 'text_delta' && typeof d.text === 'string')
+                            completion += d.text;
+                    }
+                    if (decoded.type === 'message_delta') {
+                        const u = decoded.usage;
+                        if (u)
+                            usage = extractUsage('anthropic', { usage: u }) ?? usage;
+                    }
+                    if (decoded.type === 'message_start') {
+                        const msg = decoded.message;
+                        if (msg?.usage)
+                            usage = extractUsage('anthropic', { usage: msg.usage }) ?? usage;
+                    }
+                }
+                else {
+                    // Best-effort generic
+                    if (typeof decoded.outputText === 'string')
+                        completion += decoded.outputText;
+                    if (typeof decoded.generation === 'string')
+                        completion += decoded.generation;
+                }
+            }
+            catch { /* skip */ }
+            continue;
+        }
+        // Converse-stream: payload IS the event body; the discriminator lives
+        // in the :event-type header. Some SDK serialisations also nest the body
+        // under a key matching the event type — handle both shapes.
+        if (eventType === 'contentBlockDelta' || obj.contentBlockDelta) {
+            const body = obj.contentBlockDelta ?? obj;
+            const delta = body.delta;
+            if (typeof delta?.text === 'string')
+                completion += delta.text;
+        }
+        if (eventType === 'metadata' || obj.metadata) {
+            const body = obj.metadata ?? obj;
+            const u = body.usage;
+            if (u) {
+                usage = { inputTokens: u.inputTokens, outputTokens: u.outputTokens, totalTokens: u.totalTokens ?? (u.inputTokens ?? 0) + (u.outputTokens ?? 0) };
+            }
+        }
+    }
+    return { completion, usage };
+}
+/** Content-Type for a synthesized streaming response, per provider. */
+function streamContentType(provider) {
+    if (provider === 'gemini')
+        return 'application/json';
+    if (provider === 'bedrock')
+        return 'application/vnd.amazon.eventstream';
+    return 'text/event-stream';
+}
+/**
+ * Unified streaming buffer: dispatches to the binary Bedrock eventstream parser
+ * or the text SSE/NDJSON parser based on provider.
+ */
+async function bufferAIStream(provider, url, stream) {
+    if (provider === 'bedrock')
+        return bufferBedrockEventStream(url, stream);
+    const completion = await bufferSSEStream(provider, stream);
+    return { completion };
+}
 /** Buffer a streaming SSE/NDJSON response to extract the completion text */
 async function bufferSSEStream(provider, stream) {
     const decoder = new TextDecoder();
@@ -387,7 +793,7 @@ function extractStreamUsage(provider, rawSSE) {
     return undefined;
 }
 /** Build a minimal non-streaming JSON response body from a completion string (for replay) */
-function synthesizeCompletionJSON(provider, completion) {
+function synthesizeCompletionJSON(provider, completion, url) {
     if (provider === 'gemini') {
         return {
             candidates: [{ content: { parts: [{ text: completion }], role: 'model' }, finishReason: 'STOP' }],
@@ -403,6 +809,29 @@ function synthesizeCompletionJSON(provider, completion) {
             stop_sequence: null,
         };
     }
+    if (provider === 'bedrock') {
+        const kind = url ? bedrockApiKind(url) : undefined;
+        const vendor = url ? bedrockVendor(extractBedrockModelId(url)) : 'unknown';
+        if (kind === 'converse' || kind === 'converse-stream') {
+            return {
+                output: { message: { role: 'assistant', content: [{ text: completion }] } },
+                stopReason: 'end_turn',
+                usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+            };
+        }
+        if (vendor === 'anthropic') {
+            return {
+                id: 'replay',
+                type: 'message',
+                role: 'assistant',
+                content: [{ type: 'text', text: completion }],
+                stop_reason: 'end_turn',
+                stop_sequence: null,
+            };
+        }
+        // Generic fallback
+        return { outputText: completion };
+    }
     // OpenAI / Grok / Kimi format
     return {
         id: 'replay',
@@ -411,8 +840,43 @@ function synthesizeCompletionJSON(provider, completion) {
     };
 }
 /** Build a minimal SSE/NDJSON ReadableStream from a completion string (for replay) */
-function synthesizeSSEStream(provider, completion) {
+function synthesizeSSEStream(provider, completion, url) {
     const encoder = new TextEncoder();
+    if (provider === 'bedrock') {
+        const kind = url ? bedrockApiKind(url) : undefined;
+        const vendor = url ? bedrockVendor(extractBedrockModelId(url)) : 'unknown';
+        return new ReadableStream({
+            start(ctrl) {
+                if (kind === 'converse-stream') {
+                    ctrl.enqueue(encodeBedrockFrame('messageStart', { role: 'assistant' }));
+                    ctrl.enqueue(encodeBedrockFrame('contentBlockDelta', { contentBlockIndex: 0, delta: { text: completion } }));
+                    ctrl.enqueue(encodeBedrockFrame('contentBlockStop', { contentBlockIndex: 0 }));
+                    ctrl.enqueue(encodeBedrockFrame('messageStop', { stopReason: 'end_turn' }));
+                    ctrl.enqueue(encodeBedrockFrame('metadata', { usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 }, metrics: { latencyMs: 0 } }));
+                }
+                else if (vendor === 'anthropic') {
+                    // InvokeModelWithResponseStream wraps the inner Anthropic SSE event JSON in { bytes }
+                    const wrap = (eventType, inner) => {
+                        const innerJson = JSON.stringify(inner);
+                        const b64 = typeof btoa === 'function' ? btoa(innerJson) : Buffer.from(innerJson, 'utf8').toString('base64');
+                        return encodeBedrockFrame(eventType, { bytes: b64 });
+                    };
+                    ctrl.enqueue(wrap('chunk', { type: 'message_start', message: { id: 'replay', type: 'message', role: 'assistant', content: [], stop_reason: null, stop_sequence: null } }));
+                    ctrl.enqueue(wrap('chunk', { type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } }));
+                    ctrl.enqueue(wrap('chunk', { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: completion } }));
+                    ctrl.enqueue(wrap('chunk', { type: 'content_block_stop', index: 0 }));
+                    ctrl.enqueue(wrap('chunk', { type: 'message_delta', delta: { stop_reason: 'end_turn', stop_sequence: null } }));
+                    ctrl.enqueue(wrap('chunk', { type: 'message_stop' }));
+                }
+                else {
+                    // Generic fallback: one chunk wrapping the completion text
+                    const b64 = typeof btoa === 'function' ? btoa(JSON.stringify({ outputText: completion })) : Buffer.from(JSON.stringify({ outputText: completion }), 'utf8').toString('base64');
+                    ctrl.enqueue(encodeBedrockFrame('chunk', { bytes: b64 }));
+                }
+                ctrl.close();
+            },
+        });
+    }
     return new ReadableStream({
         start(ctrl) {
             if (provider === 'gemini') {
@@ -483,30 +947,42 @@ export function installAIInterceptor() {
                     url, provider, model: capturedModel, messages: capturedMessages,
                     body: capturedReq, promptSnippet: capturedSnippet,
                 };
-                const isStreaming = capturedReq.stream === true;
+                const isStreaming = provider === 'bedrock'
+                    ? (bedrockApiKind(url) ?? '').endsWith('-stream')
+                    : capturedReq.stream === true;
                 try {
                     const cloned = response.clone();
                     if (!isStreaming) {
                         // Non-streaming: parse JSON response for usage
                         const responseBody = await cloned.json();
-                        captured.usage = extractUsage(provider, responseBody);
+                        captured.usage = extractUsage(provider, responseBody, url);
                     }
                     else if (cloned.body) {
-                        // Streaming: read the raw SSE text to extract usage from final events
-                        try {
-                            const decoder = new TextDecoder();
-                            const reader = cloned.body.getReader();
-                            let rawSSE = '';
-                            for (;;) {
-                                const { done, value } = await reader.read();
-                                if (done)
-                                    break;
-                                rawSSE += decoder.decode(value, { stream: true });
+                        if (provider === 'bedrock') {
+                            // Binary eventstream: parse frames to extract usage
+                            try {
+                                const { usage } = await bufferBedrockEventStream(url, cloned.body);
+                                captured.usage = usage;
                             }
-                            reader.releaseLock();
-                            captured.usage = extractStreamUsage(provider, rawSSE);
+                            catch { /* parse failed */ }
+                        }
+                        else {
+                            // SSE/NDJSON text: extract usage from final events
+                            try {
+                                const decoder = new TextDecoder();
+                                const reader = cloned.body.getReader();
+                                let rawSSE = '';
+                                for (;;) {
+                                    const { done, value } = await reader.read();
+                                    if (done)
+                                        break;
+                                    rawSSE += decoder.decode(value, { stream: true });
+                                }
+                                reader.releaseLock();
+                                captured.usage = extractStreamUsage(provider, rawSSE);
+                            }
+                            catch { /* stream read failed */ }
                         }
-                        catch { /* stream read failed */ }
                     }
                 }
                 catch {
@@ -534,17 +1010,28 @@ export function installAIInterceptor() {
             if (rawBody && typeof rawBody === 'string') {
                 const body = JSON.parse(rawBody);
                 model = extractModel(provider, body, url);
-                prompt = extractPrompt(provider, body);
-                isStreaming = body.stream === true;
+                prompt = extractPrompt(provider, body, url);
+                isStreaming = provider === 'bedrock'
+                    ? (bedrockApiKind(url) ?? '').endsWith('-stream')
+                    : body.stream === true;
                 // Capture full messages array for rich display in the dashboard
                 if (Array.isArray(body.messages))
                     messages = body.messages;
                 else if (Array.isArray(body.contents))
                     messages = body.contents; // Gemini
             }
+            else if (provider === 'bedrock') {
+                // No body parsed but URL alone is enough to set streaming flag
+                isStreaming = (bedrockApiKind(url) ?? '').endsWith('-stream');
+                model = extractModel(provider, {}, url);
+            }
         }
         catch {
             // Ignore parse errors — still pass through
+            if (provider === 'bedrock') {
+                isStreaming = (bedrockApiKind(url) ?? '').endsWith('-stream');
+                model = extractModel(provider, {}, url);
+            }
         }
         const ctx = getCaptureContext();
         // Observability-only mode: no trace handle, no capture context — record via pushTelemetryEvent
@@ -556,9 +1043,9 @@ export function installAIInterceptor() {
             const response = await originalFetch(input, init);
             if (isStreaming && response.body) {
                 const [streamForCaller, streamForRecorder] = response.body.tee();
-                bufferSSEStream(provider, streamForRecorder).then((completion) => {
+                bufferAIStream(provider, url, streamForRecorder).then(({ completion, usage }) => {
                     const durationMs = rawDateNow() - start;
-                    pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: { streamed: true, completion }, timestamp: start, durationMs });
+                    pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: { streamed: true, completion }, timestamp: start, durationMs, ...(usage ? { usage } : {}) });
                 }).catch(() => {
                     const durationMs = rawDateNow() - start;
                     pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: null, streamed: true, streamRaw: '', timestamp: start, durationMs });
@@ -568,8 +1055,8 @@ export function installAIInterceptor() {
             try {
                 const cloned = response.clone();
                 const responseBody = await cloned.json();
-                const completion = extractCompletion(provider, responseBody);
-                const usage = extractUsage(provider, responseBody);
+                const completion = extractCompletion(provider, responseBody, url);
+                const usage = extractUsage(provider, responseBody, url);
                 const durationMs = rawDateNow() - start;
                 const event = {
                     id, type: 'ai', name: model, input: eventInput, output: { completion },
@@ -594,16 +1081,16 @@ export function installAIInterceptor() {
             if (frozen && frozen.type === 'ai') {
                 pushTelemetryEvent(frozen);
                 const frozenOutput = frozen.output;
-                const completion = frozenOutput ? extractCompletion(provider, frozenOutput) : '(replayed)';
+                const completion = frozenOutput ? extractCompletion(provider, frozenOutput, url) : '(replayed)';
                 if (isStreaming) {
-                    return new Response(synthesizeSSEStream(provider, completion), {
+                    return new Response(synthesizeSSEStream(provider, completion, url), {
                         status: 200,
-                        headers: { 'Content-Type': provider === 'gemini' ? 'application/json' : 'text/event-stream' },
+                        headers: { 'Content-Type': streamContentType(provider) },
                     });
                 }
                 const body = frozenOutput?.streamed === true
-                    ? synthesizeCompletionJSON(provider, completion)
-                    : (frozenOutput ?? synthesizeCompletionJSON(provider, completion));
+                    ? synthesizeCompletionJSON(provider, completion, url)
+                    : (frozenOutput ?? synthesizeCompletionJSON(provider, completion, url));
                 return new Response(JSON.stringify(body), {
                     status: 200,
                     headers: { 'Content-Type': 'application/json' },
@@ -614,9 +1101,9 @@ export function installAIInterceptor() {
             const response = await originalFetch(input, init);
             if (isStreaming && response.body) {
                 const [streamForCaller, streamForRecorder] = response.body.tee();
-                bufferSSEStream(provider, streamForRecorder).then((completion) => {
+                bufferAIStream(provider, url, streamForRecorder).then(({ completion, usage }) => {
                     const durationMs = rawDateNow() - start;
-                    pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: { streamed: true, completion }, timestamp: start, durationMs });
+                    pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: { streamed: true, completion }, timestamp: start, durationMs, ...(usage ? { usage } : {}) });
                 }).catch(() => {
                     const durationMs = rawDateNow() - start;
                     pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: null, streamed: true, streamRaw: '', timestamp: start, durationMs });
@@ -626,8 +1113,8 @@ export function installAIInterceptor() {
             try {
                 const cloned = response.clone();
                 const responseBody = await cloned.json();
-                const completion = extractCompletion(provider, responseBody);
-                const usage = extractUsage(provider, responseBody);
+                const completion = extractCompletion(provider, responseBody, url);
+                const usage = extractUsage(provider, responseBody, url);
                 const durationMs = rawDateNow() - start;
                 pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: { completion }, timestamp: start, durationMs, ...(usage ? { usage } : {}) });
             }
@@ -654,18 +1141,18 @@ export function installAIInterceptor() {
                 if (isReplayMatch && historicalEvent) {
                     recorder.record(historicalEvent);
                     const historicalOutput = historicalEvent.output;
-                    const completion = historicalOutput ? extractCompletion(provider, historicalOutput) : '(replayed)';
+                    const completion = historicalOutput ? extractCompletion(provider, historicalOutput, url) : '(replayed)';
                     traceAtCall.recordLLMStep({ model, provider, prompt, completion, workflowEventId: id });
                     if (isStreaming) {
                         // Current caller expects a streaming response — always synthesize SSE
-                        return new Response(synthesizeSSEStream(provider, completion), {
+                        return new Response(synthesizeSSEStream(provider, completion, url), {
                             status: 200,
-                            headers: { 'Content-Type': provider === 'gemini' ? 'application/json' : 'text/event-stream' },
+                            headers: { 'Content-Type': streamContentType(provider) },
                         });
                     }
                     if (historicalOutput?.streamed === true) {
                         // Original was streamed but caller now expects JSON — synthesize a completion response
-                        return new Response(JSON.stringify(synthesizeCompletionJSON(provider, completion)), {
+                        return new Response(JSON.stringify(synthesizeCompletionJSON(provider, completion, url)), {
                             status: 200,
                             headers: { 'Content-Type': 'application/json' },
                         });
@@ -680,10 +1167,10 @@ export function installAIInterceptor() {
             if (isStreaming) {
                 if (response.body) {
                     const [streamForCaller, streamForRecorder] = response.body.tee();
-                    recorder.trackAsync(bufferSSEStream(provider, streamForRecorder).then((completion) => {
+                    recorder.trackAsync(bufferAIStream(provider, url, streamForRecorder).then(({ completion, usage }) => {
                         const durationMs = rawDateNow() - start;
                         traceAtCall.recordLLMStep({ model, provider, prompt, completion, workflowEventId: id, durationMs });
-                        recorder.record({ id, type: 'ai', name: model, input: { url, provider, model, prompt, messages }, output: { streamed: true, completion }, timestamp: start, durationMs });
+                        recorder.record({ id, type: 'ai', name: model, input: { url, provider, model, prompt, messages }, output: { streamed: true, completion }, timestamp: start, durationMs, ...(usage ? { usage } : {}) });
                     }).catch(() => {
                         const durationMs = rawDateNow() - start;
                         traceAtCall.recordLLMStep({ model, provider, prompt, completion: '(streamed-error)', workflowEventId: id, durationMs });
@@ -704,9 +1191,9 @@ export function installAIInterceptor() {
                 try {
                     const cloned = response.clone();
                     const responseBody = await cloned.json();
-                    const completion = extractCompletion(provider, responseBody);
-                    const usage = extractUsage(provider, responseBody);
-                    const assistantMessage = extractAssistantMessage(provider, responseBody);
+                    const completion = extractCompletion(provider, responseBody, url);
+                    const usage = extractUsage(provider, responseBody, url);
+                    const assistantMessage = extractAssistantMessage(provider, responseBody, url);
                     traceAtCall.recordLLMStep({ model, provider, prompt, completion, workflowEventId: id, durationMs });
                     recorder.record({ id, type: 'ai', name: model, input: { url, provider, model, prompt, messages }, output: assistantMessage ?? responseBody, timestamp: start, durationMs, usage });
                 }
@@ -723,7 +1210,7 @@ export function installAIInterceptor() {
         const response = await originalFetch(input, init);
         if (isStreaming && response.body) {
             const [streamForCaller, streamForRecorder] = response.body.tee();
-            bufferSSEStream(provider, streamForRecorder).then((completion) => {
+            bufferAIStream(provider, url, streamForRecorder).then(({ completion }) => {
                 traceAtCall.recordLLMStep({ model, provider, prompt, completion });
             }).catch(() => {
                 traceAtCall.recordLLMStep({ model, provider, prompt, completion: '(streamed-error)' });
@@ -734,7 +1221,7 @@ export function installAIInterceptor() {
             try {
                 const cloned = response.clone();
                 const responseBody = await cloned.json();
-                const completion = extractCompletion(provider, responseBody);
+                const completion = extractCompletion(provider, responseBody, url);
                 traceAtCall.recordLLMStep({ model, provider, prompt, completion });
             }
             catch {