adaptive-memory-multi-model-router 2.14.16 → 2.14.18

package/src/tui/dashboard.ts

@@ -17,6 +17,8 @@ console.log(`
 `);
 
 import * as blessed from 'blessed';
+import * as fs from 'fs';
+import * as path from 'path';
 
 // ── State ──
 let activeModel = 'nvidia/llama-3.1-8b';
@@ -24,6 +26,30 @@ let totalCost = 0.000087;
 let reqCount = 4;
 const log: string[] = [];
 
+// ── Vault (Bookmark Database) ──
+interface Bookmark {
+  id: string;
+  query: string;
+  response: string;
+  model: string;
+  timestamp: number;
+  tags: string[];
+}
+const VAULT_PATH = path.join(process.cwd(), '.a3m-vault.json');
+let vault: Bookmark[] = [];
+
+function loadVault() {
+  try {
+    if (fs.existsSync(VAULT_PATH)) {
+      vault = JSON.parse(fs.readFileSync(VAULT_PATH, 'utf-8'));
+    }
+  } catch { /* ignore */ }
+}
+function saveVault() {
+  fs.writeFileSync(VAULT_PATH, JSON.stringify(vault, null, 2), 'utf-8');
+}
+loadVault();
+
 // ── Screen ──
 const screen = blessed.screen({
   smartCSR: true,
@@ -78,7 +104,7 @@ function render() {
   if (visible.length === 0) {
     out += `  ${D('Type a query — auto-routed to cheapest model.')}\n\n`;
     out += `  ${D('Commands:')}\n`;
-    out += `  {#2563eb-fg}/route{/} ${D('<query>')}       /cost              /model nvidia\n`;
+    out += `  {#2563eb-fg}/route{/} ${D('<query>')}       /vault             /cost\n`;
     out += `  {#2563eb-fg}/health{/}              /models            /clear\n`;
     out += `  {#2563eb-fg}/exit{/}                /help\n\n`;
     out += `  ${D('nvidia (free)  ·  groq (free)  ·  deepseek ($9.46)')}\n`;
@@ -88,13 +114,60 @@ function render() {
   screen.render();
 }
 
+function vaultList() {
+  if (vault.length === 0) {
+    log.push(`  {#be185d-fg}Vault{/}  ${D('empty — no bookmarks yet')}`);
+    return;
+  }
+  log.push(`  {#be185d-fg}Vault{/}  ${D(`${vault.length} bookmarks`)}`);
+  const show = vault.slice(-10).reverse();
+  for (const b of show) {
+    const date = new Date(b.timestamp).toLocaleDateString();
+    const snippet = b.query.length > 40 ? b.query.slice(0, 40) + '…' : b.query;
+    log.push(`  {#2563eb-fg}${b.id}{/}  ${D(snippet)}  {#059669-fg}${b.model}{/}  ${D(date)}`);
+  }
+}
+
+function vaultAdd(query: string, response = '', tags: string[] = []) {
+  const id = `bm${Date.now().toString(36)}`;
+  const bm: Bookmark = { id, query, response, model: activeModel, timestamp: Date.now(), tags };
+  vault.push(bm);
+  saveVault();
+  log.push(`  {#be185d-fg}Vault{/}  ${D(`saved: ${id}`)}`);
+}
+
+function vaultSearch(term: string) {
+  const q = term.toLowerCase();
+  const results = vault.filter(b => b.query.toLowerCase().includes(q) || b.response.toLowerCase().includes(q));
+  if (results.length === 0) {
+    log.push(`  {#be185d-fg}Vault{/}  ${D(`no results for "${term}"`)}`);
+    return;
+  }
+  log.push(`  {#be185d-fg}Vault{/}  ${D(`${results.length} results for "${term}"`)}`);
+  for (const b of results.slice(0, 5)) {
+    const snippet = b.query.length > 50 ? b.query.slice(0, 50) + '…' : b.query;
+    log.push(`  {#2563eb-fg}${b.id}{/}  ${D(snippet)}`);
+  }
+}
+
 function cmd(c: string) {
   if (!c) return;
   log.push(`{bold}{#0891b2-fg}▸{/} ${c}`);
 
   if (c === '/exit' || c === '/q') { screen.destroy(); process.exit(0); }
-  else if (c === '/help') log.push(`  ${D('/route /cost /health /models /model <p> /clear /exit')}`);
+  else if (c === '/help') log.push(`  ${D('/route /vault /cost /health /models /model <p> /clear /exit')}`);
   else if (c === '/clear') log.length = 0;
+  else if (c === '/vault') vaultList();
+  else if (c.startsWith('/vault list')) vaultList();
+  else if (c.startsWith('/vault add ')) {
+    const query = c.replace('/vault add ', '').trim();
+    if (query) vaultAdd(query);
+    else log.push(`  ${D('Usage: /vault add <query>')}`);
+  }
+  else if (c.startsWith('/vault search ')) {
+    const term = c.replace('/vault search ', '').trim();
+    vaultSearch(term);
+  }
   else if (c === '/cost') {
     log.push(`  {#be185d-fg}A3M{/}  Cost:`);
     log.push(`  ${D('nvidia $0  |  deepseek $0.000009  |  groq $0  |  cerebras $0')}`);
@@ -130,4 +203,4 @@ prompt.key('enter', () => { const v = prompt.getValue().trim(); prompt.clearValu
 screen.append(box);
 render();
 prompt.focus();
-screen.render();
+screen.render();

package/src/utils/tokenUtils.ts

@@ -2,12 +2,150 @@
  * Token counting utilities for provider cost estimation
  */
 
-export function countTokens(text: string): number {
-  if (!text) return 0;
-  // Rough estimate: ~4 chars per token for English text
-  return Math.ceil(text.length / 4);
+export interface TokenCost {
+  input_per_1k: number;
+  output_per_1k: number;
 }
 
+// Current provider rates (2024-2025)
+export const MODEL_COSTS: Record<string, TokenCost> = {
+  // OpenAI
+  "gpt-4o": { input_per_1k: 2.50, output_per_1k: 10.00 },
+  "gpt-4o-mini": { input_per_1k: 0.15, output_per_1k: 0.60 },
+  "gpt-4-turbo": { input_per_1k: 10.00, output_per_1k: 30.00 },
+  "gpt-3.5-turbo": { input_per_1k: 0.50, output_per_1k: 1.50 },
+
+  // Anthropic
+  "claude-3.5-sonnet": { input_per_1k: 3.00, output_per_1k: 15.00 },
+  "claude-3-opus": { input_per_1k: 15.00, output_per_1k: 75.00 },
+  "claude-3-haiku": { input_per_1k: 0.25, output_per_1k: 1.25 },
+
+  // Google
+  "gemini-2.0-flash": { input_per_1k: 0.00, output_per_1k: 0.00 },  // Free
+  "gemini-1.5-pro": { input_per_1k: 1.25, output_per_1k: 5.00 },
+  "gemini-1.5-flash": { input_per_1k: 0.075, output_per_1k: 0.30 },
+
+  // Groq
+  "groq/llama-3.3-70b": { input_per_1k: 0.59, output_per_1k: 0.79 },
+  "groq/llama-3.1-8b": { input_per_1k: 0.05, output_per_1k: 0.08 },
+
+  // Cerebras
+  "cerebras/llama-3.3-70b": { input_per_1k: 0.60, output_per_1k: 0.60 },
+
+  // Mistral
+  "mistral-large": { input_per_1k: 2.00, output_per_1k: 6.00 },
+  "mistral-small": { input_per_1k: 0.20, output_per_1k: 0.60 },
+};
+
+/**
+ * Count tokens in text (approximate for English).
+ * Based on ~1.3 tokens per word for typical English text.
+ */
+export function countTokens(text: string, model: string = "gpt-4o"): number {
+  if (!text || text.length === 0) return 0;
+
+  // Use model-specific approximation if available
+  // Otherwise use generic word-based estimate
+  const words = text.trim().split(/\s+/).length;
+
+  // Fine-tune based on model family
+  if (model.includes("claude")) {
+    // Anthropic models: ~1.5 tokens per word
+    return Math.ceil(words * 1.5);
+  } else if (model.includes("gemini")) {
+    // Google: ~1.2 tokens per word (SentencePiece)
+    return Math.ceil(words * 1.2);
+  } else if (model.includes("llama")) {
+    // Llama: ~1.4 tokens per word (BPE)
+    return Math.ceil(words * 1.4);
+  }
+
+  // Default: ~1.3 tokens per word (GPT-4 average)
+  return Math.ceil(words * 1.3);
+}
+
+/**
+ * Alias for countTokens for backward compatibility.
+ */
 export function estimateTokens(text: string): number {
   return countTokens(text);
 }
+
+/**
+ * Estimate cost for a prompt/completion pair.
+ */
+export function estimateCost(
+  prompt_tokens: number,
+  completion_tokens: number,
+  model: string
+): number {
+  const costs = MODEL_COSTS[model] || MODEL_COSTS["gpt-4o"];
+
+  const input_cost = (prompt_tokens / 1000) * costs.input_per_1k;
+  const output_cost = (completion_tokens / 1000) * costs.output_per_1k;
+
+  return input_cost + output_cost;
+}
+
+/**
+ * Estimate cost from raw text (approximates both prompt and completion).
+ */
+export function estimateCostFromText(
+  prompt: string,
+  completion: string,
+  model: string
+): number {
+  const prompt_tokens = countTokens(prompt, model);
+  // Completion typically has higher token density
+  const completion_tokens = Math.ceil(countTokens(completion, model) * 1.2);
+
+  return estimateCost(prompt_tokens, completion_tokens, model);
+}
+
+/**
+ * Get cost info for a model.
+ */
+export function getModelCost(model: string): TokenCost {
+  return MODEL_COSTS[model] || MODEL_COSTS["gpt-4o"];
+}
+
+/**
+ * List all supported models with their costs.
+ */
+export function listModelsByCost(): Array<{ model: string; input: number; output: number }> {
+  return Object.entries(MODEL_COSTS)
+    .map(([model, cost]) => ({
+      model,
+      input: cost.input_per_1k,
+      output: cost.output_per_1k
+    }))
+    .sort((a, b) => (a.input + a.output) - (b.input + b.output));
+}
+
+/**
+ * Find cheapest models for a given task.
+ */
+export function findCheapestModels(task: "fast" | "quality" | "balanced" | "coding", count: number = 3): string[] {
+  const sorted = listModelsByCost();
+
+  // Different profiles for different needs
+  const profiles = {
+    fast: sorted.filter(m => m.output < 1.0).slice(0, count).map(m => m.model),
+    quality: sorted.filter(m => m.output > 10).slice(0, count).map(m => m.model),
+    balanced: sorted.slice(0, count * 2).slice(count, count * 2).map(m => m.model),
+    coding: sorted.filter(m => m.model.includes("codex") || m.model.includes("claude") || m.model.includes("llama")).slice(0, count).map(m => m.model)
+  };
+
+  return profiles[task] || profiles.balanced;
+}
+
+export default {
+  countTokens,
+  estimateTokens,
+  estimateCost,
+  estimateCostFromText,
+  getModelCost,
+  listModelsByCost,
+  findCheapestModels,
+  MODEL_COSTS
+};

package/test-council/1-structure-tests.test.js

@@ -0,0 +1,353 @@
+/**
+ * Structure Tests - Code Structure & Export Coverage
+ * 
+ * Tests that verify all exported functions, classes, and types work correctly.
+ * This file provides comprehensive coverage of the public API surface.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Import all exports from the main module
+const {
+  // Routing engine
+  routeQuery,
+  routeBatch,
+  recommendForTask,
+  extractQueryFeatures,
+  MODEL_PROFILES,
+  updateModelProfile,
+  getProviderHealth,
+  
+  // Retry handling
+  ProviderRetryHandler,
+  createRetryHandler,
+  getDefaultRetryHandler,
+  DEFAULT_RETRY_CONFIG,
+  DEFAULT_PROVIDER_CONFIG,
+  PROVIDER_CONTEXT_LIMITS,
+  
+  // Providers
+  DEFAULT_PROVIDERS,
+  getAvailableProviders,
+  registerProvider,
+  deregisterProvider,
+  updateProvider,
+  healthCheck,
+  checkAllProviders,
+  findCheapestAvailableProvider,
+  findFastestAvailableProvider,
+  loadConfig,
+  saveConfig,
+  
+  // Cost tracking
+  CostTracker,
+  BudgetEnforcer,
+  BudgetExceededError,
+  createBudgetEnforcer,
+  
+  // Memory
+  MemoryTree,
+  
+  // Utilities
+  countTokens,
+  estimateTokens,
+  
+  // Cache
+  SemanticCache,
+  
+  // Security
+  GuardrailEngine,
+  
+  // Analytics
+  CostAnalytics,
+  
+  // Observability
+  Tracer,
+  getTracer,
+  createTracer,
+  MetricsCollector,
+  getMetrics,
+  createMetricsCollector,
+  observabilityMiddleware,
+  observabilityPlugin,
+  budgetAlertMiddleware,
+  
+  // Ensemble
+  HALOOrchestrator,
+  
+  // Factory
+  createA3MRouter,
+} = require('../dist/index.js');
+
+// ============================================================
+// STRUCTURE TESTS
+// ============================================================
+
+describe('1. Structure - Routing Engine Exports', () => {
+  
+  describe('routeQuery', () => {
+    it('is a function', () => {
+      expect(typeof routeQuery).toBe('function');
+    });
+    
+    it('returns object with primary_model', () => {
+      const result = routeQuery('test query');
+      expect(result).toHaveProperty('primary_model');
+    });
+    
+    it('returns object with fallback_models array', () => {
+      const result = routeQuery('test query');
+      expect(result).toHaveProperty('fallback_models');
+      expect(Array.isArray(result.fallback_models)).toBe(true);
+    });
+    
+    it('returns object with estimated_cost number', () => {
+      const result = routeQuery('test query');
+      expect(result).toHaveProperty('estimated_cost');
+      expect(typeof result.estimated_cost).toBe('number');
+    });
+    
+    it('returns object with confidence number', () => {
+      const result = routeQuery('test query');
+      expect(result).toHaveProperty('confidence');
+      expect(typeof result.confidence).toBe('number');
+    });
+  });
+  
+  describe('routeBatch', () => {
+    it('is a function', () => {
+      expect(typeof routeBatch).toBe('function');
+    });
+    
+    it('returns array of same length as input', () => {
+      const queries = ['a', 'b', 'c'];
+      const results = routeBatch(queries);
+      expect(results.length).toBe(queries.length);
+    });
+  });
+  
+  describe('recommendForTask', () => {
+    it('is a function', () => {
+      expect(typeof recommendForTask).toBe('function');
+    });
+    
+    it('returns object with primary field', () => {
+      const result = recommendForTask('coding');
+      expect(result).toHaveProperty('primary');
+    });
+  });
+  
+  describe('extractQueryFeatures', () => {
+    it('is a function', () => {
+      expect(typeof extractQueryFeatures).toBe('function');
+    });
+    
+    it('returns object', () => {
+      const features = extractQueryFeatures('test');
+      expect(typeof features).toBe('object');
+    });
+  });
+  
+  describe('MODEL_PROFILES', () => {
+    it('is an object', () => {
+      expect(typeof MODEL_PROFILES).toBe('object');
+    });
+    
+    it('has at least one model', () => {
+      expect(Object.keys(MODEL_PROFILES).length).toBeGreaterThan(0);
+    });
+  });
+});
+
+describe('2. Structure - Provider Configuration Exports', () => {
+  
+  describe('DEFAULT_PROVIDERS', () => {
+    it('is an object', () => {
+      expect(typeof DEFAULT_PROVIDERS).toBe('object');
+    });
+  });
+  
+  describe('getAvailableProviders', () => {
+    it('is a function', () => {
+      expect(typeof getAvailableProviders).toBe('function');
+    });
+    
+    it('returns an object', () => {
+      const providers = getAvailableProviders();
+      expect(typeof providers).toBe('object');
+    });
+  });
+  
+  describe('registerProvider', () => {
+    it('is a function', () => {
+      expect(typeof registerProvider).toBe('function');
+    });
+  });
+  
+  describe('deregisterProvider', () => {
+    it('is a function', () => {
+      expect(typeof deregisterProvider).toBe('function');
+    });
+  });
+  
+  describe('updateProvider', () => {
+    it('is a function', () => {
+      expect(typeof updateProvider).toBe('function');
+    });
+  });
+  
+  describe('healthCheck', () => {
+    it('is a function', () => {
+      expect(typeof healthCheck).toBe('function');
+    });
+  });
+});
+
+describe('3. Structure - Retry Handler Exports', () => {
+  
+  describe('ProviderRetryHandler', () => {
+    it('is a class', () => {
+      expect(typeof ProviderRetryHandler).toBe('function');
+    });
+    
+    it('can be instantiated', () => {
+      const handler = new ProviderRetryHandler();
+      expect(handler).toBeInstanceOf(ProviderRetryHandler);
+    });
+    
+    it('has getConfig method', () => {
+      const handler = new ProviderRetryHandler();
+      expect(typeof handler.getConfig).toBe('function');
+    });
+    
+    it('has isRetryableError method', () => {
+      const handler = new ProviderRetryHandler();
+      expect(typeof handler.isRetryableError).toBe('function');
+    });
+  });
+  
+  describe('createRetryHandler', () => {
+    it('is a function', () => {
+      expect(typeof createRetryHandler).toBe('function');
+    });
+  });
+  
+  describe('DEFAULT_RETRY_CONFIG', () => {
+    it('is an object', () => {
+      expect(typeof DEFAULT_RETRY_CONFIG).toBe('object');
+    });
+  });
+  
+  describe('PROVIDER_CONTEXT_LIMITS', () => {
+    it('is an object', () => {
+      expect(typeof PROVIDER_CONTEXT_LIMITS).toBe('object');
+    });
+  });
+});
+
+describe('4. Structure - Cost Tracking Exports', () => {
+  
+  describe('CostTracker', () => {
+    it('is a class', () => {
+      expect(typeof CostTracker).toBe('function');
+    });
+    
+    it('can be instantiated', () => {
+      const tracker = new CostTracker();
+      expect(tracker).toBeTruthy();
+    });
+  });
+  
+  describe('BudgetEnforcer', () => {
+    it('is a class', () => {
+      expect(typeof BudgetEnforcer).toBe('function');
+    });
+  });
+  
+  describe('BudgetExceededError', () => {
+    it('is an Error class', () => {
+      expect(typeof BudgetExceededError).toBe('function');
+      const error = new BudgetExceededError('test');
+      expect(error).toBeInstanceOf(Error);
+    });
+  });
+});
+
+describe('5. Structure - Memory Exports', () => {
+  
+  describe('MemoryTree', () => {
+    it('is a class', () => {
+      expect(typeof MemoryTree).toBe('function');
+    });
+    
+    it('can be instantiated', () => {
+      const memory = new MemoryTree({ maxSize: 100 });
+      expect(memory).toBeTruthy();
+    });
+    
+    it('has add method', () => {
+      const memory = new MemoryTree({ maxSize: 100 });
+      expect(typeof memory.add).toBe('function');
+    });
+    
+    it('has search method', () => {
+      const memory = new MemoryTree({ maxSize: 100 });
+      expect(typeof memory.search).toBe('function');
+    });
+    
+    it('has getStats method', () => {
+      const memory = new MemoryTree({ maxSize: 100 });
+      expect(typeof memory.getStats).toBe('function');
+    });
+  });
+});
+
+describe('6. Structure - Utility Exports', () => {
+  
+  describe('countTokens', () => {
+    it('is a function', () => {
+      expect(typeof countTokens).toBe('function');
+    });
+    
+    it('returns positive number for non-empty string', () => {
+      const tokens = countTokens('hello world');
+      expect(typeof tokens).toBe('number');
+      expect(tokens).toBeGreaterThan(0);
+    });
+  });
+  
+  describe('estimateTokens', () => {
+    it('is a function', () => {
+      expect(typeof estimateTokens).toBe('function');
+    });
+  });
+});
+
+describe('7. Structure - Factory Exports', () => {
+  
+  describe('createA3MRouter', () => {
+    it('is a function', () => {
+      expect(typeof createA3MRouter).toBe('function');
+    });
+    
+    it('returns an object', () => {
+      const router = createA3MRouter({});
+      expect(typeof router).toBe('object');
+    });
+    
+    it('returns object with route function', () => {
+      const router = createA3MRouter({});
+      expect(typeof router.route).toBe('function');
+    });
+    
+    it('returns object with costTracker', () => {
+      const router = createA3MRouter({});
+      expect(router.costTracker).toBeTruthy();
+    });
+    
+    it('returns object with memoryTree', () => {
+      const router = createA3MRouter({});
+      expect(router.memoryTree).toBeTruthy();
+    });
+  });
+});