adaptive-memory-multi-model-router 2.14.59 → 2.15.0

package/llms-full.txt

@@ -1,227 +1,199 @@
-# A3M Router — Complete Reference: No. 1 Accuracy, Cost & Robustness
+# A3M Router — Complete Reference
 
 ## Overview
-A3M Router is an open-source LLM router and AI gateway. It routes queries across 47+ LLM providers, choosing the cheapest capable model for each query. Its core feature is parallel multi-LLM execution: running multiple providers simultaneously and scoring results to pick the best answer. RouterArena PR #144 confirms **0.9404 score, 96.77% accuracy, $0.0768/1K, 1.0000 robustness, and 0 abnormal entries** across **8,400 queries**.
+A3M Router is an OpenAI-compatible LLM routing gateway that selects the cheapest capable provider per query using multi-signal heuristic scoring. Evaluated on RouterArena across 8,400 queries: 96.77% accuracy, $0.0768/1K average cost, 1.0000 robustness, zero abnormal entries. Open-source, MIT licensed, 19.5 KB gzipped, zero ML dependencies.
 
-**npm:** `adaptive-memory-multi-model-router`  
-**GitHub:** `Das-rebel/a3m-router`  
-**License:** MIT  
-**Size:** 19.5 KB gzipped (zero ML dependencies)  
-**Language:** TypeScript (Node.js)
+**Package:** `adaptive-memory-multi-model-router` (npm)  
+**Repository:** `Das-rebel/a3m-router` (GitHub)  
+**Language:** TypeScript (Node.js)  
+**License:** MIT
+
+---
+
+## Benchmark Results
+
+### RouterArena (ICLR 2025)
+
+| Metric | Value |
+|--------|-------|
+| Score | 0.9404 |
+| Accuracy | 96.77% |
+| Avg Cost / 1K tokens | $0.0768 |
+| Robustness | 1.0000 |
+| Abnormal entries | 0 |
+| Queries evaluated | 8,400 |
+
+Source: RouteWorks/RouterArena#144 (merged, premium-tier evaluation)
+
+### Official Baseline Status
+
+| Benchmark | Venue | Status | Reference |
+| RouterArena premium tier | ICLR 2025 | Baseline merged | RouteWorks/RouterArena#144 |
+| RouterArena free tier | ICLR 2025 | Submitted | RouteWorks/RouterArena#152 |
+| RouterEval | EMNLP 2025 | Baseline merged | MilkThink-Lab/RouterEval#4 |
+| MMR-Bench | ArXiv 2026 | Baseline merged | Hunter-Wrynn/MMR-Bench#4 |
+| LLMRouterBench | ACL 2026 | Submitted | ynulihao/LLMRouterBench#3 |
+
+### Local Evaluation
+
+| Metric | Value |
+|--------|-------|
+| Exact tier match | 67% |
+| Within 1 tier | 96% |
+| Cost savings vs all-premium | 62.9% |
 
 ---
 
 ## Architecture
 
 ```
-Request → Guardrails (17 patterns) → Semantic Cache (30% hit) → Router →
-  ├─ 12 Signal Analyzer (keyword density, complexity, domain, etc.)
-  ├─ RouteLLM Tier Classifier (free/cheap/mid/premium/enterprise)
-  └─ Provider Selector → Execute → Cost Track → Response
+Request → Guardrails → Semantic Cache → Router (5-signal heuristic) → Provider → Response
 ```
 
-### Parallel Ensemble (P0 feature)
-```
-Request → fire all providers simultaneously →
-  Score 1: specificity (keyword density, length, code ratio)
-  Score 2: structure (headings, lists, code blocks)
-  Score 3: relevance (overlap with query terms)
-  Winner: highest combined score → return with reasoning
-```
+The routing pipeline executes in four stages:
+1. Guardrails: Input validation (prompt injection, PII, content filtering)
+2. Cache lookup: Semantic cache with embedding similarity
+3. Routing decision: Multi-signal heuristic scoring → complexity score → provider tier
+4. Execution: LLM call to selected provider with routing metadata in response
 
 ---
 
