cachegate 1.1.1 → 1.2.0

package/test/router.test.js

@@ -1,195 +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');
-
-// metrics.js and router.js both read env vars once at require time, so
-// each test gets a fresh, isolated metrics log by clearing the require
-// cache and pointing METRICS_LOG_PATH at a throwaway temp file first.
-function freshModules(metricsLogPath) {
-  process.env.METRICS_LOG_PATH = metricsLogPath;
-  delete require.cache[require.resolve('../metrics')];
-  delete require.cache[require.resolve('../router')];
-  const metrics = require('../metrics');
-  const router = require('../router');
-  return { metrics, router };
-}
-
-function tempLogPath() {
-  return path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'router-test-')), 'metrics.jsonl');
-}
-
-test('isVirtualModel only matches the router: prefix', () => {
-  const { router } = freshModules(tempLogPath());
-  assert.equal(router.isVirtualModel('router:fast-cheap'), true);
-  assert.equal(router.isVirtualModel('gpt-4o-mini'), false);
-  assert.equal(router.isVirtualModel('claude-sonnet-4-5-20250929'), false);
-  assert.equal(router.isVirtualModel(undefined), false);
-});
-
-test('pickCandidate returns an error for an unknown tier', async () => {
-  const { router } = freshModules(tempLogPath());
-  const decision = await router.pickCandidate('router:does-not-exist');
-  assert.ok(decision.error);
-});
-
-test('pickCandidate picks the cheaper candidate when both are healthy (no history)', async () => {
-  const { router } = freshModules(tempLogPath());
-  // gpt-4o-mini ($0.15/$0.60 per 1M) is cheaper than claude-haiku-4-5
-  // ($0.80/$4.00 per 1M) at the fixed comparison token counts - see
-  // router.js's COMPARISON_INPUT_TOKENS/OUTPUT_TOKENS.
-  const decision = await router.pickCandidate('router:fast-cheap');
-  assert.equal(decision.provider, 'openai');
-  assert.equal(decision.model, 'gpt-4o-mini');
-  assert.equal(decision.reason.allUnhealthy, false);
-});
-
-test('pickCandidate exposes the full ranked candidate list, in the same order as the top pick', async () => {
-  const { router } = freshModules(tempLogPath());
-  const decision = await router.pickCandidate('router:fast-cheap');
-  assert.deepEqual(decision.rankedCandidates, [
-    { provider: 'openai', model: 'gpt-4o-mini' },
-    { provider: 'anthropic', model: 'claude-haiku-4-5-20251001' }
-  ]);
-  // The top pick is always the first entry - server.js's failover loop
-  // relies on this to know which candidate it started with.
-  assert.equal(decision.rankedCandidates[0].provider, decision.provider);
-  assert.equal(decision.rankedCandidates[0].model, decision.model);
-});
-
-test('pickCandidate skips a candidate whose recent error rate is too high, even if cheaper', async () => {
-  const logPath = tempLogPath();
-  const { metrics, router } = freshModules(logPath);
-
-  // Make openai (the cheaper candidate in router:fast-cheap) look
-  // unhealthy: mostly errors in its recent history.
-  for (let i = 0; i < 10; i++) {
-    metrics.record({ provider: 'openai', error: 'simulated failure' });
-  }
-  metrics.record({ provider: 'anthropic', latency_ms: 500 });
-
-  // Metrics writes go through a stream; give it a tick to flush before
-  // reading the file back.
-  await new Promise((resolve) => setTimeout(resolve, 50));
-
-  const decision = await router.pickCandidate('router:fast-cheap');
-  assert.equal(decision.provider, 'anthropic');
-  assert.equal(decision.model, 'claude-haiku-4-5-20251001');
-  assert.equal(decision.reason.allUnhealthy, false);
-});
-
-test('pickCandidate still returns a candidate when every option is unhealthy', async () => {
-  const logPath = tempLogPath();
-  const { metrics, router } = freshModules(logPath);
-
-  for (let i = 0; i < 10; i++) {
-    metrics.record({ provider: 'openai', error: 'simulated failure' });
-    metrics.record({ provider: 'anthropic', error: 'simulated failure' });
-  }
-  await new Promise((resolve) => setTimeout(resolve, 50));
-
-  const decision = await router.pickCandidate('router:fast-cheap');
-  assert.ok(decision.provider);
-  assert.equal(decision.reason.allUnhealthy, true);
-});
-
-test('pickCandidate reports which strategy it used', async () => {
-  const { router } = freshModules(tempLogPath());
-  const decision = await router.pickCandidate('router:fast-cheap');
-  assert.equal(decision.reason.strategy, 'cost'); // default, no ROUTER_STRATEGY set
-});
-
-async function flush() {
-  await new Promise((resolve) => setTimeout(resolve, 50));
-}
-
-test('ROUTER_STRATEGY=latency picks the fastest healthy candidate even when it costs more', async () => {
-  const logPath = tempLogPath();
-  process.env.ROUTER_STRATEGY = 'latency';
-  const { metrics, router } = freshModules(logPath);
-
-  // gpt-4o-mini is the cheaper candidate in router:fast-cheap, but make
-  // it noticeably slower than claude-haiku here.
-  for (let i = 0; i < 5; i++) metrics.record({ provider: 'openai', latency_ms: 2000 });
-  for (let i = 0; i < 5; i++) metrics.record({ provider: 'anthropic', latency_ms: 100 });
-  await flush();
-
-  const decision = await router.pickCandidate('router:fast-cheap');
-  assert.equal(decision.provider, 'anthropic');
-  assert.equal(decision.model, 'claude-haiku-4-5-20251001');
-  assert.equal(decision.reason.strategy, 'latency');
-
-  delete process.env.ROUTER_STRATEGY;
-});
-
-test('ROUTER_STRATEGY=latency falls back to cost as a tiebreaker when latency is equal (e.g. both unknown)', async () => {
-  process.env.ROUTER_STRATEGY = 'latency';
-  const { router } = freshModules(tempLogPath()); // no recorded latencies at all - both candidates are unknown
-
-  const decision = await router.pickCandidate('router:fast-cheap');
-  assert.equal(decision.model, 'gpt-4o-mini'); // the cheaper of the two, same as the default cost strategy would pick
-
-  delete process.env.ROUTER_STRATEGY;
-});
-
-test('ROUTER_STRATEGY=latency-guarded-cost excludes a candidate far slower than the fastest known one, even if cheaper', async () => {
-  const logPath = tempLogPath();
-  process.env.ROUTER_STRATEGY = 'latency-guarded-cost';
-  const { metrics, router } = freshModules(logPath);
-
-  // openai/gpt-4o-mini is the cheaper candidate, but 3000ms is far more
-  // than 3x (the default guard multiplier) slower than anthropic's
-  // 100ms - it should get excluded by the guard despite being cheaper.
-  for (let i = 0; i < 5; i++) metrics.record({ provider: 'openai', latency_ms: 3000 });
-  for (let i = 0; i < 5; i++) metrics.record({ provider: 'anthropic', latency_ms: 100 });
-  await flush();
-
-  const decision = await router.pickCandidate('router:fast-cheap');
-  assert.equal(decision.provider, 'anthropic');
-  assert.equal(decision.reason.strategy, 'latency-guarded-cost');
-  assert.equal(decision.reason.latencyGuardExcludedACandidate, true);
-
-  delete process.env.ROUTER_STRATEGY;
-});
-
-test('ROUTER_STRATEGY=latency-guarded-cost keeps a candidate that is only modestly slower, and still picks by cost', async () => {
-  const logPath = tempLogPath();
-  process.env.ROUTER_STRATEGY = 'latency-guarded-cost';
-  const { metrics, router } = freshModules(logPath);
-
-  // 150ms is only 1.5x anthropic's 100ms - comfortably inside the
-  // default 3x guard multiplier, so openai stays in the pool and wins
-  // on cost as usual.
-  for (let i = 0; i < 5; i++) metrics.record({ provider: 'openai', latency_ms: 150 });
-  for (let i = 0; i < 5; i++) metrics.record({ provider: 'anthropic', latency_ms: 100 });
-  await flush();
-
-  const decision = await router.pickCandidate('router:fast-cheap');
-  assert.equal(decision.model, 'gpt-4o-mini');
-  assert.equal(decision.reason.latencyGuardExcludedACandidate, false);
-
-  delete process.env.ROUTER_STRATEGY;
-});
-
-test('ROUTER_STRATEGY=latency-guarded-cost degrades to plain cost when there is no latency data yet', async () => {
-  process.env.ROUTER_STRATEGY = 'latency-guarded-cost';
-  const { router } = freshModules(tempLogPath()); // no history at all
-
-  const decision = await router.pickCandidate('router:fast-cheap');
-  assert.equal(decision.model, 'gpt-4o-mini'); // nothing to guard against yet
-  assert.equal(decision.reason.latencyGuardExcludedACandidate, false);
-
-  delete process.env.ROUTER_STRATEGY;
-});
-
-test('an unrecognized ROUTER_STRATEGY value falls back to "cost" rather than erroring', async () => {
-  process.env.ROUTER_STRATEGY = 'fastest-vibes';
-  const { router } = freshModules(tempLogPath());
-
-  const decision = await router.pickCandidate('router:fast-cheap');
-  assert.equal(decision.reason.strategy, 'cost');
-  assert.equal(decision.model, 'gpt-4o-mini');
-
-  delete process.env.ROUTER_STRATEGY;
-});

