adaptive-memory-multi-model-router 2.14.49 → 2.14.51

package/benchmark-provider-results.json

@@ -0,0 +1,245 @@
+{
+  "meta": {
+    "date": "2026-05-26T20:20:48.824Z",
+    "questions": 10
+  },
+  "results": {
+    "groq-llama-3.3-70b": {
+      "name": "Groq Llama 3.3 70B",
+      "successRate": 1,
+      "avgLatency": 325,
+      "avgOutputLen": 277,
+      "inputCostPer1M": 0,
+      "questions": [
+        {
+          "id": 1,
+          "success": true,
+          "latency": 262,
+          "content": "2 + 2 = 4.",
+          "status": 200
+        },
+        {
+          "id": 2,
+          "success": true,
+          "latency": 414,
+          "content": "**Checking Primality in Python**\n================================\n\nBelow is an example of a Python function that checks whether a given number is prime.\n\n```python\ndef is_prime(n: int) -> bool:\n    \"\"\"\n    Checks if a number is prime.\n\n    Args:\n        n (int): The number to check.\n\n    Returns:\n        bool: True if the number is prime, False otherwise.\n    \"\"\"\n    if n <= 1:\n        return False\n    if n == 2:\n        return",
+          "status": 200
+        },
+        {
+          "id": 3,
+          "success": true,
+          "latency": 233,
+          "content": "An Application Programming Interface (API) is a set of defined rules and protocols that allows different software systems, applications, or services to communicate and exchange data with each other in a standardized and secure manner.",
+          "status": 200
+        },
+        {
+          "id": 4,
+          "success": true,
+          "latency": 430,
+          "content": "Climate change is a complex and multifaceted phenomenon, and there are several factors that contribute to it. The main causes of climate change can be divided into two categories: natural and human-induced.\n\n**Natural Causes:**\n\n1. **Volcanic Eruptions**: Volcanic eruptions can release large amounts of ash, sulfur dioxide, and other gases into the atmosphere, which can reflect sunlight and cool the planet.\n2. **Changes in Earth's Orbit**: Changes in Earth's orbit around the",
+          "status": 200
+        },
+        {
+          "id": 5,
+          "success": true,
+          "latency": 176,
+          "content": "Code flows like a stream\nLogic dancing on the screen\nBeauty in the bug",
+          "status": 200
+        },
+        {
+          "id": 6,
+          "success": true,
+          "latency": 541,
+          "content": "**Improving AI Models with Data**\n\nArtificial Intelligence (AI) models are only as good as the data they're trained on. The quality, quantity, and diversity of data have a direct impact on the performance and accuracy of AI models. Here's why data is crucial for improving AI models:\n\n* **Training and Validation**: AI models learn from data by identifying patterns, relationships, and trends. The more data available, the better the model can learn and generalize to new, unseen situations.\n*",
+          "status": 200
+        },
+        {
+          "id": 7,
+          "success": true,
+          "latency": 144,
+          "content": "1. Java\n2. Python\n3. C++",
+          "status": 200
+        },
+        {
+          "id": 8,
+          "success": true,
+          "latency": 482,
+          "content": "**Machine Learning Overview**\n===============\n\nMachine learning (ML) is a subset of artificial intelligence (AI) that involves the use of algorithms and statistical models to enable machines to perform tasks without being explicitly programmed. It allows systems to learn from data, identify patterns, and make decisions or predictions based on that data.\n\n**Key Characteristics**\n--------------------\n\n1.  **Data-Driven**: Machine learning relies on large amounts of data to learn and improve its performance.\n2.  **Algorithm-Based**: ML uses",
+          "status": 200
+        },
+        {
+          "id": 9,
+          "success": true,
+          "latency": 417,
+          "content": "**Reversing a String in Python**\n=====================================\n\nYou can reverse a string in Python using slicing. Here is a simple function that accomplishes this:\n\n```python\ndef reverse_string(input_str):\n    \"\"\"\n    Reverses the input string.\n\n    Args:\n        input_str (str): The string to be reversed.\n\n    Returns:\n        str: The reversed string.\n    \"\"\"\n    return input_str[::-1]\n\n# Example usage:\nif __name__ == \"__main__\":\n    input_str",
+          "status": 200
+        },
+        {
+          "id": 10,
+          "success": true,
+          "latency": 154,
+          "content": "The capital of Japan is Tokyo.",
+          "status": 200
+        }
+      ]
+    },
+    "groq-llama-3.1-8b": {
+      "name": "Groq Llama 3.1 8B",
+      "successRate": 1,
+      "avgLatency": 286,
+      "avgOutputLen": 280,
+      "inputCostPer1M": 0,
+      "questions": [
+        {
+          "id": 1,
+          "success": true,
+          "latency": 364,
+          "content": "2 + 2 = 4.",
+          "status": 200
+        },
+        {
+          "id": 2,
+          "success": true,
+          "latency": 319,
+          "content": "**Prime Number Checker Function**\n=====================================\n\nHere's a Python function to check if a given number is prime or not.\n\n```python\ndef is_prime(n):\n    \"\"\"\n    Checks if a number is prime.\n\n    Args:\n        n (int): The number to check.\n\n    Returns:\n        bool: True if the number is prime, False otherwise.\n    \"\"\"\n    if n <= 1:\n        return False  # Numbers less than or equal to 1 are not prime.\n    for",
+          "status": 200
+        },
+        {
+          "id": 3,
+          "success": true,
+          "latency": 189,
+          "content": "An API (Application Programming Interface) is a set of defined rules and protocols that enables different software systems to communicate with each other, exchanging data and functionality to achieve a specific task or outcome.",
+          "status": 200
+        },
+        {
+          "id": 4,
+          "success": true,
+          "latency": 371,
+          "content": "Climate change is a complex issue with multiple causes, but some of the main contributors include:\n\n1. **Greenhouse gases**: The burning of fossil fuels such as coal, oil, and gas releases carbon dioxide (CO2), methane (CH4), and other gases that trap heat in the atmosphere, leading to global warming. The main greenhouse gases responsible for climate change are:\n\t* Carbon dioxide (CO2): 65% of human-caused greenhouse gas emissions.\n\t* Methane (CH",
+          "status": 200
+        },
+        {
+          "id": 5,
+          "success": true,
+          "latency": 193,
+          "content": "Code flows like the sea\nPuzzles solved in digital\nSilent, dark delight",
+          "status": 200
+        },
+        {
+          "id": 6,
+          "success": true,
+          "latency": 396,
+          "content": "**Summary:**\n\nAI models, a key component of Artificial Intelligence, improve significantly with access to a large and diverse dataset. The quality and quantity of the data play a crucial role in enhancing the performance, accuracy, and efficiency of AI models.\n\nHere are some key points summarizing the importance of data in AI model improvement:\n\n1. **Training and Learning**: AI models learn from data by identifying patterns, relationships, and trends. The more data provided, the better the model can learn and improve.\n",
+          "status": 200
+        },
+        {
+          "id": 7,
+          "success": true,
+          "latency": 149,
+          "content": "Here are three programming languages:\n\n1. Java\n2. Python\n3. C++",
+          "status": 200
+        },
+        {
+          "id": 8,
+          "success": true,
+          "latency": 273,
+          "content": "Machine learning (ML) is a subset of artificial intelligence (AI) that involves the use of algorithms and statistical models to enable computers to learn from data, make decisions, and improve their performance on a task without being explicitly programmed. In other words, machine learning allows computers to learn from experience and improve their accuracy over time.\n\nMachine learning typically involves the following steps:\n\n1. **Data collection**: Gathering a large dataset relevant to the problem you want to solve.\n2. **Model training**: Using the",
+          "status": 200
+        },
+        {
+          "id": 9,
+          "success": true,
+          "latency": 476,
+          "content": "**Reversing a String in Python**\n=====================================\n\nYou can reverse a string in Python using the slicing feature of the language. Here's an example:\n\n```python\ndef reverse_string(s):\n    \"\"\"\n    Reverse a string.\n\n    Args:\n        s (str): The string to be reversed.\n\n    Returns:\n        str: The reversed string.\n    \"\"\"\n    return s[::-1]\n\n# Example usage:\nprint(reverse_string(\"Hello World\"))  # Output: \"dlroW olle",
+          "status": 200
+        },
+        {
+          "id": 10,
+          "success": true,
+          "latency": 129,
+          "content": "The capital of Japan is Tokyo.",
+          "status": 200
+        }
+      ]
+    },
+    "groq-qwen-3-32b": {
+      "name": "Groq Qwen 3 32B",
+      "successRate": 1,
+      "avgLatency": 459,
+      "avgOutputLen": 454,
+      "inputCostPer1M": 0,
+      "questions": [
+        {
+          "id": 1,
+          "success": true,
+          "latency": 648,
+          "content": "<think>\nOkay, so the question is, What is 2+2? Hmm, that's pretty straightforward. But let me make sure I'm not missing anything. First, let's recall basic addition. Adding two numbers means combining their quantities. So, two plus two should be four. But wait, is there any context where this might not be the case? Like, are we talking about regular integers here? I don't think so. The user didn't specify anything unusual, so it",
+          "status": 200
+        },
+        {
+          "id": 2,
+          "success": true,
+          "latency": 307,
+          "content": "<think>\nOkay, I need to write a Python function to check if a number is prime. Let me think about how to approach this. \n\nFirst, what's a prime number? A prime number is a number greater than 1 that has no divisors other than 1 and itself. So numbers less than 2 aren't prime. For example, 2 is prime, 3 is prime, but 4 is not because it's divisible by 2.\n\nSo the function should return",
+          "status": 200
+        },
+        {
+          "id": 3,
+          "success": true,
+          "latency": 417,
+          "content": "<think>\nOkay, I need to explain what an API is in one sentence. Let me start by recalling what I know. API stands for Application Programming Interface. From what I've heard, it's a way for different software applications to communicate with each other. So, maybe something like, \"An API is a set of protocols and tools that allow different software applications to communicate with each other.\" Wait, does that cover it?\n\nLet me check another angle. APIs act as intermediaries between different systems",
+          "status": 200
+        },
+        {
+          "id": 4,
+          "success": true,
+          "latency": 380,
+          "content": "<think>\nOkay, I need to figure out what causes climate change. Let's start by recalling what I know. Climate change is when the Earth's average temperature rises over time, right? But what actually causes this? I've heard about greenhouse gases being a major factor. Maybe things like carbon dioxide (CO2) and methane? I think cars, factories, and burning fossil fuels like coal, oil, and natural gas release a lot of CO2. That probably traps heat in the atmosphere.",
+          "status": 200
+        },
+        {
+          "id": 5,
+          "success": true,
+          "latency": 553,
+          "content": "<think>\nOkay, I need to write a haiku about programming. Let me start by recalling what a haiku is. It's a traditional Japanese poem with three lines. The structure is 5 syllables in the first line, 7 in the second, and 5 in the third. So, 5-7-5.\n\nFirst, I should brainstorm words and concepts related to programming. Words like code, debug, logic, syntax, loops, algorithms, bugs, servers, maybe",
+          "status": 200
+        },
+        {
+          "id": 6,
+          "success": true,
+          "latency": 518,
+          "content": "<think>\nOkay, the user wants a summary of \"AI models improve with data.\" Let me start by understanding the core idea here. The main point is that more data leads to better AI performance. But I need to make sure to cover the key aspects.\n\nFirst, I should mention that data is essential for training AI models. Then, explain how additional data helps the model learn patterns and generalize better. Maybe include types of data like diverse and high-quality examples. Also, data expansion techniques like data",
+          "status": 200
+        },
+        {
+          "id": 7,
+          "success": true,
+          "latency": 518,
+          "content": "<think>\nOkay, the user wants a list of three programming languages. Let me think about which ones to mention. Popular ones like Python, JavaScript, and Java come to mind. Python is great for beginners because of its readability. JavaScript is essential for web development, both front-end and with Node.js for back-end. Java has been around a long time and is widely used in enterprise applications. Alternatively, I could include C++ or C# for systems programming or game development. Let me make sure",
+          "status": 200
+        },
+        {
+          "id": 8,
+          "success": true,
+          "latency": 464,
+          "content": "<think>\nOkay, so the user is asking \"What is machine learning?\" Let me start by recalling what I know. Machine learning is a subset of artificial intelligence, right? But I need to explain it clearly without jargon. Maybe start with the basic definition: it's about making computers learn from data without being explicitly programmed.\n\nWait, how does that work? I should mention algorithms that improve with experience. Maybe use examples like email spam filters or recommendation systems. Oh, and there are different types",
+          "status": 200
+        },
+        {
+          "id": 9,
+          "success": true,
+          "latency": 368,
+          "content": "<think>\nOkay, I need to figure out how to reverse a string in Python. Let me think... Hmm, I remember that strings in Python are immutable, so maybe I need to convert it into a list first? Wait, but there's probably a simpler way. Oh right! String slicing can do that.\n\nWait, how does slicing work again? Like, the syntax is [start:stop:step]. So if I want to reverse it, I can set the step to -1.",
+          "status": 200
+        },
+        {
+          "id": 10,
+          "success": true,
+          "latency": 415,
+          "content": "<think>\nOkay, the user is asking for the capital of Japan. Let me start by recalling what I know. Japan is an island nation in East Asia. Its capital is... hmm, I think it's Tokyo. But wait, wasn't there a time when the capital was Kyoto or something else? Let me verify.\n\nI remember that Japan used to have Kyoto as its capital for a long time, especially during the feudal era. But after the Meiji Restoration in the late 19th",
+          "status": 200
+        }
+      ]
+    }
+  }
+}

