adaptive-memory-multi-model-router 2.14.46 → 2.14.48

package/scripts/benchmark-local-routerarena.ts

@@ -1,176 +0,0 @@
-/**
- * Local benchmark using RouterArena cached queries.
- * 
- * We use the cached results to determine ground truth:
- * - A query's "actual tier" is based on which model produced the BEST answer
- * - We compare our routing decision against this ground truth
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { routeQuery, createRouterContext } from '../src/index';
-
-// Load cached results from RouterArena
-const CACHE_DIR = '/tmp/routerarena/cached_results';
-
-interface CachedResult {
-  global_index: string;
-  generated_answer: string;
-  success: boolean;
-  token_usage: { input_tokens: number; output_tokens: number };
-  provider: string;
-}
-
-interface GroundTruthTier {
-  query: string;
-  global_index: string;
-  actualTier: 'free' | 'cheap' | 'mid' | 'premium';
-  groundTruthModel: string;
-}
-
-interface BenchmarkResult {
-  timestamp: string;
-  version: string;
-  total: number;
-  correct: number;
-  accuracy: number;
-  confusion: { [key: string]: { [key: string]: number } };
-  tierAccuracy: { [tier: string]: { correct: number; total: number } };
-  sampleQueries: { query: string; actual: string; predicted: string; correct: boolean }[];
-}
-
-async function loadCachedResults(model: string): Promise<{ [key: string]: CachedResult }> {
-  const results: { [key: string]: CachedResult } = {};
-  const filePath = path.join(CACHE_DIR, `${model}.jsonl`);
-  
-  if (!fs.existsSync(filePath)) {
-    console.log(`Cache not found: ${filePath}`);
-    return results;
-  }
-  
-  const content = fs.readFileSync(filePath, 'utf-8');
-  for (const line of content.split('\n')) {
-    if (line.trim()) {
-      const entry = JSON.parse(line);
-      results[entry.global_index] = entry;
-    }
-  }
-  
-  return results;
-}
-
-function inferTierFromModel(model: string): 'free' | 'cheap' | 'mid' | 'premium' {
-  const m = model.toLowerCase();
-  if (m.includes('deepseek')) return 'free';
-  if (m.includes('gpt') && m.includes('mini')) return 'cheap';
-  if (m.includes('mistral') || m.includes('ministral')) return 'mid';
-  if (m.includes('gemini') || m.includes('claude') || m.includes('gpt-4')) return 'premium';
-  return 'mid';
-}
-
-async function runBenchmark(): Promise<void> {
-  console.log('Loading cached results...');
-  
-  // Load cached results for all models
-  const deepseekResults = await loadCachedResults('deepseek-chat');
-  const gptResults = await loadCachedResults('gpt-4o-mini');
-  const haikuResults = await loadCachedResults('claude-3-haiku-20240307');
-  const geminiResults = await loadCachedResults('gemini-2.0-flash-001');
-  
-  console.log(`Loaded: deepseek=${Object.keys(deepseekResults).length}, gpt=${Object.keys(gptResults).length}, haiku=${Object.keys(haikuResults).length}, gemini=${Object.keys(geminiResults).length}`);
-  
-  // Create ground truth: for each query, which model is best?
-  // We need a sample query text - we'll use the global_index as identifier
-  const queries = Object.keys(deepseekResults).slice(0, 500); // Sample 500 for speed
-  
-  console.log(`\nBenchmarking ${queries.length} queries...`);
-  
-  // Create router context
-  const context = await createRouterContext();
-  
-  const confusion: { [key: string]: { [key: string]: number } } = {
-    'free': {}, 'cheap': {}, 'mid': {}, 'premium': {}
-  };
-  
-  const tierAccuracy: { [key: string]: { correct: number; total: number } } = {
-    'free': { correct: 0, total: 0 },
-    'cheap': { correct: 0, total: 0 },
-    'mid': { correct: 0, total: 0 },
-    'premium': { correct: 0, total: 0 }
-  };
-  
-  let correct = 0;
-  const sampleQueries: BenchmarkResult['sampleQueries'] = [];
-  
-  for (const idx of queries) {
-    const deepseekResult = deepseekResults[idx];
-    
-    // Infer the "actual" tier based on which model would be best
-    // For simplicity, use deepseek as reference (it's the most capable free model)
-    const actualTier = 'free'; // Default assumption
-    
-    // Route using our router
-    const query = `[${idx}] ${deepseekResult?.generated_answer?.substring(0, 100) || 'query'}`;
-    
-    try {
-      const result = await routeQuery(idx, context);
-      const predictedTier = inferTierFromModel(result.model);
-      
-      const isCorrect = predictedTier === actualTier;
-      if (isCorrect) correct++;
-      
-      // Update confusion
-      if (!confusion[actualTier][predictedTier]) confusion[actualTier][predictedTier] = 0;
-      confusion[actualTier][predictedTier]++;
-      
-      tierAccuracy[actualTier].total++;
-      if (isCorrect) tierAccuracy[actualTier].correct++;
-      
-      if (sampleQueries.length < 50) {
-        sampleQueries.push({
-          query: idx,
-          actual: actualTier,
-          predicted: predictedTier,
-          correct: isCorrect
-        });
-      }
-    } catch (e) {
-      console.error(`Error routing ${idx}: ${e}`);
-    }
-  }
-  
-  const result: BenchmarkResult = {
-    timestamp: new Date().toISOString(),
-    version: '2.14.26',
-    total: queries.length,
-    correct,
-    accuracy: correct / queries.length,
-    confusion,
-    tierAccuracy,
-    sampleQueries
-  };
-  
-  console.log('\n=== Local Benchmark Results ===');
-  console.log(`Total: ${result.total}, Correct: ${result.correct}`);
-  console.log(`Accuracy: ${(result.accuracy * 100).toFixed(1)}%`);
-  console.log('\nTier Accuracy:');
-  for (const [tier, stats] of Object.entries(result.tierAccuracy)) {
-    const pct = stats.total > 0 ? (100 * stats.correct / stats.total).toFixed(0) : 'N/A';
-    console.log(`  ${tier}: ${stats.correct}/${stats.total} (${pct}%)`);
-  }
-  console.log('\nConfusion Matrix (rows=actual, cols=predicted):');
-  console.log('       free  cheap   mid prem');
-  for (const actual of ['free', 'cheap', 'mid', 'premium']) {
-    const row = confusion[actual];
-    const free = row['free'] || 0;
-    const cheap = row['cheap'] || 0;
-    const mid = row['mid'] || 0;
-    const prem = row['premium'] || 0;
-    console.log(`${actual.padEnd(8)}${free.toString().padStart(5)} ${cheap.toString().padStart(5)} ${mid.toString().padStart(5)} ${prem.toString().padStart(5)}`);
-  }
-  
-  fs.writeFileSync('./benchmark-local-results.json', JSON.stringify(result, null, 2));
-  console.log('\nSaved to benchmark-local-results.json');
-}
-
-runBenchmark().catch(console.error);

package/scripts/benchmark.js

@@ -1,145 +0,0 @@
-#!/usr/bin/env node
-/**
- * A3M Router Real Benchmark
- * Runs actual queries through the router and measures cost savings
- */
-
-const QUERY_SET = {
-  simple: [
-    "What is 2+2?",
-    "What is the capital of France?",
-    "How do you say hello in Spanish?",
-    "What day is it today?",
-    "Convert 100 Celsius to Fahrenheit",
-    "What is the largest planet in the solar system?",
-    "How many ounces in a pound?",
-    "What is the speed of light?",
-    "Who wrote Romeo and Juliet?",
-    "What is photosynthesis?",
-    "What is the square root of 144?",
-    "Name three primary colors",
-    "What is the chemical symbol for gold?",
-    "How many continents are there?",
-    "What is gravity?",
-  ],
-  medium: [
-    "Summarize this article about climate change in 3 bullet points",
-    "Translate this paragraph from English to French",
-    "Write a Python function to sort a list",
-    "Explain the difference between TCP and UDP",
-    "Write a SQL query to find the top 10 customers by revenue",
-    "Summarize the key points of the Paris Agreement",
-    "Create a REST API endpoint in Express.js",
-    "Explain Docker containers vs virtual machines",
-    "Write a regex to validate email addresses",
-    "Describe the water cycle in simple terms",
-  ],
-  complex: [
-    "Analyze the economic implications of AI automation on developing countries",
-    "Write a detailed technical design document for a microservices architecture",
-    "Compare and contrast the philosophical frameworks of Kant and Hume on causation",
-    "Design a distributed caching strategy for a social media platform at scale",
-    "Critically evaluate the evidence for and against universal basic income",
-    "Write a comprehensive literature review on transformer architecture improvements since 2020",
-    "Propose a novel approach to reducing bias in large language model training",
-    "Architect a real-time collaboration system similar to Google Docs",
-    "Analyze the geopolitical implications of rare earth mineral supply chains",
-    "Design an experiment to test the effectiveness of retrieval-augmented generation",
-  ],
-};
-
-// Expand to 100 queries
-const allSimple = Array(47).fill(null).map((_, i) => QUERY_SET.simple[i % QUERY_SET.simple.length]);
-const allMedium = Array(33).fill(null).map((_, i) => QUERY_SET.medium[i % QUERY_SET.medium.length]);
-const allComplex = Array(20).fill(null).map((_, i) => QUERY_SET.complex[i % QUERY_SET.complex.length]);
-
-console.log("=== A3M Router Benchmark ===\n");
-console.log(`Running ${allSimple.length + allMedium.length + allComplex.length} queries...`);
-
-try {
-  const { createA3MRouter } = require("../src/index.js");
-  const router = createA3MRouter();
-
-  const results = { simple: [], medium: [], complex: [] };
-  let gpt4Total = 0;
-  let smartTotal = 0;
-
-  // Cost model per query by type and provider
-  const costModel = {
-    simple: { gpt4: 0.0045, groq: 0.00009 },
-    medium: { gpt4: 0.015, gpt4mini: 0.000075 },
-    complex: { gpt4: 0.036 },
-  };
-
-  // Route simple queries
-  console.log("\nRouting 47 simple queries...");
-  for (const q of allSimple) {
-    try {
-      const result = router.route(q);
-      results.simple.push(result);
-    } catch {
-      results.simple.push({ provider: "groq", simulated: true });
-    }
-    gpt4Total += costModel.simple.gpt4;
-    smartTotal += costModel.simple.groq;
-  }
-
-  // Route medium queries
-  console.log("Routing 33 medium queries...");
-  for (const q of allMedium) {
-    try {
-      const result = router.route(q);
-      results.medium.push(result);
-    } catch {
-      results.medium.push({ provider: "gpt4mini", simulated: true });
-    }
-    gpt4Total += costModel.medium.gpt4;
-    smartTotal += costModel.medium.gpt4mini;
-  }
-
-  // Route complex queries
-  console.log("Routing 20 complex queries...");
-  for (const q of allComplex) {
-    try {
-      const result = router.route(q);
-      results.complex.push(result);
-    } catch {
-      results.complex.push({ provider: "gpt4", simulated: true });
-    }
-    gpt4Total += costModel.complex.gpt4;
-    smartTotal += costModel.complex.gpt4;
-  }
-
-  console.log(`\nAll GPT-4o:  $${gpt4Total.toFixed(4)}`);
-  console.log(`A3M Router:  $${smartTotal.toFixed(4)}`);
-  console.log(`Savings:     ${((1 - smartTotal / gpt4Total) * 100).toFixed(1)}%`);
-} catch (e) {
-  console.log("Router not available, running simulation mode.\n");
-
-  // Simulate with cost model
-  const costs = {
-    simple: { gpt4: 0.0045, groq: 0.00009 },
-    medium: { gpt4: 0.015, gpt4mini: 0.000075 },
-    complex: { gpt4: 0.036 },
-  };
-
-  let gpt4Total = 0;
-  let smartTotal = 0;
-
-  allSimple.forEach(() => {
-    gpt4Total += costs.simple.gpt4;
-    smartTotal += costs.simple.groq;
-  });
-  allMedium.forEach(() => {
-    gpt4Total += costs.medium.gpt4;
-    smartTotal += costs.medium.gpt4mini;
-  });
-  allComplex.forEach(() => {
-    gpt4Total += costs.complex.gpt4;
-    smartTotal += costs.complex.gpt4;
-  });
-
-  console.log(`All GPT-4o: $${gpt4Total.toFixed(4)}`);
-  console.log(`A3M Router:  $${smartTotal.toFixed(4)}`);
-  console.log(`Savings:     ${((1 - smartTotal / gpt4Total) * 100).toFixed(1)}%`);
-}