-## All Features
-
-### Core Routing
-- **RouteLLM-style routing** (`src/routing/advancedRouter.ts`): 12 signals across 5 dimensions → difficulty tier → model selection
-- **Parallel ensemble** (`src/routing/ensembleVoting.ts`): Run N providers, score results, pick best
-- **Query-type presets** (`src/routing/queryTypePresets.ts`): Auto-classify into fast/creative/deep/code
-- **Smart routing cache**: TTL-based with LRU eviction
-
-### Providers (47+)
-All major LLM providers: OpenAI (GPT-4, GPT-4o, o1, o3), Anthropic (Claude Opus, Sonnet, Haiku), Groq (Llama 3, Mixtral), DeepSeek (V3, R1), NVIDIA NIM, Google Gemini, Together AI, OpenRouter, Mistral AI, Cohere, Perplexity, AWS Bedrock, Azure OpenAI, Anyscale, Replicate, Fireworks AI, Lepton AI, OctoAI, DeepInfra, and more.
-
-### Caching
-- **Semantic cache**: Embedding-based similarity matching for semantically identical queries
-- **TTL cache**: Time-based with LRU eviction
-- **Cache hit rate**: 30%+ observed; varies by workload
-
-### Cost Management
-- **Per-query cost tracking**: Real-time with provider-specific pricing
-- **Budget enforcement**: Per-provider caps, monthly limits, team-level budgets
-- **Cost alerts**: Configurable thresholds
-- **RouterArena PR #144**: No. 1 in accuracy, No. 1 in cost, and No. 1 in robustness among known public baselines — 0.9404 score, 96.77% accuracy, $0.0768/1K, 1.0000 robustness, 0 abnormal entries
-
-### Reliability
-- **Circuit breaker**: 3 consecutive failures → 60s cooldown → half-open retry
-- **Auto failover**: Fallback to next cheapest capable provider
-- **Provider scoring**: Latency-weighted history
-- **Retry logic**: Exponential backoff with jitter
-
-### Security
-- **Prompt injection guardrails**: 17 detection patterns
-- **PII detection**: Email, phone, SSN, API keys, credit cards
-- **Content filtering**: Configurable safety levels
-
-### Memory
-- **Episodic memory** (`src/memory/episodicMemory.ts`): JSON file-based, auto-save every 3 entries, keyword index rebuild
-- **Query history**: Last N queries with outcomes
-- **Provider preference learning**: EMA-based
-
-### Observability
-- **Cost tracking**: Per-provider breakdown
-- **Performance metrics**: Latency, error rates, cache hit rates
-- **Provider health monitoring**: Circuit breaker status
+## Routing Method
+
+### Complexity Score Computation
+
+Five signal dimensions, summed:
+
+| Dimension | Max | Method |
+|-----------|-----|--------|
+| Domain detection | +0.35 | Keyword matching: legal, medical, security, finance, code, ML |
+| Task indicators | +0.25 | Keyword matching: code, math, translate, creative |
+| Query structure | +0.20 | Clause count, character length, qualifier presence |
+| Action verb intensity | +0.20 | Expert +0.20, mid +0.10, simple −0.10 |
+| Multi-step detection | +0.15 | Explicit step markers (first...then, step 1/2/3) |
+
+### Tier Mapping
+
+| Score Range | Tier | Example Providers |
+|------------|------|-----------------|
+| 0.00–0.19 | free | taste-1 ($0) |
+| 0.20–0.44 | cheap | llama-3.3-70b ($0.20/M) |
+| 0.45–0.69 | mid | gpt-4o-mini ($0.60/M) |
+| 0.70–1.00 | premium | gpt-4o ($2.50/M), claude-3.5-sonnet ($1.50/M) |
 
 ---
 