package/benchmark-results.json

@@ -0,0 +1,54 @@
+{
+  "timestamp": "2026-06-03T21:05:16.421Z",
+  "version": "2.14.26",
+  "queries": 200,
+  "exact_accuracy": 67,
+  "adjacent_accuracy": 96,
+  "over_routed": 13,
+  "under_routed": 53,
+  "cost_savings_vs_premium": 62.9,
+  "by_tier": {
+    "free": {
+      "correct": 48,
+      "total": 50
+    },
+    "cheap": {
+      "correct": 45,
+      "total": 60
+    },
+    "mid": {
+      "correct": 18,
+      "total": 50
+    },
+    "premium": {
+      "correct": 23,
+      "total": 40
+    }
+  },
+  "confusion": {
+    "free": {
+      "free": 48,
+      "cheap": 2,
+      "mid": 0,
+      "premium": 0
+    },
+    "cheap": {
+      "free": 13,
+      "cheap": 45,
+      "mid": 1,
+      "premium": 1
+    },
+    "mid": {
+      "free": 1,
+      "cheap": 22,
+      "mid": 18,
+      "premium": 9
+    },
+    "premium": {
+      "free": 2,
+      "cheap": 4,
+      "mid": 11,
+      "premium": 23
+    }
+  }
+}

package/council-votes/architecture-vote.md

