cachegate 1.1.0 → 1.2.0

package/test/failover.test.js

@@ -1,99 +0,0 @@
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const { isRetryableError, dispatchWithFailover } = require('../failover');
-
-function httpError(message, status) {
-  return Object.assign(new Error(message), { status });
-}
-
-test('isRetryableError treats a bad request (400) as not retryable', () => {
-  assert.equal(isRetryableError(httpError('bad request', 400)), false);
-});
-
-test('isRetryableError treats an unknown model (404) as not retryable', () => {
-  assert.equal(isRetryableError(httpError('not found', 404)), false);
-});
-
-test('isRetryableError treats rate limits, server errors, and auth failures as retryable', () => {
-  assert.equal(isRetryableError(httpError('rate limited', 429)), true);
-  assert.equal(isRetryableError(httpError('server error', 500)), true);
-  assert.equal(isRetryableError(httpError('bad gateway', 502)), true);
-  assert.equal(isRetryableError(httpError('unauthorized', 401)), true);
-});
-
-test('isRetryableError treats a network failure with no status at all as retryable', () => {
-  assert.equal(isRetryableError(new Error('ECONNRESET')), true);
-});
-
-test('dispatchWithFailover resolves on the first candidate when it succeeds, attempts=1', async () => {
-  const candidates = [{ provider: 'openai', model: 'gpt-4o-mini' }, { provider: 'anthropic', model: 'claude-haiku-4-5-20251001' }];
-  const dispatch = async (c) => ({ ok: true, provider: c.provider });
-
-  const outcome = await dispatchWithFailover(candidates, dispatch);
-  assert.equal(outcome.attempts, 1);
-  assert.equal(outcome.candidate.provider, 'openai');
-  assert.deepEqual(outcome.result, { ok: true, provider: 'openai' });
-});
-
-test('dispatchWithFailover moves to the next candidate on a retryable failure', async () => {
-  const candidates = [{ provider: 'openai', model: 'gpt-4o-mini' }, { provider: 'anthropic', model: 'claude-haiku-4-5-20251001' }];
-  const failedAttempts = [];
-  const dispatch = async (c) => {
-    if (c.provider === 'openai') throw httpError('rate limited', 429);
-    return { ok: true, provider: c.provider };
-  };
-
-  const outcome = await dispatchWithFailover(candidates, dispatch, (candidate, err) => {
-    failedAttempts.push({ candidate, message: err.message });
-  });
-
-  assert.equal(outcome.attempts, 2);
-  assert.equal(outcome.candidate.provider, 'anthropic');
-  assert.equal(failedAttempts.length, 1);
-  assert.equal(failedAttempts[0].candidate.provider, 'openai');
-});
-
-test('dispatchWithFailover does not retry a non-retryable (400) error, even with candidates left', async () => {
-  const candidates = [{ provider: 'openai', model: 'gpt-4o-mini' }, { provider: 'anthropic', model: 'claude-haiku-4-5-20251001' }];
-  let anthropicCalled = false;
-  const dispatch = async (c) => {
-    if (c.provider === 'openai') throw httpError('bad request', 400);
-    anthropicCalled = true;
-    return { ok: true };
-  };
-
-  await assert.rejects(
-    () => dispatchWithFailover(candidates, dispatch),
-    /bad request/
-  );
-  assert.equal(anthropicCalled, false);
-});
-
-test('dispatchWithFailover rethrows the last error when every candidate fails', async () => {
-  const candidates = [{ provider: 'openai', model: 'gpt-4o-mini' }, { provider: 'anthropic', model: 'claude-haiku-4-5-20251001' }];
-  const dispatch = async (c) => {
-    throw httpError(`${c.provider} down`, 503);
-  };
-
-  await assert.rejects(
-    () => dispatchWithFailover(candidates, dispatch),
-    /anthropic down/ // the LAST attempt's error, not the first
-  );
-});
-
-test('dispatchWithFailover calls onAttemptFailed for every failed candidate, including the last', async () => {
-  const candidates = [{ provider: 'openai', model: 'gpt-4o-mini' }, { provider: 'anthropic', model: 'claude-haiku-4-5-20251001' }];
-  const seen = [];
-  const dispatch = async (c) => {
-    throw httpError(`${c.provider} down`, 503);
-  };
-
-  await assert.rejects(() => dispatchWithFailover(candidates, dispatch, (candidate, err, isLastCandidate) => {
-    seen.push({ provider: candidate.provider, isLastCandidate });
-  }));
-
-  assert.deepEqual(seen, [
-    { provider: 'openai', isLastCandidate: false },
-    { provider: 'anthropic', isLastCandidate: true }
-  ]);
-});

