Revert "refactor(web): remove Snowflake-backed public leaderboard endpoints"

apps/web/src/app/api/public/leaderboard-model-provider-usage/route.ts

@@ -0,0 +1,174 @@
+import { z } from 'zod';
+
+import { normalizePublicInferenceProvider } from '@/lib/public-inference-provider';
+import {
+  createPublicSnowflakeReport,
+  publicSnowflakeReportOptions,
+} from '@/lib/public-snowflake-report';
+import { LEADERBOARD_MODEL_PROVIDER_USAGE_REDIS_KEY } from '@/lib/redis-keys';
+
+const MINIMUM_TOKENS = 10_000_000;
+const MAXIMUM_ERROR_RATE = 0.5;
+
+const LEADERBOARD_MODEL_PROVIDER_USAGE_QUERY = `
+select
+     mu.requested_model as "model"
+    , mu.inference_provider as "provider"
+    , sum(mu.total_cost_microdollars) as "sum_cost"
+    , sum(mu.total_input_tokens) + sum(mu.total_output_tokens) as "sum_tokens"
+    , sum(mu.total_input_tokens) as "sum_input_tokens"
+    , sum(mu.total_cache_hit_tokens) as "sum_cache_hit_tokens"
+    , sum(mu.request_count) as "sum_request_count"
+    , sum(mu.error_count) as "sum_error_count"
+from kilo_dw.dbt_prod.microdollar_usage_daily as mu
+where
+    mu.usage_date >= dateadd(week, -1, current_date())
+    and mu.usage_date < current_date()
+    and mu.provider not in ('custom', 'direct-byok')
+    and mu.total_output_tokens > 0
+    and mu.is_user_byok = false
+    and mu.requested_model not ilike '%mercury-edit%'
+group by 1, 2
+order by 4 desc;
+`;
+
+const modelProviderUsageSchema = z.array(
+  z.object({
+    model: z.string().min(1),
+    provider: z.string().min(1),
+    sumTokens: z.number(),
+    costPerRequest: z.number(),
+    costPerMillionTokens: z.number(),
+    cacheRatio: z.number(),
+    errorRate: z.number(),
+    percentageOfModel: z.number(),
+  })
+);
+
+type ModelProviderUsage = z.infer<typeof modelProviderUsageSchema>[number];
+
+type AggregatedUsage = {
+  model: string;
+  provider: string;
+  sumCost: number;
+  sumTokens: number;
+  sumInputTokens: number;
+  sumCacheHitTokens: number;
+  sumRequestCount: number;
+  sumErrorCount: number;
+};
+
+function normalizeModel(model: string): string {
+  const withoutTrailingSlashes = model.replace(/\/+$/, '');
+  const slashIndex = withoutTrailingSlashes.lastIndexOf('/');
+  const withoutProvider = withoutTrailingSlashes.startsWith('openrouter/')
+    ? withoutTrailingSlashes
+    : slashIndex >= 0
+      ? withoutTrailingSlashes.slice(slashIndex + 1)
+      : withoutTrailingSlashes;
+  const colonIndex = withoutProvider.indexOf(':');
+
+  if (colonIndex < 0 || withoutProvider.slice(colonIndex) === ':free') {
+    return withoutProvider;
+  }
+
+  return withoutProvider.slice(0, colonIndex);
+}
+
+function ratio(numerator: number, denominator: number): number {
+  return denominator === 0 ? 0 : numerator / denominator;
+}
+
+function parseAndAggregateUsage(rows: string[][]): ModelProviderUsage[] {
+  const usageByModelAndProvider = new Map<string, AggregatedUsage>();
+
+  for (const row of rows) {
+    const [rawModel, rawProvider, ...rawAggregates] = row;
+    const [sumCost, sumTokens, sumInputTokens, sumCacheHitTokens, sumRequestCount, sumErrorCount] =
+      rawAggregates.map(Number);
+    const model = normalizeModel(rawModel?.trim() || '');
+    const provider = normalizePublicInferenceProvider(rawProvider?.trim() || 'unknown');
+
+    if (
+      !model ||
+      ![
+        sumCost,
+        sumTokens,
+        sumInputTokens,
+        sumCacheHitTokens,
+        sumRequestCount,
+        sumErrorCount,
+      ].every(Number.isFinite)
+    ) {
+      throw new Error('Snowflake returned an invalid leaderboard model provider usage row');
+    }
+
+    if (provider.key === 'other') {
+      continue;
+    }
+
+    const aggregationKey = `${model}\0${provider.key}`;
+    const existing = usageByModelAndProvider.get(aggregationKey);
+
+    if (existing) {
+      existing.sumCost += sumCost;
+      existing.sumTokens += sumTokens;
+      existing.sumInputTokens += sumInputTokens;
+      existing.sumCacheHitTokens += sumCacheHitTokens;
+      existing.sumRequestCount += sumRequestCount;
+      existing.sumErrorCount += sumErrorCount;
+    } else {
+      usageByModelAndProvider.set(aggregationKey, {
+        model,
+        provider: provider.name,
+        sumCost,
+        sumTokens,
+        sumInputTokens,
+        sumCacheHitTokens,
+        sumRequestCount,
+        sumErrorCount,
+      });
+    }
+  }
+
+  const aggregatedUsage = [...usageByModelAndProvider.values()];
+  const totalTokensByModel = new Map<string, number>();
+
+  for (const usage of aggregatedUsage) {
+    totalTokensByModel.set(
+      usage.model,
+      (totalTokensByModel.get(usage.model) ?? 0) + usage.sumTokens
+    );
+  }
+
+  return aggregatedUsage
+    .filter(usage => usage.sumTokens >= MINIMUM_TOKENS)
+    .sort(
+      (left, right) =>
+        right.sumTokens - left.sumTokens ||
+        left.model.localeCompare(right.model) ||
+        left.provider.localeCompare(right.provider)
+    )
+    .map(usage => ({
+      model: usage.model,
+      provider: usage.provider,
+      sumTokens: usage.sumTokens,
+      costPerRequest: ratio(usage.sumCost, usage.sumRequestCount - usage.sumErrorCount) / 1e6,
+      costPerMillionTokens: ratio(usage.sumCost, usage.sumTokens),
+      cacheRatio: ratio(usage.sumCacheHitTokens, usage.sumInputTokens),
+      errorRate: ratio(usage.sumErrorCount, usage.sumRequestCount),
+      percentageOfModel:
+        ratio(usage.sumTokens, totalTokensByModel.get(usage.model) ?? 0) * 100,
+    })).filter(usage => usage.errorRate < MAXIMUM_ERROR_RATE);
+}
+
+export const GET = createPublicSnowflakeReport({
+  cacheKey: LEADERBOARD_MODEL_PROVIDER_USAGE_REDIS_KEY,
+  errorMessage: 'Failed to fetch leaderboard model provider usage',
+  parseRows: parseAndAggregateUsage,
+  query: LEADERBOARD_MODEL_PROVIDER_USAGE_QUERY,
+  schema: modelProviderUsageSchema,
+  source: 'public-leaderboard-model-provider-usage-api',
+});
+
+export const OPTIONS = publicSnowflakeReportOptions;