@@ -0,0 +1,121 @@
+# Architecture Vote
+
+**Project:** A3M Router Architecture Analysis  
+**Date:** 2026-06-03  
+**Agents:** 3 (Architecture, Performance, Test Coverage)  
+**Goal:** Identify top 3 improvements via council vote
+
+---
+
+## Architecture Vote
+
+### Finding 1: BROKEN MAIN ENTRY POINT (Critical)
+
+**Files:**
+- `src/index.ts` (lines 63, 112)
+- `src/routing/advancedRouter.ts` (MISSING)
+- `src/cost/costTracker.ts` (MISSING)
+
+**Problem:** The main public API (`index.ts`) exports from modules that do not exist:
+```typescript
+// Line 63 - MODULE NOT FOUND
+export { CostTracker } from './cost/costTracker';
+
+// Lines 110-112 - MODULE NOT FOUND  
+import { CostTracker } from './cost/costTracker';
+```
+
+The `routing/advancedRouter.ts` is imported but never created - only `universal_router.py` (Python) exists.
+
+**Solution:** 
+1. Create `src/routing/advancedRouter.ts` as TypeScript wrapper around Python router, OR
+2. Consolidate routing into existing TypeScript modules (`crossModelValidation.ts`, `providerRetry.ts`)
+3. Replace missing `CostTracker` with existing `costAnalytics.ts` (already has full functionality)
+
+**Deletion test:** FIXING SCATTERS complexity - deleting the broken exports would make the module load but lose public API surface. Must fix the imports properly.
+
+---
+
+### Finding 2: ROUTING LOGIC DUALITY (Python/TypeScript Boundary Leak)
+
+**Files:**
+- `src/routing/universal_router.py` (Python - learned routing, model profiles, online learning)
+- `src/routing/providerRetry.ts` (TypeScript - thin wrapper)
+- `src/ensemble.ts` (TypeScript - parallel execution, but assumes router works)
+- `src/index.ts` (broken export chain)
+
+**Problem:** The routing engine is split across two languages with no clear seam:
+- `UniversalModelRouter` (Python) has all the ML logic: learned profiles, quality prediction, online learning
+- TypeScript has fragments: `crossModelValidation.ts` (validator), `providerRetry.ts` (retry), `providerHealth.ts` (health)
+- `ensemble.ts` calls `router.chat()` but router is undefined in TypeScript
+
+The boundary leaks: `ensemble.ts` needs a router but can't access the Python `UniversalModelRouter` from TypeScript.
+
+**Solution:** 
+1. Implement routing logic in TypeScript for tight integration with ensemble
+2. Keep `universal_router.py` as optional optimization, not required
+3. Create `src/routing/index.ts` that exports unified routing interface
+
+**Deletion test:** CONCENTRATES complexity - currently routing logic is scattered across 4+ files in 2 languages. Consolidation would reduce cognitive load.
+
+---
+
+### Finding 3: MEMORY SYSTEM FRAGMENTATION (6 implementations, no clear hierarchy)
+
+**Files:**
+- `src/memory/memoryTree.ts` (TypeScript, main)
+- `src/memory/semantic_memory.py` (Python, ChromaDB optional)
+- `src/memory/agentic_memory.py` (Python)
+- `src/memory/working_memory.py` (Python)
+- `src/memory/simple_memory.py` (Python)
+- `src/memory/obsidianVault.ts` (TypeScript, export only)
+
+**Problem:** 6 memory implementations with unclear purpose:
+- No abstract base class or interface
+- `MemoryTree.ts` has 3KB chunking, but Python memories have different semantics
+- `semantic_memory.py` mentions "Memoria framework (arXiv:2512.12686)" but not integrated
+- No clear path for when to use which memory
+
+**Solution:**
+1. Create abstract `MemoryStore` interface in TypeScript
+2. Implement as `LocalMemoryStore` (current MemoryTree) and `SemanticMemoryStore` (current semantic_memory.py)
+3. Drop `agentic_memory.py`, `working_memory.py`, `simple_memory.py` if unused or consolidate
+
+**Deletion test:** CONCENTRATES complexity - consolidating 6 memory implementations into 2 clear abstractions reduces the surface area significantly.
+
+---
+
+### Finding 4: PROVIDER CONFIG TIGHT COUPLING (47+ providers baked in)
+
+**Files:**
+- `src/providers/providerConfig.ts` (1000+ lines of hardcoded provider definitions)
+
+**Problem:** 47+ providers are baked into a single 1000+ line file with no abstraction:
+- Adding/removing providers requires modifying core code
+- Provider-specific logic (format: openai/anthropic/google) is duplicated per-provider
+- No plugin architecture for third-party providers
+
+**Solution:**
+1. Create `ProviderAdapter` interface for API format handling (OpenAI, Anthropic, Google)
+2. Move provider definitions to `providers/` as individual files
+3. Implement registry pattern with hot-reload from config files
+
+**Deletion test:** CONCENTRATES complexity - but splitting 1000 lines into 47 files creates new complexity. Better to create adapters and keep definitions data-driven.
+
+---
+
+## Vote: Priority Ranking
+
+**I vote for Finding #1 (Broken Main Entry Point) as highest priority.**
+
+**Rationale:** This is the only finding that currently BREAKS the build. The other findings are architectural debt, but Finding 1 prevents the public API from loading at all. No amount of internal refactoring matters if `import { A3MRouter } from 'adaptive-memory-multi-model-router'` fails.
+
+**Implementation order:**
+1. **P0:** Fix broken imports in `src/index.ts`
+2. **P1:** Unify routing across Python/TypeScript boundary
+3. **P2:** Consolidate memory system into 2 clear implementations
+4. **P3:** Extract provider adapters from hardcoded config
+
+---
+
+*Submitted by: Architecture Agent*

