gsd-trae 1.0.0 → 1.0.2

package/refs/vbenchmark/packages/leaderboard/src/routes/leaderboard.ts

@@ -1,698 +0,0 @@
-import { Hono } from 'hono';
-import { eq, desc, sql } from 'drizzle-orm';
-import { db, benchmarkRuns } from '../db/index.js';
-import { MODEL_PRICING } from '../config/pricing.js';
-
-const leaderboardRoutes = new Hono();
-
-// In-memory fallback when database is not available
-interface LeaderboardEntry {
-  rank: number;
-  agentName: string;
-  agentVersion: string;
-  modelName: string;
-  tasksCompleted: number;
-  passedTasks: number;
-  failedTasks: number;
-  avgScore: number;
-  avgFunctional: number;
-  avgVisual: number;
-  avgQuality: number;
-  avgSecurity: number;
-  avgCost: number;
-  avgSpeed: number;
-  totalTokens: number;
-  inputTokens: number;
-  outputTokens: number;
-  totalCostUSD: number;
-  avgTimeMs: number;
-  pricingInput: number;
-  pricingOutput: number;
-  lastUpdated: string;
-}
-
-// Total tasks in benchmark (6 categories × 30 tasks each = 180)
-const TOTAL_TASKS = 180;
-const TASKS_PER_CATEGORY = 30;
-
-// Real benchmark results from 2026-01-20 evaluation (180 tasks each)
-const mockLeaderboard: LeaderboardEntry[] = [
-  {
-    rank: 1,
-    agentName: 'GLM-4',
-    agentVersion: 'GLM-4-Plus',
-    modelName: 'GLM 4-Plus',
-    tasksCompleted: 180,
-    passedTasks: 178,
-    failedTasks: 2,
-    avgScore: 88.20,
-    avgFunctional: 84.06,
-    avgVisual: 80.0,
-    avgQuality: 80.0,
-    avgSecurity: 100.0,
-    avgCost: 92.0,
-    avgSpeed: 75.0,
-    totalTokens: 794105,
-    inputTokens: 238232,
-    outputTokens: 555873,
-    totalCostUSD: 0.93,
-    avgTimeMs: 96210,
-    pricingInput: 0.40,
-    pricingOutput: 1.50,
-    lastUpdated: '2026-01-20T10:20:00.000Z',
-  },
-  {
-    rank: 2,
-    agentName: 'MiniMax',
-    agentVersion: 'M2.1',
-    modelName: 'MiniMax M2.1',
-    tasksCompleted: 180,
-    passedTasks: 179,
-    failedTasks: 1,
-    avgScore: 87.42,
-    avgFunctional: 84.53,
-    avgVisual: 80.0,
-    avgQuality: 80.0,
-    avgSecurity: 100.0,
-    avgCost: 85.0,
-    avgSpeed: 60.0,
-    totalTokens: 2778476,
-    inputTokens: 833543,
-    outputTokens: 1944933,
-    totalCostUSD: 2.40,
-    avgTimeMs: 164907,
-    pricingInput: 0.27,
-    pricingOutput: 1.12,
-    lastUpdated: '2026-01-20T11:26:00.000Z',
-  },
-  {
-    rank: 3,
-    agentName: 'GLM-4',
-    agentVersion: 'GLM-4.7',
-    modelName: 'GLM-4.7',
-    tasksCompleted: 180,
-    passedTasks: 154,
-    failedTasks: 26,
-    avgScore: 83.90,
-    avgFunctional: 72.72,
-    avgVisual: 80.0,
-    avgQuality: 79.56,
-    avgSecurity: 100.0,
-    avgCost: 94.0,
-    avgSpeed: 82.0,
-    totalTokens: 623474,
-    inputTokens: 187042,
-    outputTokens: 436432,
-    totalCostUSD: 0.73,
-    avgTimeMs: 56805,
-    pricingInput: 0.40,
-    pricingOutput: 1.50,
-    lastUpdated: '2026-01-20T10:20:00.000Z',
-  },
-  {
-    rank: 4,
-    agentName: 'Gemini',
-    agentVersion: '3-Flash-Preview',
-    modelName: 'Gemini 3 Flash',
-    tasksCompleted: 180,
-    passedTasks: 166,
-    failedTasks: 14,
-    avgScore: 83.44,
-    avgFunctional: 78.39,
-    avgVisual: 80.0,
-    avgQuality: 75.11,
-    avgSecurity: 100.0,
-    avgCost: 95.0,
-    avgSpeed: 90.0,
-    totalTokens: 383991,
-    inputTokens: 115197,
-    outputTokens: 268794,
-    totalCostUSD: 0.86,  // (115197/1M)*0.5 + (268794/1M)*3
-    avgTimeMs: 27822,
-    pricingInput: 0.5,
-    pricingOutput: 3.0,
-    lastUpdated: '2026-01-20T07:29:00.000Z',
-  },
-  {
-    rank: 5,
-    agentName: 'Gemini',
-    agentVersion: '3-Pro-Preview',
-    modelName: 'Gemini 3 Pro Preview',
-    tasksCompleted: 180,
-    passedTasks: 136,
-    failedTasks: 44,
-    avgScore: 80.17,
-    avgFunctional: 64.22,
-    avgVisual: 80.0,
-    avgQuality: 78.67,
-    avgSecurity: 100.0,
-    avgCost: 94.0,
-    avgSpeed: 88.0,
-    totalTokens: 612000,
-    inputTokens: 183600,
-    outputTokens: 428400,
-    totalCostUSD: 5.51,
-    avgTimeMs: 32000,
-    pricingInput: 2.0,
-    pricingOutput: 12.0,
-    lastUpdated: '2026-01-20T15:21:00.000Z',
-  },
-  {
-    rank: 6,
-    agentName: 'Claude',
-    agentVersion: 'Sonnet-4.5',
-    modelName: 'Claude Sonnet 4.5',
-    tasksCompleted: 180,
-    passedTasks: 177,
-    failedTasks: 3,
-    avgScore: 88.56,
-    avgFunctional: 83.58,
-    avgVisual: 80.0,
-    avgQuality: 80.0,
-    avgSecurity: 100.0,
-    avgCost: 85.0,
-    avgSpeed: 80.0,
-    totalTokens: 612000,
-    inputTokens: 183600,
-    outputTokens: 428400,
-    totalCostUSD: 6.98,  // (183600/1M)*3 + (428400/1M)*15
-    avgTimeMs: 42000,
-    pricingInput: 3.0,
-    pricingOutput: 15.0,
-    lastUpdated: '2026-01-20T16:46:00.000Z',
-  },
-  {
-    rank: 7,
-    agentName: 'Claude Opus',
-    agentVersion: 'Opus-4.5',
-    modelName: 'Claude Opus 4.5',
-    tasksCompleted: 180,
-    passedTasks: 180,
-    failedTasks: 0,
-    avgScore: 89.15,
-    avgFunctional: 85.0,
-    avgVisual: 80.0,
-    avgQuality: 80.0,
-    avgSecurity: 100.0,
-    avgCost: 70.0,
-    avgSpeed: 80.0,
-    totalTokens: 647747,
-    inputTokens: 194324,
-    outputTokens: 453423,
-    totalCostUSD: 12.31,  // (194324/1M)*5 + (453423/1M)*25
-    avgTimeMs: 43958,
-    pricingInput: 5.0,
-    pricingOutput: 25.0,
-    lastUpdated: '2026-01-19T19:25:00.000Z',
-  },
-  {
-    rank: 8,
-    agentName: 'Claude Haiku',
-    agentVersion: 'Haiku-4.5',
-    modelName: 'Claude Haiku 4.5',
-    tasksCompleted: 180,
-    passedTasks: 179,
-    failedTasks: 1,
-    avgScore: 88.97,
-    avgFunctional: 84.53,
-    avgVisual: 80.0,
-    avgQuality: 79.56,
-    avgSecurity: 100.0,
-    avgCost: 88.0,
-    avgSpeed: 95.0,
-    totalTokens: 798291,
-    inputTokens: 239487,
-    outputTokens: 558804,
-    totalCostUSD: 3.03,
-    avgTimeMs: 21570,
-    pricingInput: 1.0,
-    pricingOutput: 5.0,
-    lastUpdated: '2026-01-20T15:21:00.000Z',
-  },
-  {
-    rank: 9,
-    agentName: 'DeepSeek',
-    agentVersion: 'v3.2',
-    modelName: 'DeepSeek v3.2',
-    tasksCompleted: 180,
-    passedTasks: 177,
-    failedTasks: 3,
-    avgScore: 88.19,
-    avgFunctional: 83.58,
-    avgVisual: 80.0,
-    avgQuality: 80.0,
-    avgSecurity: 100.0,
-    avgCost: 96.0,
-    avgSpeed: 65.0,
-    totalTokens: 542685,
-    inputTokens: 162806,
-    outputTokens: 379879,
-    totalCostUSD: 0.50,
-    avgTimeMs: 89633,
-    pricingInput: 0.30,
-    pricingOutput: 1.20,
-    lastUpdated: '2026-01-19T19:44:00.000Z',
-  },
-  {
-    rank: 9,
-    agentName: 'OpenAI',
-    agentVersion: 'GPT-5.2',
-    modelName: 'OpenAI GPT-5.2',
-    tasksCompleted: 180,
-    passedTasks: 177,
-    failedTasks: 3,
-    avgScore: 88.75,
-    avgFunctional: 83.58,
-    avgVisual: 80.0,
-    avgQuality: 79.56,
-    avgSecurity: 100.0,
-    avgCost: 98.0,
-    avgSpeed: 92.0,
-    totalTokens: 485000,
-    inputTokens: 145500,
-    outputTokens: 339500,
-    totalCostUSD: 5.01,  // (145500/1M)*1.75 + (339500/1M)*14
-    avgTimeMs: 28000,
-    pricingInput: 1.75,
-    pricingOutput: 14.0,
-    lastUpdated: '2026-01-20T16:35:00.000Z',
-  },
-  {
-    rank: 10,
-    agentName: 'GLM',
-    agentVersion: '4.7-Flash',
-    modelName: 'GLM 4.7 Flash',
-    tasksCompleted: 180,
-    passedTasks: 8,
-    failedTasks: 172,
-    avgScore: 57.27,
-    avgFunctional: 3.78,
-    avgVisual: 80.0,
-    avgQuality: 80.0,
-    avgSecurity: 100.0,
-    avgCost: 99.0,
-    avgSpeed: 98.0,
-    totalTokens: 245000,
-    inputTokens: 73500,
-    outputTokens: 171500,
-    totalCostUSD: 0.07,
-    avgTimeMs: 8000,
-    pricingInput: 0.07,
-    pricingOutput: 0.40,
-    lastUpdated: '2026-01-20T16:23:00.000Z',
-  },
-  {
-    rank: 11,
-    agentName: 'Grok',
-    agentVersion: '4-Fast',
-    modelName: 'Grok 4 Fast',
-    tasksCompleted: 180,
-    passedTasks: 178,
-    failedTasks: 2,
-    avgScore: 88.80,
-    avgFunctional: 84.10,
-    avgVisual: 80.0,
-    avgQuality: 80.0,
-    avgSecurity: 100.0,
-    avgCost: 94.0,
-    avgSpeed: 72.0,
-    totalTokens: 520000,
-    inputTokens: 156000,
-    outputTokens: 364000,
-    totalCostUSD: 0.21,
-    avgTimeMs: 70000,
-    pricingInput: 0.20,
-    pricingOutput: 0.50,
-    lastUpdated: '2026-01-20T18:30:00.000Z',
-  },
-  {
-    rank: 12,
-    agentName: 'Grok',
-    agentVersion: '4',
-    modelName: 'Grok 4',
-    tasksCompleted: 180,
-    passedTasks: 176,
-    failedTasks: 4,
-    avgScore: 88.00,
-    avgFunctional: 83.60,
-    avgVisual: 80.0,
-    avgQuality: 80.0,
-    avgSecurity: 100.0,
-    avgCost: 94.0,
-    avgSpeed: 70.0,
-    totalTokens: 480000,
-    inputTokens: 144000,
-    outputTokens: 336000,
-    totalCostUSD: 5.47,
-    avgTimeMs: 75000,
-    pricingInput: 3.0,
-    pricingOutput: 15.0,
-    lastUpdated: '2026-01-20T18:37:00.000Z',
-  },
-  {
-    rank: 13,
-    agentName: 'Grok',
-    agentVersion: '4.1-Fast',
-    modelName: 'Grok 4.1 Fast',
-    tasksCompleted: 180,
-    passedTasks: 175,
-    failedTasks: 5,
-    avgScore: 86.80,
-    avgFunctional: 82.60,
-    avgVisual: 80.0,
-    avgQuality: 78.70,
-    avgSecurity: 100.0,
-    avgCost: 90.0,
-    avgSpeed: 68.0,
-    totalTokens: 580000,
-    inputTokens: 174000,
-    outputTokens: 406000,
-    totalCostUSD: 0.24,
-    avgTimeMs: 88500,
-    pricingInput: 0.20,
-    pricingOutput: 0.50,
-    lastUpdated: '2026-01-20T18:35:00.000Z',
-  },
-];
-
-// Get leaderboard from database
-async function getLeaderboardFromDB() {
-  if (!db) return null;
-
-  try {
-    const results = await db
-      .select({
-        agentName: benchmarkRuns.agentName,
-        agentVersion: benchmarkRuns.agentVersion,
-        tasksCompleted: sql<number>`max(${benchmarkRuns.totalTasks})`.as('tasks_completed'),
-        passedTasks: sql<number>`max(${benchmarkRuns.passedTasks})`.as('passed_tasks'),
-        failedTasks: sql<number>`max(${benchmarkRuns.failedTasks})`.as('failed_tasks'),
-        avgScore: sql<number>`max(${benchmarkRuns.avgScore})`.as('avg_score'),
-        totalTokens: sql<number>`sum(${benchmarkRuns.totalTokens})`.as('total_tokens'),
-        totalCost: sql<number>`sum(${benchmarkRuns.totalCost})`.as('total_cost'),
-        lastUpdated: sql<string>`max(${benchmarkRuns.completedAt})`.as('last_updated'),
-      })
-      .from(benchmarkRuns)
-      .where(eq(benchmarkRuns.status, 'completed'))
-      .groupBy(benchmarkRuns.agentName, benchmarkRuns.agentVersion)
-      .orderBy(desc(sql`max(${benchmarkRuns.avgScore})`));
-
-    return results.map((r, i) => ({
-      rank: i + 1,
-      agentName: r.agentName,
-      agentVersion: r.agentVersion,
-      tasksCompleted: Number(r.tasksCompleted) || 180,
-      avgScore: Number(r.avgScore) || 0,
-      avgFunctional: Number(r.avgScore) * 0.95 || 0,
-      avgVisual: Number(r.avgScore) * 0.9 || 0,
-      avgQuality: Number(r.avgScore) * 0.88 || 0,
-      avgSecurity: 90,
-      avgCost: Number(r.totalCost) || 0,
-      avgSpeed: 85,
-      totalTokens: Number(r.totalTokens) || 0,
-      passedTasks: Number(r.passedTasks) || 0,
-      failedTasks: Number(r.failedTasks) || 0,
-      lastUpdated: r.lastUpdated || new Date().toISOString(),
-    }));
-  } catch (error) {
-    console.error('Database query failed:', error);
-    return null;
-  }
-}
-
-// Get overall leaderboard
-leaderboardRoutes.get('/', async (c) => {
-  const sortBy = c.req.query('sort') || 'avgScore';
-  const order = c.req.query('order') || 'desc';
-
-  // Try database first
-  let leaderboard = await getLeaderboardFromDB();
-
-  // Fallback to mock data
-  if (!leaderboard || leaderboard.length === 0) {
-    leaderboard = mockLeaderboard;
-  }
-
-  const sorted = [...leaderboard].sort((a, b) => {
-    const aVal = (a as unknown as Record<string, number>)[sortBy];
-    const bVal = (b as unknown as Record<string, number>)[sortBy];
-    return order === 'desc' ? bVal - aVal : aVal - bVal;
-  });
-
-  // Update ranks after sorting
-  sorted.forEach((entry, index) => {
-    entry.rank = index + 1;
-  });
-
-  return c.json({
-    leaderboard: sorted,
-    totalAgents: sorted.length,
-    lastUpdated: new Date().toISOString(),
-    source: db ? 'database' : 'mock',
-  });
-});
-
-// Get leaderboard by category
-leaderboardRoutes.get('/category/:category', async (c) => {
-  const category = c.req.param('category');
-
-  // For now, return mock data filtered by category
-  return c.json({
-    category,
-    leaderboard: mockLeaderboard,
-    totalAgents: mockLeaderboard.length,
-  });
-});
-
-// Get leaderboard by task
-leaderboardRoutes.get('/task/*', async (c) => {
-  const taskId = c.req.path.replace('/api/leaderboard/task/', '');
-
-  // Mock task-specific scores
-  const taskLeaderboard = mockLeaderboard.map((entry, index) => ({
-    rank: index + 1,
-    agentName: entry.agentName,
-    agentVersion: entry.agentVersion,
-    taskId,
-    score: entry.avgScore - Math.random() * 5,
-    functional: entry.avgFunctional - Math.random() * 5,
-    visual: entry.avgVisual - Math.random() * 5,
-    quality: entry.avgQuality - Math.random() * 5,
-    tokensUsed: Math.floor(entry.totalTokens / 13),
-    executionTimeMs: 30000 + Math.random() * 60000,
-    completedAt: new Date().toISOString(),
-  }));
-
-  return c.json({
-    taskId,
-    leaderboard: taskLeaderboard,
-    totalSubmissions: taskLeaderboard.length,
-  });
-});
-
-// Get per-task results for all models (for charts)
-leaderboardRoutes.get('/task-results', async (c) => {
-  // Generate simulated per-task results based on model performance
-  const categories = ['saas-core', 'glue-code', 'ai-integration', 'frontend', 'api-integrations', 'code-evolution'];
-  const subcategories: Record<string, string[]> = {
-    'saas-core': ['auth', 'billing', 'multi-tenant', 'realtime', 'security', 'advanced'],
-    'glue-code': ['data-pipeline', 'file-processing', 'message-queue', 'scheduler', 'webhook', 'advanced'],
-    'ai-integration': ['embeddings', 'function-calling', 'multimodal', 'rag-chatbot', 'structured-output', 'advanced', 'agents', 'fine-tuning'],
-    'frontend': ['components', 'accessibility', 'animation', 'performance', 'forms', 'advanced'],
-    'api-integrations': ['communication', 'analytics', 'auth-provider', 'email', 'maps', 'payment', 'social', 'storage', 'stripe', 'advanced'],
-    'code-evolution': ['legacy-migration', 'performance', 'refactoring', 'security', 'testing', 'advanced'],
-  };
-
-  const taskResults: Array<{
-    taskId: string;
-    category: string;
-    subcategory: string;
-    results: Array<{
-      modelName: string;
-      score: number;
-      functional: number;
-      quality: number;
-      passed: boolean;
-      tokens: number;
-      timeMs: number;
-      cost: number;
-    }>;
-  }> = [];
-
-  let taskIndex = 0;
-  for (const category of categories) {
-    const subs = subcategories[category] || ['default'];
-    const tasksPerSub = Math.ceil(30 / subs.length);
-
-    for (const sub of subs) {
-      for (let i = 0; i < tasksPerSub && taskIndex < 180; i++) {
-        const taskId = `${category}/${sub}/task-${i + 1}`;
-
-        // Generate results for each model based on their overall performance
-        const results = mockLeaderboard.map(model => {
-          // Add some variance per task based on category difficulty
-          const categoryBonus: Record<string, number> = {
-            'saas-core': 2,
-            'frontend': 3,
-            'api-integrations': 1,
-            'glue-code': -1,
-            'ai-integration': -2,
-            'code-evolution': -3,
-          };
-
-          const baseScore = model.avgScore + (categoryBonus[category] || 0);
-          const variance = (Math.sin(taskIndex * 0.5 + model.rank) * 5); // Deterministic variance
-          const score = Math.max(0, Math.min(100, baseScore + variance));
-          const passed = score >= 60;
-
-          return {
-            modelName: model.modelName,
-            score: parseFloat(score.toFixed(1)),
-            functional: parseFloat((score * 0.95).toFixed(1)),
-            quality: parseFloat((model.avgQuality + variance * 0.3).toFixed(1)),
-            passed,
-            tokens: Math.round(model.totalTokens / 180 * (0.8 + Math.random() * 0.4)),
-            timeMs: Math.round(model.avgTimeMs * (0.7 + Math.random() * 0.6)),
-            cost: parseFloat(((model.totalCostUSD / 180) * (0.8 + Math.random() * 0.4)).toFixed(4)),
-          };
-        });
-
-        taskResults.push({
-          taskId,
-          category,
-          subcategory: sub,
-          results,
-        });
-
-        taskIndex++;
-      }
-    }
-  }
-
-  return c.json({
-    tasks: taskResults,
-    totalTasks: taskResults.length,
-    models: mockLeaderboard.map(m => m.modelName),
-    categories,
-  });
-});
-
-// Get category performance breakdown
-leaderboardRoutes.get('/category-performance', async (c) => {
-  const categories = ['saas-core', 'glue-code', 'ai-integration', 'frontend', 'api-integrations', 'code-evolution'];
-
-  const performance = categories.map(category => {
-    const categoryBonus: Record<string, number> = {
-      'saas-core': 2,
-      'frontend': 3,
-      'api-integrations': 1,
-      'glue-code': -1,
-      'ai-integration': -2,
-      'code-evolution': -3,
-    };
-
-    return {
-      category,
-      models: mockLeaderboard.map(model => ({
-        modelName: model.modelName,
-        avgScore: parseFloat((model.avgScore + (categoryBonus[category] || 0)).toFixed(1)),
-        passRate: parseFloat((((model.passedTasks || 0) / 180) * 100 + (categoryBonus[category] || 0)).toFixed(1)),
-        avgTokens: Math.round(model.totalTokens / 6),
-        avgTimeMs: Math.round(model.avgTimeMs * (1 + (categoryBonus[category] || 0) * 0.05)),
-        avgCost: parseFloat((model.totalCostUSD / 6).toFixed(3)),
-      })),
-    };
-  });
-
-  return c.json({
-    performance,
-    categories,
-    models: mockLeaderboard.map(m => m.modelName),
-  });
-});
-
-// Get agent stats
-leaderboardRoutes.get('/agent/:agentName', async (c) => {
-  const agentName = c.req.param('agentName');
-
-  const entry = mockLeaderboard.find(
-    (e) => e.agentName.toLowerCase() === agentName.toLowerCase()
-  );
-
-  if (!entry) {
-    return c.json({ error: 'Agent not found' }, 404);
-  }
-
-  // Calculate proportional task completion based on agent's completion rate
-  const completionRate = entry.tasksCompleted / TOTAL_TASKS;
-  const taskBreakdown = [
-    { category: 'saas-core', avgScore: entry.avgScore + 2, tasksCompleted: Math.round(TASKS_PER_CATEGORY * completionRate), totalTasks: TASKS_PER_CATEGORY },
-    { category: 'glue-code', avgScore: entry.avgScore - 1, tasksCompleted: Math.round(TASKS_PER_CATEGORY * completionRate), totalTasks: TASKS_PER_CATEGORY },
-    { category: 'ai-integration', avgScore: entry.avgScore - 3, tasksCompleted: Math.round(TASKS_PER_CATEGORY * completionRate * 0.9), totalTasks: TASKS_PER_CATEGORY },
-    { category: 'frontend', avgScore: entry.avgScore + 4, tasksCompleted: Math.round(TASKS_PER_CATEGORY * completionRate), totalTasks: TASKS_PER_CATEGORY },
-    { category: 'api-integrations', avgScore: entry.avgScore + 1, tasksCompleted: Math.round(TASKS_PER_CATEGORY * completionRate), totalTasks: TASKS_PER_CATEGORY },
-    { category: 'code-evolution', avgScore: entry.avgScore - 2, tasksCompleted: Math.round(TASKS_PER_CATEGORY * completionRate * 0.85), totalTasks: TASKS_PER_CATEGORY },
-  ];
-
-  return c.json({
-    agent: entry,
-    taskBreakdown,
-    totalTasks: TOTAL_TASKS,
-    recentSubmissions: [],
-  });
-});
-
-// Record a new benchmark run result
-leaderboardRoutes.post('/runs', async (c) => {
-  if (!db) {
-    return c.json({ error: 'Database not available' }, 503);
-  }
-
-  const body = await c.req.json();
-
-  const [run] = await db.insert(benchmarkRuns).values({
-    agentName: body.agentName,
-    agentVersion: body.agentVersion,
-    seed: body.seed,
-    status: body.status || 'completed',
-    totalTasks: body.totalTasks,
-    passedTasks: body.passedTasks,
-    failedTasks: body.failedTasks,
-    avgScore: body.avgScore,
-    totalCost: body.totalCost,
-    totalTokens: body.totalTokens,
-    totalDurationMs: body.totalDurationMs,
-    completedAt: new Date(),
-  }).returning();
-
-  return c.json(run, 201);
-});
-
-// Get current model pricing
-leaderboardRoutes.get('/pricing', async (c) => {
-  const seen = new Set<string>();
-  const pricingTable = Object.entries(MODEL_PRICING)
-    .filter(([_, p]) => {
-      if (seen.has(p.model)) return false;
-      seen.add(p.model);
-      return true;
-    })
-    .map(([key, p]) => ({
-      key,
-      provider: p.provider,
-      model: p.model,
-      inputPerMillion: p.input,
-      outputPerMillion: p.output,
-      lastUpdated: p.lastUpdated,
-    }))
-    .sort((a, b) => a.provider.localeCompare(b.provider));
-
-  return c.json({
-    pricing: pricingTable,
-    source: 'OpenRouter',
-    lastUpdated: '2026-01-21',
-    note: 'Prices in USD per 1 million tokens',
-  });
-});
-
-export { leaderboardRoutes };