@littlebearapps/platform-admin-sdk 1.4.2 → 2.0.0

package/templates/shared/workers/lib/usage/collectors/openai.ts

@@ -0,0 +1,171 @@
+/**
+ * OpenAI Usage Collector
+ *
+ * Collects API usage from the OpenAI Organization Usage API.
+ * Requires Admin API key (sk-admin-...) with read permissions.
+ *
+ * Fetches both completions and embeddings endpoints with group_by=model
+ * to get per-model breakdown.
+ *
+ * This is a FLOW metric (usage that accumulates) - safe to SUM.
+ *
+ * @see https://platform.openai.com/docs/api-reference/usage
+ */
+
+import type { Env, OpenAIUsageData } from '../shared';
+import { fetchWithRetry } from '../shared';
+import { createLoggerFromEnv } from '@littlebearapps/platform-consumer-sdk';
+import type { ExternalCollector } from './index';
+
+/** Response shape from OpenAI Usage API (completions + embeddings endpoints) */
+interface UsageAPIResponse {
+  object?: string;
+  data?: Array<{
+    start_time?: number;
+    end_time?: number;
+    results?: Array<{
+      input_tokens?: number;
+      output_tokens?: number;
+      num_model_requests?: number;
+      project_id?: string;
+      user_id?: string;
+      api_key_id?: string;
+      model?: string;
+    }>;
+  }>;
+}
+
+/**
+ * Collect OpenAI API usage from the Organization Usage API.
+ * Requires Admin API key (sk-admin-...) with read permissions.
+ */
+export async function collectOpenAIUsage(env: Env): Promise<OpenAIUsageData | null> {
+  const log = createLoggerFromEnv(env, 'platform-usage', 'platform:usage:openai');
+  if (!env.OPENAI_ADMIN_API_KEY) {
+    log.info('No OPENAI_ADMIN_API_KEY configured, skipping usage collection');
+    return null;
+  }
+
+  try {
+    // Get usage for yesterday (completed day)
+    const yesterday = new Date();
+    yesterday.setUTCDate(yesterday.getUTCDate() - 1);
+    yesterday.setUTCHours(0, 0, 0, 0);
+    const startTime = Math.floor(yesterday.getTime() / 1000);
+
+    const headers = {
+      Authorization: `Bearer ${env.OPENAI_ADMIN_API_KEY}`,
+      'Content-Type': 'application/json',
+    };
+
+    const result: OpenAIUsageData = {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      totalCost: 0,
+      requestCount: 0,
+      modelBreakdown: {},
+    };
+
+    // Fetch completions and embeddings in parallel
+    const [completionsRes, embeddingsRes] = await Promise.all([
+      fetchWithRetry(
+        `https://api.openai.com/v1/organization/usage/completions?start_time=${startTime}&bucket_width=1d&group_by=model`,
+        { headers }
+      ),
+      fetchWithRetry(
+        `https://api.openai.com/v1/organization/usage/embeddings?start_time=${startTime}&bucket_width=1d&group_by=model`,
+        { headers }
+      ),
+    ]);
+
+    // Handle completions response
+    if (!completionsRes.ok) {
+      const errorText = await completionsRes.text();
+      if (completionsRes.status === 401 || completionsRes.status === 403) {
+        log.info('Usage API access denied - ensure using Admin API key with read permissions', {
+          status: completionsRes.status,
+        });
+        return null;
+      }
+      log.error(`Completions API returned ${completionsRes.status}: ${errorText}`);
+      return null;
+    }
+
+    const completionsData = (await completionsRes.json()) as UsageAPIResponse;
+    aggregateUsage(completionsData, result);
+
+    // Handle embeddings response (non-fatal — embeddings may not be used)
+    if (embeddingsRes.ok) {
+      const embeddingsData = (await embeddingsRes.json()) as UsageAPIResponse;
+      aggregateUsage(embeddingsData, result);
+    } else {
+      const errorText = await embeddingsRes.text();
+      log.info(`Embeddings API returned ${embeddingsRes.status} (non-fatal): ${errorText}`);
+    }
+
+    // Estimate cost from per-model breakdown
+    result.totalCost = 0;
+    for (const [, usage] of Object.entries(result.modelBreakdown)) {
+      result.totalCost += estimateModelCost(usage.inputTokens, usage.outputTokens);
+    }
+    // Fallback if no model breakdown but we have aggregate tokens
+    if (Object.keys(result.modelBreakdown).length === 0 && result.totalTokens > 0) {
+      result.totalCost = (result.inputTokens * 2.5 + result.outputTokens * 10) / 1_000_000;
+    }
+
+    log.info('Collected usage', {
+      inputTokens: result.inputTokens,
+      outputTokens: result.outputTokens,
+      requestCount: result.requestCount,
+      models: Object.keys(result.modelBreakdown).length,
+      estimatedCost: result.totalCost,
+    });
+    return result;
+  } catch (error) {
+    log.error('Failed to collect usage', error);
+    return null;
+  }
+}
+
+/** Aggregate usage data from an API response into the result object */
+function aggregateUsage(data: UsageAPIResponse, result: OpenAIUsageData): void {
+  if (!data.data || !Array.isArray(data.data)) return;
+
+  for (const bucket of data.data) {
+    if (!bucket.results || !Array.isArray(bucket.results)) continue;
+
+    for (const item of bucket.results) {
+      const inputTokens = item.input_tokens || 0;
+      const outputTokens = item.output_tokens || 0;
+      const requests = item.num_model_requests || 0;
+
+      result.inputTokens += inputTokens;
+      result.outputTokens += outputTokens;
+      result.totalTokens += inputTokens + outputTokens;
+      result.requestCount += requests;
+
+      if (item.model) {
+        if (!result.modelBreakdown[item.model]) {
+          result.modelBreakdown[item.model] = { inputTokens: 0, outputTokens: 0, requests: 0 };
+        }
+        result.modelBreakdown[item.model].inputTokens += inputTokens;
+        result.modelBreakdown[item.model].outputTokens += outputTokens;
+        result.modelBreakdown[item.model].requests += requests;
+      }
+    }
+  }
+}
+
+/** Rough per-model cost estimation (USD per MTok) */
+function estimateModelCost(inputTokens: number, outputTokens: number): number {
+  // Weighted average across common models: ~$2.50/$10 per MTok
+  return (inputTokens * 2.5 + outputTokens * 10) / 1_000_000;
+}
+
+/** Collector registration for use in collectors/index.ts COLLECTORS array */
+export const openaiCollector: ExternalCollector<OpenAIUsageData | null> = {
+  name: 'openai',
+  collect: collectOpenAIUsage,
+  defaultValue: null,
+};