package/council-votes/coverage-vote.md

@@ -0,0 +1,93 @@
+## Test Coverage Vote
+
+### Finding 1: GuardrailEngine Has Zero Tests (CRITICAL)
+- **Files:** `src/security/guardrails.ts` (500+ lines)
+- **Problem:** Critical security module has NO tests despite handling:
+  - Prompt injection detection (DAN, jailbreak, ignore instructions)
+  - PII redaction (emails, phones, SSN, credit cards, API keys)
+  - Content filtering (violence, hate, self-harm)
+  - Output validation and hallucination detection
+- **Solution:** Add comprehensive tests for:
+  - Each prompt injection pattern detection
+  - PII redaction for all types
+  - Content filter thresholds
+  - GuardrailEngine.checkInput() and checkOutput() full paths
+  - Custom guardrail registration
+  - Blocklist management
+- **Tests gained:** ~25 tests covering security-critical paths
+
+### Finding 2: EnsembleOrchestrator Has Zero Tests (CORE P0)
+- **Files:** `src/ensemble.ts`, `tests/routing/ensembleVoting.test.ts` (partial)
+- **Problem:** Core P0 feature (parallel multi-LLM execution with result merging) has only partial tests in `tests/routing/`. The `EnsembleOrchestrator` class is NOT tested, and these critical paths are missing:
+  - Actual provider calls (mocked in ensembleVoting.test.ts)
+  - Majority voting strategy
+  - Weighted voting strategy  
+  - Conservative strategy with uncertainty detection
+  - All-providers-fail error handling
+- **Solution:** Add integration tests for EnsembleOrchestrator with:
+  - Mock providers returning different answers
+  - Strategy-specific voting logic
+  - Confidence scoring accuracy
+  - Reasoning generation
+- **Tests gained:** ~15 tests for the unique differentiator
+
+### Finding 3: CostAnalytics Has Zero Tests (BUSINESS-CRITICAL)
+- **Files:** `src/analytics/costAnalytics.ts`
+- **Problem:** Cost tracking and savings calculation has no tests:
+  - No verification of savings calculation against known baselines
+  - No tests for BASELINE_COSTS accuracy
+  - No export format tests (JSON/CSV)
+  - No period filtering (hour/day/week/month)
+  - No auto-rotation when maxRecords exceeded
+- **Solution:** Add tests for:
+  - Savings calculation accuracy (compare against known costs)
+  - Period filtering correctness
+  - Export format validation
+  - Provider/query type breakdown accuracy
+- **Tests gained:** ~12 tests for cost accuracy
+
+### Finding 4: SDK Class (A3MRouter) Has Only Structure Tests
+- **Files:** `src/sdk.ts`, `test-council/1-structure-tests.test.ts`
+- **Problem:** SDK wrapper has basic type-checking but no behavioral tests:
+  - No tests for route() behavior
+  - No tests for analyze() feature extraction
+  - No tests for tier classification thresholds
+  - No tests for recommend() method
+- **Solution:** Add behavioral tests verifying:
+  - Route decisions match expected patterns
+  - Feature extraction accuracy
+  - Tier classification boundaries (free/cheap/mid/premium)
+  - Batch routing consistency
+- **Tests gained:** ~10 tests
+
+### Finding 5: Observability Middleware Not Tested
+- **Files:** `src/observability/middleware.ts`
+- **Problem:** Middleware components not tested:
+  - observabilityMiddleware not tested
+  - budgetAlertMiddleware not tested  
+  - Integration with Express/Fastify not tested
+- **Solution:** Add middleware tests verifying:
+  - Request/response interception
+  - Header injection
+  - Budget alert triggers
+  - Error propagation
+- **Tests gained:** ~8 tests
+
+---
+
+## Vote
+
+**I vote for Finding #1 (GuardrailEngine) as highest priority.**
+
+### Rationale:
+1. **Security-critical code without tests = production risk** - Prompt injection and PII handling bugs can leak sensitive data or bypass safety
+2. **Measurable impact** - Every user query goes through guardrails before routing
+3. **Clear scope** - 500+ lines with well-defined functions that are easy to test
+4. **Existing patterns** - The providerRetry.test.ts shows how to structure similar complex tests
+
+### Implementation estimate:
+- **GuardrailEngine:** ~3 hours for comprehensive tests
+- **EnsembleOrchestrator:** ~2 hours  
+- **CostAnalytics:** ~1.5 hours
+- **SDK:** ~1 hour
+- **Middleware:** ~1 hour