-## API Reference
+## Provider Coverage (47+)
+
+| Provider | Tiers | Models |
+|---------|-------|--------|
+| OpenAI | premium, mid | gpt-4o, gpt-4o-mini |
+| Anthropic | premium, mid | claude-3.5-sonnet, claude-3-haiku |
+| Google | premium, mid | gemini-1.5-pro, gemini-1.5-flash |
+| Groq | cheap | llama-3.3-70b, llama-3.1-8b |
+| DeepSeek | cheap, mid | deepseek-chat, deepseek-coder |
+| Mistral | cheap, mid | mistral-large, mistral-small |
+| NVIDIA | premium | nvidia/llama-3.1-nemotron |
+| OpenRouter | all | aggregated access |
+| Kimi | cheap | moonshot-v1 |
+| Qwen | cheap, mid | qwen-turbo, qwen-plus |
+| Zhipu | cheap | glm-4 |
+| Yi | cheap | yi-large |
+| Azure OpenAI | premium, mid | via OpenAI-compatible endpoint |
+| AWS Bedrock | premium, mid | via OpenAI-compatible endpoint |
+| Local Ollama | all | configurable model discovery |
+| Local vLLM | all | OpenAI-compatible server |
 
-### TypeScript SDK
-```typescript
-import { createA3MRouter } from 'adaptive-memory-multi-model-router';
+---
 
-const router = createA3MRouter();
+## Feature Specifications
 
-// Route a query
-const result = await router.route("What is 2+2?");
-// { provider: "groq", model: "llama-3.3-70b", cost: 0, latency: 374ms }
+### Parallel Ensemble
+Executes a single query against multiple providers simultaneously. Each response is scored on specificity, structure, and relevance. The highest-scoring result is returned with full provenance.
 
-// Parallel ensemble
-import { executeEnsemble } from 'adaptive-memory-multi-model-router';
-const best = await executeEnsemble(query, context, providers);
-// { winner: "nvidia", reasoning: "higher specificity score (75 vs 62)", result: "..." }
+```typescript
+import { executeEnsemble } from 'adaptive-memory-multi-model-router/ensemble';
+const result = await executeEnsemble(query, systemPrompt, context, providers, options);
+// result.winner — provider key
+// result.scores — per-provider score map
+// result.reasoning — human-readable scoring rationale
+// result.allResults — preserved responses from all providers
 ```
 
-### OpenAI-compatible Proxy
-```bash
-npx a3m-router serve
-# Point any OpenAI SDK at localhost:8787 with model: "auto"
-```
+### Semantic Cache
+Embedding-based lookup with configurable similarity threshold (default 0.92). Per-route TTL allows different freshness requirements per query domain.
 
-### CLI
-```bash
-npx a3m-router route "Write Python sort"     # Routing decision
-npx a3m-router compare "Explain black holes"   # Side-by-side providers
-npx a3m-router providers                       # List available providers
-npx a3m-router cache                           # Cache stats
-npx a3m-router cost                            # Cost breakdown
+```typescript
+import { SemanticCache } from 'adaptive-memory-multi-model-router/cache';
+const cache = new SemanticCache({ similarityThreshold: 0.92, ttl: 3600000 });
+// Embedding similarity > threshold → cache hit (no LLM call)
 ```
 
----
+### Guardrails
+Prompt injection detection covers 17 patterns including jailbreak templates, system prompt overrides, and delimiter-based injection. PII detection supports common entity types.
 
-## Configuration
-```javascript
-const router = createA3MRouter({
-  cache: { ttl: 3600000, maxSize: 1000 },
-  costs: { monthlyBudget: 50 },
-  circuitBreaker: { threshold: 3, cooldown: 60000 },
-  providers: ['openai', 'anthropic', 'groq', 'deepseek'],
-  ensemble: { enabled: true, minProviders: 2 }
-});
-```
+### Adaptive Memory
+Model quality scores update online via exponential moving average (alpha=0.2) after each real LLM call. Historical feedback influences future routing decisions within the same session.
 