apps/web/src/app/api/public/leaderboard-model-usage/route.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+
+import {
+  createPublicSnowflakeReport,
+  publicSnowflakeReportOptions,
+} from '@/lib/public-snowflake-report';
+import { LEADERBOARD_MODEL_USAGE_REDIS_KEY } from '@/lib/redis-keys';
+
+const LEADERBOARD_MODEL_USAGE_QUERY = `
+select
+    to_char(mu.usage_date, 'YYYY-MM-DD') as usage_date
+    , coalesce(mu.requested_model, mu.model) as "model"
+    , case
+        when mu.feature ilike '%claw%' then 'kiloclaw'
+        when mu.mode ilike '%code%' then 'code'
+        when mu.mode ilike '%review%' then 'review'
+        when mu.mode ilike '%plan%' then 'plan'
+        when mu.mode ilike '%ask%' then 'ask'
+        when mu.mode ilike '%debug%' then 'debug'
+        else null
+      end as mode
+    , sum(coalesce(mu.total_input_tokens, 0)) + sum(coalesce(mu.total_output_tokens, 0)) as "tokens"
+from kilo_dw.dbt_prod.microdollar_usage_daily as mu
+where
+    mu.usage_date >= dateadd(week, -1, current_date())
+    and mu.usage_date < current_date()
+    and mu.total_input_tokens > 0
+    and mu.provider != 'custom'
+group by 1, 2, 3
+order by 1 desc, 4 desc;
+`;
+
+const modelUsageSchema = z.array(
+  z.object({
+    usageDate: z.string(),
+    model: z.string().min(1),
+    mode: z.enum(['kiloclaw', 'code', 'review', 'plan', 'ask', 'debug']).nullable(),
+    tokens: z.number(),
+  })
+);
+
+type ModelUsage = z.infer<typeof modelUsageSchema>[number];
+
+function parseModelUsage(rows: string[][]): ModelUsage[] {
+  return rows.map(row => {
+    const [usageDate, model, modeValue, tokenValue] = row;
+    const tokens = Number(tokenValue);
+    const mode = modeValue || null;
+
+    if (!usageDate || !model || !Number.isFinite(tokens)) {
+      throw new Error('Snowflake returned an invalid model usage row');
+    }
+
+    return modelUsageSchema.element.parse({
+      usageDate,
+      model,
+      mode,
+      tokens,
+    });
+  });
+}
+
+export const GET = createPublicSnowflakeReport({
+  cacheKey: LEADERBOARD_MODEL_USAGE_REDIS_KEY,
+  errorMessage: 'Failed to fetch leaderboard model usage',
+  parseRows: parseModelUsage,
+  query: LEADERBOARD_MODEL_USAGE_QUERY,
+  schema: modelUsageSchema,
+  source: 'public-leaderboard-model-usage-api',
+});
+
+export const OPTIONS = publicSnowflakeReportOptions;

