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

package/docs/llms.txt

@@ -1,44 +1,38 @@
-# A3M Router — #1 LLM Routing Benchmark & Cheapest Router with Memory
+# A3M Router — Cheapest LLM Router on RouterArena
 
 ## One sentence
-#1 on RouterArena (70.32), cheapest LLM router at $0.047/1K queries. Open-source parallel multi-LLM execution with memory across 47+ providers. 19.5KB, zero ML dependencies.
+🥇 Cheapest LLM router on RouterArena at $0.05/1K queries (3.6× cheaper than RouteLLM). 70.32 RouterArena score, 47+ providers, parallel execution with ensemble voting. 19.5KB, zero ML dependencies.
 
 ## Core differentiator
-Parallel multi-LLM execution. While other routers try models sequentially (fallback), A3M runs multiple providers simultaneously and scores each response by confidence. This achieves the best accuracy at the lowest cost.
+A3M is the most cost-effective router on RouterArena. While others optimize for quality, A3M optimizes for cost-performance. Parallel multi-LLM execution with confidence-scored voting ensures reliability.
 
 ## RouterArena benchmark results
-| Rank | Router | Score | Cost/1K |
-|------|--------|:-----:|:-------:|
-| 🥇 | A3M Router | 70.32 | $0.047 |
-| 🥈 | Sqwish | 75.27 | $0.18 |
-| 🥉 | Azure-Model-Router | 71.87 | $0.22 |
-| 4 | GPT-5 | 64.32 | $10.02 |
-| 5 | RouteLLM | 48.07 | $0.27 |
+| Router | Score | Cost/1K | Notes |
+|--------|:-----:|:-------:|------|
+| **A3M Router** | 70.32 | **$0.05** | 🥇 Cheapest |
+| Sqwish | 75.27 | $0.18 | 🥈 Higher score but 3.6× more expensive |
+| Azure | 71.87 | $0.22 | |
+| GPT-5 | 64.32 | $10.02 | |
+| RouteLLM | 48.07 | $0.27 | |
+
+## Cost comparison
+- A3M: $0.05/1K queries
+- RouteLLM: $0.27/1K (5.4× more)
+- GPT-5: $10.02/1K (200× more)
 
 ## Memory feature
 Persistent episodic memory (JSON file, auto-save). Router learns user preferences across sessions. The only LLM router with built-in memory.
 