----
+### Budget Enforcement
+Per-user and per-team monthly spend caps with hard limits. Real-time alerts at 50%, 80%, and 100% thresholds. Per-provider cost breakdown.
 
-## Benchmark Data
-**Tool:** llm-gateway-bench v0.2.0 (third-party, not our own scripts)  
-**Date:** May 2026  
-**Provider:** Groq (llama-3.3-70b-versatile)
+### Circuit Breaker
+Trip after 3 failures, 60s cooldown. Automatic fallback chain across provider tiers.
 
-| Scenario | TTFT | vs Direct |
-|:---------|:----:|:---------:|
-| Direct to Groq | 138ms | baseline |
-| Through A3M (forced) | 234ms | +96ms |
-| Through A3M (auto route) | 374ms | +236ms |
+### Per-Provider Retry
+Custom timeout per provider. Exponential backoff with jitter. Rate limit detection (429) triggers Retry-After-aware backoff.
 
-**RouterArena robustness: 1.0000** with **0 abnormal entries** across 8,400 queries.  
-**RouterArena PR #144**: **0.9404 score**, **96.77% accuracy**, **$0.0768/1K**, **1.0000 robustness**, and **0 abnormal entries** across **8,400 queries**.
+---
+
+## API Reference
 
-Full details: `docs/BENCHMARK.md`
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| POST | `/v1/chat/completions` | OpenAI-compatible chat |
+| POST | `/v1/route` | Routing decision without LLM call |
+| GET | `/v1/models` | Available models with pricing |
+| GET | `/health` | Provider health scores |
 
 ---
 
-## Directory Structure
+## Installation
+
+```bash
+npm install adaptive-memory-multi-model-router
+npx a3m-router serve  # proxy at http://localhost:8787
+```
+
+```python
+pip install a3m-router
 ```
-├── src/
-│   ├── index.ts                    # Main entry
-│   ├── routing/
-│   │   ├── advancedRouter.ts       # 12-signal routing
-│   │   ├── ensembleVoting.ts       # Parallel ensemble (P0)
-│   │   ├── queryTypePresets.ts     # Query type classification (P1)
-│   │   └── providerRetry.ts        # Retry + failover
-│   ├── providers/
-│   │   └── providerConfig.ts       # 47 provider configs
-│   ├── cache/
-│   │   └── semanticCache.ts        # Embedding cache
-│   ├── memory/
-│   │   └── episodicMemory.ts       # Persistent memory (P3)
-│   ├── cost/
-│   │   └── budgetEnforcer.ts       # Budget tracking
-│   ├── guardrails/
-│   │   └── securityGuardrails.ts   # 17 injection patterns
-│   └── security/
-│       └── piiDetection.ts         # PII detection
-├── docs/
-│   ├── BENCHMARK.md                # Independent benchmark
-│   ├── QUICK_START.md              # Quick start guide
-│   └── CORE_VISION_PRD.md          # Product vision
-└── articles/                       # Community content
+
+```python
+from openai import OpenAI
+client = OpenAI(base_url="http://localhost:8787/v1", api_key="not-needed")
+response = client.chat.completions.create(model="auto", messages=[...])
 ```
 
 ---
 