package/templates/shared/workers/lib/usage/collectors/resend.ts

@@ -0,0 +1,79 @@
+/**
+ * Resend Email Usage Collector
+ *
+ * Collects email usage from the Resend API:
+ * - Domain count via GET /domains
+ * - Email count via GET /emails (paginated, counts all from response)
+ *
+ * This is a FLOW metric (emails sent accumulate) - safe to SUM.
+ *
+ * @see https://resend.com/docs/api-reference/emails/list-emails
+ * @see https://resend.com/docs/api-reference/domains/list-domains
+ */
+
+import type { Env, ResendUsageData } from '../shared';
+import { fetchWithRetry } from '../shared';
+import { createLoggerFromEnv } from '@littlebearapps/platform-consumer-sdk';
+import type { ExternalCollector } from './index';
+
+/**
+ * Collect Resend email usage.
+ * Fetches domains and recent emails in parallel.
+ */
+export async function collectResendUsage(env: Env): Promise<ResendUsageData | null> {
+  const log = createLoggerFromEnv(env, 'platform-usage', 'platform:usage:resend');
+  if (!env.RESEND_API_KEY) {
+    log.info('No RESEND_API_KEY configured, skipping usage collection');
+    return null;
+  }
+
+  const headers = { Authorization: `Bearer ${env.RESEND_API_KEY}` };
+
+  try {
+    const [domainsResponse, emailsResponse] = await Promise.all([
+      fetchWithRetry('https://api.resend.com/domains', { headers }),
+      fetchWithRetry('https://api.resend.com/emails', { headers }),
+    ]);
+
+    if (!domainsResponse.ok) {
+      const errorText = await domainsResponse.text();
+      log.error(`Domains API returned ${domainsResponse.status}: ${errorText}`);
+      return null;
+    }
+
+    const domainsData = (await domainsResponse.json()) as {
+      data?: Array<{ id: string; name: string; status: string }>;
+    };
+
+    let emailsSent = 0;
+    if (emailsResponse.ok) {
+      const emailsData = (await emailsResponse.json()) as {
+        data?: Array<{ id: string; created_at: string }>;
+      };
+      emailsSent = emailsData.data?.length ?? 0;
+    } else {
+      log.info('Emails API not available, defaulting to 0', { status: emailsResponse.status });
+    }
+
+    const result: ResendUsageData = {
+      emailsSent,
+      domainsCount: domainsData.data?.length || 0,
+    };
+
+    log.info('Collected usage', {
+      emailsSent: result.emailsSent,
+      domainsCount: result.domainsCount,
+    });
+    return result;
+  } catch (error) {
+    log.error('Failed to collect usage', error);
+    return null;
+  }
+}
+
+/** Collector registration for use in collectors/index.ts COLLECTORS array */
+export const resendCollector: ExternalCollector<ResendUsageData | null> = {
+  name: 'resend',
+  collect: collectResendUsage,
+  defaultValue: null,
+};

