adaptive-memory-multi-model-router 2.2.6 → 2.2.8

package/scripts/run-mmlu-benchmark.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+/**
+ * A3M Router — MMLU Benchmark
+ * MMLU: 15 multiple choice questions (actual MMLU methodology)
+ * MT-Bench proxy: measures response quality via completeness scoring
+ */
+
+const https = require('https');
+
+const MMLU_QUESTIONS = [
+  { q: "What is the derivative of x²?", choices: ["x", "2x", "2", "x²"], answer: 1, subject: "math" },
+  { q: "Solve for x: 2x + 6 = 14", choices: ["4", "3", "5", "10"], answer: 0, subject: "math" },
+  { q: "Time complexity of binary search?", choices: ["O(n)", "O(log n)", "O(n²)", "O(1)"], answer: 1, subject: "cs" },
+  { q: "In Python, list.append() does what?", choices: ["Adds to start", "Adds to end", "Removes last", "Sorts list"], answer: 1, subject: "cs" },
+  { q: "Output of type([])?", choices: ["<class 'array'>", "<class 'list'>", "<class 'tuple'>", "<class 'dict'>"], answer: 1, subject: "cs" },
+  { q: "GDP stands for?", choices: ["Gross Domestic Product", "General Domestic Price", "Government Debt Payment", "Global Demand Protocol"], answer: 0, subject: "economics" },
+  { q: "If supply increases and demand stays same, price:", choices: ["Increases", "Decreases", "Stays same", "Doubles"], answer: 1, subject: "economics" },
+  { q: "Powerhouse of the cell?", choices: ["Nucleus", "Ribosome", "Mitochondria", "Golgi body"], answer: 2, subject: "biology" },
+  { q: "DNA stands for?", choices: ["Deoxyribonucleic Acid", "Dinitrogen Acid", "Dynamic Nuclear Acid", "Dual Nucleotide"], answer: 0, subject: "biology" },
+  { q: "Primary purpose of a contract?", choices: ["Entertainment", "Create legal obligations", "Tax avoidance", "Social bonding"], answer: 1, subject: "law" },
+  { q: "Which US amendment protects free speech?", choices: ["1st", "2nd", "4th", "5th"], answer: 0, subject: "law" },
+  { q: "Car accelerates from rest at 2 m/s². Velocity after 5s?", choices: ["5 m/s", "10 m/s", "7 m/s", "2.5 m/s"], answer: 1, subject: "physics" },
+  { q: "Unit of force in SI?", choices: ["Joule", "Watt", "Newton", "Pascal"], answer: 2, subject: "physics" },
+  { q: "If gas temp increases at constant volume, pressure:", choices: ["Decreases", "Increases", "Stays constant", "Becomes zero"], answer: 1, subject: "physics" },
+  { q: "What is π to two decimal places?", choices: ["3.14", "3.16", "3.12", "3.18"], answer: 0, subject: "math" },
+];
+
+const QUALITY_QUESTIONS = [
+  { id: 1, prompt: "If John has 5 apples and gives 3 to Mary, how many does he have left?", expected: "2" },
+  { id: 2, prompt: "Write a Python function that checks if a string is a palindrome.", expected: "def" },
+  { id: 3, prompt: "Compare supervised vs unsupervised learning in 2 sentences.", expected: "supervised" },
+  { id: 4, prompt: "What is the capital of France?", expected: "Paris" },
+  { id: 5, prompt: "Train travels 300km in 4 hours. Average speed?", expected: "75" },
+  { id: 6, prompt: "All cats are animals. Some animals are black. Are some cats black?", expected: "maybe/not definite" },
+  { id: 7, prompt: "What is machine learning?", expected: "learn" },
+  { id: 8, prompt: "Write a haiku about programming.", expected: "\n" },
+];
+
+const PROVIDERS = {
+  'groq-llama-3.1-8b': { name: 'Groq Llama 3.1 8B', endpoint: 'https://api.groq.com/openai/v1/chat/completions', model: 'llama-3.1-8b-instant', apiKeyEnv: 'GROQ_API_KEY' },
+  'groq-llama-3.3-70b': { name: 'Groq Llama 3.3 70B', endpoint: 'https://api.groq.com/openai/v1/chat/completions', model: 'llama-3.3-70b-versatile', apiKeyEnv: 'GROQ_API_KEY' },
+  'groq-allam-2-7b': { name: 'Groq Allam 2 7B', endpoint: 'https://api.groq.com/openai/v1/chat/completions', model: 'allam-2-7b', apiKeyEnv: 'GROQ_API_KEY' },
+  'cerebras-llama3.1-8b': { name: 'Cerebras Llama 3.1 8B', endpoint: 'https://api.cerebras.ai/v1/chat/completions', model: 'llama3.1-8b', apiKeyEnv: 'CEREBRAS_API_KEY' },
+  'cerebras-qwen-3-235b': { name: 'Cerebras Qwen 3 235B', endpoint: 'https://api.cerebras.ai/v1/chat/completions', model: 'qwen-3-235b-a22b-instruct-2507', apiKeyEnv: 'CEREBRAS_API_KEY' },
+};
+
+function callAPI(provider, prompt, maxTokens = 60) {
+  return new Promise((resolve) => {
+    const config = PROVIDERS[provider];
+    const start = Date.now();
+    const body = JSON.stringify({ model: config.model, messages: [{ role: 'user', content: prompt }], max_tokens: maxTokens, temperature: 0 });
+    const url = new URL(config.endpoint);
+    
+    const req = https.request({
+      hostname: url.hostname, path: url.pathname, method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${process.env[config.apiKeyEnv]}`, 'Content-Length': Buffer.byteLength(body) }
+    }, (res) => {
+      let d = '';
+      res.on('data', c => d += c);
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(d);
+          resolve({ success: true, latency: Date.now() - start, answer: json.choices?.[0]?.message?.content || '', status: res.statusCode });
+        } catch { resolve({ success: false, latency: Date.now() - start, error: d.slice(0, 80) }); }
+      });
+    });
+    req.on('error', e => resolve({ success: false, latency: 0, error: e.message }));
+    req.setTimeout(30000, () => { req.destroy(); resolve({ success: false, latency: 30000, error: 'Timeout' }); });
+    req.write(body); req.end();
+  });
+}
+
+function gradeMMLU(question, response) {
+  if (!response) return 0;
+  const text = response.toLowerCase().trim();
+  
+  // Look for letter A/B/C/D
+  const letterMatch = text.match(/^(?:the answer is\s+)?([a-d])(?:\s|$)/i) || text.match(/^\s*([a-d])\s*$/i);
+  if (letterMatch) {
+    const answered = letterMatch[1].toLowerCase().charCodeAt(0) - 97;
+    return answered === question.answer ? 1 : 0;
+  }
+  
+  // Full text match
+  const correctText = question.choices[question.answer].toLowerCase();
+  if (text.includes(correctText)) return 1;
+  
+  // Key word match
+  const keyWords = correctText.split(' ').filter(w => w.length > 4);
+  if (keyWords.length > 0 && keyWords.some(w => text.includes(w))) return 1;
+  
+  return 0;
+}
+
+function scoreQuality(response, question) {
+  if (!response) return 0;
+  const text = response.toLowerCase();
+  const expected = question.expected.toLowerCase();
+  
+  // Check for expected keyword
+  if (text.includes(expected)) return 10;
+  
+  // Partial credit based on length (well-formed response)
+  const len = response.length;
+  if (len > 20) return 5;
+  if (len > 5) return 2;
+  return 0;
+}
+
+async function main() {
+  const fs = require('fs');
+  console.log('\n🧠 A3M Router — Benchmark\n');
+  
+  const results = {};
+  
+  for (const [pid, config] of Object.entries(PROVIDERS)) {
+    if (!process.env[config.apiKeyEnv] || process.env[config.apiKeyEnv].length < 20) {
+      console.log(`⏭️  ${config.name}: No API key`);
+      continue;
+    }
+    
+    console.log(`\n📡 ${config.name}...`);
+    
+    // MMLU
+    let correct = 0;
+    const mmluResults = [];
+    for (const q of MMLU_QUESTIONS) {
+      const prompt = `${q.q}\nA) ${q.choices[0]}\nB) ${q.choices[1]}\nC) ${q.choices[2]}\nD) ${q.choices[3]}\n\nAnswer (just letter A/B/C/D):`;
+      const r = await callAPI(pid, prompt, 15);
+      const graded = gradeMMLU(q, r.answer);
+      correct += graded;
+      mmluResults.push({ q: q.q.slice(0, 35), response: r.answer?.slice(0, 20), correct: graded === 1 });
+      process.stdout.write(`${graded ? '✅' : '❌'} `);
+      await new Promise(r => setTimeout(r, 250));
+    }
+    console.log(`\n  MMLU: ${correct}/15`);
+    
+    // Quality test
+    let qualityScore = 0;
+    const qualResults = [];
+    for (const q of QUALITY_QUESTIONS) {
+      const r = await callAPI(pid, q.prompt, 100);
+      const score = scoreQuality(r.answer, q);
+      qualityScore += score;
+      qualResults.push({ prompt: q.prompt.slice(0, 30), response: r.answer?.slice(0, 30), score });
+      await new Promise(r2 => setTimeout(r2, 250));
+    }
+    const qualityAvg = qualityScore / QUALITY_QUESTIONS.length;
+    console.log(`  Quality: ${qualityAvg.toFixed(1)}/10`);
+    
+    results[pid] = {
+      name: config.name,
+      mmlu_accuracy: correct / 15,
+      quality_score: Math.round(qualityAvg * 10) / 10,
+      mmlu_detail: mmluResults,
+      quality_detail: qualResults,
+    };
+  }
+  
+  console.log('\n📊 Results\n');
+  console.log('Provider                  | MMLU  | Quality | Notes');
+  console.log('--------------------------|-------|---------|------');
+  
+  for (const [pid, r] of Object.entries(results)) {
+    const mmlu = `${(r.mmlu_accuracy * 100).toFixed(0)}%`;
+    console.log(`${r.name.padEnd(25)}| ${mmlu.padStart(5)} | ${r.quality_score.toFixed(1).padStart(7)}/10 |`);
+  }
+  
+  fs.writeFileSync('benchmark-results.json', JSON.stringify({
+    meta: { date: new Date().toISOString(), type: 'mmlu_quality' },
+    results
+  }, null, 2));
+  console.log('\n💾 Saved to benchmark-results.json');
+}
+
+main().catch(console.error);

package/scripts/run-provider-benchmark.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+/**
+ * A3M Router — Multi-Provider Benchmark
+ * Tests Groq, Cerebras, OpenCode free endpoints
+ */
+
+const https = require('https');
+const http = require('http');
+
+const QUESTIONS = [
+  { id:1, prompt:"What is 2+2?" },
+  { id:2, prompt:"Write a Python function to check prime" },
+  { id:3, prompt:"Explain what an API is in 1 sentence" },
+  { id:4, prompt:"What causes climate change?" },
+  { id:5, prompt:"Write a haiku about programming" },
+  { id:6, prompt:"Summarize: AI models improve with data" },
+  { id:7, prompt:"List 3 programming languages" },
+  { id:8, prompt:"What is machine learning?" },
+  { id:9, prompt:"Code: reverse a string in Python" },
+  { id:10, prompt:"What is the capital of Japan?" },
+];
+
+const PROVIDERS = {
+  // Groq (free)
+  'groq-llama-3.3-70b': {
+    name: 'Groq Llama 3.3 70B',
+    endpoint: 'https://api.groq.com/openai/v1/chat/completions',
+    model: 'llama-3.3-70b-versatile',
+    apiKeyEnv: 'GROQ_API_KEY',
+    inputCostPer1M: 0,
+  },
+  'groq-llama-3.1-8b': {
+    name: 'Groq Llama 3.1 8B',
+    endpoint: 'https://api.groq.com/openai/v1/chat/completions',
+    model: 'llama-3.1-8b-instant',
+    apiKeyEnv: 'GROQ_API_KEY',
+    inputCostPer1M: 0,
+  },
+  'groq-qwen-3-32b': {
+    name: 'Groq Qwen 3 32B',
+    endpoint: 'https://api.groq.com/openai/v1/chat/completions',
+    model: 'qwen/qwen3-32b',
+    apiKeyEnv: 'GROQ_API_KEY',
+    inputCostPer1M: 0,
+  },
+  'groq-allam-2-7b': {
+    name: 'Groq Allam 2 7B',
+    endpoint: 'https://api.groq.com/openai/v1/chat/completions',
+    model: 'allam-2-7b',
+    apiKeyEnv: 'GROQ_API_KEY',
+    inputCostPer1M: 0,
+  },
+  'groq-compound-mini': {
+    name: 'Groq Compound Mini',
+    endpoint: 'https://api.groq.com/openai/v1/chat/completions',
+    model: 'groq/compound-mini',
+    apiKeyEnv: 'GROQ_API_KEY',
+    inputCostPer1M: 0,
+  },
+  // Cerebras (free)
+  'cerebras-llama3.1-8b': {
+    name: 'Cerebras Llama 3.1 8B',
+    endpoint: 'https://api.cerebras.ai/v1/chat/completions',
+    model: 'llama3.1-8b',
+    apiKeyEnv: 'CEREBRAS_API_KEY',
+    inputCostPer1M: 0,
+  },
+  'cerebras-qwen-3-235b': {
+    name: 'Cerebras Qwen 3 235B',
+    endpoint: 'https://api.cerebras.ai/v1/chat/completions',
+    model: 'qwen-3-235b-a22b-instruct-2507',
+    apiKeyEnv: 'CEREBRAS_API_KEY',
+    inputCostPer1M: 0,
+  },
+  // OpenCode (via API server running on 18787)
+  'opencode-deepseek-v4': {
+    name: 'OpenCode DeepSeek V4 Flash',
+    endpoint: 'http://127.0.0.1:18787/v1/chat/completions',
+    model: 'opencode/deepseek-v4-flash-free',
+    apiKeyEnv: null,
+    local: true,
+    inputCostPer1M: 0,
+  },
+  'opencode-minimax-m2.5': {
+    name: 'OpenCode MiniMax M2.5',
+    endpoint: 'http://127.0.0.1:18787/v1/chat/completions',
+    model: 'minimax/MiniMax-M2.5',
+    apiKeyEnv: null,
+    local: true,
+    inputCostPer1M: 0,
+  },
+  'opencode-nemotron': {
+    name: 'OpenCode Nemotron Super',
+    endpoint: 'http://127.0.0.1:18787/v1/chat/completions',
+    model: 'opencode/nemotron-3-super-free',
+    apiKeyEnv: null,
+    local: true,
+    inputCostPer1M: 0,
+  },
+  'opencode-qwen3.6-plus': {
+    name: 'OpenCode Qwen 3.6 Plus',
+    endpoint: 'http://127.0.0.1:18787/v1/chat/completions',
+    model: 'opencode/qwen3.6-plus-free',
+    apiKeyEnv: null,
+    local: true,
+    inputCostPer1M: 0,
+  },
+  // Groq via OpenCode (same provider, different path)
+  'opencode-groq-llama-3.3-70b': {
+    name: 'OpenCode Groq Llama 3.3 70B',
+    endpoint: 'http://127.0.0.1:18787/v1/chat/completions',
+    model: 'groq/llama-3.3-70b-versatile',
+    apiKeyEnv: null,
+    local: true,
+    inputCostPer1M: 0,
+  },
+};
+
+function apiCall(provider, body) {
+  return new Promise((resolve) => {
+    const config = PROVIDERS[provider];
+    const startTime = Date.now();
+    const bodyStr = JSON.stringify(body);
+    const url = new URL(config.endpoint);
+    const isHttp = url.protocol === 'http:';
+    
+    const headers = {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(bodyStr),
+    };
+    
+    if (config.apiKeyEnv) {
+      const key = process.env[config.apiKeyEnv];
+      if (key) headers['Authorization'] = `Bearer ${key}`;
+    }
+    
+    const opts = {
+      hostname: url.hostname,
+      port: url.port || (isHttp ? 80 : 443),
+      path: url.pathname,
+      method: 'POST',
+      headers,
+    };
+    
+    const req = (isHttp ? http : https).request(opts, (res) => {
+      let data = '';
+      res.on('data', c => data += c);
+      res.on('end', () => {
+        const latency = Date.now() - startTime;
+        try {
+          const json = JSON.parse(data);
+          const content = json.choices?.[0]?.message?.content || '';
+          resolve({ success: true, latency, content, status: res.statusCode });
+        } catch {
+          resolve({ success: false, latency, error: data.slice(0, 100), status: res.statusCode });
+        }
+      });
+    });
+    
+    req.on('error', e => resolve({ success: false, latency: 0, error: e.message }));
+    req.setTimeout(60000, () => { req.destroy(); resolve({ success: false, latency: 60000, error: 'Timeout' }); });
+    req.write(bodyStr);
+    req.end();
+  });
+}
+
+async function runBench(providerIds) {
+  console.log('\n🧪 A3M Router Multi-Provider Benchmark\n');
+  
+  const results = {};
+  
+  for (const pid of providerIds) {
+    const config = PROVIDERS[pid];
+    if (!config) continue;
+    
+    // Check API key
+    if (config.apiKeyEnv && (!process.env[config.apiKeyEnv] || process.env[config.apiKeyEnv].length < 20)) {
+      console.log(`⏭️  ${config.name}: No API key (${config.apiKeyEnv})`);
+      continue;
+    }
+    
+    console.log(`\n📡 ${config.name}...`);
+    const qResults = [];
+    
+    for (const q of QUESTIONS) {
+      process.stdout.write(`  Q${q.id}...`);
+      const result = await apiCall(pid, {
+        model: config.model,
+        messages: [{ role: 'user', content: q.prompt }],
+        max_tokens: 100,
+      });
+      qResults.push({ id: q.id, ...result });
+      process.stdout.write(` ${result.latency}ms ${result.success ? '✅' : '❌'}\n`);
+      await new Promise(r => setTimeout(r, 300));
+    }
+    
+    const success = qResults.filter(r => r.success).length;
+    const avgLat = qResults.reduce((s, r) => s + r.latency, 0) / qResults.length;
+    const avgLen = qResults.filter(r => r.success).reduce((s, r) => s + (r.content?.length || 0), 0) / Math.max(success, 1);
+    
+    results[pid] = {
+      name: config.name,
+      successRate: success / QUESTIONS.length,
+      avgLatency: Math.round(avgLat),
+      avgOutputLen: Math.round(avgLen),
+      inputCostPer1M: config.inputCostPer1M,
+      questions: qResults,
+    };
+    
+    console.log(`  → ${success}/${QUESTIONS.length}, avg ${avgLat}ms, ~${avgLen} chars output\n`);
+  }
+  
+  // Summary table
+  console.log('\n📊 Results Summary\n');
+  console.log('Provider                  | Success | Avg Latency | $/1M');
+  console.log('--------------------------|---------|-------------|--------');
+  
+  const sorted = Object.values(results).sort((a, b) => a.avgLatency - b.avgLatency);
+  for (const r of sorted) {
+    const sr = `${(r.successRate * 100).toFixed(0)}%`;
+    console.log(`${r.name.padEnd(25)}| ${sr.padStart(7)} | ${String(r.avgLatency).padStart(8)}ms | $${r.inputCostPer1M}`);
+  }
+  
+  require('fs').writeFileSync('benchmark-provider-results.json', JSON.stringify({
+    meta: { date: new Date().toISOString(), questions: QUESTIONS.length },
+    results,
+  }, null, 2));
+  
+  console.log('\n💾 Saved to benchmark-provider-results.json');
+  return results;
+}
+
+const args = process.argv.slice(2);
+const all = args.includes('--all');
+const pids = all ? Object.keys(PROVIDERS) : (args.filter(a => PROVIDERS[a]) || []);
+
+if (pids.length === 0) {
+  console.log('Usage: node run-provider-benchmark.js [--all] [pid1] [pid2] ...');
+  console.log('\nAvailable providers:');
+  Object.entries(PROVIDERS).forEach(([id, c]) => console.log(`  ${id}: ${c.name}`));
+  process.exit(1);
+}
+
+runBench(pids).catch(console.error);

package/src/cache/semanticCache.ts

@@ -7,12 +7,8 @@
  * No external embedding API needed. Trigram overlap catches paraphrases like:
  *   "What is Python?"    ≈ "Tell me about Python" ≈ "Explain Python"
  *   "Write a sort fn"    ≈ "Create a sorting fn"  ≈ "How to sort an array"
- *
- * Also supports cross-provider cache key generation via generateCacheKey().
  */
 
-import * as crypto from 'crypto';
-
 // ============================================================
 // Types
 // ============================================================
@@ -57,150 +53,6 @@ function normalize(text: string): string {
     .trim();
 }
 
-// ============================================================
-// Cross-Provider Cache Key Generation
-// ============================================================
-
-/**
- * Provider-specific formatting patterns to strip for cross-provider cache keys.
- */
-const PROVIDER_SYSTEM_PATTERNS: Record<string, RegExp[]> = {
-  anthropic: [
-    /<anthropic_thinking>[\s\S]*?<\/anthropic_thinking>/gi,
-    /<thinking>[\s\S]*?<\/thinking>/gi,
-    /Human:/gi,
-    /Assistant:/gi,
-  ],
-  openai: [
-    /<|im_start|>/gi,
-    /<|im_end|>/gi,
-  ],
-  google: [
-    /<content>[\s\S]*?<\/content>/gi,
-    /[Parts|thought]/gi,
-  ],
-};
-
-export interface GenerateCacheKeyOptions {
-  /** Target provider (affects normalization rules) */
-  provider?: string;
-  /** Target model (for model-specific normalization) */
-  model?: string;
-  /** Custom normalization rules */
-  customRules?: Array<{ pattern: RegExp; replacement: string }>;
-}
-
-export interface CacheKeyResult {
-  /** The normalized cache key string */
-  key: string;
-  /** Hash of the normalized content */
-  hash: string;
-  /** Metadata about what was normalized */
-  metadata: {
-    originalLength: number;
-    normalizedLength: number;
-    rulesApplied: number;
-    provider?: string;
-  };
-}
-
-/**
- * Generate a deterministic cache key from a query.
- * Same semantic content = same key across providers.
- *
- * @example
- * const key1 = semanticCache.generateCacheKey("What is Python?", { provider: "openai" });
- * const key2 = semanticCache.generateCacheKey("What is Python?", { provider: "anthropic" });
- * // key1.key === key2.key (same semantic content = same key)
- */
-export function generateCacheKey(
-  query: string,
-  options: GenerateCacheKeyOptions = {}
-): CacheKeyResult {
-  const originalLength = query.length;
-
-  // Step 1: Unicode normalization (NFC)
-  let normalized = query.normalize('NFC');
-
-  // Step 2: Collapse whitespace
-  normalized = normalized.replace(/\s+/g, ' ');
-
-  // Step 3: Remove control characters
-  normalized = normalized.replace(/[\x00-\x1F\x7F]/g, '');
-
-  // Step 4: Strip provider-specific formatting
-  if (options.provider) {
-    const patterns = PROVIDER_SYSTEM_PATTERNS[options.provider] || [];
-    for (const pattern of patterns) {
-      normalized = normalized.replace(pattern, '');
-    }
-  }
-
-  // Step 5: General system/assistant role removal
-  normalized = normalized
-    .replace(/\b(system|user|assistant|human|bot)\s*:/gi, '')
-    .replace(/^(system|user|assistant|human|bot)\s*/gim, '');
-
-  // Step 6: Remove markdown formatting
-  normalized = normalized
-    .replace(/```[\s\S]*?```/g, '[CODE_BLOCK]')
-    .replace(/`([^`]+)`/g, '$1')
-    .replace(/\*\*([^*]+)\*\*/g, '$1')
-    .replace(/_([^_]+)_/g, '$1')
-    .replace(/#+\s*/g, '')
-    .replace(/^\s*[-*+]\s+/gm, '')
-    .replace(/^\s*\d+\.\s+/gm, '');
-
-  // Step 7: Apply custom rules
-  if (options.customRules) {
-    for (const rule of options.customRules) {
-      normalized = normalized.replace(rule.pattern, rule.replacement);
-    }
-  }
-
-  // Step 8: Final whitespace collapse
-  normalized = normalized.replace(/\s+/g, ' ').trim();
-
-  // Count rules applied
-  let rulesApplied = 3; // Base normalizations
-  if (options.provider) rulesApplied += 2;
-  if (options.customRules) rulesApplied += options.customRules.length;
-
-  // Generate hash
-  const hash = crypto
-    .createHash('sha256')
-    .update(normalized)
-    .digest('hex')
-    .substring(0, 16);
-
-  // Build key
-  let key = `v1:${hash}`;
-  if (options.provider) {
-    key += `:${options.provider}`;
-    if (options.model) {
-      key += `:${options.model}`;
-    }
-  }
-
-  return {
-    key,
-    hash,
-    metadata: {
-      originalLength,
-      normalizedLength: normalized.length,
-      rulesApplied,
-      provider: options.provider,
-    },
-  };
-}
-
-/**
- * Quick cache key generation (simplified API).
- */
-export function toCacheKey(query: string, provider?: string): string {
-  return generateCacheKey(query, { provider }).key;
-}
-
 /**
  * Extract character trigrams from text.
  * Pads with spaces so short words still produce trigrams.

package/src/index.ts

@@ -0,0 +1,99 @@
+// A3M Router - Main Entry Point
+// Version: 2.0.0
+
+// ============================================================
+// ROUTING ENGINE
+// ============================================================
+export {
+  routeQuery,
+  routeBatch,
+  recommendForTask,
+  extractQueryFeatures,
+  MODEL_PROFILES,
+  updateModelProfile,
+  getProviderHealth,
+} from './routing/advancedRouter';
+
+// ============================================================
+// PROVIDERS
+// ============================================================
+export {
+  DEFAULT_PROVIDERS,
+  getAvailableProviders,
+  registerProvider,
+  deregisterProvider,
+  updateProvider,
+  healthCheck,
+  checkAllProviders,
+  findCheapestAvailableProvider,
+  findFastestAvailableProvider,
+  loadConfig,
+  saveConfig,
+} from './providers/providerConfig';
+
+export type {
+  ProviderTier,
+  ProviderFormat,
+  ProviderType,
+  ProviderCost,
+  ProviderDefinition,
+} from './providers/providerConfig';
+
+// ============================================================
+// COST TRACKING
+// ============================================================
+export { CostTracker } from './cost/costTracker';
+
+// ============================================================
+// MEMORY
+// ============================================================
+export { MemoryTree } from './memory/memoryTree';
+export type { MemoryChunk, TreeNode } from './memory/memoryTree';
+
+// ============================================================
+// UTILITIES
+// ============================================================
+export { countTokens, estimateTokens } from './utils/tokenUtils';
+export { MODEL_COSTS } from './utils/tokenUtils';
+
+// ============================================================
+// v2.0.0 FEATURES
+// ============================================================
+export { SemanticCache } from './cache/semanticCache';
+export { GuardrailEngine } from './security/guardrails';
+export { CostAnalytics } from './analytics/costAnalytics';
+export { createProxyServer } from './server/proxyServer';
+
+// ============================================================
+// CONVENIENCE: Create a router instance
+// ============================================================
+import { routeQuery, routeBatch, recommendForTask } from './routing/advancedRouter';
+import { getAvailableProviders, healthCheck } from './providers/providerConfig';
+import { CostTracker } from './cost/costTracker';
+import { MemoryTree } from './memory/memoryTree';
+
+export interface A3MRouterOptions {
+  defaultProvider?: string;
+  enableCache?: boolean;
+  enableGuardrails?: boolean;
+  costLimit?: number;
+}
+
+export function createA3MRouter(options?: A3MRouterOptions) {
+  const costTracker = new CostTracker();
+  const memoryTree = new MemoryTree();
+
+  return {
+    route: routeQuery,
+    routeBatch,
+    recommendForTask,
+    getAvailableProviders,
+    healthCheck,
+    costTracker,
+    memoryTree,
+    options: options || {},
+  };
+}
+
+// Default export
+export default createA3MRouter;