package/scripts/benchmark.sh

@@ -1,61 +0,0 @@
-#!/bin/bash
-# A3M Router Benchmark Script
-# Compares: All-GPT-4 vs Smart Routing vs All-Cheap
-
-echo "=== A3M Router Cost Benchmark ==="
-echo ""
-echo "Running 100 simulated queries..."
-echo "  47 simple (Q&A, math, basic tasks)"
-echo "  33 medium (summarization, translation, code)"
-echo "  20 complex (reasoning, creative writing, analysis)"
-echo ""
-
-# Cost per 1K tokens (input)
-GPT4_COST=0.03          # $30/1M tokens
-GPT4_MINI_COST=0.00015  # $0.15/1M tokens
-GROQ_COST=0.00059       # $0.59/1M tokens
-CEREBRAS_COST=0.00060   # $0.60/1M tokens
-FREE_COST=0.00          # CommandCode/OpenCode
-
-# Average tokens per query type
-SIMPLE_TOKENS=150
-MEDIUM_TOKENS=500
-COMPLEX_TOKENS=1200
-
-# All GPT-4 baseline
-all_gpt4=$(echo "scale=4; (47 * $SIMPLE_TOKENS + 33 * $MEDIUM_TOKENS + 20 * $COMPLEX_TOKENS) * $GPT4_COST / 1000" | bc)
-echo "📊 All queries → GPT-4o:"
-echo "   Cost: \$$all_gpt4"
-echo ""
-
-# Smart routing (A3M approach)
-# Simple → Groq/Cerebras, Medium → GPT-4o-mini, Complex → GPT-4o
-smart_simple=$(echo "scale=4; 47 * $SIMPLE_TOKENS * $GROQ_COST / 1000" | bc)
-smart_medium=$(echo "scale=4; 33 * $MEDIUM_TOKENS * $GPT4_MINI_COST / 1000" | bc)
-smart_complex=$(echo "scale=4; 20 * $COMPLEX_TOKENS * $GPT4_COST / 1000" | bc)
-smart_total=$(echo "scale=4; $smart_simple + $smart_medium + $smart_complex" | bc)
-savings=$(echo "scale=1; (1 - $smart_total / $all_gpt4) * 100" | bc)
-echo "📊 A3M Router (smart routing):"
-echo "   Simple (47) → Groq:     \$$smart_simple"
-echo "   Medium (33) → GPT-4o-mini: \$$smart_medium"
-echo "   Complex (20) → GPT-4o:  \$$smart_complex"
-echo "   Total: \$$smart_total"
-echo "   Savings: ${savings}%"
-echo ""
-
-# All cheap (worst quality)
-all_cheap=$(echo "scale=4; (47 * $SIMPLE_TOKENS + 33 * $MEDIUM_TOKENS + 20 * $COMPLEX_TOKENS) * $GROQ_COST / 1000" | bc)
-echo "📊 All queries → Groq (cheapest):"
-echo "   Cost: \$$all_cheap"
-echo "   Quality: Lower (complex queries suffer)"
-echo ""
-
-# Monthly projection at scale
-echo "=== Monthly Projection ==="
-for queries in "10000" "100000" "1000000"; do
-  scale=$(echo "scale=0; $queries / 100" | bc)
-  gpt4_monthly=$(echo "scale=2; $all_gpt4 * $scale" | bc)
-  smart_monthly=$(echo "scale=2; $smart_total * $scale" | bc)
-  monthly_savings=$(echo "scale=2; $gpt4_monthly - $smart_monthly" | bc)
-  printf "  %s queries/month: GPT-4=\$%-8s A3M=\$%-8s Save=\$%s/mo\n" "$queries" "$gpt4_monthly" "$smart_monthly" "$monthly_savings"
-done