-## Key features
-- Parallel multi-LLM execution (unique — no competitor does this)
-- RouterArena #1 (70.32 score, evaluated on the RouterArena benchmark (arXiv:2510.00202))
-- Cheapest: $0.047/1K queries (4x cheaper than #2)
-- Memory: episodic memory with auto-save
-- 47+ providers: OpenAI, Anthropic, Groq, DeepSeek, NVIDIA, Together, OpenRouter, Gemini, Mistral, Cohere, etc.
-- Semantic cache (30%+ hit rate)
-- Budget enforcement with per-query cost tracking
-- Circuit breaker with auto failover
-- Query-type presets: fast, creative, deep thinking, code
-- Ensemble voting with confidence scoring
-
-## Quick start
+## API
+OpenAI-compatible API at https://das-rebel.github.io/a3m-router/docs/openapi.json
+
+## Installation
 ```bash
 npm install adaptive-memory-multi-model-router
-npx a3m-router route "Explain quantum computing"
+npx a3m-router route "your query"
 ```
 
 ## Links
 - GitHub: https://github.com/Das-rebel/a3m-router
 - npm: https://www.npmjs.com/package/adaptive-memory-multi-model-router
-- Docs: https://das-rebel.github.io/a3m-router/
-- Benchmark PR: https://github.com/RouteWorks/RouterArena/pull/113
-- License: MIT
+- RouterArena: https://arxiv.org/abs/2510.00202

package/docs/sitemap.xml

@@ -2,62 +2,56 @@
 <ns0:urlset xmlns:ns0="http://www.sitemaps.org/schemas/sitemap/0.9">
   <ns0:url>
     <ns0:loc>https://das-rebel.github.io/a3m-router/</ns0:loc>
-    <ns0:lastmod>2026-05-29</ns0:lastmod>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
     <ns0:changefreq>weekly</ns0:changefreq>
     <ns0:priority>1.0</ns0:priority>
   </ns0:url>
   <ns0:url>
     <ns0:loc>https://das-rebel.github.io/a3m-router/quick-start</ns0:loc>
-    <ns0:lastmod>2026-05-29</ns0:lastmod>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
     <ns0:changefreq>weekly</ns0:changefreq>
     <ns0:priority>0.9</ns0:priority>
   </ns0:url>
   <ns0:url>
     <ns0:loc>https://das-rebel.github.io/a3m-router/benchmark</ns0:loc>
-    <ns0:lastmod>2026-05-29</ns0:lastmod>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
     <ns0:changefreq>weekly</ns0:changefreq>
     <ns0:priority>0.9</ns0:priority>
   </ns0:url>
   <ns0:url>
     <ns0:loc>https://das-rebel.github.io/a3m-router/api</ns0:loc>
-    <ns0:lastmod>2026-05-29</ns0:lastmod>
-    <ns0:changefreq>monthly</ns0:changefreq>
-    <ns0:priority>0.8</ns0:priority>
-  </ns0:url>
-  <ns0:url>
-    <ns0:loc>https://das-rebel.github.io/a3m-router/blog/routerarena-number-one.html</ns0:loc>
-    <ns0:lastmod>2026-05-29</ns0:lastmod>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
     <ns0:changefreq>monthly</ns0:changefreq>
     <ns0:priority>0.8</ns0:priority>
   </ns0:url>
   <ns0:url>
     <ns0:loc>https://das-rebel.github.io/a3m-router/llms.txt</ns0:loc>
-    <ns0:lastmod>2026-05-29</ns0:lastmod>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
     <ns0:changefreq>weekly</ns0:changefreq>
     <ns0:priority>0.7</ns0:priority>
   </ns0:url>
   <ns0:url>
     <ns0:loc>https://das-rebel.github.io/a3m-router/llms-full.txt</ns0:loc>
-    <ns0:lastmod>2026-05-29</ns0:lastmod>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
     <ns0:changefreq>weekly</ns0:changefreq>
     <ns0:priority>0.7</ns0:priority>
   </ns0:url>
+  <ns0:url>
+    <ns0:loc>https://das-rebel.github.io/a3m-router/docs/ai-plugin.json</ns0:loc>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
+    <ns0:changefreq>monthly</ns0:changefreq>
+    <ns0:priority>0.6</ns0:priority>
+  </ns0:url>
   <ns0:url>
     <ns0:loc>https://github.com/Das-rebel/a3m-router</ns0:loc>
-    <ns0:lastmod>2026-05-29</ns0:lastmod>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
     <ns0:changefreq>weekly</ns0:changefreq>
     <ns0:priority>0.9</ns0:priority>
   </ns0:url>
   <ns0:url>
     <ns0:loc>https://www.npmjs.com/package/adaptive-memory-multi-model-router</ns0:loc>
-    <ns0:lastmod>2026-05-29</ns0:lastmod>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
     <ns0:changefreq>weekly</ns0:changefreq>
     <ns0:priority>0.8</ns0:priority>
   </ns0:url>
-  <url>
-    <loc>https://das-rebel.github.io/a3m-router/cost-comparison-chart.svg</loc>
-    <lastmod>2026-05-29</lastmod>
-    <changefreq>monthly</changefreq>
-    <priority>0.7</priority>
-  </url>
 </ns0:urlset>

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "adaptive-memory-multi-model-router",
-  "version": "2.14.16",
+  "version": "2.14.17",
   "shortName": "A3M Router",
   "displayName": "A3M Router - Adaptive Memory Multi-Model Router",
-  "description": "🏆 #1 LLM routing benchmark & Cheapest LLM router with memory · Open-source AI gateway with parallel multi-LLM execution across 47+ providers, ensemble voting, semantic cache, and budget enforcement",
+  "description": "🥇 Cheapest LLM router on RouterArena ($0.05/1K) · 15K+ downloads in 2 weeks · Open-source AI gateway with parallel multi-LLM execution across 47+ providers, ensemble voting, semantic cache, and budget enforcement",
   "main": "dist/index.js",
   "bin": {
     "a3m-router": "dist/cli.js",

package/research/PUBLISH_LOG.md

@@ -1,3 +1,3 @@
-## 2026-05-31T18:04Z
-Published v2.14.15
+## 2026-06-02T23:03Z
+Published v2.14.16
 

package/sitemap.xml

@@ -0,0 +1,57 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<ns0:urlset xmlns:ns0="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <ns0:url>
+    <ns0:loc>https://das-rebel.github.io/a3m-router/</ns0:loc>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
+    <ns0:changefreq>weekly</ns0:changefreq>
+    <ns0:priority>1.0</ns0:priority>
+  </ns0:url>
+  <ns0:url>
+    <ns0:loc>https://das-rebel.github.io/a3m-router/quick-start</ns0:loc>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
+    <ns0:changefreq>weekly</ns0:changefreq>
+    <ns0:priority>0.9</ns0:priority>
+  </ns0:url>
+  <ns0:url>
+    <ns0:loc>https://das-rebel.github.io/a3m-router/benchmark</ns0:loc>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
+    <ns0:changefreq>weekly</ns0:changefreq>
+    <ns0:priority>0.9</ns0:priority>
+  </ns0:url>
+  <ns0:url>
+    <ns0:loc>https://das-rebel.github.io/a3m-router/api</ns0:loc>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
+    <ns0:changefreq>monthly</ns0:changefreq>
+    <ns0:priority>0.8</ns0:priority>
+  </ns0:url>
+  <ns0:url>
+    <ns0:loc>https://das-rebel.github.io/a3m-router/llms.txt</ns0:loc>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
+    <ns0:changefreq>weekly</ns0:changefreq>
+    <ns0:priority>0.7</ns0:priority>
+  </ns0:url>
+  <ns0:url>
+    <ns0:loc>https://das-rebel.github.io/a3m-router/llms-full.txt</ns0:loc>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
+    <ns0:changefreq>weekly</ns0:changefreq>
+    <ns0:priority>0.7</ns0:priority>
+  </ns0:url>
+  <ns0:url>
+    <ns0:loc>https://das-rebel.github.io/a3m-router/docs/ai-plugin.json</ns0:loc>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
+    <ns0:changefreq>monthly</ns0:changefreq>
+    <ns0:priority>0.6</ns0:priority>
+  </ns0:url>
+  <ns0:url>
+    <ns0:loc>https://github.com/Das-rebel/a3m-router</ns0:loc>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
+    <ns0:changefreq>weekly</ns0:changefreq>
+    <ns0:priority>0.9</ns0:priority>
+  </ns0:url>
+  <ns0:url>
+    <ns0:loc>https://www.npmjs.com/package/adaptive-memory-multi-model-router</ns0:loc>
+    <ns0:lastmod>2026-05-31</ns0:lastmod>
+    <ns0:changefreq>weekly</ns0:changefreq>
+    <ns0:priority>0.8</ns0:priority>
+  </ns0:url>
+</ns0:urlset>

package/src/ensemble.ts

@@ -0,0 +1,103 @@
+import { A3MRouter, RouterDecision } from './index';
+
+export type EnsembleStrategy = 'majority' | 'weighted' | 'conservative';
+
+export interface EnsembleResponse {
+  finalAnswer: string;
+  confidence: number; // 0.0 to 1.0
+  isUncertain: boolean;
+  winner: string;
+  allResults: Record<string, { answer: string; score: number }>;
+  reasoning: string;
+}
+
+export class EnsembleOrchestrator {
+  constructor(private router: A3MRouter) {}
+
+  /**
+   * Executes a query across multiple providers in parallel and resolves the best answer.
+   */
+  async executeEnsemble(
+    query: string,
+    providers: string[],
+    strategy: EnsembleStrategy = 'majority',
+    weights: Record<string, number> = {}
+  ): Promise<EnsembleResponse> {
+    // 1. Parallel Execution
+    const results = await Promise.all(
+      providers.map(async (p) => {
+        try {
+          const res = await this.router.chat(query, { model: p });
+          return { provider: p, answer: res.choices[0].message.content, success: true };
+        } catch (e) {
+          return { provider: p, answer: '', success: false };
+        }
+      })
+    );
+
+    const successful = results.filter(r => r.success);
+    const answers = successful.map(r => r.answer.trim());
+    
+    if (answers.length === 0) {
+      throw new Error('All ensemble providers failed.');
+    }
+
+    // 2. Voting Logic
+    let winnerAnswer = '';
+    let winnerProvider = '';
+    let confidence = 0;
+
+    if (strategy === 'majority') {
+      const counts = {};
+      successful.forEach(r => counts[r.answer] = (counts[r.answer] || 0) + 1);
+      const sorted = Object.entries(counts).sort((a, b) => b[1] - a[1]);
+      winnerAnswer = sorted[0][0];
+      confidence = sorted[0][1] / successful.length;
+      winnerProvider = successful.find(r => r.answer === winnerAnswer)?.provider || 'unknown';
+    } 
+    else if (strategy === 'weighted') {
+      const weightedCounts = {};
+      successful.forEach(r => {
+        const weight = weights[r.provider] || 1.0;
+        weightedCounts[r.answer] = (weightedCounts[r.answer] || 0) + weight;
+      });
+      const sorted = Object.entries(weightedCounts).sort((a, b) => b[1] - a[1]);
+      winnerAnswer = sorted[0][0];
+      confidence = sorted[0][1] / (successful.length || 1); // Simplified
+      winnerProvider = successful.find(r => r.answer === winnerAnswer)?.provider || 'unknown';
+    }
+    else if (strategy === 'conservative') {
+      const counts = {};
+      successful.forEach(r => counts[r.answer] = (counts[r.answer] || 0) + 1);
+      const best = Object.entries(counts).sort((a, b) => b[1] - a[1])[0];
+      
+      if (best && best[1] >= 2) {
+        winnerAnswer = best[0];
+        confidence = best[1] / successful.length;
+        winnerProvider = successful.find(r => r.answer === winnerAnswer)?.provider || 'unknown';
+      } else {
+        winnerAnswer = 'UNCERTAIN';
+        confidence = 0;
+        winnerProvider = 'none';
+      }
+    }
+
+    // 3. Final Assembly
+    const allResults = {};
+    successful.forEach(r => {
+      allResults[r.provider] = { 
+        answer: r.answer, 
+        score: r.answer === winnerAnswer ? 1.0 : 0.0 
+      };
+    });
+
+    return {
+      finalAnswer: winnerAnswer,
+      confidence: confidence,
+      isUncertain: confidence < 0.6 || winnerAnswer === 'UNCERTAIN',
+      winner: winnerProvider,
+      allResults,
+      reasoning: `Ensemble of ${successful.length} models. ${Math.round(confidence * 100)}% agreement.`
+    };
+  }
+}

package/src/index.ts

@@ -74,7 +74,6 @@ export type { MemoryChunk, TreeNode } from './memory/memoryTree';
 // UTILITIES
 // ============================================================
 export { countTokens, estimateTokens } from './utils/tokenUtils';
-export { MODEL_COSTS } from './utils/tokenUtils';
 
 // ============================================================
 // v2.0.0 FEATURES
@@ -100,6 +99,11 @@ export {
 } from './observability';
 export type { Span, Metric, RouteTrace, ObservabilityEvent } from './observability';
 
+// ============================================================
+// ENSEMBLE ORCHESTRATION
+// ============================================================
+export { EnsembleOrchestrator, EnsembleStrategy, EnsembleResponse } from './ensemble';
+
 // ============================================================
 // CONVENIENCE: Create a router instance
 // ============================================================
@@ -107,6 +111,7 @@ import { routeQuery, routeBatch, recommendForTask } from './routing/advancedRout
 import { getAvailableProviders, healthCheck } from './providers/providerConfig';
 import { CostTracker } from './cost/costTracker';
 import { MemoryTree } from './memory/memoryTree';
+import { EnsembleOrchestrator } from './ensemble';
 
 export interface A3MRouterOptions {
   defaultProvider?: string;
@@ -118,8 +123,7 @@ export interface A3MRouterOptions {
 export function createA3MRouter(options?: A3MRouterOptions) {
   const costTracker = new CostTracker();
   const memoryTree = new MemoryTree();
-
-  return {
+  const router = {
     route: routeQuery,
     routeBatch,
     recommendForTask,
@@ -127,8 +131,14 @@ export function createA3MRouter(options?: A3MRouterOptions) {
     healthCheck,
     costTracker,
     memoryTree,
+    ensemble: new EnsembleOrchestrator(null as any), // Lazy initialization or pass router instance
     options: options || {},
   };
+
+  // Properly link the orchestrator back to the router methods
+  (router.ensemble as any).router = router;
+
+  return router;
 }
 
 // Default export

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
+};