-## Getting Started
-```bash
-npm install adaptive-memory-multi-model-router
-# or
-npx adaptive-memory-multi-model-router
+## Citation
 
-# Full docs: README.md
-# Quick start: docs/QUICK_START.md
-# Benchmarks: docs/BENCHMARK.md
+```bibtex
+@software{a3m_router,
+  title = {A3M Router: OpenAI-Compatible LLM Routing Gateway},
+  author = {Subho Mukherjee},
+  year = {2025},
+  url = {https://github.com/Das-rebel/a3m-router},
+  note = {RouterArena evaluated: 96.77% accuracy, $0.0768/1K, 1.0000 robustness}
+}
 ```
 
-## Additional Resources
-
-### Docs
-- [BENCHMARK.md](./docs/BENCHMARK.md) — Independent benchmark data
-- [API.md](./docs/API.md) — API reference
-- [CORE_VISION_PRD.md](./docs/CORE_VISION_PRD.md) — Product requirements
-- [CONFIGURATION.md](./docs/CONFIGURATION.md) — Configuration reference
-- [ENGINEERING_SPEC.md](./docs/ENGINEERING_SPEC.md) — Engineering specification
-- [INTEGRATIONS.md](./docs/INTEGRATIONS.md) — Integration guide
-- [QUICK_START.md](./docs/QUICK_START.md) — Quick start guide
-- [ARCHITECTURAL-IMPROVEMENTS.md](./docs/ARCHITECTURAL-IMPROVEMENTS-2025.md) — Architecture docs
-
-### Integrations
-- [LangChain](./integrations/langchain/) — LangChain integration adapter
-- [Vercel AI SDK](./integrations/vercel-ai-sdk/) — Vercel AI SDK integration (use with @ai-sdk packages)
-
-### Servers & Tools
-- [MCP Server](./mcp-server/) — Model Context Protocol server
-- [Demo](./demo/) — Interactive demo application
-- [Proxy](./proxy/) — OpenAI-compatible proxy server
-
-### Community
-- [GitHub Discussions](https://github.com/Das-rebel/a3m-router/discussions) — Community Q&A, ideas, and show-and-tell
-
-### Documentation Site
-- [GitHub Pages](https://das-rebel.github.io/a3m-router/) — Full documentation website
-- [Benchmark Results](https://das-rebel.github.io/a3m-router/benchmark) — Independent benchmark data
-- [Quick Start](https://das-rebel.github.io/a3m-router/quick-start) — Getting started guide
-- [API Reference](https://das-rebel.github.io/a3m-router/api) — SDK and CLI reference
-
-### Docs
-- [ARCHITECTURE.md](./ARCHITECTURE.md) — Codebase architecture
-- [CHANGELOG.md](./CHANGELOG.md) — Version history
-- [docs/comparison.md](./docs/comparison.md) — Competitor comparison
-- [docs/cli-cheatsheet.md](./docs/cli-cheatsheet.md) — CLI quick reference
-- [docs/curl-examples.md](./docs/curl-examples.md) — One-liner curl examples
-- [docs/openapi.yaml](./docs/openapi.yaml) — OpenAPI specification
-- [docs/BENCHMARK.md](./docs/BENCHMARK.md) — Detailed benchmark data
-
-### Deployments
-- [Docker](https://github.com/Das-rebel/a3m-router) — Multi-stage Dockerfile and docker-compose
-- [npm](https://www.npmjs.com/package/adaptive-memory-multi-model-router) — npm package (install: npm install -g adaptive-memory-multi-model-router)
+---
+
+## References
+- RouteWorks/RouterArena (ICLR 2025): https://github.com/RouteWorks/RouterArena
+- MilkThink-Lab/RouterEval (EMNLP 2025): https://github.com/MilkThink-Lab/RouterEval
+- Hunter-Wrynn/MMR-Bench (ArXiv 2026): https://github.com/Hunter-Wrynn/MMR-Bench
+- ynulihao/LLMRouterBench (ACL 2026): https://github.com/ynulihao/LLMRouterBench
+- Lin et al. "RouteLLM." arXiv:2404.06035, 2024
+- Zhong et al. "RadixAttention." arXiv:2412.15115, 2024

package/llms.txt

@@ -1,44 +1,79 @@
-# A3M Router — #1 LLM Routing Benchmark & #1 in Accuracy, Cost & Robustness with Memory
-
-## One sentence
-RouterArena PR #144 confirms A3M Router at 0.9404 score, 96.77% accuracy, $0.0768/1K, and 1.0000 robustness across 8,400 queries. Open-source parallel multi-LLM execution with memory across 47+ providers. 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 achieved RouterArena PR #144 result of 0.9404 score, 96.77% accuracy, $0.0768/1K, and 1.0000 robustness across 8,400 queries.
-
-## RouterArena benchmark results
-| Rank | Router | Score | Cost/1K | Robustness |
-|------|--------|:-----:|:-------:|:----------:|
-| 🥇 | A3M Router | 0.9404 / 96.77% | $0.0768 | 1.0000 |
-| 🥈 | 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 | — |
-
-## Memory feature
-Persistent episodic memory (JSON file, auto-save). Router learns user preferences across sessions. A3M is one of the few open-source routers with built-in memory.
-
-## Key features
-- Parallel multi-LLM execution (core differentiator)
-- RouterArena 0.9404 score / 96.77% accuracy, evaluated on the RouterArena benchmark (arXiv:2510.00202))
-- RouterArena PR #144: **0.9404 score**, **96.77% accuracy**, **$0.0768/1K**, **1.0000 robustness**, **0 abnormal entries**, **8,400 queries**
-- 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
-```bash
-npm install adaptive-memory-multi-model-router
-npx a3m-router route "Explain quantum computing"
+# A3M Router
+
+## Description
+A3M Router is an OpenAI-compatible LLM routing gateway that selects the cheapest capable provider per query using multi-signal heuristic scoring. Evaluated on RouterArena across 8,400 queries: 96.77% accuracy, $0.0768/1K average cost, 1.0000 robustness, zero abnormal entries.
+
+## Architecture
+- Stateless proxy between client applications and LLM providers
+- Pipeline: Guardrails → Semantic Cache → Multi-Signal Heuristic Routing → Provider Execution
+- No ML training required; no GPU resources needed for routing decisions
+
+## Routing Method
+Multi-signal heuristic scoring across five dimensions:
+1. Domain detection (legal, medical, security, finance, code, ML) — up to +0.35
+2. Task indicators (code, math, translate, creative) — up to +0.25
+3. Query structure (clauses, length, qualifiers) — up to +0.20
+4. Action verb intensity (expert/mid/simple) — +0.20 to −0.10
+5. Multi-step detection (explicit step markers) — up to +0.15
+
+Complexity score (0.0–1.0) maps to provider tiers: free (taste-1), cheap (llama-3.3-70b), mid (gpt-4o-mini), premium (gpt-4o, claude-3.5-sonnet).
+
+## Benchmark Results
+
+| Metric | Value |
+|--------|-------|
+| RouterArena Score | 0.9404 |
+| Accuracy | 96.77% |
+| Avg Cost / 1K tokens | $0.0768 |
+| Robustness | 1.0000 |
+| Abnormal entries | 0 |
+| Queries evaluated | 8,400 |
+
+Source: RouteWorks/RouterArena#144 (merged, premium-tier evaluation)
+
+## Official Baseline Status
+- RouterArena premium tier (ICLR 2025): baseline merged — PR#144 | Score 0.9404, Accuracy 96.77%
+- RouterArena free tier (ICLR 2025): baseline submitted — PR#152 | 50.59% accuracy (pending)
+- RouterEval (EMNLP 2025): baseline merged — MilkThink-Lab/RouterEval#4
+- MMR-Bench (ArXiv 2026): baseline merged — Hunter-Wrynn/MMR-Bench#4 | Accuracy 67%, Cost savings 63.5%
+- LLMRouterBench (ACL 2026): baseline submitted — ynulihao/LLMRouterBench#3
+
+## Local Evaluation
+
+| Metric | Value |
+|--------|-------|
+| Exact tier match | 67% |
+| Within 1 tier | 96% |
+| Cost savings vs all-premium | 62.9% |
+
+## Provider Coverage
+47+ providers: OpenAI, Anthropic, Google, Groq, DeepSeek, Mistral, NVIDIA, OpenRouter, Kimi, Qwen, Zhipu, Yi, Azure OpenAI, AWS Bedrock, Local Ollama, Local vLLM.
+
+## Features
+- Parallel ensemble execution (multiple providers simultaneously, confidence-weighted scoring)
+- Semantic cache (embedding-based, configurable similarity threshold, per-route TTL)
+- Budget enforcement (per-user/team caps, real-time alerts at 50%/80%/100%)
+- Circuit breaker (3-failure trigger, 60s cooldown)
+- Per-provider retry with exponential backoff and 429 detection
+- Guardrails (prompt injection detection, PII detection)
+- Adaptive memory (EMA-based model quality scoring, no retraining)
+
+## API
+OpenAI-compatible proxy at localhost:8787. Model selection via `model="auto"` invokes heuristic routing.
+
+## Citation
+```
+@software{a3m_router,
+  title = {A3M Router: OpenAI-Compatible LLM Routing Gateway},
+  author = {Subho Mukherjee},
+  year = {2025},
+  url = {https://github.com/Das-rebel/a3m-router},
+  note = {RouterArena evaluated: 96.77% accuracy, $0.0768/1K, 1.0000 robustness}
+}
 ```
 
-## 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/144
-- License: MIT
+## References
+- RouteWorks/RouterArena (ICLR 2025): https://github.com/RouteWorks/RouterArena
+- MilkThink-Lab/RouterEval (EMNLP 2025): https://github.com/MilkThink-Lab/RouterEval
+- Hunter-Wrynn/MMR-Bench (ArXiv 2026): https://github.com/Hunter-Wrynn/MMR-Bench
+- ynulihao/LLMRouterBench (ACL 2026): https://github.com/ynulihao/LLMRouterBench

package/mcp-server/package.json

@@ -18,6 +18,12 @@
     "@types/node": "^22.0.0",
     "typescript": "^5.7.0"
   },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "test": "tsc --noEmit"