package/templates/shared/workers/lib/usage/collectors/stripe.ts

@@ -0,0 +1,192 @@
+/**
+ * Stripe Revenue Collector
+ *
+ * Collects subscription revenue data from the Stripe REST API.
+ * Tracks MRR, ARR, active/churned/trial subscriptions, and failed payments.
+ *
+ * Requires STRIPE_SECRET_KEY (sk_live_... or sk_test_...).
+ *
+ * This is a FLOW metric (revenue accumulates) - safe to SUM.
+ *
+ * @see https://docs.stripe.com/api/subscriptions/list
+ * @see https://docs.stripe.com/api/invoices/list
+ */
+
+import type { Env, StripeRevenueData } from '../shared';
+import { fetchWithRetry } from '../shared';
+import { createLoggerFromEnv } from '@littlebearapps/platform-consumer-sdk';
+import type { ExternalCollector } from './index';
+
+/** Maximum pages to fetch to prevent runaway pagination */
+const MAX_PAGES = 10;
+
+/** Stripe subscription from the API */
+interface StripeSubscription {
+  id: string;
+  status: string;
+  canceled_at?: number | null;
+  items?: {
+    data?: Array<{
+      plan?: {
+        amount?: number;
+        interval?: string;
+        interval_count?: number;
+      };
+    }>;
+  };
+}
+
+/** Stripe list response */
+interface StripeListResponse<T> {
+  data?: T[];
+  has_more?: boolean;
+}
+
+/**
+ * Fetch a paginated Stripe endpoint with safety limit.
+ */
+async function fetchStripeList<T>(
+  url: string,
+  headers: Record<string, string>,
+  log: ReturnType<typeof createLoggerFromEnv>
+): Promise<T[]> {
+  const items: T[] = [];
+  let currentUrl = url;
+  let page = 0;
+
+  while (page < MAX_PAGES) {
+    const response = await fetchWithRetry(currentUrl, { headers });
+    if (!response.ok) {
+      const errorText = await response.text();
+      log.error(`Stripe API returned ${response.status}: ${errorText}`);
+      break;
+    }
+
+    const data = (await response.json()) as StripeListResponse<T>;
+    if (data.data) {
+      items.push(...data.data);
+    }
+
+    if (!data.has_more || !data.data?.length) break;
+
+    // Use the last item's ID for cursor-based pagination
+    const lastItem = data.data[data.data.length - 1] as { id?: string };
+    if (!lastItem?.id) break;
+    const separator = currentUrl.includes('?') ? '&' : '?';
+    currentUrl = `${url}${separator}starting_after=${lastItem.id}`;
+    page++;
+  }
+
+  return items;
+}
+
+/**
+ * Calculate monthly amount from a subscription's plan.
+ * Normalises yearly/quarterly plans to monthly equivalent.
+ */
+function monthlyAmount(sub: StripeSubscription): number {
+  let total = 0;
+  for (const item of sub.items?.data || []) {
+    const amount = item.plan?.amount || 0;
+    const interval = item.plan?.interval || 'month';
+    const count = item.plan?.interval_count || 1;
+
+    // Normalise to monthly — Stripe amounts are in cents
+    if (interval === 'year') {
+      total += amount / (12 * count);
+    } else if (interval === 'week') {
+      total += (amount * 52) / (12 * count);
+    } else if (interval === 'day') {
+      total += (amount * 365) / (12 * count);
+    } else {
+      // month
+      total += amount / count;
+    }
+  }
+  return total / 100; // Convert cents to USD
+}
+
+/**
+ * Collect Stripe subscription revenue data.
+ */
+export async function collectStripeRevenue(env: Env): Promise<StripeRevenueData | null> {
+  const log = createLoggerFromEnv(env, 'platform-usage', 'platform:usage:stripe');
+  if (!env.STRIPE_SECRET_KEY) {
+    log.info('No STRIPE_SECRET_KEY configured, skipping revenue collection');
+    return null;
+  }
+
+  try {
+    const headers = {
+      Authorization: `Bearer ${env.STRIPE_SECRET_KEY}`,
+      'Content-Type': 'application/x-www-form-urlencoded',
+    };
+
+    // Fetch active subscriptions
+    const subscriptions = await fetchStripeList<StripeSubscription>(
+      'https://api.stripe.com/v1/subscriptions?limit=100&status=all',
+      headers,
+      log
+    );
+
+    let mrr = 0;
+    let activeSubscriptions = 0;
+    let churnedSubscriptions = 0;
+    let trialSubscriptions = 0;
+
+    const thirtyDaysAgo = Math.floor(Date.now() / 1000) - 30 * 24 * 60 * 60;
+
+    for (const sub of subscriptions) {
+      if (sub.status === 'active') {
+        activeSubscriptions++;
+        mrr += monthlyAmount(sub);
+      } else if (sub.status === 'trialing') {
+        trialSubscriptions++;
+      } else if (
+        sub.status === 'canceled' &&
+        sub.canceled_at &&
+        sub.canceled_at >= thirtyDaysAgo
+      ) {
+        churnedSubscriptions++;
+      }
+    }
+
+    // Count failed payments (open invoices that are past due)
+    const failedInvoices = await fetchStripeList<{ id: string }>(
+      'https://api.stripe.com/v1/invoices?limit=100&status=open',
+      headers,
+      log
+    );
+    const failedPayments = failedInvoices.length;
+
+    const result: StripeRevenueData = {
+      mrr,
+      arr: mrr * 12,
+      activeSubscriptions,
+      churnedSubscriptions,
+      failedPayments,
+      trialSubscriptions,
+      totalRevenue: mrr, // Current month snapshot
+      currency: 'usd',
+    };
+
+    log.info('Collected revenue', {
+      mrr: result.mrr,
+      arr: result.arr,
+      activeSubscriptions: result.activeSubscriptions,
+      churnedSubscriptions: result.churnedSubscriptions,
+    });
+
+    return result;
+  } catch (error) {
+    log.error('Failed to collect revenue', error);
+    return null;
+  }
+}
+
+/** Collector registration for use in collectors/index.ts COLLECTORS array */
+export const stripeCollector: ExternalCollector<StripeRevenueData | null> = {
+  name: 'stripe',
+  collect: collectStripeRevenue,
+  defaultValue: null,
+};