package/scripts/compare-providers.sh

@@ -1,230 +0,0 @@
-#!/bin/bash
-# =============================================================================
-# A3M Router — Provider Comparison Script
-# =============================================================================
-# Compares responses from multiple LLM providers to the SAME prompt.
-# Works with any provider that has an OpenAI-compatible API.
-#
-# Usage:
-#   ./scripts/compare-providers.sh "What is 2+2?"
-#   ./scripts/compare-providers.sh                            # defaults
-#
-# Requires at least one of: GROQ_API_KEY, NV_API_KEY, CEREBRAS_API_KEY
-# =============================================================================
-
-set -e
-
-PROMPT="${1:-Say hello in exactly 3 words.}"
-TIMEOUT=15
-
-# Color codes
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-MAGENTA='\033[0;35m'
-CYAN='\033[0;36m'
-NC='\033[0m' # No Color
-
-echo ""
-echo -e "${BLUE}══════════════════════════════════════════════════════════════${NC}"
-echo -e "${BLUE}  A3M Router — Provider Comparison${NC}"
-echo -e "${BLUE}  Prompt: \"${PROMPT}\"${NC}"
-echo -e "${BLUE}══════════════════════════════════════════════════════════════${NC}"
-echo ""
-
-RESULTS_DIR=$(mktemp -d)
-trap 'rm -rf "$RESULTS_DIR"' EXIT
-
-COMPLETED=0
-FAILED=0
-
-# -------------------------------------------------------------------------
-# Helper: call a provider and save result
-# -------------------------------------------------------------------------
-call_provider() {
-  local name=$1
-  local url=$2
-  local auth_header=$3
-  local model=$4
-  local data_file="$RESULTS_DIR/${name//\//_}.json"
-
-  # Build the curl payload
-  local payload
-  payload=$(jq -n \
-    --arg model "$model" \
-    --arg content "$PROMPT" \
-    '{
-      model: $model,
-      messages: [{role: "user", content: $content}],
-      max_tokens: 100,
-      temperature: 0.7
-    }')
-
-  # Execute with timeout, capture response and HTTP code
-  local http_code
-  http_code=$(curl -s -o "$data_file" -w "%{http_code}" \
-    --max-time "$TIMEOUT" \
-    -H "Authorization: Bearer $auth_header" \
-    -H "Content-Type: application/json" \
-    -d "$payload" \
-    "$url" 2>/dev/null)
-
-  if [ "$http_code" = "200" ]; then
-    COMPLETED=$((COMPLETED + 1))
-    echo "$data_file"
-  else
-    FAILED=$((FAILED + 1))
-    # Store error for display
-    echo "{\"error\": true, \"http_code\": $http_code, \"body\": $(cat "$data_file" 2>/dev/null || echo '"timeout or connection error"')}" > "$data_file"
-    echo "$data_file"
-  fi
-}
-
-# -------------------------------------------------------------------------
-# Print a single provider's result
-# -------------------------------------------------------------------------
-print_result() {
-  local name=$1
-  local color=$2
-  local data_file=$3
-
-  if jq -e '.error == true' "$data_file" >/dev/null 2>&1; then
-    local code
-    code=$(jq -r '.http_code' "$data_file")
-    echo -e "${color}  ❌ $name${NC} (HTTP $code)"
-    jq -r '.body | if length > 200 then .[0:200] + "..." else . end' "$data_file" 2>/dev/null | sed 's/^/    /'
-    return
-  fi
-
-  local content model usage_in usage_out usage_total
-  content=$(jq -r '.choices[0].message.content // "N/A"' "$data_file" 2>/dev/null)
-  model=$(jq -r '.model // "N/A"' "$data_file" 2>/dev/null)
-  usage_in=$(jq -r '.usage.prompt_tokens // "?"' "$data_file" 2>/dev/null)
-  usage_out=$(jq -r '.usage.completion_tokens // "?"' "$data_file" 2>/dev/null)
-
-  echo -e "${color}  ● $name${NC}"
-  echo "    Model:      $model"
-  echo "    Tokens:     ${usage_in} in / ${usage_out} out"
-  echo "    Response:   $content"
-}
-
-# =============================================================================
-# Collect results (parallel execution)
-# =============================================================================
-
-echo -e "${YELLOW}  Sending parallel requests...${NC}"
-echo ""
-
-# Groq
-if [ -n "$GROQ_API_KEY" ]; then
-  groq_file=$(call_provider "Groq" \
-    "https://api.groq.com/openai/v1/chat/completions" \
-    "$GROQ_API_KEY" \
-    "llama-3.3-70b-versatile")
-else
-  echo -e "${RED}  ❌ Groq — GROQ_API_KEY not set${NC}"
-  FAILED=$((FAILED + 1))
-fi
-
-# NVIDIA NIM
-if [ -n "$NV_API_KEY" ]; then
-  nvidia_file=$(call_provider "NVIDIA NIM" \
-    "https://integrate.api.nvidia.com/v1/chat/completions" \
-    "$NV_API_KEY" \
-    "meta/llama-3.3-70b-instruct")
-else
-  echo -e "${RED}  ❌ NVIDIA NIM — NV_API_KEY not set${NC}"
-  FAILED=$((FAILED + 1))
-fi
-
-# Cerebras
-if [ -n "$CEREBRAS_API_KEY" ]; then
-  cerebras_file=$(call_provider "Cerebras" \
-    "https://api.cerebras.ai/v1/chat/completions" \
-    "$CEREBRAS_API_KEY" \
-    "llama-3.3-70b")
-else
-  echo -e "${RED}  ❌ Cerebras — CEREBRAS_API_KEY not set${NC}"
-  FAILED=$((FAILED + 1))
-fi
-
-# OpenAI
-if [ -n "$OPENAI_API_KEY" ]; then
-  openai_file=$(call_provider "OpenAI" \
-    "https://api.openai.com/v1/chat/completions" \
-    "$OPENAI_API_KEY" \
-    "gpt-4o-mini")
-else
-  echo -e "${RED}  ❌ OpenAI — OPENAI_API_KEY not set${NC}"
-  FAILED=$((FAILED + 1))
-fi
-
-# Anthropic (different API shape, handle separately)
-if [ -n "$ANTHROPIC_API_KEY" ]; then
-  anthro_file="$RESULTS_DIR/anthropic.json"
-  local http_code
-  http_code=$(curl -s -o "$anthro_file" -w "%{http_code}" \
-    --max-time "$TIMEOUT" \
-    -H "x-api-key: $ANTHROPIC_API_KEY" \
-    -H "anthropic-version: 2023-06-01" \
-    -H "Content-Type: application/json" \
-    -d "$(jq -n \
-      --arg content "$PROMPT" \
-      '{
-        model: "claude-3-5-haiku-latest",
-        max_tokens: 100,
-        messages: [{role: "user", content: $content}]
-      }')" \
-    "https://api.anthropic.com/v1/messages" 2>/dev/null)
-
-  if [ "$http_code" = "200" ]; then
-    COMPLETED=$((COMPLETED + 1))
-  else
-    echo "{\"error\": true, \"http_code\": $http_code}" > "$anthro_file"
-    FAILED=$((FAILED + 1))
-  fi
-else
-  echo -e "${RED}  ❌ Anthropic — ANTHROPIC_API_KEY not set${NC}"
-  FAILED=$((FAILED + 1))
-fi
-
-echo ""
-
-# =============================================================================
-# Print results
-# =============================================================================
-echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo -e "${GREEN}  Results — ${COMPLETED} succeeded, ${FAILED} failed${NC}"
-echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo ""
-
-# Print each result if the file exists
-[ -n "$groq_file" ] && [ -f "$groq_file" ] && print_result "Groq" "$MAGENTA" "$groq_file"
-[ -n "$nvidia_file" ] && [ -f "$nvidia_file" ] && print_result "NVIDIA NIM" "$CYAN" "$nvidia_file"
-[ -n "$cerebras_file" ] && [ -f "$cerebras_file" ] && print_result "Cerebras" "$GREEN" "$cerebras_file"
-[ -n "$openai_file" ] && [ -f "$openai_file" ] && print_result "OpenAI" "$YELLOW" "$openai_file"
-if [ -n "$anthro_file" ] && [ -f "$anthro_file" ]; then
-  if jq -e '.error == true' "$anthro_file" >/dev/null 2>&1; then
-    echo -e "${RED}  ❌ Anthropic (HTTP $(jq -r '.http_code' "$anthro_file"))${NC}"
-  else
-    local content
-    content=$(jq -r '.content[0].text // "N/A"' "$anthro_file" 2>/dev/null)
-    local model
-    model=$(jq -r '.model // "N/A"' "$anthro_file" 2>/dev/null)
-    echo -e "${BLUE}  ● Anthropic${NC}"
-    echo "    Model:      $model"
-    echo "    Response:   $content"
-  fi
-fi
-
-echo ""
-echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo -e "  Run with A3M Proxy (after ${YELLOW}npx a3m-router serve${NC}):"
-echo ""
-echo "    curl http://localhost:8787/v1/chat/completions \\"
-echo "      -H \"Content-Type: application/json\" \\"
-echo "      -d '{\"model\":\"auto\",\"messages\":[{\"role\":\"user\",\"content\":\"$PROMPT\"}]}'"
-echo ""
-echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo ""

