@kylindc/ccxray 1.2.0

package/server/config.js

@@ -0,0 +1,190 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { createStorage } = require('./storage');
+
+// ── Config ──────────────────────────────────────────────────────────
+const PORT = parseInt(process.env.PROXY_PORT || '5577', 10);
+const ANTHROPIC_HOST = process.env.ANTHROPIC_TEST_HOST || 'api.anthropic.com';
+const ANTHROPIC_PORT = parseInt(process.env.ANTHROPIC_TEST_PORT || '443', 10);
+const ANTHROPIC_PROTOCOL = process.env.ANTHROPIC_TEST_PROTOCOL || 'https';
+const LOGS_DIR = path.join(os.homedir(), '.ccxray', 'logs');
+const LEGACY_LOGS_DIR = path.join(__dirname, '..', 'logs');
+const RESTORE_DAYS = parseInt(process.env.RESTORE_DAYS || '3', 10);
+
+// ── Bedrock config ───────────────────────────────────────────────────
+const BEDROCK_REGION = process.env.BEDROCK_REGION || '';
+const BEDROCK_PROFILE_ARN = process.env.BEDROCK_PROFILE_ARN || '';
+const BEDROCK_MODEL_ID = process.env.BEDROCK_MODEL_ID || '';
+const BEDROCK_BEARER_TOKEN = process.env.BEDROCK_BEARER_TOKEN || '';
+const _CLAUDE_CODE_USE_BEDROCK = process.env.CLAUDE_CODE_USE_BEDROCK || '';
+
+// IS_BEDROCK_MODE is true when any activation trigger is set.
+// index.js also sets this to true when --bedrock CLI flag is found.
+let IS_BEDROCK_MODE = !!(BEDROCK_REGION || _CLAUDE_CODE_USE_BEDROCK === '1' || _CLAUDE_CODE_USE_BEDROCK === 'true');
+
+// Region resolution: BEDROCK_REGION → AWS_REGION → AWS_DEFAULT_REGION → us-east-1
+const BEDROCK_RESOLVED_REGION = BEDROCK_REGION
+  || process.env.AWS_REGION
+  || process.env.AWS_DEFAULT_REGION
+  || 'us-east-1';
+
+// Bedrock activation source label (for startup log)
+const BEDROCK_ACTIVATION_SOURCE = BEDROCK_REGION ? 'BEDROCK_REGION'
+  : (_CLAUDE_CODE_USE_BEDROCK === '1' || _CLAUDE_CODE_USE_BEDROCK === 'true') ? 'CLAUDE_CODE_USE_BEDROCK'
+  : '--bedrock flag';
+
+// Optional: override Bedrock endpoint host/port for testing
+const BEDROCK_TEST_HOST = process.env.BEDROCK_TEST_HOST || '';
+const BEDROCK_TEST_PORT = parseInt(process.env.BEDROCK_TEST_PORT || '443', 10);
+const BEDROCK_TEST_PROTOCOL = process.env.BEDROCK_TEST_PROTOCOL || 'https';
+
+// Resolved credentials (set by index.js at startup in Bedrock mode)
+let BEDROCK_CREDENTIALS = null;
+
+// ── Anthropic → Bedrock model ID mapping table ───────────────────────
+// Keys are Anthropic model ID prefixes, longest match wins.
+const BEDROCK_MODEL_MAP = {
+  // Claude 4 family
+  'claude-opus-4-20250514':     'anthropic.claude-opus-4-20250514-v1:0',
+  'claude-sonnet-4-20250514':   'anthropic.claude-sonnet-4-20250514-v1:0',
+  'claude-haiku-4-20250514':    'anthropic.claude-haiku-4-20250514-v1:0',
+  'claude-opus-4':              'anthropic.claude-opus-4-20250514-v1:0',
+  'claude-sonnet-4':            'anthropic.claude-sonnet-4-20250514-v1:0',
+  'claude-haiku-4':             'anthropic.claude-haiku-4-20250514-v1:0',
+  // Claude 3.7
+  'claude-3-7-sonnet-20250219': 'anthropic.claude-3-7-sonnet-20250219-v1:0',
+  'claude-3-7-sonnet':          'anthropic.claude-3-7-sonnet-20250219-v1:0',
+  // Claude 3.5
+  'claude-3-5-sonnet-20241022': 'anthropic.claude-3-5-sonnet-20241022-v2:0',
+  'claude-3-5-sonnet-20240620': 'anthropic.claude-3-5-sonnet-20240620-v1:0',
+  'claude-3-5-sonnet':          'anthropic.claude-3-5-sonnet-20241022-v2:0',
+  'claude-3-5-haiku-20241022':  'anthropic.claude-3-5-haiku-20241022-v1:0',
+  'claude-3-5-haiku':           'anthropic.claude-3-5-haiku-20241022-v1:0',
+  // Claude 3
+  'claude-3-opus-20240229':     'anthropic.claude-3-opus-20240229-v1:0',
+  'claude-3-opus':              'anthropic.claude-3-opus-20240229-v1:0',
+  'claude-3-sonnet-20240229':   'anthropic.claude-3-sonnet-20240229-v1:0',
+  'claude-3-sonnet':            'anthropic.claude-3-sonnet-20240229-v1:0',
+  'claude-3-haiku-20240307':    'anthropic.claude-3-haiku-20240307-v1:0',
+  'claude-3-haiku':             'anthropic.claude-3-haiku-20240307-v1:0',
+};
+
+function resolveBedrockModelId(anthropicModelId) {
+  if (anthropicModelId) {
+    if (BEDROCK_MODEL_MAP[anthropicModelId]) return BEDROCK_MODEL_MAP[anthropicModelId];
+    const keys = Object.keys(BEDROCK_MODEL_MAP).sort((a, b) => b.length - a.length);
+    for (const key of keys) {
+      if (anthropicModelId.startsWith(key)) return BEDROCK_MODEL_MAP[key];
+    }
+  }
+  if (BEDROCK_MODEL_ID) return BEDROCK_MODEL_ID;
+  throw new Error(`No Bedrock model ID for '${anthropicModelId}'. Set BEDROCK_MODEL_ID to override.`);
+}
+
+function buildBedrockUrl(region, modelId, profileArn) {
+  const segment = profileArn ? encodeURIComponent(profileArn) : encodeURIComponent(modelId);
+  if (BEDROCK_TEST_HOST) {
+    return `${BEDROCK_TEST_PROTOCOL}://${BEDROCK_TEST_HOST}:${BEDROCK_TEST_PORT}/model/${segment}/invoke-with-response-stream`;
+  }
+  return `https://bedrock-runtime.${region}.amazonaws.com/model/${segment}/invoke-with-response-stream`;
+}
+
+// Storage adapter (local by default, S3 via STORAGE_BACKEND=s3)
+const storage = createStorage();
+
+// Model → context window fallback mapping (used when LiteLLM data unavailable)
+// https://docs.anthropic.com/en/docs/about-claude/models
+const MODEL_CONTEXT_FALLBACK = {
+  'claude-opus-4':     200_000,
+  'claude-sonnet-4':   200_000,
+  'claude-haiku-4':    200_000,
+  'claude-3-5-sonnet': 200_000,
+  'claude-3-5-haiku':  200_000,
+  'claude-3-opus':     200_000,
+  'claude-3-sonnet':   200_000,
+  'claude-3-haiku':    200_000,
+};
+const DEFAULT_CONTEXT = 200_000;
+
+// Extract effective model ID from system prompt (includes [1m] suffix if present).
+// API request model field never includes [1m], but system prompt does:
+//   "The exact model ID is claude-opus-4-6[1m]."
+function extractModelFromSystem(system) {
+  if (!Array.isArray(system)) return null;
+  for (const block of system) {
+    const text = typeof block === 'string' ? block : (block?.text || '');
+    const m = text.match(/exact model ID is (claude-[^\s.]+)/);
+    if (m) return m[1];
+  }
+  return null;
+}
+
+function getMaxContext(model, system) {
+  // Prefer model ID from system prompt (has [1m] suffix when applicable)
+  const effective = extractModelFromSystem(system) || model;
+  if (!effective) return DEFAULT_CONTEXT;
+  // 1) Explicit suffix: "claude-opus-4-6[1m]" → 1M
+  if (/\[1m\]/i.test(effective)) return 1_000_000;
+  // 2) Known Claude Code defaults (200K standard plan)
+  const stripped = effective.replace(/\[.*\]/, '');
+  const keys = Object.keys(MODEL_CONTEXT_FALLBACK).sort((a, b) => b.length - a.length);
+  for (const key of keys) {
+    if (stripped.startsWith(key)) return MODEL_CONTEXT_FALLBACK[key];
+  }
+  // 3) LiteLLM dynamic data — only for unknown models not in fallback table
+  const { getModelContext } = require('./pricing');
+  const dynamic = getModelContext(stripped);
+  if (dynamic) return dynamic;
+  return DEFAULT_CONTEXT;
+}
+
+// Ensure logs dir exists; migrate from legacy location if needed
+if (!fs.existsSync(LOGS_DIR)) {
+  fs.mkdirSync(LOGS_DIR, { recursive: true });
+  // One-time migration from old package-relative logs/
+  const legacyIndex = path.join(LEGACY_LOGS_DIR, 'index.ndjson');
+  if (fs.existsSync(legacyIndex)) {
+    try {
+      const files = fs.readdirSync(LEGACY_LOGS_DIR);
+      for (const f of files) {
+        fs.renameSync(path.join(LEGACY_LOGS_DIR, f), path.join(LOGS_DIR, f));
+      }
+      console.log(`Migrated logs from ${LEGACY_LOGS_DIR} → ${LOGS_DIR}`);
+    } catch (e) {
+      console.error(`Log migration failed: ${e.message}`);
+    }
+  }
+}
+
+module.exports = {
+  PORT,
+  ANTHROPIC_HOST,
+  ANTHROPIC_PORT,
+  ANTHROPIC_PROTOCOL,
+  LOGS_DIR,
+  RESTORE_DAYS,
+  storage,
+  MODEL_CONTEXT_FALLBACK,
+  DEFAULT_CONTEXT,
+  getMaxContext,
+  // Bedrock
+  get IS_BEDROCK_MODE() { return IS_BEDROCK_MODE; },
+  set IS_BEDROCK_MODE(v) { IS_BEDROCK_MODE = v; },
+  BEDROCK_REGION,
+  BEDROCK_RESOLVED_REGION,
+  BEDROCK_ACTIVATION_SOURCE,
+  BEDROCK_PROFILE_ARN,
+  BEDROCK_MODEL_ID,
+  BEDROCK_BEARER_TOKEN,
+  BEDROCK_TEST_HOST,
+  BEDROCK_TEST_PORT,
+  BEDROCK_TEST_PROTOCOL,
+  get BEDROCK_CREDENTIALS() { return BEDROCK_CREDENTIALS; },
+  set BEDROCK_CREDENTIALS(v) { BEDROCK_CREDENTIALS = v; },
+  BEDROCK_MODEL_MAP,
+  resolveBedrockModelId,
+  buildBedrockUrl,
+};