package/test/semanticCache.test.js

@@ -1,167 +0,0 @@
-// Exercises the real storage/lookup machinery (list writes, trimming,
-// cosine-similarity scoring) against an actual Redis instance, not a
-// mock - this test file spins up its own throwaway redis-server for
-// the duration of the run so `npm test` stays self-contained. It never
-// calls a real embedding API: a deterministic fake embedder is injected
-// via the `embeddings` option both findMatch() and store() accept, so
-// the similarity math is genuinely exercised without needing
-// OPENAI_API_KEY or network access.
-
-const { test, before, after } = require('node:test');
-const assert = require('node:assert/strict');
-const { spawn } = require('child_process');
-const net = require('net');
-
-let redisProcess;
-let redisClient;
-let semanticCache;
-let cache;
-
-function getFreePort() {
-  return new Promise((resolve, reject) => {
-    const srv = net.createServer();
-    srv.listen(0, () => {
-      const { port } = srv.address();
-      srv.close(() => resolve(port));
-    });
-    srv.on('error', reject);
-  });
-}
-
-function waitForRedisReady(proc) {
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => reject(new Error('redis-server did not become ready in time')), 10_000);
-    proc.stdout.on('data', (chunk) => {
-      if (chunk.toString().includes('Ready to accept connections')) {
-        clearTimeout(timeout);
-        resolve();
-      }
-    });
-    proc.on('error', reject);
-  });
-}
-
-// A small fixed-dimension deterministic "embedding": each word maps to
-// a pseudo-random but stable vector slot via a simple hash, so two
-// texts sharing words end up with similar vectors and unrelated texts
-// don't - enough to exercise cosine-similarity thresholding
-// meaningfully without a real embedding model.
-function fakeEmbed(text) {
-  const dims = 32;
-  const vec = new Array(dims).fill(0);
-  for (const word of text.toLowerCase().split(/\W+/).filter(Boolean)) {
-    let h = 0;
-    for (let i = 0; i < word.length; i++) h = (h * 31 + word.charCodeAt(i)) >>> 0;
-    vec[h % dims] += 1;
-  }
-  return Promise.resolve(vec);
-}
-
-const fakeEmbeddings = { isEnabled: () => true, embed: fakeEmbed };
-
-before(async () => {
-  const port = await getFreePort();
-  process.env.REDIS_URL = `redis://127.0.0.1:${port}`;
-  redisProcess = spawn('redis-server', ['--port', String(port), '--save', '', '--appendonly', 'no'], {
-    stdio: ['ignore', 'pipe', 'pipe']
-  });
-  await waitForRedisReady(redisProcess);
-
-  redisClient = require('../redisClient');
-  await redisClient.ready;
-  semanticCache = require('../semanticCache');
-  cache = require('../cache');
-});
-
-after(async () => {
-  try { await redisClient.client.quit(); } catch { /* already closed */ }
-  if (redisProcess) redisProcess.kill();
-});
-
-test('isEnabled() is true once Redis is connected and embeddings report enabled', () => {
-  assert.equal(semanticCache.isEnabled(fakeEmbeddings), true);
-});
-
-test('isEnabled() is false when embeddings are disabled, even with Redis connected', () => {
-  assert.equal(semanticCache.isEnabled({ isEnabled: () => false }), false);
-});
-
-test('the exact-match cache (cache.js) still works over the same shared connection', async () => {
-  const payload = { model: 'gpt-4o-mini', messages: [{ role: 'user', content: 'shared connection check' }] };
-  assert.equal(await cache.get(payload), null);
-  await cache.set(payload, { provider: 'openai', model: 'gpt-4o-mini', content: 'ok' });
-  const hit = await cache.get(payload);
-  assert.equal(hit.content, 'ok');
-});
-
-test('findMatch() returns null when nothing has been stored yet', async () => {
-  const payload = { model: 'router-test-model-empty', messages: [{ role: 'user', content: 'is anyone there' }] };
-  const result = await semanticCache.findMatch(payload, { embeddings: fakeEmbeddings });
-  assert.equal(result, null);
-});
-
-test('store() then findMatch() with the identical prompt finds a match (similarity ~1)', async () => {
-  const model = 'router-test-model-identical';
-  const payload = { model, messages: [{ role: 'user', content: 'how do I reset my password' }] };
-  const entry = { provider: 'openai', model, content: 'Go to Settings > Security > Reset password.' };
-
-  const stored = await semanticCache.store(payload, entry, { embeddings: fakeEmbeddings });
-  assert.equal(stored, true);
-
-  const match = await semanticCache.findMatch(payload, { embeddings: fakeEmbeddings });
-  assert.ok(match, 'expected a match for the identical prompt');
-  assert.equal(match.entry.content, entry.content);
-  assert.ok(match.similarity > 0.99, `expected near-1 similarity, got ${match.similarity}`);
-});
-
-test('findMatch() does not match an unrelated prompt under the same model', async () => {
-  const model = 'router-test-model-unrelated';
-  const stored = { model, messages: [{ role: 'user', content: 'how do I reset my password' }] };
-  await semanticCache.store(stored, { provider: 'openai', model, content: 'reset password steps' }, { embeddings: fakeEmbeddings });
-
-  const unrelated = { model, messages: [{ role: 'user', content: 'what is the weather in Tokyo tomorrow' }] };
-  const match = await semanticCache.findMatch(unrelated, { embeddings: fakeEmbeddings, threshold: 0.93 });
-  assert.equal(match, null);
-});
-
-test('findMatch()/store() skip tool-calling requests entirely (never cached, never matched)', async () => {
-  const model = 'router-test-model-tools';
-  const payload = {
-    model,
-    messages: [{ role: 'user', content: 'call the tool' }],
-    tools: [{ type: 'function', function: { name: 'do_thing' } }]
-  };
-  const stored = await semanticCache.store(payload, { provider: 'openai', model, content: 'x' }, { embeddings: fakeEmbeddings });
-  assert.equal(stored, false);
-
-  const match = await semanticCache.findMatch(payload, { embeddings: fakeEmbeddings });
-  assert.equal(match, null);
-});
-
-test('per-model list is trimmed to SEMANTIC_CACHE_MAX_CANDIDATES', async () => {
-  const originalMax = process.env.SEMANTIC_CACHE_MAX_CANDIDATES;
-  process.env.SEMANTIC_CACHE_MAX_CANDIDATES = '3';
-  delete require.cache[require.resolve('../semanticCache')];
-  const scopedSemanticCache = require('../semanticCache');
-
-  const model = 'router-test-model-trim';
-  for (let i = 0; i < 5; i++) {
-    await scopedSemanticCache.store(
-      { model, messages: [{ role: 'user', content: `distinct prompt number ${i}` }] },
-      { provider: 'openai', model, content: `answer ${i}` },
-      { embeddings: fakeEmbeddings }
-    );
-  }
-
-  const length = await redisClient.client.lLen(`SEMANTIC_LIST:${model}`);
-  assert.equal(length, 3);
-
-  if (originalMax === undefined) delete process.env.SEMANTIC_CACHE_MAX_CANDIDATES;
-  else process.env.SEMANTIC_CACHE_MAX_CANDIDATES = originalMax;
-});
-
-test('cosineSimilarity() is 1 for identical vectors and 0 for orthogonal ones', () => {
-  assert.equal(semanticCache.cosineSimilarity([1, 0], [1, 0]), 1);
-  assert.equal(semanticCache.cosineSimilarity([1, 0], [0, 1]), 0);
-  assert.equal(semanticCache.cosineSimilarity([1, 0], [0, 0]), 0); // zero vector is defined as no similarity, not NaN
-});