package/scripts/content-planner.js

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-const https = require('https');
-async function getJSON(url) {
-  return new Promise((resolve, reject) => {
-    https.get(url, { headers: { 'User-Agent': 'a3m-router' } }, (res) => {
-      let d = '';
-      res.on('data', c => d += c);
-      res.on('end', () => { try { resolve(JSON.parse(d)); } catch { reject(new Error('parse')); } });
-    }).on('error', reject);
-  });
-}
-async function main() {
-  console.log('\n📅 A3M — Content Planner\n');
-  let stars = 0, dl = 0, issues = 0;
-  try { const r = await getJSON('https://api.github.com/repos/Das-rebel/a3m-router'); stars = r.stargazers_count || 0; issues = r.open_issues_count || 0; } catch {}
-  try { const n = await getJSON('https://api.npmjs.org/downloads/point/last-week/adaptive-memory-multi-model-router'); dl = n.downloads || 0; } catch {}
-  console.log(`  📦 Weekly downloads: ${dl.toLocaleString()}`);
-  console.log(`  ⭐ GitHub stars: ${stars}`);
-  console.log(`  🐛 Open issues: ${issues}\n`);
-  console.log('  📌 RECOMMENDED: "How A3M Saves $X/Year on LLM Costs" — case study\n');
-  console.log('  📌 RECOMMENDED: A3M vs LiteLLM vs RouteLLM — benchmark comparison\n');
-  console.log('  📌 RECOMMENDED: Video demo of parallel execution (asciinema)\n');
-  console.log('  📌 RECOMMENDED: "How to Save 62% on LLM APIs" blog post\n');
-}
-main().catch(console.error);