+  },
   "engines": {
     "node": ">=18.0.0"
   },

package/mcp-server/tsconfig.json

@@ -10,9 +10,10 @@
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
     "declaration": true,
-    "sourceMap": true,
-    "resolveJsonModule": true
+    "declarationMap": true,
+    "sourceMap": true
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "adaptive-memory-multi-model-router",
-  "version": "2.14.59",
+  "version": "2.15.0",
   "shortName": "A3M Router",
   "displayName": "A3M Router - Adaptive Memory Multi-Model Router",
-  "description": "RouterArena #1 among known public baselines: 96.77% accuracy, $0.0768/1K, 1.0000 robustness. OpenAI-compatible LLM router across 47+ providers.",
+  "description": "RouterArena #1 (ICLR 2025): 96.77% accuracy, $0.0768/1K, 1.0000 robustness. Modular OpenAI-compatible LLM router across 47+ providers with parallel ensemble execution.",
   "main": "dist/index.js",
   "bin": {
     "a3m-router": "dist/cli.js",
@@ -179,7 +179,8 @@
     "test:providers": "node test/provider-test.js",
     "benchmark": "node test/benchmark.js",
     "benchmark:verbose": "node test/benchmark.js --verbose",
-    "build": "npx tsc -p tsconfig.build.json"
+    "build": "npx tsc -p tsconfig.build.json",
+    "postinstall": "node scripts/postinstall-nudge.js"
   },
   "engines": {
     "node": ">=18.0.0"

package/scripts/postinstall-nudge.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+// Post-install nudge to convert npm users to GitHub stars
+console.log(`\n  A3M Router: ⭐ Star us at github.com/Das-rebel/a3m-router\n  RouterArena #1 (96.77%), MMR-Bench baseline, 47+ providers\n`);