package/test/metrics-postgres.test.js

@@ -1,183 +0,0 @@
-// Postgres-backed persistence is OPT-IN (see metrics.js's own comment) -
-// these tests exercise that path specifically, against a real local
-// Postgres. Needs a real local server to actually run against; the
-// `before()` hook below probes connectivity ONCE with a clear warning
-// (`⚠️ Skipping metrics-postgres.test.js...`) rather than letting 20
-// individual tests each fail with their own raw ECONNREFUSED - every
-// test still reports as passing (each returns early via `pgAvailable`)
-// so a machine without Postgres available doesn't see a red suite, it
-// sees a skipped one. **Corrected 2026-08-29**: this comment previously
-// claimed the opposite ("fails loudly... rather than silently
-// skipping") - checked directly by actually stopping Postgres and
-// running the suite, and that was never what the code below does. A CI
-// environment without a real Postgres service configured will report
-// green here while silently not exercising this file at all - the
-// workflow's own Postgres service container is what makes these tests
-// actually run, not just avoid failing.
-//
-// MEMOCODE_ROUTER_DATABASE_URL (not DATABASE_URL) is used here on
-// purpose - keeps this suite from ever accidentally pointing at a real
-// production database if that variable happened to be set in whatever
-// environment runs the tests.
-const { test, before, after, beforeEach } = require('node:test');
-const assert = require('node:assert/strict');
-
-const TEST_DATABASE_URL =
-  process.env.MEMOCODE_ROUTER_TEST_DATABASE_URL || 'postgres://postgres:dryrun@localhost:5432/router_metrics_dryrun';
-
-function freshPgMetrics() {
-  process.env.MEMOCODE_ROUTER_DATABASE_URL = TEST_DATABASE_URL;
-  delete process.env.DATABASE_URL; // make sure only the test var is what's triggering Postgres mode
-  delete require.cache[require.resolve('../metrics')];
-  return require('../metrics');
-}
-
-async function flush() {
-  await new Promise((resolve) => setTimeout(resolve, 100));
-}
-
-let pgAvailable = true;
-let metrics;
-
-before(async () => {
-  metrics = freshPgMetrics();
-  try {
-    // Prove connectivity up front with a clear failure message, rather
-    // than 20 individual tests each failing with their own ECONNREFUSED.
-    await metrics.readRecent(1);
-  } catch (err) {
-    pgAvailable = false;
-    console.warn(`⚠️ Skipping metrics-postgres.test.js - no local Postgres reachable at ${TEST_DATABASE_URL} (${err.message})`);
-  }
-});
-
-beforeEach(async () => {
-  if (!pgAvailable) return;
-  // Reset between tests so each one starts from a known-empty table,
-  // same isolation guarantee freshMetrics() gives the file-backed suite
-  // via a fresh temp directory per test.
-  const { Pool } = require('pg');
-  const pool = new Pool({ connectionString: TEST_DATABASE_URL });
-  await pool.query('DROP TABLE IF EXISTS router_metrics');
-  await pool.end();
-  metrics = freshPgMetrics();
-});
-
-after(async () => {
-  if (metrics) await metrics.closePostgresPoolForTests();
-});
-
-test('usingPostgres() is true once MEMOCODE_ROUTER_DATABASE_URL is set', () => {
-  if (!pgAvailable) return;
-  assert.equal(metrics.usingPostgres(), true);
-});
-
-test('record() + readRecent(): a real INSERT round-trips back out with the same fields', async () => {
-  if (!pgAvailable) return;
-  metrics.record({ provider: 'openai', model: 'gpt-4o-mini', latency_ms: 120, cost_usd: 0.001, cache_hit: false });
-  await flush();
-
-  const rows = await metrics.readRecent();
-  assert.equal(rows.length, 1);
-  assert.equal(rows[0].provider, 'openai');
-  assert.equal(rows[0].model, 'gpt-4o-mini');
-  assert.equal(rows[0].latency_ms, 120);
-  assert.equal(rows[0].cost_usd, 0.001);
-  assert.ok(rows[0].timestamp, 'expected a real timestamp column value back');
-});
-
-test('record() persists error + error_type together, exactly like the file backend', async () => {
-  if (!pgAvailable) return;
-  metrics.record({
-    provider: 'anthropic',
-    error: '401 {"type":"error","error":{"type":"authentication_error"}}',
-    error_type: 'authentication_error'
-  });
-  await flush();
-
-  const rows = await metrics.readRecent();
-  assert.equal(rows[0].error_type, 'authentication_error');
-  assert.ok(rows[0].error.includes('authentication_error'));
-});
-
-test('providerStats(): error rate, avg latency, and lastErrorType all compute correctly from real rows', async () => {
-  if (!pgAvailable) return;
-  metrics.record({ provider: 'openai', latency_ms: 100 });
-  metrics.record({ provider: 'openai', latency_ms: 200 });
-  metrics.record({ provider: 'openai', error: '429 {"error":{"type":"rate_limit_error"}}', error_type: 'rate_limit_error' });
-  await flush();
-
-  const stats = await metrics.providerStats();
-  assert.equal(stats.openai.sampleSize, 3);
-  assert.equal(stats.openai.errorRate, 1 / 3);
-  assert.equal(stats.openai.avgLatencyMs, 150);
-  assert.equal(stats.openai.lastErrorType, 'rate_limit_error');
-});
-
-test('rangeSummary(): cost, cache-hit breakdown, and by_provider all agree with what was actually inserted', async () => {
-  if (!pgAvailable) return;
-  metrics.record({ provider: 'openai', cost_usd: 0.001, cache_hit: false });
-  metrics.record({ provider: 'openai', cost_usd: 0, cache_hit: true, cache_type: 'exact' });
-  metrics.record({ provider: 'anthropic', error: '500 boom', error_type: 'unknown' });
-  await flush();
-
-  const summary = await metrics.rangeSummary(14);
-  assert.equal(summary.sample_size, 3);
-  assert.equal(summary.total_cost_usd, 0.001);
-  assert.equal(summary.cache_hit_rate.exact, 1 / 3);
-  assert.equal(summary.error_rate, 1 / 3);
-  assert.equal(summary.by_provider.openai.requests, 2);
-  assert.equal(summary.by_provider.anthropic.requests, 1);
-  assert.equal(summary.by_provider.anthropic.errorRate, 1);
-});
-
-test('rangeSummary(): a row older than the requested window is excluded', async () => {
-  if (!pgAvailable) return;
-  const { Pool } = require('pg');
-  const pool = new Pool({ connectionString: TEST_DATABASE_URL });
-  await pool.query(
-    `CREATE TABLE IF NOT EXISTS router_metrics (id BIGSERIAL PRIMARY KEY, ts TIMESTAMPTZ NOT NULL DEFAULT now(),
-       provider TEXT, model TEXT, requested_model TEXT, cache_hit BOOLEAN, cache_type TEXT,
-       latency_ms INTEGER, cost_usd DOUBLE PRECISION, error TEXT, error_type TEXT)`
-  );
-  await pool.query(`INSERT INTO router_metrics (ts, provider, cost_usd) VALUES (now() - interval '30 days', 'openai', 0.05)`);
-  await pool.end();
-
-  metrics.record({ provider: 'openai', cost_usd: 0.001 }); // today, should count
-  await flush();
-
-  const summary = await metrics.rangeSummary(14); // 30-day-old row is outside this window
-  assert.equal(summary.sample_size, 1);
-  assert.equal(summary.total_cost_usd, 0.001);
-});
-
-test('pruneOlderThan(): deletes only rows past the cutoff, returns their ids, leaves fresh rows alone', async () => {
-  if (!pgAvailable) return;
-  const { Pool } = require('pg');
-  const pool = new Pool({ connectionString: TEST_DATABASE_URL });
-  await pool.query(
-    `CREATE TABLE IF NOT EXISTS router_metrics (id BIGSERIAL PRIMARY KEY, ts TIMESTAMPTZ NOT NULL DEFAULT now(),
-       provider TEXT, model TEXT, requested_model TEXT, cache_hit BOOLEAN, cache_type TEXT,
-       latency_ms INTEGER, cost_usd DOUBLE PRECISION, error TEXT, error_type TEXT)`
-  );
-  await pool.query(`INSERT INTO router_metrics (ts, provider) VALUES (now() - interval '100 days', 'openai')`);
-  await pool.end();
-
-  metrics.record({ provider: 'anthropic' }); // fresh, should survive
-  await flush();
-
-  const deleted = await metrics.pruneOlderThan(30);
-  assert.equal(deleted.length, 1);
-
-  const remaining = await metrics.readRecent();
-  assert.equal(remaining.length, 1);
-  assert.equal(remaining[0].provider, 'anthropic');
-});
-
-test('classifyErrorType() is the exact same function regardless of storage backend (not duplicated/reimplemented)', () => {
-  if (!pgAvailable) return;
-  assert.equal(
-    metrics.classifyErrorType('401 {"error":{"type":"authentication_error"}}'),
-    'authentication_error'
-  );
-});