apps/web/src/app/api/public/leaderboard-provider-race/route.test.ts

@@ -0,0 +1,109 @@
+import { describe, test, expect, jest } from '@jest/globals';
+import type { resolveSnowflakeConfig } from '@/lib/snowflake';
+import type { GET as RouteGet } from './route';
+
+jest.mock('@sentry/nextjs', () => ({ captureException: jest.fn() }));
+
+jest.mock('@/lib/redis', () => ({
+  redisClient: {
+    get: jest.fn<() => Promise<string | null>>().mockResolvedValue(null),
+    set: jest.fn<() => Promise<string>>().mockResolvedValue('OK'),
+  },
+}));
+
+jest.mock('@/lib/snowflake', () => ({
+  resolveSnowflakeConfig: jest.fn(),
+  executeSnowflakeStatement: jest.fn(),
+}));
+
+type SnowflakeConfig = ReturnType<typeof resolveSnowflakeConfig>;
+
+const FAKE_CONFIG = { accountHost: 'test.snowflakecomputing.com' } as SnowflakeConfig;
+
+// The route builds a module-level in-process cache (1h TTL) at import time, so
+// each test loads it in an isolated module registry to keep that cache from
+// leaking between cases.
+async function loadGet(opts: {
+  config?: SnowflakeConfig;
+  rows?: string[][];
+  statementError?: Error;
+}): Promise<typeof RouteGet> {
+  let GET!: typeof RouteGet;
+  await jest.isolateModulesAsync(async () => {
+    const snowflake = await import('@/lib/snowflake');
+    const config = opts.config === undefined ? FAKE_CONFIG : opts.config;
+    jest.mocked(snowflake.resolveSnowflakeConfig).mockReturnValue(config);
+    if (opts.statementError) {
+      jest.mocked(snowflake.executeSnowflakeStatement).mockRejectedValue(opts.statementError);
+    } else {
+      jest.mocked(snowflake.executeSnowflakeStatement).mockResolvedValue(opts.rows ?? []);
+    }
+    ({ GET } = await import('./route'));
+  });
+  return GET;
+}
+
+describe('GET /api/public/leaderboard-provider-race', () => {
+  test('returns 503 when Snowflake is not configured', async () => {
+    const GET = await loadGet({ config: null });
+
+    const response = await GET();
+
+    expect(response.status).toBe(503);
+    expect(response.headers.get('Access-Control-Allow-Origin')).toBe('*');
+  });
+
+  test('returns 502 when the Snowflake query fails (e.g. is_open_weights backfill not landed)', async () => {
+    const GET = await loadGet({ statementError: new Error('invalid identifier IS_OPEN_WEIGHTS') });
+
+    const response = await GET();
+
+    expect(response.status).toBe(502);
+  });
+
+  test('maps explicit is_open_weights to booleans and NULL/unknown to null', async () => {
+    const GET = await loadGet({
+      rows: [
+        ['2026-07-14', 'Anthropic', 'false', '12345'],
+        ['2026-07-14', 'Alibaba', 'true', '6789'],
+        // The SQL API returns NULL cells as null at runtime despite the
+        // string[] row type; unmapped models land here.
+        ['2026-07-14', 'other', null, '999'] as unknown as string[],
+        // A future model_dim mapping gap must not be silently bucketed as closed.
+        ['2026-07-14', 'Mystery', 'unexpected', '111'],
+      ],
+    });
+
+    const response = await GET();
+
+    expect(response.status).toBe(200);
+    expect(await response.json()).toEqual([
+      { weekStart: '2026-07-14', provider: 'Anthropic', isOpenWeights: false, tokens: 12345 },
+      { weekStart: '2026-07-14', provider: 'Alibaba', isOpenWeights: true, tokens: 6789 },
+      { weekStart: '2026-07-14', provider: 'other', isOpenWeights: null, tokens: 999 },
+      { weekStart: '2026-07-14', provider: 'Mystery', isOpenWeights: null, tokens: 111 },
+    ]);
+    expect(response.headers.get('Cache-Control')).toContain('public');
+    expect(response.headers.get('Access-Control-Allow-Origin')).toBe('*');
+  });
+
+  test('returns 502 when a row is malformed', async () => {
+    const GET = await loadGet({ rows: [['2026-07-14', 'Anthropic', 'true', 'not-a-number']] });
+
+    const response = await GET();
+
+    expect(response.status).toBe(502);
+  });
+});
+
+describe('OPTIONS /api/public/leaderboard-provider-race', () => {
+  test('returns 204 with CORS headers', async () => {
+    const { OPTIONS } = await import('./route');
+
+    const response = OPTIONS();
+
+    expect(response.status).toBe(204);
+    expect(response.headers.get('Access-Control-Allow-Origin')).toBe('*');
+    expect(response.headers.get('Access-Control-Allow-Methods')).toBe('GET');
+  });
+});