package/templates/shared/workers/lib/usage/shared/types.ts

@@ -60,6 +60,10 @@ export interface Env {
   MINIMAX_API_KEY?: string;
   GCP_PROJECT_ID?: string;
   GCP_SERVICE_ACCOUNT_JSON?: string; // JSON string for service account credentials
+  // Stripe
+  STRIPE_SECRET_KEY?: string; // Stripe secret key (sk_live_... or sk_test_...)
+  // GitHub org name (for billing API — replaces hardcoded org)
+  GITHUB_ORG?: string;
   // Live usage API authentication
   USAGE_API_KEY?: string;
   // Platform SDK bindings (pilot integration)
@@ -951,6 +955,48 @@ export interface GeminiUsageData {
   methodBreakdown: Record<string, number>;
 }
 
+/**
+ * Stripe revenue data (Flow metric — revenue accumulates)
+ * Collected via Stripe REST API
+ */
+export interface StripeRevenueData {
+  /** Monthly Recurring Revenue in USD */
+  mrr: number;
+  /** Annual Recurring Revenue (MRR × 12) */
+  arr: number;
+  /** Number of active subscriptions */
+  activeSubscriptions: number;
+  /** Subscriptions cancelled in last 30 days */
+  churnedSubscriptions: number;
+  /** Open/unpaid invoices */
+  failedPayments: number;
+  /** Subscriptions currently in trial */
+  trialSubscriptions: number;
+  /** Total revenue collected in period (USD) */
+  totalRevenue: number;
+  /** Currency (typically 'usd') */
+  currency: string;
+}
+
+/**
+ * Configuration for a custom HTTP collector.
+ * Use with `createCustomCollector()` factory in `collectors/custom-http.ts`.
+ */
+export interface CustomHttpCollectorConfig {
+  /** Unique name for the collector */
+  name: string;
+  /** API endpoint URL */
+  url: string;
+  /** Auth type: bearer token, basic auth, or API key header */
+  auth: { type: 'bearer'; envKey: string }
+    | { type: 'basic'; usernameEnvKey: string; passwordEnvKey: string }
+    | { type: 'api-key'; headerName: string; envKey: string };
+  /** Map of metric name → JSON path in response (dot notation) */
+  metrics: Record<string, { jsonPath: string; unit: string; isCost?: boolean }>;
+  /** Optional request headers */
+  headers?: Record<string, string>;
+}
+
 // =============================================================================
 // ERROR HANDLING TYPES
 // =============================================================================

package/templates/shared/workers/platform-usage.ts

@@ -1100,16 +1100,106 @@ async function handleScheduled(
       }
 
       // Persist collected external metrics to D1 third_party_usage table.
-      // The collector framework returns results keyed by collector name.
-      // TODO: Add your own persistence logic for each registered collector.
-      // See workers/lib/usage/collectors/example.ts for the collector template.
+      // Uncomment the blocks below for providers you've registered in collectors/index.ts.
       //
-      // Example:
-      //   const myProviderData = externalMetrics.results['my-provider'];
-      //   if (myProviderData) {
-      //     await persistThirdPartyUsage(trackedEnv, today, 'my-provider', 'metric_name', value, 'unit', cost);
-      //     totalD1Writes++;
+      // --- OpenAI (FLOW metric) ---
+      // const openaiData = externalMetrics.results['openai'] as import('./lib/usage/shared').OpenAIUsageData | null;
+      // if (openaiData) {
+      //   await persistThirdPartyUsage(trackedEnv, today, 'openai', 'input_tokens', openaiData.inputTokens, 'tokens', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'openai', 'output_tokens', openaiData.outputTokens, 'tokens', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'openai', 'request_count', openaiData.requestCount, 'requests', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'openai', 'estimated_cost', openaiData.totalCost, 'usd', openaiData.totalCost);
+      //   for (const [model, usage] of Object.entries(openaiData.modelBreakdown)) {
+      //     await persistThirdPartyUsage(trackedEnv, today, 'openai', `model:${model}:input_tokens`, usage.inputTokens, 'tokens', 0);
+      //     await persistThirdPartyUsage(trackedEnv, today, 'openai', `model:${model}:output_tokens`, usage.outputTokens, 'tokens', 0);
       //   }
+      //   totalD1Writes += 4 + Object.keys(openaiData.modelBreakdown).length * 2;
+      // }
+      //
+      // --- Anthropic (FLOW metric) ---
+      // const anthropicData = externalMetrics.results['anthropic'] as import('./lib/usage/shared').AnthropicUsageData | null;
+      // if (anthropicData) {
+      //   await persistThirdPartyUsage(trackedEnv, today, 'anthropic', 'input_tokens', anthropicData.inputTokens, 'tokens', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'anthropic', 'output_tokens', anthropicData.outputTokens, 'tokens', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'anthropic', 'estimated_cost', anthropicData.totalCost, 'usd', anthropicData.totalCost);
+      //   for (const [model, usage] of Object.entries(anthropicData.modelBreakdown)) {
+      //     await persistThirdPartyUsage(trackedEnv, today, 'anthropic', `model:${model}:input_tokens`, usage.inputTokens, 'tokens', 0);
+      //     await persistThirdPartyUsage(trackedEnv, today, 'anthropic', `model:${model}:output_tokens`, usage.outputTokens, 'tokens', 0);
+      //   }
+      //   totalD1Writes += 3 + Object.keys(anthropicData.modelBreakdown).length * 2;
+      // }
+      //
+      // --- GitHub (FLOW metric) ---
+      // const githubData = externalMetrics.results['github'] as import('./lib/usage/collectors/github').GitHubExternalMetrics | undefined;
+      // if (githubData?.billing) {
+      //   const b = githubData.billing;
+      //   await persistThirdPartyUsage(trackedEnv, today, 'github', 'actions_minutes', b.actionsMinutes, 'minutes', b.actionsMinutesCost);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'github', 'copilot_seats', b.copilotSeats, 'seats', b.copilotCost);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'github', 'total_net_cost', b.totalNetCost, 'usd', b.totalNetCost);
+      //   totalD1Writes += 3;
+      // }
+      //
+      // --- Stripe (FLOW metric) ---
+      // const stripeData = externalMetrics.results['stripe'] as import('./lib/usage/shared').StripeRevenueData | null;
+      // if (stripeData) {
+      //   await persistThirdPartyUsage(trackedEnv, today, 'stripe', 'mrr', stripeData.mrr, 'usd', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'stripe', 'arr', stripeData.arr, 'usd', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'stripe', 'active_subscriptions', stripeData.activeSubscriptions, 'count', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'stripe', 'churned_subscriptions', stripeData.churnedSubscriptions, 'count', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'stripe', 'failed_payments', stripeData.failedPayments, 'count', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'stripe', 'trial_subscriptions', stripeData.trialSubscriptions, 'count', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'stripe', 'total_revenue', stripeData.totalRevenue, 'usd', 0);
+      //   totalD1Writes += 7;
+      // }
+      //
+      // --- Apify (FLOW metric) ---
+      // const apifyData = externalMetrics.results['apify'] as import('./lib/usage/shared').ApifyUsageData | null;
+      // if (apifyData) {
+      //   await persistThirdPartyUsage(trackedEnv, today, 'apify', 'total_credits_usd', apifyData.totalUsageCreditsUsd, 'usd', apifyData.totalUsageCreditsUsd);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'apify', 'actor_compute_units', apifyData.actorComputeUnits, 'units', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'apify', 'data_transfer_gb', apifyData.dataTransferGb, 'gb', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'apify', 'storage_gb', apifyData.storageGb, 'gb', 0);
+      //   totalD1Writes += 4;
+      // }
+      //
+      // --- Resend (FLOW metric) ---
+      // const resendData = externalMetrics.results['resend'] as import('./lib/usage/shared').ResendUsageData | null;
+      // if (resendData) {
+      //   await persistThirdPartyUsage(trackedEnv, today, 'resend', 'emails_sent', resendData.emailsSent, 'count', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'resend', 'domains_count', resendData.domainsCount, 'count', 0);
+      //   totalD1Writes += 2;
+      // }
+      //
+      // --- DeepSeek (STOCK metric — gauge, do NOT SUM) ---
+      // const deepseekData = externalMetrics.results['deepseek'] as import('./lib/usage/shared').DeepSeekBalanceData | null;
+      // if (deepseekData) {
+      //   await persistThirdPartyUsage(trackedEnv, today, 'deepseek', 'total_balance', deepseekData.totalBalance, 'usd', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'deepseek', 'granted_balance', deepseekData.grantedBalance, 'usd', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'deepseek', 'topped_up_balance', deepseekData.toppedUpBalance, 'usd', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'deepseek', 'is_available', deepseekData.isAvailable ? 1 : 0, 'boolean', 0);
+      //   totalD1Writes += 4;
+      // }
+      //
+      // --- Minimax (STOCK metric — gauge, do NOT SUM) ---
+      // const minimaxData = externalMetrics.results['minimax'] as import('./lib/usage/shared').MinimaxQuotaData | null;
+      // if (minimaxData) {
+      //   await persistThirdPartyUsage(trackedEnv, today, 'minimax', 'remaining_quota', minimaxData.remainingQuota, 'units', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'minimax', 'total_quota', minimaxData.totalQuota, 'units', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'minimax', 'usage_percentage', minimaxData.usagePercentage, 'percent', 0);
+      //   totalD1Writes += 3;
+      // }
+      //
+      // --- Gemini (FLOW metric) ---
+      // const geminiData = externalMetrics.results['gemini'] as import('./lib/usage/shared').GeminiUsageData | null;
+      // if (geminiData) {
+      //   await persistThirdPartyUsage(trackedEnv, today, 'gemini', 'request_count', geminiData.requestCount, 'requests', 0);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'gemini', 'estimated_cost', geminiData.estimatedCostUsd, 'usd', geminiData.estimatedCostUsd);
+      //   await persistThirdPartyUsage(trackedEnv, today, 'gemini', 'avg_latency_ms', geminiData.avgLatencyMs, 'ms', 0);
+      //   for (const [method, count] of Object.entries(geminiData.methodBreakdown)) {
+      //     await persistThirdPartyUsage(trackedEnv, today, 'gemini', `method:${method}`, count, 'requests', 0);
+      //   }
+      //   totalD1Writes += 3 + Object.keys(geminiData.methodBreakdown).length;
+      // }
 
       // 7b. Collect and persist Cloudflare subscription data (once daily at midnight)
       const cfSubscriptions = await graphql.getAccountSubscriptions();

package/templates/standard/dashboard/src/components/errors/ErrorStats.tsx

@@ -0,0 +1,53 @@
+import { useState, useEffect } from 'react';
+
+interface Stats {
+  byPriority: Record<string, number>;
+  byWorker: Array<{ script_name: string; count: number }>;
+  total: number;
+}
+
+export function ErrorStats() {
+  const [stats, setStats] = useState<Stats | null>(null);
+
+  useEffect(() => {
+    fetch('/api/errors/stats')
+      .then(res => res.json())
+      .then((data: Stats) => setStats(data))
+      .catch(() => {});
+  }, []);
+
+  if (!stats) {
+    return (
+      <div className="grid grid-cols-2 md:grid-cols-5 gap-4">
+        {Array.from({ length: 5 }).map((_, i) => (
+          <div key={i} className="bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700 p-4 animate-pulse">
+            <div className="h-4 bg-gray-200 dark:bg-gray-700 rounded w-8 mb-2" />
+            <div className="h-8 bg-gray-200 dark:bg-gray-700 rounded w-12" />
+          </div>
+        ))}
+      </div>
+    );
+  }
+
+  const priorities = ['P0', 'P1', 'P2', 'P3', 'P4'];
+  const colours: Record<string, string> = {
+    P0: 'text-red-600 dark:text-red-400',
+    P1: 'text-orange-600 dark:text-orange-400',
+    P2: 'text-yellow-600 dark:text-yellow-400',
+    P3: 'text-blue-600 dark:text-blue-400',
+    P4: 'text-gray-600 dark:text-gray-400',
+  };
+
+  return (
+    <div className="grid grid-cols-2 md:grid-cols-5 gap-4">
+      {priorities.map(p => (
+        <div key={p} className="bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700 p-4">
+          <div className="text-xs font-medium text-gray-500 dark:text-gray-400 uppercase">{p}</div>
+          <div className={`text-2xl font-bold mt-1 ${colours[p]}`}>
+            {stats.byPriority[p] ?? 0}
+          </div>
+        </div>
+      ))}
+    </div>
+  );
+}