elasticdash-sdk 0.2.8 → 0.2.9

package/src/interceptors/ai-interceptor.ts

@@ -65,7 +65,7 @@ function extractPromptSnippet(body: Record<string, unknown>): string | undefined
 
 type UsageInfo = { inputTokens?: number; outputTokens?: number; totalTokens?: number }
 
-function extractUsage(provider: string, body: Record<string, unknown>): UsageInfo | undefined {
+function extractUsage(provider: string, body: Record<string, unknown>, url?: string): UsageInfo | undefined {
   if (provider === 'openai' || provider === 'grok' || provider === 'kimi') {
     const u = body.usage as Record<string, number> | undefined
     if (!u) return undefined
@@ -81,10 +81,25 @@ function extractUsage(provider: string, body: Record<string, unknown>): UsageInf
     if (!u) 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 as Record<string, number> | undefined
+      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 as Record<string, number> | undefined
+      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: string, body: Record<string, unknown>): Record<string, unknown> | null {
+function extractAssistantMessage(provider: string, body: Record<string, unknown>, url?: string): Record<string, unknown> | null {
   if (provider === 'openai' || provider === 'grok' || provider === 'kimi') {
     const choices = body.choices
     if (Array.isArray(choices) && choices.length > 0) {
@@ -105,6 +120,17 @@ function extractAssistantMessage(provider: string, body: Record<string, unknown>
       if (content && typeof content === 'object') return content as Record<string, unknown>
     }
   }
+  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 as Record<string, unknown> | undefined
+      const msg = output?.message
+      if (msg && typeof msg === 'object') return msg as Record<string, unknown>
+    } else if (vendor === 'anthropic' && Array.isArray(body.content)) {
+      return { role: 'assistant', content: body.content }
+    }
+  }
   return null
 }
 
@@ -115,6 +141,7 @@ const AI_PATTERNS: Record<string, RegExp> = {
   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 */
@@ -125,18 +152,120 @@ function detectProvider(url: string): string | null {
   return null
 }
 
-/** Extract model name from request body or URL (for Gemini) */
+/**
+ * Bedrock URL routes:
+ *   POST /model/{modelId}/invoke
+ *   POST /model/{modelId}/invoke-with-response-stream
+ *   POST /model/{modelId}/converse
+ *   POST /model/{modelId}/converse-stream
+ */
+type BedrockApiKind = 'invoke' | 'invoke-stream' | 'converse' | 'converse-stream'
+
+/** @internal — exported for tests only */
+export function bedrockApiKind(url: string): BedrockApiKind | undefined {
+  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: string): string {
+  const m = /\/model\/([^/]+)\//.exec(url)
+  if (!m) return 'unknown'
+  try { return decodeURIComponent(m[1]) } catch { return m[1] }
+}
+
+type BedrockVendor = 'anthropic' | 'amazon' | 'cohere' | 'meta' | 'mistral' | 'ai21' | 'stability' | 'unknown'
+
+/** @internal — exported for tests only */
+export function bedrockVendor(modelId: string): BedrockVendor {
+  // 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: string, body: Record<string, unknown>, url: string): string {
   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: string, body: Record<string, unknown>): string {
+function extractPrompt(provider: string, body: Record<string, unknown>, url?: string): string {
+  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: unknown) => (b && typeof b === 'object' ? String((b as Record<string, unknown>).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: unknown) => {
+            if (!m || typeof m !== 'object') return String(m)
+            const msg = m as Record<string, unknown>
+            let content = msg.content
+            if (Array.isArray(content)) {
+              content = content
+                .map((b: unknown) => (b && typeof b === 'object' ? String((b as Record<string, unknown>).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: unknown) => {
+            if (!m || typeof m !== 'object') return String(m)
+            const msg = m as Record<string, unknown>
+            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
@@ -215,12 +344,65 @@ function extractPrompt(provider: string, body: Record<string, unknown>): string
 }
 
 /** Extract completion text from response body */
-function extractCompletion(provider: string, responseBody: Record<string, unknown>): string {
+function extractCompletion(provider: string, responseBody: Record<string, unknown>, url?: string): string {
   // 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 as Record<string, unknown> | undefined
+      const msg = output?.message as Record<string, unknown> | undefined
+      if (msg && Array.isArray(msg.content)) {
+        return msg.content
+          .map((b: unknown) => (b && typeof b === 'object' ? String((b as Record<string, unknown>).text ?? '') : ''))
+          .filter(Boolean)
+          .join('')
+      }
+      return ''
+    }
+
+    if (vendor === 'anthropic') {
+      const content = responseBody.content
+      if (Array.isArray(content)) {
+        return content
+          .map((block: unknown) => {
+            if (block && typeof block === 'object') {
+              const b = block as Record<string, unknown>
+              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 as unknown[])
+        .map((r) => (r && typeof r === 'object' ? String((r as Record<string, unknown>).outputText ?? (r as Record<string, unknown>).text ?? '') : ''))
+        .filter(Boolean)
+        .join('')
+    }
+    if (Array.isArray(responseBody.choices)) {
+      // Mistral
+      const first = (responseBody.choices as unknown[])[0] as Record<string, unknown> | undefined
+      const msg = first?.message as Record<string, unknown> | undefined
+      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) {
@@ -280,6 +462,227 @@ function extractCompletion(provider: string, responseBody: Record<string, unknow
   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: Uint8Array, init = 0xFFFFFFFF): number {
+  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: Uint8Array[]): Uint8Array {
+  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
+}
+
+interface BedrockFrame { headers: Record<string, string>; payload: Uint8Array }
+
+/** @internal — exported for tests only */
+export function parseBedrockEventStream(buf: Uint8Array): BedrockFrame[] {
+  const frames: BedrockFrame[] = []
+  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: Record<string, string> = {}
+    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: Record<number, number> = { 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: string, payloadObj: Record<string, unknown>): Uint8Array {
+  const encoder = new TextEncoder()
+  const payload = encoder.encode(JSON.stringify(payloadObj))
+
+  const writeHeader = (name: string, value: string): Uint8Array => {
+    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: string,
+  stream: ReadableStream<Uint8Array>,
+): Promise<{ completion: string; usage?: UsageInfo }> {
+  const reader = stream.getReader()
+  const chunks: Uint8Array[] = []
+  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: UsageInfo | undefined
+
+  for (const frame of frames) {
+    let obj: Record<string, unknown>
+    try {
+      obj = JSON.parse(decoder.decode(frame.payload)) as Record<string, unknown>
+    } 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) as Record<string, unknown>
+        if (vendor === 'anthropic') {
+          if (decoded.type === 'content_block_delta') {
+            const d = decoded.delta as Record<string, unknown> | undefined
+            if (d?.type === 'text_delta' && typeof d.text === 'string') completion += d.text
+          }
+          if (decoded.type === 'message_delta') {
+            const u = (decoded as Record<string, unknown>).usage as Record<string, number> | undefined
+            if (u) usage = extractUsage('anthropic', { usage: u }) ?? usage
+          }
+          if (decoded.type === 'message_start') {
+            const msg = (decoded as Record<string, unknown>).message as Record<string, unknown> | undefined
+            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 as Record<string, unknown> | undefined) ?? obj
+      const delta = body.delta as Record<string, unknown> | undefined
+      if (typeof delta?.text === 'string') completion += delta.text
+    }
+    if (eventType === 'metadata' || obj.metadata) {
+      const body = (obj.metadata as Record<string, unknown> | undefined) ?? obj
+      const u = body.usage as Record<string, number> | undefined
+      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: string): string {
+  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: string,
+  url: string,
+  stream: ReadableStream<Uint8Array>,
+): Promise<{ completion: string; usage?: UsageInfo }> {
+  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: string,
@@ -397,6 +800,7 @@ function extractStreamUsage(provider: string, rawSSE: string): UsageInfo | undef
 function synthesizeCompletionJSON(
   provider: string,
   completion: string,
+  url?: string,
 ): Record<string, unknown> {
   if (provider === 'gemini') {
     return {
@@ -413,6 +817,29 @@ function synthesizeCompletionJSON(
       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',
@@ -425,9 +852,44 @@ function synthesizeCompletionJSON(
 function synthesizeSSEStream(
   provider: string,
   completion: string,
+  url?: string,
 ): ReadableStream<Uint8Array> {
   const encoder = new TextEncoder()
 
+  if (provider === 'bedrock') {
+    const kind = url ? bedrockApiKind(url) : undefined
+    const vendor = url ? bedrockVendor(extractBedrockModelId(url)) : 'unknown'
+    return new ReadableStream<Uint8Array>({
+      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: string, inner: Record<string, unknown>) => {
+            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<Uint8Array>({
     start(ctrl) {
       if (provider === 'gemini') {
@@ -503,27 +965,37 @@ export function installAIInterceptor(): void {
           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() as Record<string, unknown>
-            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 })
-              }
-              reader.releaseLock()
-              captured.usage = extractStreamUsage(provider, rawSSE)
-            } catch { /* stream read failed */ }
+            if (provider === 'bedrock') {
+              // Binary eventstream: parse frames to extract usage
+              try {
+                const { usage } = await bufferBedrockEventStream(url, cloned.body)
+                captured.usage = usage
+              } 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 {
           // Response body not available — usage won't be captured
@@ -555,14 +1027,24 @@ export function installAIInterceptor(): void {
       if (rawBody && typeof rawBody === 'string') {
         const body = JSON.parse(rawBody) as Record<string, unknown>
         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()
@@ -578,9 +1060,9 @@ export function installAIInterceptor(): void {
 
       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 })
@@ -591,8 +1073,8 @@ export function installAIInterceptor(): void {
       try {
         const cloned = response.clone()
         const responseBody = await cloned.json() as Record<string, unknown>
-        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: WorkflowEvent = {
           id, type: 'ai', name: model, input: eventInput, output: { completion },
@@ -619,18 +1101,18 @@ export function installAIInterceptor(): void {
       if (frozen && frozen.type === 'ai') {
         pushTelemetryEvent(frozen)
         const frozenOutput = frozen.output as Record<string, unknown> | null
-        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' },
@@ -643,9 +1125,9 @@ export function installAIInterceptor(): void {
 
       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 })
@@ -656,8 +1138,8 @@ export function installAIInterceptor(): void {
       try {
         const cloned = response.clone()
         const responseBody = await cloned.json() as Record<string, unknown>
-        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 } : {}) })
       } catch {
@@ -687,20 +1169,20 @@ export function installAIInterceptor(): void {
         if (isReplayMatch && historicalEvent) {
           recorder.record(historicalEvent)
           const historicalOutput = historicalEvent.output as Record<string, unknown> | null
-          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' },
             })
@@ -722,10 +1204,10 @@ export function installAIInterceptor(): void {
         if (response.body) {
           const [streamForCaller, streamForRecorder] = response.body.tee()
           recorder.trackAsync(
-            bufferSSEStream(provider, streamForRecorder).then((completion) => {
+            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 })
@@ -745,9 +1227,9 @@ export function installAIInterceptor(): void {
         try {
           const cloned = response.clone()
           const responseBody = await cloned.json() as Record<string, unknown>
-          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 })
         } catch {
@@ -766,7 +1248,7 @@ export function installAIInterceptor(): void {
 
     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)' })
@@ -776,7 +1258,7 @@ export function installAIInterceptor(): void {
       try {
         const cloned = response.clone()
         const responseBody = await cloned.json() as Record<string, unknown>
-        const completion = extractCompletion(provider, responseBody)
+        const completion = extractCompletion(provider, responseBody, url)
         traceAtCall.recordLLMStep({ model, provider, prompt, completion })
       } catch {
         traceAtCall.recordLLMStep({ model, provider, prompt, completion: '' })