package/data/adaptive-benchmark.json

@@ -0,0 +1,92 @@
+{
+  "description": "Adaptive benchmark — tier labels based on router's actual complexity scoring and available provider landscape",
+  "providerContext": {
+    "free": ["ollama/*", "google/gemini-1.5-flash", "commandcode/*", "openrouter/*:free"],
+    "cheap": ["minimax/*"],
+    "mid": ["mistral/*", "cerebras/*", "groq/*", "meta-llama/llama-3.1-70b-instruct"],
+    "premium": ["google/gemini-pro-1.5", "mistralai/mistral-large", "openai/*", "anthropic/*"]
+  },
+  "queries": [
+    {"query": "What is 2+2?", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "What is the capital of France?", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "How do you say hello in Spanish?", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "Convert 100 Celsius to Fahrenheit", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "What is the largest planet in the solar system?", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "How many ounces in a pound?", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "What is the speed of light?", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "Who wrote Romeo and Juliet?", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "What is photosynthesis?", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "What is the square root of 144?", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "Name three primary colors", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "What is the chemical symbol for gold?", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "How many continents are there?", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "What is gravity?", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "Define ubiquitous", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "What does benevolent mean?", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "How many bytes in a kilobyte?", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "What is H2O commonly known as?", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "Translate good morning to French", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "What is the time in Tokyo?", "expectedTier": "free", "complexityRange": [0, 0.15]},
+    {"query": "Write a Python function to sort a list", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "Explain the difference between TCP and UDP", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "Write a SQL query to find duplicate records", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "Create a REST API endpoint in Express.js", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "Explain Docker containers vs virtual machines", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "Write a regex to validate email addresses", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "How do I reverse a string in JavaScript?", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "Write a for loop in Python", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "What is the difference between let and const in JavaScript?", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "Explain what an API is to a non-technical person", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "How do I center a div in CSS?", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "Write a basic HTML form", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "Explain git merge vs rebase", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "What is a RESTful API?", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "How do I read a file in Node.js?", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "Write a simple unit test in Jest", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "Explain what a database index does", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "How do I parse JSON in Python?", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "Write a Python script to send an email", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "Create a simple login form in HTML/CSS", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "How do I make an HTTP request in JavaScript?", "expectedTier": "cheap", "complexityRange": [0.1, 0.4]},
+    {"query": "Design a REST API for a blog with users, posts, and comments", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "Explain how OAuth 2.0 authentication works", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "Design a rate limiting system for a web API", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "How would you implement a caching layer for a web application", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "Compare and contrast SQL and NoSQL databases", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "Design a user authentication system with JWT tokens", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "Explain the CAP theorem and its implications", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "How do you design a URL shortening service like bit.ly?", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "Design a real-time notification system", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "Explain the pros and cons of microservices vs monolith", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "How would you implement search functionality in a web application", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "Design a payment processing system", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "Explain how blockchain achieves consensus", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "Design a multi-tenant SaaS architecture", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "How do you handle database migrations in production?", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "Design a logging and monitoring system", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "Explain load balancing algorithms", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "How would you design a file upload system?", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "Design a chat application with WebSockets", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "Explain event-driven architecture patterns", "expectedTier": "mid", "complexityRange": [0.4, 0.7]},
+    {"query": "Design a distributed system that handles 10 million transactions per second", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Architect a real-time collaboration system like Google Docs", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Design a machine learning pipeline from data ingestion to model serving", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Create a comprehensive technical design for a social media platform", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Design a zero-downtime deployment strategy for a distributed system", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Architect a system that processes streaming data with sub-second latency", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Design a fraud detection system using machine learning", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Create an architecture for a global CDN with edge computing", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Design a multi-region active-active database architecture", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Architect a system for real-time video transcoding at scale", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Design a privacy-preserving data analytics system", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Create a comprehensive security architecture for a financial platform", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Design a system that handles 1 billion events per day", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Architect a serverless system with consistent performance under load", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Design a data warehouse architecture for petabyte-scale analytics", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Create a multi-cloud hybrid architecture strategy", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Design a system for real-time anomaly detection in financial transactions", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Architect a mesh network for IoT at scale", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Design a comprehensive disaster recovery strategy for a global platform", "expectedTier": "premium", "complexityRange": [0.6, 1.0]},
+    {"query": "Create an architecture for autonomous vehicle sensor fusion", "expectedTier": "premium", "complexityRange": [0.6, 1.0]}
+  ]
+}