package/test/metrics.test.js

@@ -1,282 +0,0 @@
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-function freshMetrics() {
-  const logPath = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'metrics-test-')), 'metrics.jsonl');
-  process.env.METRICS_LOG_PATH = logPath;
-  delete require.cache[require.resolve('../metrics')];
-  return require('../metrics');
-}
-
-async function flush() {
-  await new Promise((resolve) => setTimeout(resolve, 50));
-}
-
-test('readRecent returns [] when no log file exists yet', async () => {
-  const metrics = freshMetrics();
-  const rows = await metrics.readRecent();
-  assert.deepEqual(rows, []);
-});
-
-test('record() writes a line that readRecent() can read back, with a timestamp added', async () => {
-  const metrics = freshMetrics();
-  metrics.record({ provider: 'openai', latency_ms: 120, cost_usd: 0.001 });
-  await flush();
-
-  const rows = await metrics.readRecent();
-  assert.equal(rows.length, 1);
-  assert.equal(rows[0].provider, 'openai');
-  assert.ok(rows[0].timestamp, 'expected record() to stamp a timestamp');
-});
-
-test('a malformed line in the log is skipped, not fatal', async () => {
-  const metrics = freshMetrics();
-  metrics.record({ provider: 'openai', latency_ms: 10 });
-  await flush();
-  fs.appendFileSync(metrics.currentLogPath(), 'not valid json\n');
-  metrics.record({ provider: 'anthropic', latency_ms: 20 });
-  await flush();
-
-  const rows = await metrics.readRecent();
-  assert.equal(rows.length, 2);
-});
-
-test('currentLogPath() names a per-UTC-day file, and record() actually writes there', async () => {
-  const metrics = freshMetrics();
-  const today = new Date().toISOString().slice(0, 10);
-  assert.match(metrics.currentLogPath(), new RegExp(`metrics-${today}\\.jsonl$`));
-
-  metrics.record({ provider: 'openai' });
-  await flush();
-  assert.ok(fs.existsSync(metrics.currentLogPath()), "record() should write to today's rotated file");
-});
-
-test('listLogFiles() finds only files matching the rotation naming pattern, sorted ascending by date', async () => {
-  const metrics = freshMetrics();
-  fs.writeFileSync(path.join(metrics.DATA_DIR, 'metrics-2026-08-10.jsonl'), '');
-  fs.writeFileSync(path.join(metrics.DATA_DIR, 'metrics-2026-08-01.jsonl'), '');
-  fs.writeFileSync(path.join(metrics.DATA_DIR, 'not-a-metrics-file.txt'), '');
-
-  const files = await metrics.listLogFiles();
-  assert.deepEqual(files.map((f) => f.date), ['2026-08-01', '2026-08-10']);
-});
-
-test('readRecent() aggregates across multiple real day-files, newest data included first', async () => {
-  const metrics = freshMetrics();
-  fs.writeFileSync(
-    path.join(metrics.DATA_DIR, 'metrics-2026-08-01.jsonl'),
-    JSON.stringify({ timestamp: '2026-08-01T00:00:00.000Z', provider: 'anthropic', tag: 'old' }) + '\n'
-  );
-  fs.writeFileSync(
-    path.join(metrics.DATA_DIR, 'metrics-2026-08-02.jsonl'),
-    JSON.stringify({ timestamp: '2026-08-02T00:00:00.000Z', provider: 'openai', tag: 'newer' }) + '\n'
-  );
-
-  const rows = await metrics.readRecent(10);
-  assert.equal(rows.length, 2);
-  assert.deepEqual(rows.map((r) => r.tag), ['old', 'newer']); // chronological order preserved
-});
-
-test('readRecent(limit) stops opening older files once enough rows are collected', async () => {
-  const metrics = freshMetrics();
-  fs.writeFileSync(
-    path.join(metrics.DATA_DIR, 'metrics-2026-08-01.jsonl'),
-    JSON.stringify({ timestamp: '2026-08-01T00:00:00.000Z', tag: 'should-not-be-needed' }) + '\n'
-  );
-  fs.writeFileSync(
-    path.join(metrics.DATA_DIR, 'metrics-2026-08-02.jsonl'),
-    Array.from({ length: 5 }, (_, i) => JSON.stringify({ timestamp: '2026-08-02T00:00:00.000Z', tag: `row-${i}` })).join('\n') + '\n'
-  );
-
-  const rows = await metrics.readRecent(5);
-  assert.equal(rows.length, 5);
-  assert.ok(rows.every((r) => r.tag.startsWith('row-')), 'the older file should not have been needed to satisfy limit:5');
-});
-
-test('pruneOlderThan() deletes only day-files strictly older than the cutoff, and is never called by anything else in this module', async () => {
-  const metrics = freshMetrics();
-  const oldPath = path.join(metrics.DATA_DIR, 'metrics-2026-01-01.jsonl');
-  const recentPath = metrics.currentLogPath();
-  fs.writeFileSync(oldPath, '{}\n');
-  metrics.record({ provider: 'openai' });
-  await flush();
-
-  const deleted = await metrics.pruneOlderThan(30);
-  assert.deepEqual(deleted, [oldPath]);
-  assert.equal(fs.existsSync(oldPath), false);
-  assert.equal(fs.existsSync(recentPath), true, "pruneOlderThan should never touch today's file");
-});
-
-test('providerStats() computes error rate and average latency per provider', async () => {
-  const metrics = freshMetrics();
-  metrics.record({ provider: 'openai', latency_ms: 100 });
-  metrics.record({ provider: 'openai', latency_ms: 200 });
-  metrics.record({ provider: 'openai', error: 'boom' });
-  await flush();
-
-  const stats = await metrics.providerStats();
-  assert.equal(stats.openai.sampleSize, 3);
-  assert.equal(stats.openai.errorRate, 1 / 3);
-  assert.equal(stats.openai.avgLatencyMs, 150); // average of the two non-error latencies
-});
-
-test('providerStats() only considers the most recent windowSize entries', async () => {
-  const metrics = freshMetrics();
-  for (let i = 0; i < 5; i++) metrics.record({ provider: 'openai', error: 'boom' });
-  for (let i = 0; i < 5; i++) metrics.record({ provider: 'openai', latency_ms: 50 });
-  await flush();
-
-  const stats = await metrics.providerStats(5); // window covers only the second batch
-  assert.equal(stats.openai.errorRate, 0);
-  assert.equal(stats.openai.avgLatencyMs, 50);
-});
-
-test('classifyErrorType() reads Anthropic\'s own {error:{type}} shape (SDK message = "<status> <json>")', () => {
-  const metrics = freshMetrics();
-  const msg = '401 {"type":"error","error":{"type":"authentication_error","message":"API key is invalid."},"request_id":null}';
-  assert.equal(metrics.classifyErrorType(msg), 'authentication_error');
-});
-
-test('classifyErrorType() reads OpenAI\'s own {error:{type,code}} shape', () => {
-  const metrics = freshMetrics();
-  const msg = '429 {"error":{"message":"You exceeded your current quota.","type":"insufficient_quota","param":null,"code":"insufficient_quota"}}';
-  assert.equal(metrics.classifyErrorType(msg), 'insufficient_quota');
-});
-
-test('classifyErrorType() reads an invalid-key error identified only by code, not type', () => {
-  const metrics = freshMetrics();
-  const msg = '401 {"error":{"message":"Incorrect API key provided.","type":"invalid_request_error","param":null,"code":"invalid_api_key"}}';
-  assert.equal(metrics.classifyErrorType(msg), 'authentication_error');
-});
-
-test('classifyErrorType() falls back to keyword matching when the message has no parseable JSON body', () => {
-  const metrics = freshMetrics();
-  assert.equal(metrics.classifyErrorType('connect ECONNREFUSED - the key looks invalid'), 'authentication_error');
-  assert.equal(metrics.classifyErrorType('insufficient funds on this account'), 'insufficient_quota');
-  assert.equal(metrics.classifyErrorType('429 rate limit exceeded, slow down'), 'rate_limit_error');
-  assert.equal(metrics.classifyErrorType('connect ECONNREFUSED 127.0.0.1:4000'), 'unknown');
-});
-
-test('classifyErrorType() never throws on an empty/undefined message', () => {
-  const metrics = freshMetrics();
-  assert.equal(metrics.classifyErrorType(''), 'unknown');
-  assert.equal(metrics.classifyErrorType(undefined), 'unknown');
-});
-
-test('providerStats() reports the MOST RECENT error\'s classified type, not an earlier one still in the window', async () => {
-  const metrics = freshMetrics();
-  metrics.record({
-    provider: 'anthropic',
-    error: '429 {"type":"error","error":{"type":"rate_limit_error"}}',
-    error_type: 'rate_limit_error'
-  });
-  metrics.record({ provider: 'anthropic', latency_ms: 500 }); // recovered in between
-  metrics.record({
-    provider: 'anthropic',
-    error: '401 {"type":"error","error":{"type":"authentication_error"}}',
-    error_type: 'authentication_error'
-  });
-  await flush();
-
-  const stats = await metrics.providerStats();
-  assert.equal(stats.anthropic.lastErrorType, 'authentication_error');
-  assert.ok(stats.anthropic.lastErrorAt, 'expected a timestamp on the last error');
-});
-
-test('providerStats() classifies on the fly for an older record written before error_type existed', async () => {
-  const metrics = freshMetrics();
-  // No error_type field at all - simulates a log line from before this
-  // feature existed, still stored on disk after an upgrade.
-  metrics.record({ provider: 'openai', error: '401 {"error":{"type":"authentication_error"}}' });
-  await flush();
-
-  const stats = await metrics.providerStats();
-  assert.equal(stats.openai.lastErrorType, 'authentication_error');
-});
-
-test('providerStats() reports lastErrorType as null for a provider with no errors at all', async () => {
-  const metrics = freshMetrics();
-  metrics.record({ provider: 'openai', latency_ms: 100 });
-  await flush();
-
-  const stats = await metrics.providerStats();
-  assert.equal(stats.openai.lastErrorType, null);
-  assert.equal(stats.openai.lastErrorAt, null);
-});
-
-function isoDaysAgo(days) {
-  return new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
-}
-
-function appendRaw(metrics, entry) {
-  // Deliberately appended to TODAY's physical file regardless of the
-  // entry's own (possibly historical) timestamp - this test is about
-  // rangeSummary()'s PER-ROW timestamp filtering, not file rotation
-  // (that has its own dedicated tests above). Today's file always
-  // passes rangeSummary()'s file-level date filter for any days >= 0,
-  // so the row-level filter is what's actually being exercised here.
-  fs.appendFileSync(metrics.currentLogPath(), JSON.stringify(entry) + '\n');
-}
-
-test('rangeSummary() buckets by calendar day and excludes rows outside the window', async () => {
-  const metrics = freshMetrics();
-  appendRaw(metrics, { timestamp: isoDaysAgo(0), provider: 'openai', cost_usd: 0.01, cache_hit: false });
-  appendRaw(metrics, { timestamp: isoDaysAgo(0), provider: 'openai', cost_usd: 0.02, cache_hit: true, cache_type: 'exact' });
-  appendRaw(metrics, { timestamp: isoDaysAgo(1), provider: 'anthropic', cost_usd: 0.05, cache_hit: true, cache_type: 'semantic' });
-  appendRaw(metrics, { timestamp: isoDaysAgo(30), provider: 'anthropic', cost_usd: 99, cache_hit: false }); // outside a 14-day window
-
-  const summary = await metrics.rangeSummary(14);
-  assert.equal(summary.sample_size, 3);
-  assert.equal(summary.total_cost_usd, 0.08);
-  assert.equal(summary.daily.length, 2); // two distinct calendar days, the 30-day-old row excluded
-  const todayBucket = summary.daily[summary.daily.length - 1];
-  assert.equal(todayBucket.requests, 2);
-  assert.equal(todayBucket.exact_hits, 1);
-  assert.equal(todayBucket.misses, 1);
-});
-
-test('rangeSummary() reports exact/semantic/combined hit rate and error rate separately', async () => {
-  const metrics = freshMetrics();
-  metrics.record({ provider: 'openai', cost_usd: 0.01, cache_hit: false });
-  metrics.record({ provider: 'openai', cost_usd: 0, cache_hit: true, cache_type: 'exact' });
-  metrics.record({ provider: 'openai', cost_usd: 0, cache_hit: true, cache_type: 'semantic' });
-  metrics.record({ provider: 'openai', error: 'boom' });
-  await flush();
-
-  const summary = await metrics.rangeSummary(14);
-  assert.equal(summary.sample_size, 4);
-  assert.equal(summary.cache_hit_rate.exact, 0.25);
-  assert.equal(summary.cache_hit_rate.semantic, 0.25);
-  assert.equal(summary.cache_hit_rate.combined, 0.5);
-  assert.equal(summary.error_rate, 0.25);
-});
-
-test('rangeSummary() computes per-provider cost, requests, error rate and avg latency', async () => {
-  const metrics = freshMetrics();
-  metrics.record({ provider: 'openai', cost_usd: 0.01, latency_ms: 100 });
-  metrics.record({ provider: 'openai', cost_usd: 0.02, latency_ms: 300 });
-  metrics.record({ provider: 'openai', error: 'boom' });
-  metrics.record({ provider: 'anthropic', cost_usd: 0.5, latency_ms: 200 });
-  await flush();
-
-  const summary = await metrics.rangeSummary(14);
-  assert.equal(summary.by_provider.openai.requests, 3);
-  assert.equal(summary.by_provider.openai.cost_usd, 0.03);
-  assert.equal(summary.by_provider.openai.errorRate, 1 / 3);
-  assert.equal(summary.by_provider.openai.avgLatencyMs, 200); // average of the two non-error latencies
-  assert.equal(summary.by_provider.anthropic.requests, 1);
-  assert.equal(summary.by_provider.anthropic.cost_usd, 0.5);
-});
-
-test('rangeSummary() on an empty log returns zeroed rates, not NaN or a crash', async () => {
-  const metrics = freshMetrics();
-  const summary = await metrics.rangeSummary(14);
-  assert.equal(summary.sample_size, 0);
-  assert.equal(summary.cache_hit_rate.combined, 0);
-  assert.equal(summary.error_rate, 0);
-  assert.deepEqual(summary.daily, []);
-  assert.deepEqual(summary.by_provider, {});
-});