package/server/cost-budget.js

@@ -0,0 +1,220 @@
+'use strict';
+
+const path = require('path');
+const { fork } = require('child_process');
+
+// ── Cost Budget: JSONL reader via child process ─────────────────────
+const FIVE_HOURS_MS = 5 * 60 * 60 * 1000;
+const TOKEN_LIMIT = 220_000;
+const SUBSCRIPTION_USD = 200;
+
+// 5-minute server-side cache
+let costsCache = null;
+const CACHE_TTL_MS = 5 * 60 * 1000;
+
+function streamUsageEntries() {
+  return new Promise((resolve, reject) => {
+    const worker = fork(path.join(__dirname, 'cost-worker.js'), [], { silent: true });
+    const chunks = [];
+    let stderrBuf = '';
+    const timeout = setTimeout(() => {
+      worker.kill();
+      reject(new Error('Worker timeout (60s)'));
+    }, 60_000);
+    worker.stdout.on('data', (chunk) => chunks.push(chunk));
+    worker.stderr.on('data', (chunk) => { stderrBuf += chunk; });
+    worker.on('error', (err) => { clearTimeout(timeout); reject(err); });
+    worker.on('exit', (code) => {
+      clearTimeout(timeout);
+      if (code !== 0 && code !== null) {
+        reject(new Error(stderrBuf || `Worker exited with code ${code}`));
+        return;
+      }
+      try {
+        const raw = Buffer.concat(chunks).toString();
+        const data = JSON.parse(raw);
+        if (!Array.isArray(data)) {
+          reject(new Error(`Worker returned ${typeof data}, expected array`));
+          return;
+        }
+        resolve(data);
+      } catch (e) {
+        reject(new Error(`Worker output parse error: ${e.message}`));
+      }
+    });
+  });
+}
+
+function floorToHour(tsMs) {
+  const d = new Date(tsMs);
+  d.setUTCMinutes(0, 0, 0);
+  return d.getTime();
+}
+
+function groupIntoBlocks(entries) {
+  if (!entries.length) return [];
+  const blocks = [];
+  let current = null;
+
+  for (const e of entries) {
+    const quotaTokens = (e.usage.input_tokens || 0) + (e.usage.output_tokens || 0);
+    const timeSinceBlockStart = current ? e.timestamp - current.startTime : Infinity;
+    const timeSinceLastEntry = current ? e.timestamp - current.lastTs : Infinity;
+    const needsNewBlock = !current || timeSinceBlockStart > FIVE_HOURS_MS || timeSinceLastEntry > FIVE_HOURS_MS;
+
+    if (needsNewBlock) {
+      const blockStart = floorToHour(e.timestamp);
+      current = {
+        startTime: blockStart,
+        endTime: blockStart + FIVE_HOURS_MS,
+        totalTokens: 0,
+        costUSD: 0,
+        models: new Set(),
+        firstTs: e.timestamp,
+        lastTs: e.timestamp,
+      };
+      blocks.push(current);
+    }
+    current.totalTokens += quotaTokens;
+    current.costUSD += e.costUSD || 0;
+    if (e.model) current.models.add(e.model);
+    current.lastTs = e.timestamp;
+  }
+
+  const now = Date.now();
+  return blocks.map(b => ({
+    startTime: new Date(b.startTime).toISOString(),
+    endTime: new Date(b.endTime).toISOString(),
+    totalTokens: b.totalTokens,
+    costUSD: b.costUSD,
+    models: [...b.models],
+    isActive: now < b.endTime && (now - b.lastTs) < FIVE_HOURS_MS,
+    _startMs: b.startTime,
+    _endMs: b.endTime,
+    _firstTs: b.firstTs,
+    _lastTs: b.lastTs,
+  }));
+}
+
+function calculateBurnRate(block) {
+  if (!block.isActive) return null;
+  const now = Date.now();
+  const durationMin = (block._lastTs - block._firstTs) / 60_000;
+  if (durationMin <= 0) return null;
+  const tokensPerMinute = block.totalTokens / durationMin;
+  const costPerHour = (block.costUSD / durationMin) * 60;
+  const minutesRemaining = Math.max(0, (block._endMs - now) / 60_000);
+  const projectedAdditionalTokens = tokensPerMinute * minutesRemaining;
+  const projectedTotalTokens = block.totalTokens + projectedAdditionalTokens;
+  const projectedAdditionalCost = (costPerHour / 60) * minutesRemaining;
+  const projectedTotalCost = block.costUSD + projectedAdditionalCost;
+  return {
+    burnRate: { tokensPerMinute: Math.round(tokensPerMinute), costPerHour: Math.round(costPerHour * 100) / 100 },
+    projection: { totalTokens: Math.round(projectedTotalTokens), totalCost: Math.round(projectedTotalCost * 100) / 100 },
+    minutesRemaining: Math.round(minutesRemaining),
+  };
+}
+
+function groupByDay(entries) {
+  const days = {};
+  for (const e of entries) {
+    const date = new Date(e.timestamp).toLocaleDateString('sv-SE');
+    if (!days[date]) days[date] = { date, totalTokens: 0, costUSD: 0, models: new Set(), sessions: new Set() };
+    const d = days[date];
+    d.totalTokens +=
+      (e.usage.input_tokens || 0) +
+      (e.usage.output_tokens || 0) +
+      (e.usage.cache_creation_input_tokens || 0) +
+      (e.usage.cache_read_input_tokens || 0);
+    d.costUSD += e.costUSD || 0;
+    if (e.model) d.models.add(e.model);
+    if (e.sessionId) d.sessions.add(e.sessionId);
+  }
+  const result = [];
+  const now = new Date();
+  for (let i = 181; i >= 0; i--) {
+    const d = new Date(now);
+    d.setDate(d.getDate() - i);
+    const dateStr = d.toLocaleDateString('sv-SE');
+    const day = days[dateStr] || { date: dateStr, totalTokens: 0, costUSD: 0, models: new Set(), sessions: new Set() };
+    result.push({ date: day.date, totalTokens: day.totalTokens, costUSD: Math.round(day.costUSD * 100) / 100, models: [...day.models], sessionCount: day.sessions.size });
+  }
+  return result;
+}
+
+function groupByMonth(entries) {
+  const months = {};
+  for (const e of entries) {
+    const d = new Date(e.timestamp);
+    const key = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}`;
+    if (!months[key]) months[key] = { month: key, totalTokens: 0, costUSD: 0, models: new Set() };
+    const m = months[key];
+    m.totalTokens +=
+      (e.usage.input_tokens || 0) +
+      (e.usage.output_tokens || 0) +
+      (e.usage.cache_creation_input_tokens || 0) +
+      (e.usage.cache_read_input_tokens || 0);
+    m.costUSD += e.costUSD || 0;
+    if (e.model) m.models.add(e.model);
+  }
+  return Object.values(months)
+    .map(m => ({ month: m.month, totalTokens: m.totalTokens, costUSD: Math.round(m.costUSD * 100) / 100, models: [...m.models] }))
+    .sort((a, b) => a.month.localeCompare(b.month));
+}
+
+let costsInflight = null;
+
+function startComputation() {
+  if (costsInflight) return costsInflight;
+  costsInflight = (async () => {
+    try {
+      const usageEntries = await streamUsageEntries();
+      const blocks = groupIntoBlocks(usageEntries);
+      const daily = groupByDay(usageEntries);
+      const monthly = groupByMonth(usageEntries);
+      const data = { blocks, daily, monthly };
+      costsCache = { data, computedAt: Date.now() };
+      return data;
+    } catch (err) {
+      console.error('Cost computation failed:', err.message);
+      throw err;
+    } finally {
+      costsInflight = null;
+    }
+  })();
+  return costsInflight;
+}
+
+async function getOrComputeCosts() {
+  const now = Date.now();
+  if (costsCache && (now - costsCache.computedAt) < CACHE_TTL_MS) {
+    return costsCache.data;
+  }
+  return startComputation();
+}
+
+// Returns cached data immediately, or null if not ready yet.
+// Triggers background computation if cache is stale/missing.
+function getCostsCacheOrNull() {
+  const now = Date.now();
+  if (costsCache && (now - costsCache.computedAt) < CACHE_TTL_MS) {
+    return costsCache.data;
+  }
+  // Kick off background computation but don't wait
+  startComputation().catch(() => {});
+  return null;
+}
+
+// Call at startup to begin warming the cache in the background
+function warmUp() {
+  startComputation().catch(() => {});
+}
+
+module.exports = {
+  TOKEN_LIMIT,
+  SUBSCRIPTION_USD,
+  getOrComputeCosts,
+  getCostsCacheOrNull,
+  calculateBurnRate,
+  warmUp,
+};

package/server/cost-worker.js

@@ -0,0 +1,110 @@
+'use strict';
+
+// Worker process for JSONL cost parsing — runs in a child process
+// to avoid blocking the main event loop during heavy I/O + JSON.parse.
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const os = require('os');
+
+function calculateCostSimple(usage, model) {
+  // Simplified cost calc — doesn't need full pricing module
+  // Rates per token (not per million)
+  const rates = {
+    'claude-sonnet-4-5-20250514': { input: 3e-6, output: 15e-6, cache_read: 0.3e-6, cache_create: 3.75e-6 },
+    'claude-opus-4-5-20250514': { input: 15e-6, output: 75e-6, cache_read: 1.5e-6, cache_create: 18.75e-6 },
+    'claude-haiku-3-5-20241022': { input: 0.8e-6, output: 4e-6, cache_read: 0.08e-6, cache_create: 1e-6 },
+  };
+  // Find matching rate by prefix
+  let r = null;
+  for (const [k, v] of Object.entries(rates)) {
+    if (model && model.startsWith(k.split('-202')[0])) { r = v; break; }
+  }
+  if (!r) r = { input: 3e-6, output: 15e-6, cache_read: 0.3e-6, cache_create: 3.75e-6 }; // default sonnet
+  return (usage.input_tokens || 0) * r.input
+    + (usage.output_tokens || 0) * r.output
+    + (usage.cache_read_input_tokens || 0) * r.cache_read
+    + (usage.cache_creation_input_tokens || 0) * r.cache_create;
+}
+
+async function collectJsonlFiles(dir, results = []) {
+  let items;
+  try { items = await fs.promises.readdir(dir); } catch { return results; }
+  for (const item of items) {
+    const fullPath = path.join(dir, item);
+    let stat;
+    try { stat = await fs.promises.stat(fullPath); } catch { continue; }
+    if (stat.isDirectory()) await collectJsonlFiles(fullPath, results);
+    else if (item.endsWith('.jsonl')) results.push(fullPath);
+  }
+  return results;
+}
+
+function processFile(filePath) {
+  return new Promise((resolve) => {
+    const localEntries = [];
+    let rl;
+    try {
+      const stream = fs.createReadStream(filePath, { encoding: 'utf8' });
+      rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    } catch { resolve(localEntries); return; }
+
+    rl.on('line', (line) => {
+      if (!line.includes('"usage"')) return;
+      let obj;
+      try { obj = JSON.parse(line); } catch { return; }
+      const timestamp = obj.timestamp;
+      const msg = obj.message;
+      if (!timestamp || !msg || !msg.usage) return;
+      const usage = msg.usage;
+      const model = msg.model || obj.model || 'unknown';
+      const messageId = msg.id || null;
+      const totalTokens = (usage.input_tokens || 0) + (usage.output_tokens || 0)
+        + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0);
+      if (totalTokens === 0) return;
+      const costUSD = calculateCostSimple(usage, model);
+      const sessionId = path.basename(filePath, '.jsonl');
+      localEntries.push({ timestamp: new Date(timestamp).getTime(), usage, costUSD, model, sessionId, messageId });
+    });
+    rl.on('close', () => resolve(localEntries));
+    rl.on('error', () => resolve(localEntries));
+  });
+}
+
+async function run() {
+  const homedir = os.homedir();
+  const dirs = [
+    path.join(homedir, '.claude', 'projects'),
+    path.join(homedir, '.config', 'claude', 'projects'),
+  ];
+  const seen = new Set();
+  const entries = [];
+
+  for (const baseDir of dirs) {
+    try { await fs.promises.access(baseDir); } catch { continue; }
+    const jsonlFiles = await collectJsonlFiles(baseDir);
+
+    const BATCH_SIZE = 20;
+    for (let i = 0; i < jsonlFiles.length; i += BATCH_SIZE) {
+      const batch = jsonlFiles.slice(i, i + BATCH_SIZE);
+      const results = await Promise.all(batch.map(processFile));
+      for (const localEntries of results) {
+        for (const e of localEntries) {
+          if (e.messageId && seen.has(e.messageId)) continue;
+          if (e.messageId) seen.add(e.messageId);
+          entries.push(e);
+        }
+      }
+    }
+  }
+
+  entries.sort((a, b) => a.timestamp - b.timestamp);
+  // Use stdout instead of IPC — process.send() can fail silently with large payloads
+  process.stdout.write(JSON.stringify(entries));
+}
+
+run().catch(err => {
+  process.stderr.write(err.message);
+  process.exitCode = 1;
+});

package/server/eventstream.js

@@ -0,0 +1,148 @@
+'use strict';
+
+// ── CRC32 (IEEE 802.3 / zlib polynomial 0xEDB88320) ─────────────────
+
+const CRC32_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let j = 0; j < 8; j++) {
+      c = (c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1);
+    }
+    table[i] = c;
+  }
+  return table;
+})();
+
+function crc32(buf, offset, length) {
+  let crc = 0xFFFFFFFF;
+  const end = offset + length;
+  for (let i = offset; i < end; i++) {
+    crc = (crc >>> 8) ^ CRC32_TABLE[(crc ^ buf[i]) & 0xFF];
+  }
+  return (crc ^ 0xFFFFFFFF) >>> 0;
+}
+
+// ── AWS EventStream binary frame format ─────────────────────────────
+//
+// Prelude (12 bytes):
+//   [0-3]  total_length   uint32 BE  — total bytes including prelude + headers + payload + CRCs
+//   [4-7]  headers_length uint32 BE  — byte length of headers section
+//   [8-11] prelude_crc    uint32 BE  — CRC32 of bytes [0..7]
+//
+// Headers (variable, headers_length bytes):
+//   Each header entry:
+//     [0]         name_length  uint8   — byte length of header name
+//     [1..n]      name         string  — header name (name_length bytes)
+//     [n+1]       value_type   uint8   — 7 = string
+//     [n+2..n+3]  value_length uint16 BE
+//     [n+4..]     value        string  — value_length bytes
+//
+// Payload:
+//   total_length - 12 (prelude) - headers_length - 4 (message CRC) bytes
+//
+// Message CRC (4 bytes):
+//   CRC32 of all bytes from [0 .. total_length - 5]
+
+class EventStreamDecoder {
+  constructor() {
+    this._buf = Buffer.alloc(0);
+  }
+
+  // Push a chunk of binary data. Returns an array of result objects:
+  //   { event: <parsed-event-object> }             — success
+  //   { error: 'crc_mismatch' }                    — prelude or message CRC failed
+  //   { error: 'modelStreamErrorException', message } — Bedrock stream error event
+  //   (empty frames / non-chunk events are silently skipped)
+  push(chunk) {
+    this._buf = Buffer.concat([this._buf, chunk]);
+    const results = [];
+
+    while (true) {
+      if (this._buf.length < 12) break; // need at least prelude
+
+      const totalLength = this._buf.readUInt32BE(0);
+      if (this._buf.length < totalLength) break; // incomplete frame
+
+      const headersLength = this._buf.readUInt32BE(4);
+      const preludeCrc = this._buf.readUInt32BE(8);
+      const expectedPreludeCrc = crc32(this._buf, 0, 8);
+
+      if (preludeCrc !== expectedPreludeCrc) {
+        results.push({ error: 'crc_mismatch' });
+        // Skip this frame and try to resync
+        this._buf = this._buf.slice(totalLength);
+        continue;
+      }
+
+      const messageCrc = this._buf.readUInt32BE(totalLength - 4);
+      const expectedMessageCrc = crc32(this._buf, 0, totalLength - 4);
+
+      if (messageCrc !== expectedMessageCrc) {
+        results.push({ error: 'crc_mismatch' });
+        this._buf = this._buf.slice(totalLength);
+        continue;
+      }
+
+      // Parse headers
+      const headers = {};
+      let pos = 12;
+      const headersEnd = 12 + headersLength;
+      while (pos < headersEnd) {
+        const nameLen = this._buf[pos++];
+        const name = this._buf.slice(pos, pos + nameLen).toString('utf8');
+        pos += nameLen;
+        const valueType = this._buf[pos++];
+        if (valueType === 7) { // string
+          const valueLen = this._buf.readUInt16BE(pos);
+          pos += 2;
+          const value = this._buf.slice(pos, pos + valueLen).toString('utf8');
+          pos += valueLen;
+          headers[name] = value;
+        } else {
+          // Skip unknown value types gracefully
+          break;
+        }
+      }
+
+      // Extract payload
+      const payloadStart = headersEnd;
+      const payloadEnd = totalLength - 4;
+      const payloadBuf = this._buf.slice(payloadStart, payloadEnd);
+
+      // Consume this frame from the buffer
+      this._buf = this._buf.slice(totalLength);
+
+      const eventType = headers[':event-type'] || '';
+      const messageType = headers[':message-type'] || '';
+
+      // Handle Bedrock stream error
+      if (eventType === 'modelStreamErrorException' || messageType === 'exception') {
+        let message = eventType;
+        try {
+          const body = JSON.parse(payloadBuf.toString('utf8'));
+          message = body.message || body.Message || eventType;
+        } catch {}
+        results.push({ error: 'modelStreamErrorException', message });
+        continue;
+      }
+
+      // Only process 'chunk' events — others (initial-response, etc.) are skipped
+      if (eventType !== 'chunk' && payloadBuf.length === 0) continue;
+
+      // Decode payload: {"bytes":"<base64>"} → Anthropic SSE event JSON
+      let event = null;
+      try {
+        const payloadJson = JSON.parse(payloadBuf.toString('utf8'));
+        const decoded = Buffer.from(payloadJson.bytes || '', 'base64').toString('utf8');
+        if (decoded) event = JSON.parse(decoded);
+      } catch {}
+
+      if (event) results.push({ event });
+    }
+
+    return results;
+  }
+}
+
+module.exports = { EventStreamDecoder, crc32 };