@littlebearapps/platform-admin-sdk 2.0.0 → 2.1.0

package/templates/full/dashboard/src/lib/cloudflare/graphql.ts

@@ -0,0 +1,4785 @@
+/**
+ * Cloudflare GraphQL Analytics Client
+ *
+ * Unified client for querying Cloudflare's GraphQL Analytics API.
+ * Supports Workers, D1, KV, R2, and Durable Objects metrics.
+ *
+ * Part of task-257: Unified Cloudflare Account Usage Dashboard
+ *
+ * @example
+ * ```ts
+ * const client = new CloudflareGraphQL(env);
+ * const metrics = await client.getAllMetrics('30d');
+ * ```
+ */
+
+import { calculateDailyCosts, type DailyUsageMetrics } from './costs';
+
+const GRAPHQL_ENDPOINT = 'https://api.cloudflare.com/client/v4/graphql';
+
+/**
+ * Fetch with exponential backoff retry for transient errors.
+ * Retries on: 429 (rate limit), 500/502/503/504 (server errors), network errors.
+ *
+ * @param url - URL to fetch
+ * @param options - Fetch options
+ * @param maxRetries - Maximum number of retries (default: 3)
+ * @param baseDelayMs - Base delay in milliseconds (default: 1000)
+ * @returns Response from fetch
+ */
+async function fetchWithRetry(
+  url: string,
+  options: RequestInit,
+  maxRetries = 3,
+  baseDelayMs = 1000
+): Promise<Response> {
+  let lastError: Error | null = null;
+  let lastResponse: Response | null = null;
+
+  // Status codes that should trigger a retry
+  const RETRYABLE_STATUS_CODES = new Set([429, 500, 502, 503, 504]);
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetch(url, options);
+
+      // If not a retryable status, return response immediately
+      if (!RETRYABLE_STATUS_CODES.has(response.status)) {
+        return response;
+      }
+
+      // Store for returning if retries exhausted
+      lastResponse = response;
+
+      // If retryable and we have retries left
+      if (attempt < maxRetries) {
+        // Check for Retry-After header (Cloudflare may include this)
+        const retryAfter = response.headers.get('Retry-After');
+        let delayMs: number;
+
+        if (retryAfter) {
+          // Retry-After can be seconds or a date
+          const retryAfterSecs = parseInt(retryAfter, 10);
+          delayMs = isNaN(retryAfterSecs)
+            ? baseDelayMs * Math.pow(2, attempt)
+            : retryAfterSecs * 1000;
+        } else {
+          // Exponential backoff: baseDelay * 2^attempt + random jitter (0-500ms)
+          delayMs = baseDelayMs * Math.pow(2, attempt) + Math.random() * 500;
+        }
+
+        const reason = response.status === 429 ? 'rate limit' : `HTTP ${response.status}`;
+        console.log(
+          `[CloudflareGraphQL] Retry ${attempt + 1}/${maxRetries} (${reason}) after ${Math.round(delayMs)}ms for ${url.split('?')[0]}`
+        );
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        continue;
+      }
+
+      // Max retries exhausted
+      console.warn(
+        `[CloudflareGraphQL] Retries exhausted (HTTP ${response.status}) after ${maxRetries} retries for ${url.split('?')[0]}`
+      );
+      return response;
+    } catch (error) {
+      lastError = error as Error;
+
+      // Network errors should also retry
+      if (attempt < maxRetries) {
+        const delayMs = baseDelayMs * Math.pow(2, attempt) + Math.random() * 500;
+        console.log(
+          `[CloudflareGraphQL] Network error, retry ${attempt + 1}/${maxRetries} after ${Math.round(delayMs)}ms: ${(error as Error).message}`
+        );
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        continue;
+      }
+    }
+  }
+
+  // Return last response if we had one, otherwise throw
+  if (lastResponse) {
+    return lastResponse;
+  }
+  throw lastError || new Error('fetchWithRetry failed unexpectedly');
+}
+
+/**
+ * Time period for metrics queries
+ */
+export type TimePeriod = '24h' | '7d' | '30d';
+
+/**
+ * Date range for GraphQL queries
+ */
+export interface DateRange {
+  startDate: string; // YYYY-MM-DD
+  endDate: string; // YYYY-MM-DD
+}
+
+/**
+ * Custom date range query parameters
+ */
+export interface CustomDateRangeParams {
+  startDate: string;
+  endDate: string;
+  priorStartDate?: string;
+  priorEndDate?: string;
+}
+
+/**
+ * Comparison mode
+ */
+export type CompareMode = 'none' | 'lastMonth' | 'custom';
+
+/**
+ * Workers usage metrics
+ */
+export interface WorkersMetrics {
+  scriptName: string;
+  requests: number;
+  errors: number;
+  cpuTimeMs: number;
+  duration50thMs: number;
+  duration99thMs: number;
+}
+
+/**
+ * D1 database usage metrics
+ */
+export interface D1Metrics {
+  databaseId: string;
+  databaseName: string;
+  rowsRead: number;
+  rowsWritten: number;
+  readQueries: number;
+  writeQueries: number;
+  storageBytes: number; // From d1StorageAdaptiveGroups
+}
+
+/**
+ * KV namespace usage metrics
+ */
+export interface KVMetrics {
+  namespaceId: string;
+  namespaceName: string;
+  reads: number;
+  writes: number;
+  deletes: number;
+  lists: number;
+  storageBytes: number; // From kvStorageAdaptiveGroups
+  keyCount: number; // From kvStorageAdaptiveGroups
+}
+
+/**
+ * R2 bucket usage metrics
+ */
+export interface R2Metrics {
+  bucketName: string;
+  classAOperations: number; // PUT, POST, DELETE, LIST, etc.
+  classBOperations: number; // GET, HEAD
+  storageBytes: number;
+  egressBytes: number;
+}
+
+/**
+ * Per-script Durable Objects metrics for project attribution
+ */
+export interface DOScriptMetrics {
+  scriptName: string;
+  requests: number;
+  gbSeconds: number;
+  storageBytes?: number;
+}
+
+/**
+ * Durable Objects usage metrics
+ * Note: gbSeconds requires durableObjectsPeriodicGroups dataset (not currently queried).
+ * We default gbSeconds to 0 - duration costs won't be calculated but dashboard won't break.
+ */
+export interface DOMetrics {
+  requests: number;
+  responseBodySize: number;
+  gbSeconds: number; // Duration billing - requires separate query to durableObjectsPeriodicGroups
+  storageBytes: number; // Storage at rest - from durableObjectsStorageGroups (max storedBytes)
+  storageReadUnits: number;
+  storageWriteUnits: number;
+  storageDeleteUnits: number;
+  byScript?: DOScriptMetrics[]; // Per-script breakdown for project attribution
+}
+
+/**
+ * Vectorize index info (from REST API)
+ */
+export interface VectorizeInfo {
+  name: string;
+  vectorCount: number;
+  dimensions: number;
+}
+
+/**
+ * AI Gateway model breakdown metrics
+ */
+export interface AIGatewayModelBreakdown {
+  provider: string; // openai, google-ai-studio, workers-ai, anthropic, etc.
+  model: string;
+  requests: number;
+  cachedRequests: number;
+  tokensIn: number;
+  tokensOut: number;
+  costUsd: number;
+}
+
+/**
+ * AI Gateway usage metrics (from REST API)
+ */
+export interface AIGatewayMetrics {
+  gatewayId: string;
+  totalRequests: number;
+  cachedRequests: number;
+  totalTokens: number;
+  estimatedCostUsd: number;
+  /** Model breakdown from AI Gateway logs - optional for backwards compatibility */
+  byModel?: AIGatewayModelBreakdown[];
+}
+
+/**
+ * Workflows execution metrics (from GraphQL API)
+ * Tracks workflow executions, steps, and timing
+ */
+export interface WorkflowsMetrics {
+  workflowName: string;
+  executions: number; // WORKFLOW_START events
+  successes: number; // WORKFLOW_SUCCESS events
+  failures: number; // WORKFLOW_FAILURE events
+  wallTimeMs: number; // Total wall time in milliseconds
+  cpuTimeMs: number; // Total CPU time in milliseconds
+}
+
+/**
+ * Workflows usage summary
+ */
+export interface WorkflowsSummary {
+  totalExecutions: number;
+  totalSuccesses: number;
+  totalFailures: number;
+  totalWallTimeMs: number;
+  totalCpuTimeMs: number;
+  byWorkflow: WorkflowsMetrics[];
+}
+
+/**
+ * Workers AI metrics from Analytics Engine
+ */
+export interface WorkersAIMetrics {
+  project: string;
+  model: string;
+  requests: number;
+  inputTokens: number;
+  outputTokens: number;
+  costUsd: number;
+  isEstimated: boolean; // true for Brand Copilot (doesn't track tokens)
+}
+
+/**
+ * AI Gateway aggregated metrics from D1
+ */
+export interface AIGatewaySummary {
+  totalRequests: number;
+  totalCachedRequests: number;
+  cacheHitRate: number; // percentage
+  tokensIn: number;
+  tokensOut: number;
+  totalCostUsd: number;
+  byProvider: Record<
+    string,
+    {
+      requests: number;
+      cachedRequests: number;
+      tokensIn: number;
+      tokensOut: number;
+      costUsd: number;
+    }
+  >;
+  byModel: Record<
+    string,
+    {
+      requests: number;
+      cachedRequests: number;
+      tokensIn: number;
+      tokensOut: number;
+      costUsd: number;
+    }
+  >;
+}
+
+/**
+ * Workers AI usage summary
+ */
+export interface WorkersAISummary {
+  totalRequests: number;
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  totalCostUsd: number;
+  byProject: Record<string, { requests: number; costUsd: number; isEstimated: boolean }>;
+  byModel: Record<
+    string,
+    { requests: number; inputTokens: number; outputTokens: number; costUsd: number }
+  >;
+  metrics: WorkersAIMetrics[];
+  aiGateway?: AIGatewaySummary; // Optional AI Gateway aggregated metrics
+}
+
+/**
+ * Analytics Engine SQL API response type
+ */
+interface AnalyticsEngineResult {
+  data?: Array<Record<string, unknown>>;
+  meta?: Array<{ name: string; type: string }>;
+  rows?: number;
+  rows_before_limit_at_least?: number;
+}
+
+/**
+ * Sparkline data point for time-series visualisation
+ */
+export interface SparklinePoint {
+  date: string; // YYYY-MM-DD
+  value: number;
+}
+
+/**
+ * Sparkline data for a metric
+ */
+export interface SparklineData {
+  metricName: string;
+  points: SparklinePoint[];
+  trend: 'up' | 'down' | 'stable';
+  percentChange: number;
+}
+
+/**
+ * Daily cost breakdown by resource type (for interactive chart)
+ * Part of task-18: Usage Dashboard Interactive Chart & Table Enhancement
+ */
+export interface DailyCostBreakdown {
+  date: string; // YYYY-MM-DD
+  workers: number;
+  d1: number;
+  kv: number;
+  r2: number;
+  vectorize: number;
+  aiGateway: number;
+  durableObjects: number;
+  workersAI: number;
+  pages: number;
+  queues: number;
+  workflows: number;
+  total: number;
+  rollupVersion?: number; // 1 = legacy (inflated), 2 = accurate (MAX aggregation)
+}
+
+/**
+ * Daily cost data with aggregated totals
+ * Part of task-18: Usage Dashboard Interactive Chart & Table Enhancement
+ */
+export interface DailyCostData {
+  days: DailyCostBreakdown[];
+  totals: Omit<DailyCostBreakdown, 'date'>;
+  period: {
+    start: string; // YYYY-MM-DD
+    end: string; // YYYY-MM-DD
+  };
+  hasLegacyData?: boolean; // true if any day has rollupVersion=1 (inflated values from SUM() on cumulative data)
+}
+
+/**
+ * Workers error breakdown for health monitoring
+ */
+export interface WorkersErrorBreakdown {
+  scriptName: string;
+  totalRequests: number;
+  totalErrors: number;
+  errorRate: number; // percentage
+  errors4xx: number;
+  errors5xx: number;
+  latencyP50Ms: number;
+  latencyP99Ms: number;
+  cpuTimeP50Ms: number;
+  cpuTimeP99Ms: number;
+  subrequests: number;
+}
+
+/**
+ * Pages project metrics
+ */
+export interface PagesMetrics {
+  projectName: string;
+  subdomain: string;
+  productionDeployments: number;
+  previewDeployments: number;
+  totalBuilds: number;
+  lastDeployedAt: string | null;
+}
+
+/**
+ * Queues metrics for message processing
+ */
+export interface QueuesMetrics {
+  queueId: string;
+  queueName: string;
+  messagesProduced: number;
+  messagesConsumed: number;
+  messagesAcked: number;
+  messagesRetried: number;
+  messagesFailed: number;
+  backlogSize: number;
+  avgProcessingTimeMs: number;
+}
+
+/**
+ * Cache analytics for Workers
+ */
+export interface CacheAnalytics {
+  totalRequests: number;
+  cacheHits: number;
+  cacheMisses: number;
+  hitRate: number; // percentage
+  bandwidthSavedBytes: number;
+}
+
+/**
+ * Period comparison data
+ */
+export interface PeriodComparison {
+  current: number;
+  previous: number;
+  percentChange: number;
+  trend: 'up' | 'down' | 'stable';
+}
+
+/**
+ * Aggregated account usage
+ */
+export interface AccountUsage {
+  period: TimePeriod;
+  workers: WorkersMetrics[];
+  d1: D1Metrics[];
+  kv: KVMetrics[];
+  r2: R2Metrics[];
+  durableObjects: DOMetrics;
+  vectorize: VectorizeInfo[];
+  aiGateway: AIGatewayMetrics[];
+  pages: PagesMetrics[];
+}
+
+/**
+ * Enhanced account usage with sparklines, error breakdown, and comparison
+ */
+export interface EnhancedAccountUsage extends AccountUsage {
+  sparklines: {
+    workersRequests: SparklineData;
+    workersErrors: SparklineData;
+    d1RowsRead: SparklineData;
+    kvReads: SparklineData;
+  };
+  errorBreakdown: WorkersErrorBreakdown[];
+  queues: QueuesMetrics[];
+  cache: CacheAnalytics;
+  comparison: {
+    workersRequests: PeriodComparison;
+    workersErrors: PeriodComparison;
+    d1RowsRead: PeriodComparison;
+    totalCost: PeriodComparison;
+  };
+}
+
+/**
+ * Cloudflare subscription/plan information
+ */
+export interface CloudflareSubscription {
+  id: string;
+  ratePlanId: string;
+  ratePlanName: string;
+  price: number;
+  currency: string;
+  frequency: string; // 'monthly' | 'yearly' | 'not-applicable'
+  currentPeriodStart: string | null;
+  currentPeriodEnd: string | null;
+  state: string;
+  zoneName: string | null; // null for account-level subscriptions
+  createdDate: string;
+}
+
+/**
+ * Workers Paid plan inclusions (free tier amounts per month)
+ * Based on Cloudflare pricing as of January 2025
+ */
+export interface WorkersPaidPlanInclusions {
+  // Workers
+  requestsIncluded: number; // 10,000,000
+  cpuTimeIncluded: number; // 30,000,000 ms
+  // D1
+  d1RowsReadIncluded: number; // 25,000,000,000 (25B)
+  d1RowsWrittenIncluded: number; // 50,000,000 (50M)
+  d1StorageIncluded: number; // 5,000,000,000 bytes (5GB)
+  // KV
+  kvReadsIncluded: number; // 10,000,000
+  kvWritesIncluded: number; // 1,000,000
+  kvDeletesIncluded: number; // 1,000,000
+  kvListsIncluded: number; // 1,000,000
+  kvStorageIncluded: number; // 1,000,000,000 bytes (1GB)
+  // R2 (separate subscription but related)
+  r2ClassAIncluded: number; // 1,000,000
+  r2ClassBIncluded: number; // 10,000,000
+  r2StorageIncluded: number; // 10,000,000,000 bytes (10GB)
+  r2EgressIncluded: number; // 0 (egress free to internet)
+  // Durable Objects
+  doRequestsIncluded: number; // 1,000,000
+  doDurationIncluded: number; // 400,000 GB-seconds
+  doStorageIncluded: number; // 1,000,000,000 bytes (1GB)
+  // Vectorize
+  vectorizeQueriedDimensionsIncluded: number; // 30,000,000
+  vectorizeStoredDimensionsIncluded: number; // 5,000,000
+  // Workers AI
+  workersAINeuronsIncluded: number; // 10,000 neurons/day (gateway dependent)
+  // Queues
+  queuesOperationsIncluded: number; // 1,000,000
+}
+
+/**
+ * Cloudflare billing profile
+ */
+export interface CloudflareBillingProfile {
+  id: string;
+  firstName: string;
+  lastName: string;
+  company: string;
+  billingEmail: string;
+  accountType: string; // 'personal' | 'business'
+  country: string;
+}
+
+/**
+ * Cloudflare account subscription summary
+ */
+export interface CloudflareAccountSubscriptions {
+  subscriptions: CloudflareSubscription[];
+  billingProfile: CloudflareBillingProfile | null;
+  planInclusions: WorkersPaidPlanInclusions;
+  hasWorkersPaid: boolean;
+  hasR2Paid: boolean;
+  hasAnalyticsEngine: boolean;
+  monthlyBaseCost: number; // Total of subscription prices
+}
+
+/**
+ * GraphQL response types
+ */
+interface GraphQLResponse<T> {
+  data?: T;
+  errors?: Array<{ message: string; extensions?: { code?: string } }>;
+}
+
+/**
+ * Cloudflare GraphQL Analytics Client
+ */
+export class CloudflareGraphQL {
+  private accountId: string;
+  private apiToken: string;
+
+  constructor(env: { CLOUDFLARE_ACCOUNT_ID: string; CLOUDFLARE_API_TOKEN: string }) {
+    this.accountId = env.CLOUDFLARE_ACCOUNT_ID;
+    this.apiToken = env.CLOUDFLARE_API_TOKEN;
+  }
+
+  /**
+   * Convert a non-hyphenated UUID (from REST API) to hyphenated format (for GraphQL).
+   * REST API returns: 2fa618b3a78a4c0c884284569f2b59d6
+   * GraphQL expects: 2fa618b3-a78a-4c0c-8842-84569f2b59d6
+   */
+  private formatUuidWithHyphens(uuid: string): string {
+    // If already hyphenated, return as-is
+    if (uuid.includes('-')) return uuid;
+    // Format: 8-4-4-4-12 characters
+    return `${uuid.slice(0, 8)}-${uuid.slice(8, 12)}-${uuid.slice(12, 16)}-${uuid.slice(16, 20)}-${uuid.slice(20)}`;
+  }
+
+  /**
+   * Calculate date range for a given time period
+   */
+  private getDateRange(period: TimePeriod): DateRange {
+    const now = new Date();
+    const endDate = now.toISOString().split('T')[0]!;
+
+    const startDate = new Date(now);
+    switch (period) {
+      case '24h':
+        startDate.setDate(startDate.getDate() - 1);
+        break;
+      case '7d':
+        startDate.setDate(startDate.getDate() - 7);
+        break;
+      case '30d':
+        startDate.setDate(startDate.getDate() - 30);
+        break;
+    }
+
+    return {
+      startDate: startDate.toISOString().split('T')[0]!,
+      endDate,
+    };
+  }
+
+  /**
+   * Calculate the same period from the previous month
+   * e.g., Jan 1-7 → Dec 1-7
+   */
+  static getSamePeriodLastMonth(startDate: string, endDate: string): DateRange {
+    const start = new Date(startDate);
+    const end = new Date(endDate);
+
+    // Move to previous month
+    const priorStart = new Date(start);
+    priorStart.setMonth(priorStart.getMonth() - 1);
+
+    const priorEnd = new Date(end);
+    priorEnd.setMonth(priorEnd.getMonth() - 1);
+
+    // Handle edge case: if current period ends on day 31 but prior month only has 28-30 days
+    // Clamp to the last day of the prior month
+    const priorMonthLastDay = new Date(
+      priorStart.getFullYear(),
+      priorStart.getMonth() + 1,
+      0
+    ).getDate();
+    if (priorStart.getDate() > priorMonthLastDay) {
+      priorStart.setDate(priorMonthLastDay);
+    }
+    if (priorEnd.getDate() > priorMonthLastDay) {
+      priorEnd.setDate(priorMonthLastDay);
+    }
+
+    return {
+      startDate: priorStart.toISOString().split('T')[0]!,
+      endDate: priorEnd.toISOString().split('T')[0]!,
+    };
+  }
+
+  /**
+   * Validate and parse custom date range
+   * Returns null if validation fails
+   */
+  static validateCustomDateRange(params: CustomDateRangeParams):
+    | {
+        current: DateRange;
+        prior: DateRange;
+      }
+    | { error: string } {
+    const { startDate, endDate, priorStartDate, priorEndDate } = params;
+
+    // Parse dates
+    const start = new Date(startDate);
+    const end = new Date(endDate);
+
+    if (isNaN(start.getTime()) || isNaN(end.getTime())) {
+      return { error: 'Invalid date format. Use YYYY-MM-DD' };
+    }
+
+    // End must be >= start
+    if (end < start) {
+      return { error: 'End date must be on or after start date' };
+    }
+
+    // Max range: 90 days
+    const daysDiff = Math.ceil((end.getTime() - start.getTime()) / (1000 * 60 * 60 * 24));
+    if (daysDiff > 90) {
+      return { error: 'Maximum date range is 90 days' };
+    }
+
+    // Dates must be in the past
+    const now = new Date();
+    if (end > now) {
+      return { error: 'Dates must be in the past' };
+    }
+
+    const current: DateRange = {
+      startDate: startDate,
+      endDate: endDate,
+    };
+
+    // Calculate prior period
+    let prior: DateRange;
+    if (priorStartDate && priorEndDate) {
+      const priorStart = new Date(priorStartDate);
+      const priorEnd = new Date(priorEndDate);
+
+      if (isNaN(priorStart.getTime()) || isNaN(priorEnd.getTime())) {
+        return { error: 'Invalid prior date format. Use YYYY-MM-DD' };
+      }
+
+      prior = { startDate: priorStartDate, endDate: priorEndDate };
+    } else {
+      // Default: same duration before start date
+      const durationMs = end.getTime() - start.getTime();
+      const priorEnd = new Date(start.getTime() - 1); // Day before start
+      const priorStart = new Date(priorEnd.getTime() - durationMs);
+
+      prior = {
+        startDate: priorStart.toISOString().split('T')[0]!,
+        endDate: priorEnd.toISOString().split('T')[0]!,
+      };
+    }
+
+    return { current, prior };
+  }
+
+  /**
+   * Get metrics for a custom date range
+   */
+  async getMetricsForDateRange(dateRange: DateRange): Promise<AccountUsage> {
+    // Run all queries in parallel with custom date range
+    const [workers, d1, kv, r2, durableObjects, vectorize, aiGateway, pages] = await Promise.all([
+      this.getWorkersMetricsForRange(dateRange),
+      this.getD1MetricsForRange(dateRange),
+      this.getKVMetricsForRange(dateRange),
+      this.getR2MetricsForRange(dateRange),
+      this.getDOMetricsForRange(dateRange),
+      this.getVectorizeInfo(),
+      this.getAIGatewayMetricsForRange(dateRange),
+      this.getPagesMetrics(),
+    ]);
+
+    return {
+      period: '30d', // Default period label for custom ranges
+      workers,
+      d1,
+      kv,
+      r2,
+      durableObjects,
+      vectorize,
+      aiGateway,
+      pages,
+    };
+  }
+
+  /**
+   * Get Workers metrics for a specific date range
+   */
+  private async getWorkersMetricsForRange(dateRange: DateRange): Promise<WorkersMetrics[]> {
+    const { startDate, endDate } = dateRange;
+
+    const queryStr = `
+      query WorkersMetrics($accountTag: String!, $startDate: Date!, $endDate: Date!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            workersInvocationsAdaptive(
+              filter: {
+                date_geq: $startDate
+                date_leq: $endDate
+              }
+              limit: 100
+            ) {
+              dimensions {
+                scriptName
+              }
+              sum {
+                requests
+                errors
+              }
+              quantiles {
+                cpuTimeP50
+                cpuTimeP99
+                durationP50
+                durationP99
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    interface WorkersResponse {
+      viewer?: {
+        accounts?: Array<{
+          workersInvocationsAdaptive?: Array<{
+            dimensions?: { scriptName?: string };
+            sum?: { requests?: number; errors?: number };
+            quantiles?: {
+              cpuTimeP50?: number;
+              cpuTimeP99?: number;
+              durationP50?: number;
+              durationP99?: number;
+            };
+          }>;
+        }>;
+      };
+    }
+
+    const data = await this.query<WorkersResponse>(queryStr, {
+      accountTag: this.accountId,
+      startDate,
+      endDate,
+    });
+
+    if (!data?.viewer?.accounts?.[0]?.workersInvocationsAdaptive) {
+      return [];
+    }
+
+    return data.viewer.accounts[0].workersInvocationsAdaptive
+      .filter((item) => item.dimensions?.scriptName)
+      .map((item) => ({
+        scriptName: item.dimensions!.scriptName!,
+        requests: item.sum?.requests ?? 0,
+        errors: item.sum?.errors ?? 0,
+        // cpuTimeP50 from GraphQL is in microseconds, convert to milliseconds
+        cpuTimeMs: (item.quantiles?.cpuTimeP50 ?? 0) / 1000,
+        duration50thMs: item.quantiles?.durationP50 ?? 0,
+        duration99thMs: item.quantiles?.durationP99 ?? 0,
+      }));
+  }
+
+  /**
+   * Get D1 metrics for a specific date range
+   * Queries both d1AnalyticsAdaptiveGroups (operations) and d1StorageAdaptiveGroups (storage)
+   */
+  private async getD1MetricsForRange(dateRange: DateRange): Promise<D1Metrics[]> {
+    const { startDate, endDate } = dateRange;
+    const databases = await this.listD1Databases();
+    const results: D1Metrics[] = [];
+
+    for (const db of databases) {
+      const queryStr = `
+        query D1Metrics($accountTag: String!, $databaseId: String!, $startDate: Date!, $endDate: Date!) {
+          viewer {
+            accounts(filter: { accountTag: $accountTag }) {
+              d1AnalyticsAdaptiveGroups(
+                filter: {
+                  databaseId: $databaseId
+                  date_geq: $startDate
+                  date_leq: $endDate
+                }
+                limit: 100
+              ) {
+                sum {
+                  rowsRead
+                  rowsWritten
+                  readQueries
+                  writeQueries
+                }
+              }
+              d1StorageAdaptiveGroups(
+                filter: {
+                  databaseId: $databaseId
+                  date_geq: $startDate
+                  date_leq: $endDate
+                }
+                limit: 1
+              ) {
+                max {
+                  databaseSizeBytes
+                }
+              }
+            }
+          }
+        }
+      `;
+
+      interface D1Response {
+        viewer?: {
+          accounts?: Array<{
+            d1AnalyticsAdaptiveGroups?: Array<{
+              sum?: {
+                rowsRead?: number;
+                rowsWritten?: number;
+                readQueries?: number;
+                writeQueries?: number;
+              };
+            }>;
+            d1StorageAdaptiveGroups?: Array<{
+              max?: {
+                databaseSizeBytes?: number;
+              };
+            }>;
+          }>;
+        };
+      }
+
+      const data = await this.query<D1Response>(queryStr, {
+        accountTag: this.accountId,
+        databaseId: db.id,
+        startDate,
+        endDate,
+      });
+
+      const account = data?.viewer?.accounts?.[0];
+      const analyticsGroups = account?.d1AnalyticsAdaptiveGroups ?? [];
+      const storageGroups = account?.d1StorageAdaptiveGroups ?? [];
+
+      // Sum operations metrics
+      const totals = analyticsGroups.reduce(
+        (acc, group) => ({
+          rowsRead: acc.rowsRead + (group.sum?.rowsRead ?? 0),
+          rowsWritten: acc.rowsWritten + (group.sum?.rowsWritten ?? 0),
+          readQueries: acc.readQueries + (group.sum?.readQueries ?? 0),
+          writeQueries: acc.writeQueries + (group.sum?.writeQueries ?? 0),
+        }),
+        { rowsRead: 0, rowsWritten: 0, readQueries: 0, writeQueries: 0 }
+      );
+
+      // Get max storage bytes (most recent)
+      const storageBytes = storageGroups[0]?.max?.databaseSizeBytes ?? 0;
+
+      results.push({
+        databaseId: db.id,
+        databaseName: db.name,
+        ...totals,
+        storageBytes,
+      });
+    }
+
+    return results;
+  }
+
+  /**
+   * Get KV metrics for a specific date range
+   * Queries both kvOperationsAdaptiveGroups (operations) and kvStorageAdaptiveGroups (storage)
+   */
+  private async getKVMetricsForRange(dateRange: DateRange): Promise<KVMetrics[]> {
+    const { startDate, endDate } = dateRange;
+    const namespaces = await this.listKVNamespaces();
+    const results: KVMetrics[] = [];
+
+    for (const ns of namespaces) {
+      const queryStr = `
+        query KVMetrics($accountTag: String!, $namespaceId: String!, $startDate: Date!, $endDate: Date!) {
+          viewer {
+            accounts(filter: { accountTag: $accountTag }) {
+              kvOperationsAdaptiveGroups(
+                filter: {
+                  namespaceId: $namespaceId
+                  date_geq: $startDate
+                  date_leq: $endDate
+                }
+                limit: 100
+              ) {
+                sum {
+                  requests
+                }
+                dimensions {
+                  actionType
+                }
+              }
+              kvStorageAdaptiveGroups(
+                filter: {
+                  namespaceId: $namespaceId
+                  date_geq: $startDate
+                  date_leq: $endDate
+                }
+                limit: 1
+              ) {
+                max {
+                  byteCount
+                  keyCount
+                }
+              }
+            }
+          }
+        }
+      `;
+
+      interface KVResponse {
+        viewer?: {
+          accounts?: Array<{
+            kvOperationsAdaptiveGroups?: Array<{
+              sum?: { requests?: number };
+              dimensions?: { actionType?: string };
+            }>;
+            kvStorageAdaptiveGroups?: Array<{
+              max?: {
+                byteCount?: number;
+                keyCount?: number;
+              };
+            }>;
+          }>;
+        };
+      }
+
+      const data = await this.query<KVResponse>(queryStr, {
+        accountTag: this.accountId,
+        namespaceId: this.formatUuidWithHyphens(ns.id),
+        startDate,
+        endDate,
+      });
+
+      const operationsGroups = data?.viewer?.accounts?.[0]?.kvOperationsAdaptiveGroups;
+      const storageGroups = data?.viewer?.accounts?.[0]?.kvStorageAdaptiveGroups;
+
+      // Aggregate operations by action type
+      const totals = { reads: 0, writes: 0, deletes: 0, lists: 0 };
+      if (operationsGroups?.length) {
+        for (const group of operationsGroups) {
+          const requests = group.sum?.requests ?? 0;
+          const actionType = group.dimensions?.actionType?.toLowerCase() ?? '';
+          if (actionType === 'read' || actionType === 'get') {
+            totals.reads += requests;
+          } else if (actionType === 'write' || actionType === 'put') {
+            totals.writes += requests;
+          } else if (actionType === 'delete') {
+            totals.deletes += requests;
+          } else if (actionType === 'list') {
+            totals.lists += requests;
+          }
+        }
+      }
+
+      // Extract storage metrics (most recent snapshot)
+      const storageBytes = storageGroups?.[0]?.max?.byteCount ?? 0;
+      const keyCount = storageGroups?.[0]?.max?.keyCount ?? 0;
+
+      // Only add if we have any data
+      if (
+        totals.reads > 0 ||
+        totals.writes > 0 ||
+        totals.deletes > 0 ||
+        totals.lists > 0 ||
+        storageBytes > 0 ||
+        keyCount > 0
+      ) {
+        results.push({
+          namespaceId: ns.id,
+          namespaceName: ns.title,
+          ...totals,
+          storageBytes,
+          keyCount,
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Get R2 metrics for a specific date range
+   */
+  private async getR2MetricsForRange(dateRange: DateRange): Promise<R2Metrics[]> {
+    const { startDate, endDate } = dateRange;
+    // R2 storage uses datetime filters (Time type), operations uses date filters (Date type)
+    const datetimeStart = `${startDate}T00:00:00Z`;
+    const datetimeEnd = `${endDate}T23:59:59Z`;
+
+    // Query 1: Operations (uses Date type filters)
+    const operationsQuery = `
+      query R2Operations($accountTag: String!, $startDate: Date!, $endDate: Date!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            r2OperationsAdaptiveGroups(
+              filter: {
+                date_geq: $startDate
+                date_leq: $endDate
+              }
+              limit: 100
+            ) {
+              dimensions {
+                bucketName
+                actionType
+              }
+              sum {
+                requests
+                responseObjectSize
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    // Query 2: Storage (uses Time type filters per CF docs)
+    const storageQuery = `
+      query R2Storage($accountTag: String!, $datetimeStart: Time!, $datetimeEnd: Time!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            r2StorageAdaptiveGroups(
+              filter: {
+                datetime_geq: $datetimeStart
+                datetime_leq: $datetimeEnd
+              }
+              limit: 100
+            ) {
+              dimensions {
+                bucketName
+              }
+              max {
+                payloadSize
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    interface R2OperationsResponse {
+      viewer?: {
+        accounts?: Array<{
+          r2OperationsAdaptiveGroups?: Array<{
+            dimensions?: { bucketName?: string; actionType?: string };
+            sum?: { requests?: number; responseObjectSize?: number };
+          }>;
+        }>;
+      };
+    }
+
+    interface R2StorageResponse {
+      viewer?: {
+        accounts?: Array<{
+          r2StorageAdaptiveGroups?: Array<{
+            dimensions?: { bucketName?: string };
+            max?: { payloadSize?: number };
+          }>;
+        }>;
+      };
+    }
+
+    // Execute both queries in parallel
+    const [operationsData, storageData] = await Promise.all([
+      this.query<R2OperationsResponse>(operationsQuery, {
+        accountTag: this.accountId,
+        startDate,
+        endDate,
+      }),
+      this.query<R2StorageResponse>(storageQuery, {
+        accountTag: this.accountId,
+        datetimeStart,
+        datetimeEnd,
+      }).catch(() => null), // Storage query may fail if no data exists
+    ]);
+
+    const operations = operationsData?.viewer?.accounts?.[0]?.r2OperationsAdaptiveGroups ?? [];
+    const storage = storageData?.viewer?.accounts?.[0]?.r2StorageAdaptiveGroups ?? [];
+
+    const bucketMap = new Map<string, R2Metrics>();
+    const classAActions = new Set([
+      'PutObject',
+      'DeleteObject',
+      'ListObjects',
+      'ListObjectsV2',
+      'CreateMultipartUpload',
+      'CompleteMultipartUpload',
+      'AbortMultipartUpload',
+      'UploadPart',
+      'CopyObject',
+    ]);
+
+    for (const op of operations) {
+      const bucketName = op.dimensions?.bucketName ?? 'unknown';
+      if (!bucketMap.has(bucketName)) {
+        bucketMap.set(bucketName, {
+          bucketName,
+          classAOperations: 0,
+          classBOperations: 0,
+          storageBytes: 0,
+          egressBytes: 0,
+        });
+      }
+
+      const bucket = bucketMap.get(bucketName)!;
+      const requests = op.sum?.requests ?? 0;
+      const actionType = op.dimensions?.actionType ?? '';
+
+      if (classAActions.has(actionType)) {
+        bucket.classAOperations += requests;
+      } else {
+        bucket.classBOperations += requests;
+      }
+
+      bucket.egressBytes += op.sum?.responseObjectSize ?? 0;
+    }
+
+    for (const s of storage) {
+      const bucketName = s.dimensions?.bucketName ?? 'unknown';
+      if (bucketMap.has(bucketName)) {
+        bucketMap.get(bucketName)!.storageBytes = s.max?.payloadSize ?? 0;
+      }
+    }
+
+    return Array.from(bucketMap.values());
+  }
+
+  /**
+   * Get Durable Objects metrics for a specific date range
+   * Combines invocation metrics and duration metrics (GB-seconds for billing)
+   * Includes per-script breakdown for project attribution
+   */
+  private async getDOMetricsForRange(dateRange: DateRange): Promise<DOMetrics> {
+    const { startDate, endDate } = dateRange;
+
+    // Query 1: Per-script invocation metrics with scriptName dimension for project attribution
+    const invocationsQuery = `
+      query DOInvocations($accountTag: String!, $startDate: Date!, $endDate: Date!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            durableObjectsInvocationsAdaptiveGroups(
+              filter: {
+                date_geq: $startDate
+                date_leq: $endDate
+              }
+              limit: 10000
+            ) {
+              dimensions {
+                scriptName
+              }
+              sum {
+                requests
+                responseBodySize
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    // Query 2: Account-level duration metrics from durableObjectsPeriodicGroups
+    // Note: This dataset only supports date dimension, not scriptName
+    // Duration is in GB-seconds (the billable unit) - will be allocated proportionally per script
+    const durationQuery = `
+      query DODuration($accountTag: String!, $startDate: Date!, $endDate: Date!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            durableObjectsPeriodicGroups(
+              filter: {
+                date_geq: $startDate
+                date_leq: $endDate
+              }
+              limit: 10000
+            ) {
+              sum {
+                duration
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    // Query 3: Account-level storage metrics from durableObjectsStorageGroups
+    // Note: This dataset only supports date dimension, not scriptName
+    // Storage will be allocated proportionally per script based on request count
+    const storageQuery = `
+      query DOStorage($accountTag: String!, $startDate: Date!, $endDate: Date!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            durableObjectsStorageGroups(
+              filter: {
+                date_geq: $startDate
+                date_leq: $endDate
+              }
+              limit: 10000
+            ) {
+              max {
+                storedBytes
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    interface InvocationsResponse {
+      viewer?: {
+        accounts?: Array<{
+          durableObjectsInvocationsAdaptiveGroups?: Array<{
+            dimensions?: {
+              scriptName?: string;
+            };
+            sum?: {
+              requests?: number;
+              responseBodySize?: number;
+            };
+          }>;
+        }>;
+      };
+    }
+
+    // Note: durableObjectsPeriodicGroups doesn't support scriptName dimension
+    // Returns account-level totals only
+    interface DurationResponse {
+      viewer?: {
+        accounts?: Array<{
+          durableObjectsPeriodicGroups?: Array<{
+            sum?: {
+              duration?: number; // GB-seconds (billable unit from Cloudflare)
+            };
+          }>;
+        }>;
+      };
+    }
+
+    // Note: durableObjectsStorageGroups doesn't support scriptName dimension
+    // Returns account-level totals only
+    interface StorageResponse {
+      viewer?: {
+        accounts?: Array<{
+          durableObjectsStorageGroups?: Array<{
+            max?: {
+              storedBytes?: number;
+            };
+          }>;
+        }>;
+      };
+    }
+
+    // Execute all queries in parallel
+    const [invocationsData, durationData, storageData] = await Promise.all([
+      this.query<InvocationsResponse>(invocationsQuery, {
+        accountTag: this.accountId,
+        startDate,
+        endDate,
+      }),
+      this.query<DurationResponse>(durationQuery, {
+        accountTag: this.accountId,
+        startDate,
+        endDate,
+      }).catch(() => null), // Duration query may fail if no data exists
+      this.query<StorageResponse>(storageQuery, {
+        accountTag: this.accountId,
+        startDate,
+        endDate,
+      }).catch(() => null), // Storage query may fail if no data exists
+    ]);
+
+    // Build per-script breakdown for project attribution
+    const scriptMap = new Map<
+      string,
+      { requests: number; gbSeconds: number; storageBytes: number; responseBodySize: number }
+    >();
+
+    // Process invocation metrics per script (only dataset with scriptName dimension)
+    const invocationsGroups =
+      invocationsData?.viewer?.accounts?.[0]?.durableObjectsInvocationsAdaptiveGroups ?? [];
+
+    // Debug: Log DO invocations data for troubleshooting
+    console.log(`[CloudflareGraphQL] DO invocations groups count: ${invocationsGroups.length}`);
+    if (invocationsGroups.length > 0) {
+      console.log(
+        `[CloudflareGraphQL] DO invocations sample: ${JSON.stringify(invocationsGroups.slice(0, 3))}`
+      );
+    }
+
+    for (const group of invocationsGroups) {
+      const scriptName = group.dimensions?.scriptName ?? 'unknown';
+      const existing = scriptMap.get(scriptName) ?? {
+        requests: 0,
+        gbSeconds: 0,
+        storageBytes: 0,
+        responseBodySize: 0,
+      };
+      existing.requests += group.sum?.requests ?? 0;
+      existing.responseBodySize += group.sum?.responseBodySize ?? 0;
+      scriptMap.set(scriptName, existing);
+    }
+
+    // Get account-level duration total (durableObjectsPeriodicGroups doesn't support scriptName)
+    const durationGroups = durationData?.viewer?.accounts?.[0]?.durableObjectsPeriodicGroups ?? [];
+    let totalAccountGbSeconds = 0;
+    for (const group of durationGroups) {
+      totalAccountGbSeconds += group.sum?.duration ?? 0;
+    }
+
+    // Get account-level storage total (durableObjectsStorageGroups doesn't support scriptName)
+    const storageGroups = storageData?.viewer?.accounts?.[0]?.durableObjectsStorageGroups ?? [];
+    let maxAccountStorageBytes = 0;
+    for (const group of storageGroups) {
+      maxAccountStorageBytes = Math.max(maxAccountStorageBytes, group.max?.storedBytes ?? 0);
+    }
+
+    // Calculate total requests for proportional allocation
+    let totalRequestsForAllocation = 0;
+    for (const [, metrics] of scriptMap) {
+      totalRequestsForAllocation += metrics.requests;
+    }
+
+    // Allocate duration and storage proportionally to each script based on request count
+    if (totalRequestsForAllocation > 0) {
+      for (const [scriptName, metrics] of scriptMap) {
+        const proportion = metrics.requests / totalRequestsForAllocation;
+        metrics.gbSeconds = totalAccountGbSeconds * proportion;
+        metrics.storageBytes = maxAccountStorageBytes * proportion;
+        scriptMap.set(scriptName, metrics);
+      }
+    }
+
+    // Calculate totals
+    let totalRequests = 0;
+    let totalResponseBodySize = 0;
+    let totalGbSeconds = 0;
+
+    const byScript: DOScriptMetrics[] = [];
+    for (const [scriptName, metrics] of scriptMap) {
+      totalRequests += metrics.requests;
+      totalResponseBodySize += metrics.responseBodySize;
+      totalGbSeconds += metrics.gbSeconds;
+      byScript.push({
+        scriptName,
+        requests: metrics.requests,
+        gbSeconds: metrics.gbSeconds,
+        storageBytes: metrics.storageBytes > 0 ? metrics.storageBytes : undefined,
+      });
+    }
+
+    // Debug: Log byScript breakdown for troubleshooting
+    console.log(
+      `[CloudflareGraphQL] DO byScript count: ${byScript.length}, scripts: ${byScript.map((s) => s.scriptName).join(', ')}`
+    );
+
+    return {
+      requests: totalRequests,
+      responseBodySize: totalResponseBodySize,
+      gbSeconds: totalGbSeconds,
+      storageBytes: maxAccountStorageBytes, // Account-level storage (current state, not cumulative)
+      // Storage operation metrics not available from API - returning 0s for interface compatibility
+      storageReadUnits: 0,
+      storageWriteUnits: 0,
+      storageDeleteUnits: 0,
+      byScript: byScript.length > 0 ? byScript : undefined,
+    };
+  }
+
+  /**
+   * Get AI Gateway metrics for a specific date range
+   */
+  private async getAIGatewayMetricsForRange(dateRange: DateRange): Promise<AIGatewayMetrics[]> {
+    const { startDate, endDate } = dateRange;
+
+    try {
+      const listResponse = await fetchWithRetry(
+        `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/ai-gateway/gateways`,
+        {
+          headers: {
+            Authorization: `Bearer ${this.apiToken}`,
+            'Content-Type': 'application/json',
+          },
+        }
+      );
+
+      if (!listResponse.ok) {
+        return [];
+      }
+
+      interface GatewayListResponse {
+        result?: Array<{ id: string; name: string }>;
+        success?: boolean;
+      }
+
+      const listData = (await listResponse.json()) as GatewayListResponse;
+
+      if (!listData.success || !listData.result) {
+        return [];
+      }
+
+      const results: AIGatewayMetrics[] = [];
+
+      for (const gateway of listData.result) {
+        // Get aggregate analytics and model breakdown in parallel
+        const [analyticsResponse, modelBreakdown] = await Promise.all([
+          fetchWithRetry(
+            `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/ai-gateway/gateways/${gateway.id}/analytics?` +
+              `start=${startDate}T00:00:00Z&end=${endDate}T23:59:59Z`,
+            {
+              headers: {
+                Authorization: `Bearer ${this.apiToken}`,
+                'Content-Type': 'application/json',
+              },
+            }
+          ),
+          this.getAIGatewayModelBreakdown(gateway.id, startDate, endDate),
+        ]);
+
+        if (analyticsResponse.ok) {
+          interface AnalyticsResponse {
+            result?: {
+              totalRequests?: number;
+              cachedRequests?: number;
+              totalTokens?: number;
+              cost?: number;
+            };
+          }
+          const analyticsData = (await analyticsResponse.json()) as AnalyticsResponse;
+
+          results.push({
+            gatewayId: gateway.id,
+            totalRequests: analyticsData.result?.totalRequests ?? 0,
+            cachedRequests: analyticsData.result?.cachedRequests ?? 0,
+            totalTokens: analyticsData.result?.totalTokens ?? 0,
+            estimatedCostUsd: analyticsData.result?.cost ?? 0,
+            byModel: modelBreakdown.length > 0 ? modelBreakdown : undefined,
+          });
+        }
+      }
+
+      return results;
+    } catch (error) {
+      console.error('[CloudflareGraphQL] AI Gateway error:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Execute a GraphQL query with retry logic for rate limits
+   */
+  private async query<T>(
+    query: string,
+    variables: Record<string, unknown>,
+    queryRetryCount = 0
+  ): Promise<T | null> {
+    // Extract operation name from query for better logging
+    const opMatch = query.match(/query\s+(\w+)/);
+    const operationName = opMatch?.[1] || 'UnnamedQuery';
+
+    try {
+      const response = await fetchWithRetry(GRAPHQL_ENDPOINT, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiToken}`,
+        },
+        body: JSON.stringify({ query, variables }),
+      });
+
+      if (!response.ok) {
+        const errorBody = await response.text().catch(() => '(unable to read body)');
+        console.error(
+          `[CloudflareGraphQL] HTTP ${response.status} for ${operationName}: ${errorBody}`
+        );
+        return null;
+      }
+
+      const result = (await response.json()) as GraphQLResponse<T>;
+
+      if (result.errors?.length) {
+        // Check if errors are retryable (INTERNAL_SERVER_ERROR from CF)
+        const hasRetryableError = result.errors.some(
+          (e) => e.extensions?.code === 'INTERNAL_SERVER_ERROR'
+        );
+
+        if (hasRetryableError && queryRetryCount < 2) {
+          queryRetryCount++;
+          console.log(
+            `[CloudflareGraphQL] Retryable GraphQL error for ${operationName} (attempt ${queryRetryCount}), retrying...`
+          );
+          await new Promise((r) => setTimeout(r, 1000 * Math.pow(2, queryRetryCount)));
+          return this.query<T>(query, variables, queryRetryCount);
+        }
+
+        console.error(
+          `[CloudflareGraphQL] GraphQL errors for ${operationName}:`,
+          JSON.stringify(result.errors)
+        );
+        return null;
+      }
+
+      // Log successful query with operation name (helpful for debugging empty results)
+      console.log(`[CloudflareGraphQL] ${operationName} succeeded`);
+
+      return result.data ?? null;
+    } catch (error) {
+      console.error(`[CloudflareGraphQL] Query error for ${operationName}:`, error);
+      return null;
+    }
+  }
+
+  /**
+   * Get Workers metrics for all scripts
+   */
+  async getWorkersMetrics(period: TimePeriod): Promise<WorkersMetrics[]> {
+    const { startDate, endDate } = this.getDateRange(period);
+
+    const queryStr = `
+      query WorkersMetrics($accountTag: String!, $startDate: Date!, $endDate: Date!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            workersInvocationsAdaptive(
+              filter: {
+                date_geq: $startDate
+                date_leq: $endDate
+              }
+              limit: 100
+            ) {
+              dimensions {
+                scriptName
+              }
+              sum {
+                requests
+                errors
+              }
+              quantiles {
+                cpuTimeP50
+                cpuTimeP99
+                durationP50
+                durationP99
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    interface WorkersResponse {
+      viewer?: {
+        accounts?: Array<{
+          workersInvocationsAdaptive?: Array<{
+            dimensions?: { scriptName?: string };
+            sum?: { requests?: number; errors?: number };
+            quantiles?: {
+              cpuTimeP50?: number;
+              cpuTimeP99?: number;
+              durationP50?: number;
+              durationP99?: number;
+            };
+          }>;
+        }>;
+      };
+    }
+
+    const data = await this.query<WorkersResponse>(queryStr, {
+      accountTag: this.accountId,
+      startDate,
+      endDate,
+    });
+
+    if (!data?.viewer?.accounts?.[0]?.workersInvocationsAdaptive) {
+      console.log(
+        `[CloudflareGraphQL] getWorkersMetrics empty - query for ${startDate} to ${endDate}, data path: viewer=${!!data?.viewer}, accounts=${!!data?.viewer?.accounts?.[0]}, data=${!!data?.viewer?.accounts?.[0]?.workersInvocationsAdaptive}`
+      );
+      return [];
+    }
+
+    const results = data.viewer.accounts[0].workersInvocationsAdaptive;
+    console.log(`[CloudflareGraphQL] getWorkersMetrics found ${results.length} workers`);
+
+    return results
+      .filter((item) => item.dimensions?.scriptName)
+      .map((item) => ({
+        scriptName: item.dimensions!.scriptName!,
+        requests: item.sum?.requests ?? 0,
+        errors: item.sum?.errors ?? 0,
+        // cpuTimeP50 from GraphQL is in microseconds, convert to milliseconds
+        cpuTimeMs: (item.quantiles?.cpuTimeP50 ?? 0) / 1000,
+        duration50thMs: item.quantiles?.durationP50 ?? 0,
+        duration99thMs: item.quantiles?.durationP99 ?? 0,
+      }));
+  }
+
+  /**
+   * Get D1 database metrics for all databases
+   * Queries both d1AnalyticsAdaptiveGroups (operations) and d1StorageAdaptiveGroups (storage)
+   *
+   * Note: GraphQL only returns aggregated metrics, not per-database.
+   * We need to fetch database list via REST API first.
+   */
+  async getD1Metrics(period: TimePeriod): Promise<D1Metrics[]> {
+    const { startDate, endDate } = this.getDateRange(period);
+
+    // First, get list of D1 databases via REST API
+    const databases = await this.listD1Databases();
+
+    const results: D1Metrics[] = [];
+
+    for (const db of databases) {
+      const queryStr = `
+        query D1Metrics($accountTag: String!, $databaseId: String!, $startDate: Date!, $endDate: Date!) {
+          viewer {
+            accounts(filter: { accountTag: $accountTag }) {
+              d1AnalyticsAdaptiveGroups(
+                filter: {
+                  databaseId: $databaseId
+                  date_geq: $startDate
+                  date_leq: $endDate
+                }
+                limit: 100
+              ) {
+                sum {
+                  rowsRead
+                  rowsWritten
+                  readQueries
+                  writeQueries
+                }
+              }
+              d1StorageAdaptiveGroups(
+                filter: {
+                  databaseId: $databaseId
+                  date_geq: $startDate
+                  date_leq: $endDate
+                }
+                limit: 1
+              ) {
+                max {
+                  databaseSizeBytes
+                }
+              }
+            }
+          }
+        }
+      `;
+
+      interface D1Response {
+        viewer?: {
+          accounts?: Array<{
+            d1AnalyticsAdaptiveGroups?: Array<{
+              sum?: {
+                rowsRead?: number;
+                rowsWritten?: number;
+                readQueries?: number;
+                writeQueries?: number;
+              };
+            }>;
+            d1StorageAdaptiveGroups?: Array<{
+              max?: {
+                databaseSizeBytes?: number;
+              };
+            }>;
+          }>;
+        };
+      }
+
+      const data = await this.query<D1Response>(queryStr, {
+        accountTag: this.accountId,
+        databaseId: db.id,
+        startDate,
+        endDate,
+      });
+
+      const groups = data?.viewer?.accounts?.[0]?.d1AnalyticsAdaptiveGroups;
+      const storageGroups = data?.viewer?.accounts?.[0]?.d1StorageAdaptiveGroups;
+
+      // Aggregate operations
+      const totals = groups?.length
+        ? groups.reduce(
+            (acc, group) => ({
+              rowsRead: acc.rowsRead + (group.sum?.rowsRead ?? 0),
+              rowsWritten: acc.rowsWritten + (group.sum?.rowsWritten ?? 0),
+              readQueries: acc.readQueries + (group.sum?.readQueries ?? 0),
+              writeQueries: acc.writeQueries + (group.sum?.writeQueries ?? 0),
+            }),
+            { rowsRead: 0, rowsWritten: 0, readQueries: 0, writeQueries: 0 }
+          )
+        : { rowsRead: 0, rowsWritten: 0, readQueries: 0, writeQueries: 0 };
+
+      // Use storage from REST API (db.fileSize) as primary source
+      // Fall back to GraphQL d1StorageAdaptiveGroups if REST doesn't have it
+      const graphqlStorageBytes = storageGroups?.[0]?.max?.databaseSizeBytes ?? 0;
+      const storageBytes = db.fileSize > 0 ? db.fileSize : graphqlStorageBytes;
+
+      // Only add if we have any data (operations OR storage)
+      if (
+        totals.rowsRead > 0 ||
+        totals.rowsWritten > 0 ||
+        totals.readQueries > 0 ||
+        totals.writeQueries > 0 ||
+        storageBytes > 0
+      ) {
+        results.push({
+          databaseId: db.id,
+          databaseName: db.name,
+          ...totals,
+          storageBytes,
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * List D1 databases via REST API
+   * Returns id, name, and file_size (storage bytes) from the API
+   */
+  private async listD1Databases(): Promise<Array<{ id: string; name: string; fileSize: number }>> {
+    try {
+      const response = await fetchWithRetry(
+        `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/d1/database`,
+        {
+          headers: {
+            Authorization: `Bearer ${this.apiToken}`,
+            'Content-Type': 'application/json',
+          },
+        }
+      );
+
+      if (!response.ok) {
+        console.error(`[CloudflareGraphQL] D1 list error: ${response.status}`);
+        return [];
+      }
+
+      interface D1ListResponse {
+        result?: Array<{ uuid: string; name: string; file_size?: number }>;
+        success?: boolean;
+      }
+
+      const data = (await response.json()) as D1ListResponse;
+
+      if (!data.success || !data.result) {
+        return [];
+      }
+
+      return data.result.map((db) => ({
+        id: db.uuid,
+        name: db.name,
+        fileSize: db.file_size ?? 0,
+      }));
+    } catch (error) {
+      console.error('[CloudflareGraphQL] D1 list error:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get KV namespace metrics
+   * Queries both kvOperationsAdaptiveGroups (operations) and kvStorageAdaptiveGroups (storage)
+   */
+  async getKVMetrics(period: TimePeriod): Promise<KVMetrics[]> {
+    const { startDate, endDate } = this.getDateRange(period);
+
+    // First, get list of KV namespaces via REST API
+    const namespaces = await this.listKVNamespaces();
+
+    const results: KVMetrics[] = [];
+
+    for (const ns of namespaces) {
+      const queryStr = `
+        query KVMetrics($accountTag: String!, $namespaceId: String!, $startDate: Date!, $endDate: Date!) {
+          viewer {
+            accounts(filter: { accountTag: $accountTag }) {
+              kvOperationsAdaptiveGroups(
+                filter: {
+                  namespaceId: $namespaceId
+                  date_geq: $startDate
+                  date_leq: $endDate
+                }
+                limit: 100
+              ) {
+                sum {
+                  requests
+                }
+                dimensions {
+                  actionType
+                }
+              }
+              kvStorageAdaptiveGroups(
+                filter: {
+                  namespaceId: $namespaceId
+                  date_geq: $startDate
+                  date_leq: $endDate
+                }
+                limit: 1
+              ) {
+                max {
+                  byteCount
+                  keyCount
+                }
+              }
+            }
+          }
+        }
+      `;
+
+      interface KVResponse {
+        viewer?: {
+          accounts?: Array<{
+            kvOperationsAdaptiveGroups?: Array<{
+              sum?: { requests?: number };
+              dimensions?: { actionType?: string };
+            }>;
+            kvStorageAdaptiveGroups?: Array<{
+              max?: {
+                byteCount?: number;
+                keyCount?: number;
+              };
+            }>;
+          }>;
+        };
+      }
+
+      const data = await this.query<KVResponse>(queryStr, {
+        accountTag: this.accountId,
+        namespaceId: this.formatUuidWithHyphens(ns.id),
+        startDate,
+        endDate,
+      });
+
+      const operationsGroups = data?.viewer?.accounts?.[0]?.kvOperationsAdaptiveGroups;
+      const storageGroups = data?.viewer?.accounts?.[0]?.kvStorageAdaptiveGroups;
+
+      // Aggregate operations by action type
+      const totals = { reads: 0, writes: 0, deletes: 0, lists: 0 };
+      if (operationsGroups?.length) {
+        for (const group of operationsGroups) {
+          const requests = group.sum?.requests ?? 0;
+          const actionType = group.dimensions?.actionType?.toLowerCase() ?? '';
+          if (actionType === 'read' || actionType === 'get') {
+            totals.reads += requests;
+          } else if (actionType === 'write' || actionType === 'put') {
+            totals.writes += requests;
+          } else if (actionType === 'delete') {
+            totals.deletes += requests;
+          } else if (actionType === 'list') {
+            totals.lists += requests;
+          }
+        }
+      }
+
+      // Extract storage metrics (most recent snapshot)
+      const storageBytes = storageGroups?.[0]?.max?.byteCount ?? 0;
+      const keyCount = storageGroups?.[0]?.max?.keyCount ?? 0;
+
+      // Only add if we have any data
+      if (
+        totals.reads > 0 ||
+        totals.writes > 0 ||
+        totals.deletes > 0 ||
+        totals.lists > 0 ||
+        storageBytes > 0 ||
+        keyCount > 0
+      ) {
+        results.push({
+          namespaceId: ns.id,
+          namespaceName: ns.title,
+          ...totals,
+          storageBytes,
+          keyCount,
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * List KV namespaces via REST API
+   */
+  private async listKVNamespaces(): Promise<Array<{ id: string; title: string }>> {
+    try {
+      const response = await fetchWithRetry(
+        `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/storage/kv/namespaces`,
+        {
+          headers: {
+            Authorization: `Bearer ${this.apiToken}`,
+            'Content-Type': 'application/json',
+          },
+        }
+      );
+
+      if (!response.ok) {
+        console.error(`[CloudflareGraphQL] KV list error: ${response.status}`);
+        return [];
+      }
+
+      interface KVListResponse {
+        result?: Array<{ id: string; title: string }>;
+        success?: boolean;
+      }
+
+      const data = (await response.json()) as KVListResponse;
+
+      if (!data.success || !data.result) {
+        return [];
+      }
+
+      return data.result;
+    } catch (error) {
+      console.error('[CloudflareGraphQL] KV list error:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get R2 bucket metrics
+   */
+  async getR2Metrics(period: TimePeriod): Promise<R2Metrics[]> {
+    const { startDate, endDate } = this.getDateRange(period);
+    // R2 storage uses datetime filters (Time type), operations uses date filters (Date type)
+    const datetimeStart = `${startDate}T00:00:00Z`;
+    const datetimeEnd = `${endDate}T23:59:59Z`;
+
+    // Query 1: Operations (uses Date type filters)
+    const operationsQuery = `
+      query R2Operations($accountTag: String!, $startDate: Date!, $endDate: Date!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            r2OperationsAdaptiveGroups(
+              filter: {
+                date_geq: $startDate
+                date_leq: $endDate
+              }
+              limit: 100
+            ) {
+              dimensions {
+                bucketName
+                actionType
+              }
+              sum {
+                requests
+                responseObjectSize
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    // Query 2: Storage (uses Time type filters per CF docs)
+    const storageQuery = `
+      query R2Storage($accountTag: String!, $datetimeStart: Time!, $datetimeEnd: Time!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            r2StorageAdaptiveGroups(
+              filter: {
+                datetime_geq: $datetimeStart
+                datetime_leq: $datetimeEnd
+              }
+              limit: 100
+            ) {
+              dimensions {
+                bucketName
+              }
+              max {
+                payloadSize
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    interface R2OperationsResponse {
+      viewer?: {
+        accounts?: Array<{
+          r2OperationsAdaptiveGroups?: Array<{
+            dimensions?: { bucketName?: string; actionType?: string };
+            sum?: { requests?: number; responseObjectSize?: number };
+          }>;
+        }>;
+      };
+    }
+
+    interface R2StorageResponse {
+      viewer?: {
+        accounts?: Array<{
+          r2StorageAdaptiveGroups?: Array<{
+            dimensions?: { bucketName?: string };
+            max?: { payloadSize?: number };
+          }>;
+        }>;
+      };
+    }
+
+    // Execute both queries in parallel
+    const [operationsData, storageData] = await Promise.all([
+      this.query<R2OperationsResponse>(operationsQuery, {
+        accountTag: this.accountId,
+        startDate,
+        endDate,
+      }),
+      this.query<R2StorageResponse>(storageQuery, {
+        accountTag: this.accountId,
+        datetimeStart,
+        datetimeEnd,
+      }).catch(() => null), // Storage query may fail if no data exists
+    ]);
+
+    const operations = operationsData?.viewer?.accounts?.[0]?.r2OperationsAdaptiveGroups ?? [];
+    const storage = storageData?.viewer?.accounts?.[0]?.r2StorageAdaptiveGroups ?? [];
+
+    // Aggregate by bucket
+    const bucketMap = new Map<string, R2Metrics>();
+
+    // Class A: PUT, POST, DELETE, LIST, etc.
+    // Class B: GET, HEAD
+    const classAActions = new Set([
+      'PutObject',
+      'DeleteObject',
+      'ListObjects',
+      'ListObjectsV2',
+      'CreateMultipartUpload',
+      'CompleteMultipartUpload',
+      'AbortMultipartUpload',
+      'UploadPart',
+      'CopyObject',
+    ]);
+
+    for (const op of operations) {
+      const bucketName = op.dimensions?.bucketName ?? 'unknown';
+      if (!bucketMap.has(bucketName)) {
+        bucketMap.set(bucketName, {
+          bucketName,
+          classAOperations: 0,
+          classBOperations: 0,
+          storageBytes: 0,
+          egressBytes: 0,
+        });
+      }
+
+      const bucket = bucketMap.get(bucketName)!;
+      const requests = op.sum?.requests ?? 0;
+      const actionType = op.dimensions?.actionType ?? '';
+
+      if (classAActions.has(actionType)) {
+        bucket.classAOperations += requests;
+      } else {
+        bucket.classBOperations += requests;
+      }
+
+      bucket.egressBytes += op.sum?.responseObjectSize ?? 0;
+    }
+
+    for (const s of storage) {
+      const bucketName = s.dimensions?.bucketName ?? 'unknown';
+      if (bucketMap.has(bucketName)) {
+        bucketMap.get(bucketName)!.storageBytes = s.max?.payloadSize ?? 0;
+      }
+    }
+
+    return Array.from(bucketMap.values());
+  }
+
+  /**
+   * Get Durable Objects metrics including duration (GB-seconds)
+   * Includes per-script breakdown for project attribution via getDOMetricsForRange
+   */
+  async getDOMetrics(period: TimePeriod): Promise<DOMetrics> {
+    // Delegate to getDOMetricsForRange to get per-script breakdown for project attribution
+    const dateRange = this.getDateRange(period);
+    return this.getDOMetricsForRange(dateRange);
+  }
+
+  /**
+   * Get Vectorize index info via REST API
+   */
+  async getVectorizeInfo(): Promise<VectorizeInfo[]> {
+    try {
+      const response = await fetchWithRetry(
+        `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/vectorize/v2/indexes`,
+        {
+          headers: {
+            Authorization: `Bearer ${this.apiToken}`,
+            'Content-Type': 'application/json',
+          },
+        }
+      );
+
+      if (!response.ok) {
+        console.error(`[CloudflareGraphQL] Vectorize list error: ${response.status}`);
+        return [];
+      }
+
+      interface VectorizeListResponse {
+        result?: Array<{
+          name: string;
+          config?: {
+            dimensions?: number;
+          };
+        }>;
+        success?: boolean;
+      }
+
+      const data = (await response.json()) as VectorizeListResponse;
+
+      if (!data.success || !data.result) {
+        return [];
+      }
+
+      // For each index, get the vector count
+      const results: VectorizeInfo[] = [];
+
+      for (const index of data.result) {
+        // Get index info for vector count
+        const infoResponse = await fetchWithRetry(
+          `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/vectorize/v2/indexes/${index.name}/info`,
+          {
+            headers: {
+              Authorization: `Bearer ${this.apiToken}`,
+              'Content-Type': 'application/json',
+            },
+          }
+        );
+
+        let vectorCount = 0;
+        if (infoResponse.ok) {
+          interface IndexInfoResponse {
+            result?: { vectorsCount?: number };
+          }
+          const infoData = (await infoResponse.json()) as IndexInfoResponse;
+          vectorCount = infoData.result?.vectorsCount ?? 0;
+        }
+
+        results.push({
+          name: index.name,
+          vectorCount,
+          dimensions: index.config?.dimensions ?? 0,
+        });
+      }
+
+      return results;
+    } catch (error) {
+      console.error('[CloudflareGraphQL] Vectorize error:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get AI Gateway model breakdown from logs API
+   * Fetches logs and aggregates by provider+model
+   */
+  private async getAIGatewayModelBreakdown(
+    gatewayId: string,
+    startDate: string,
+    endDate: string
+  ): Promise<AIGatewayModelBreakdown[]> {
+    const modelMap = new Map<string, AIGatewayModelBreakdown>();
+
+    try {
+      // Fetch logs with pagination (API returns up to 50 per page)
+      let page = 1;
+      const perPage = 50;
+      let hasMore = true;
+      let totalFetched = 0;
+      const maxLogs = 500; // Limit to avoid excessive API calls
+
+      while (hasMore && totalFetched < maxLogs) {
+        const logsUrl = new URL(
+          `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/ai-gateway/gateways/${gatewayId}/logs`
+        );
+        logsUrl.searchParams.set('start_date', `${startDate}T00:00:00Z`);
+        logsUrl.searchParams.set('end_date', `${endDate}T23:59:59Z`);
+        logsUrl.searchParams.set('page', page.toString());
+        logsUrl.searchParams.set('per_page', perPage.toString());
+        logsUrl.searchParams.set('order_by', 'created_at');
+        logsUrl.searchParams.set('order_by_direction', 'desc');
+
+        const logsResponse = await fetchWithRetry(logsUrl.toString(), {
+          headers: {
+            Authorization: `Bearer ${this.apiToken}`,
+            'Content-Type': 'application/json',
+          },
+        });
+
+        if (!logsResponse.ok) {
+          const errBody = await logsResponse.text().catch(() => '');
+          console.debug(
+            `[CloudflareGraphQL] AI Gateway logs unavailable (${logsResponse.status}): ${errBody.slice(0, 200)}`
+          );
+          break;
+        }
+
+        interface LogEntry {
+          provider?: string;
+          model?: string;
+          tokens_in?: number;
+          tokens_out?: number;
+          cost?: number;
+          cached?: boolean;
+          success?: boolean;
+        }
+
+        interface LogsResponse {
+          result?: LogEntry[];
+          success?: boolean;
+          result_info?: { page?: number; per_page?: number; total_count?: number };
+        }
+
+        const logsData = (await logsResponse.json()) as LogsResponse;
+
+        if (!logsData.success || !logsData.result || logsData.result.length === 0) {
+          console.log(
+            `[CloudflareGraphQL] AI Gateway ${gatewayId} logs: success=${logsData.success}, result.length=${logsData.result?.length ?? 'null'}, page=${page}`
+          );
+          break;
+        }
+
+        // Aggregate by provider+model
+        for (const log of logsData.result) {
+          const provider = log.provider || 'unknown';
+          const model = log.model || 'unknown';
+          const key = `${provider}::${model}`;
+
+          const existing = modelMap.get(key);
+          if (existing) {
+            existing.requests += 1;
+            existing.cachedRequests += log.cached ? 1 : 0;
+            existing.tokensIn += log.tokens_in ?? 0;
+            existing.tokensOut += log.tokens_out ?? 0;
+            existing.costUsd += log.cost ?? 0;
+          } else {
+            modelMap.set(key, {
+              provider,
+              model,
+              requests: 1,
+              cachedRequests: log.cached ? 1 : 0,
+              tokensIn: log.tokens_in ?? 0,
+              tokensOut: log.tokens_out ?? 0,
+              costUsd: log.cost ?? 0,
+            });
+          }
+        }
+
+        totalFetched += logsData.result.length;
+
+        // Check if there are more pages
+        const totalCount = logsData.result_info?.total_count ?? 0;
+        hasMore = totalFetched < totalCount && logsData.result.length === perPage;
+        page++;
+      }
+    } catch (error) {
+      console.warn(`[CloudflareGraphQL] AI Gateway model breakdown error:`, error);
+    }
+
+    // Sort by requests descending
+    const result = Array.from(modelMap.values()).sort((a, b) => b.requests - a.requests);
+    console.log(
+      `[CloudflareGraphQL] AI Gateway ${gatewayId} model breakdown complete: ${result.length} models from logs`
+    );
+    return result;
+  }
+
+  /**
+   * Get AI Gateway metrics via REST API
+   */
+  async getAIGatewayMetrics(period: TimePeriod): Promise<AIGatewayMetrics[]> {
+    try {
+      // First, list all gateways
+      const listResponse = await fetchWithRetry(
+        `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/ai-gateway/gateways`,
+        {
+          headers: {
+            Authorization: `Bearer ${this.apiToken}`,
+            'Content-Type': 'application/json',
+          },
+        }
+      );
+
+      if (!listResponse.ok) {
+        console.error(`[CloudflareGraphQL] AI Gateway list error: ${listResponse.status}`);
+        return [];
+      }
+
+      interface GatewayListResponse {
+        result?: Array<{ id: string; name: string }>;
+        success?: boolean;
+      }
+
+      const listData = (await listResponse.json()) as GatewayListResponse;
+
+      if (!listData.success || !listData.result) {
+        return [];
+      }
+
+      const { startDate, endDate } = this.getDateRange(period);
+      const results: AIGatewayMetrics[] = [];
+
+      for (const gateway of listData.result) {
+        // Get aggregate analytics and model breakdown in parallel
+        const [analyticsResponse, modelBreakdown] = await Promise.all([
+          fetchWithRetry(
+            `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/ai-gateway/gateways/${gateway.id}/analytics?` +
+              `start=${startDate}T00:00:00Z&end=${endDate}T23:59:59Z`,
+            {
+              headers: {
+                Authorization: `Bearer ${this.apiToken}`,
+                'Content-Type': 'application/json',
+              },
+            }
+          ),
+          this.getAIGatewayModelBreakdown(gateway.id, startDate, endDate),
+        ]);
+
+        // Always include gateway if model breakdown was fetched, even if analytics fails
+        // This ensures we don't lose model data due to analytics API issues
+        if (analyticsResponse.ok) {
+          interface AnalyticsResponse {
+            result?: {
+              totalRequests?: number;
+              cachedRequests?: number;
+              totalTokens?: number;
+              cost?: number;
+            };
+          }
+          const analyticsData = (await analyticsResponse.json()) as AnalyticsResponse;
+
+          results.push({
+            gatewayId: gateway.id,
+            totalRequests: analyticsData.result?.totalRequests ?? 0,
+            cachedRequests: analyticsData.result?.cachedRequests ?? 0,
+            totalTokens: analyticsData.result?.totalTokens ?? 0,
+            estimatedCostUsd: analyticsData.result?.cost ?? 0,
+            byModel: modelBreakdown.length > 0 ? modelBreakdown : undefined,
+          });
+        } else {
+          // Analytics endpoint may not exist (404) - this is expected, fall back to model breakdown
+          console.debug(
+            `[CloudflareGraphQL] AI Gateway ${gateway.id} analytics API returned ${analyticsResponse.status}, using model breakdown only`
+          );
+          // Include gateway with model data even if analytics failed
+          if (modelBreakdown.length > 0) {
+            results.push({
+              gatewayId: gateway.id,
+              totalRequests: 0,
+              cachedRequests: 0,
+              totalTokens: 0,
+              estimatedCostUsd: 0,
+              byModel: modelBreakdown,
+            });
+          }
+        }
+      }
+
+      return results;
+    } catch (error) {
+      console.error('[CloudflareGraphQL] AI Gateway error:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get Pages project metrics
+   */
+  async getPagesMetrics(): Promise<PagesMetrics[]> {
+    try {
+      // List all Pages projects
+      const response = await fetchWithRetry(
+        `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/pages/projects`,
+        {
+          headers: {
+            Authorization: `Bearer ${this.apiToken}`,
+            'Content-Type': 'application/json',
+          },
+        }
+      );
+
+      if (!response.ok) {
+        console.error(`[CloudflareGraphQL] Pages list error: ${response.status}`);
+        return [];
+      }
+
+      interface PagesListResponse {
+        result?: Array<{
+          name: string;
+          subdomain: string;
+          latest_deployment?: {
+            environment?: string;
+            created_on?: string;
+          };
+        }>;
+        success?: boolean;
+      }
+
+      const data = (await response.json()) as PagesListResponse;
+      const projects = data.result ?? [];
+      const results: PagesMetrics[] = [];
+
+      // For each project, get deployment counts
+      for (const project of projects) {
+        // Get deployments for this project
+        const deploymentsResponse = await fetchWithRetry(
+          `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/pages/projects/${project.name}/deployments`,
+          {
+            headers: {
+              Authorization: `Bearer ${this.apiToken}`,
+              'Content-Type': 'application/json',
+            },
+          }
+        );
+
+        let productionDeployments = 0;
+        let previewDeployments = 0;
+        let lastDeployedAt: string | null = null;
+
+        if (deploymentsResponse.ok) {
+          interface DeploymentsResponse {
+            result?: Array<{
+              environment: string;
+              created_on: string;
+            }>;
+          }
+          const deploymentsData = (await deploymentsResponse.json()) as DeploymentsResponse;
+          const deployments = deploymentsData.result ?? [];
+
+          productionDeployments = deployments.filter((d) => d.environment === 'production').length;
+          previewDeployments = deployments.filter((d) => d.environment === 'preview').length;
+
+          if (deployments.length > 0 && deployments[0]) {
+            lastDeployedAt = deployments[0].created_on;
+          }
+        }
+
+        results.push({
+          projectName: project.name,
+          subdomain: project.subdomain,
+          productionDeployments,
+          previewDeployments,
+          totalBuilds: productionDeployments + previewDeployments,
+          lastDeployedAt,
+        });
+      }
+
+      return results;
+    } catch (error) {
+      console.error('[CloudflareGraphQL] Pages error:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get Workflows execution metrics from GraphQL API
+   * Queries the workflowsAdaptiveGroups dataset for execution counts and timing
+   */
+  async getWorkflowsMetrics(period: TimePeriod): Promise<WorkflowsSummary> {
+    try {
+      const { startDate, endDate } = this.getDateRange(period);
+
+      const query = `
+        query WorkflowsMetrics($accountTag: String!, $startDate: Date!, $endDate: Date!) {
+          viewer {
+            accounts(filter: { accountTag: $accountTag }) {
+              workflowsAdaptiveGroups(
+                filter: {
+                  date_geq: $startDate
+                  date_leq: $endDate
+                }
+                limit: 10000
+              ) {
+                dimensions {
+                  workflowName
+                  eventType
+                }
+                sum {
+                  wallTime
+                  cpuTime
+                }
+                count
+              }
+            }
+          }
+        }
+      `;
+
+      const response = await fetchWithRetry(GRAPHQL_ENDPOINT, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${this.apiToken}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          query,
+          variables: {
+            accountTag: this.accountId,
+            startDate,
+            endDate,
+          },
+        }),
+      });
+
+      if (!response.ok) {
+        console.error(`[CloudflareGraphQL] Workflows GraphQL error: ${response.status}`);
+        return this.emptyWorkflowsSummary();
+      }
+
+      interface WorkflowsGraphQLResponse {
+        data?: {
+          viewer?: {
+            accounts?: Array<{
+              workflowsAdaptiveGroups?: Array<{
+                dimensions?: {
+                  workflowName?: string;
+                  eventType?: string;
+                };
+                sum?: {
+                  wallTime?: number;
+                  cpuTime?: number;
+                };
+                count?: number;
+              }>;
+            }>;
+          };
+        };
+        errors?: Array<{ message: string }>;
+      }
+
+      const data = (await response.json()) as WorkflowsGraphQLResponse;
+
+      if (data.errors) {
+        console.error('[CloudflareGraphQL] Workflows GraphQL errors:', data.errors);
+        return this.emptyWorkflowsSummary();
+      }
+
+      const groups = data.data?.viewer?.accounts?.[0]?.workflowsAdaptiveGroups ?? [];
+
+      // Aggregate by workflow
+      const workflowMap = new Map<string, WorkflowsMetrics>();
+
+      for (const group of groups) {
+        const workflowName = group.dimensions?.workflowName ?? 'unknown';
+        const eventType = group.dimensions?.eventType ?? '';
+        const count = group.count ?? 0;
+        const wallTime = group.sum?.wallTime ?? 0;
+        const cpuTime = group.sum?.cpuTime ?? 0;
+
+        if (!workflowMap.has(workflowName)) {
+          workflowMap.set(workflowName, {
+            workflowName,
+            executions: 0,
+            successes: 0,
+            failures: 0,
+            wallTimeMs: 0,
+            cpuTimeMs: 0,
+          });
+        }
+
+        const metrics = workflowMap.get(workflowName)!;
+
+        // Map event types to metrics
+        if (eventType === 'WORKFLOW_START') {
+          metrics.executions += count;
+        } else if (eventType === 'WORKFLOW_SUCCESS') {
+          metrics.successes += count;
+          metrics.wallTimeMs += wallTime;
+        } else if (eventType === 'WORKFLOW_FAILURE' || eventType === 'WORKFLOW_ERROR') {
+          metrics.failures += count;
+        }
+        // WORKFLOW_RUNNING events only have cpuTime, add to total
+        if (eventType === 'WORKFLOW_RUNNING') {
+          metrics.cpuTimeMs += cpuTime;
+        }
+      }
+
+      const byWorkflow = Array.from(workflowMap.values());
+
+      // Calculate totals
+      const summary: WorkflowsSummary = {
+        totalExecutions: byWorkflow.reduce((sum, w) => sum + w.executions, 0),
+        totalSuccesses: byWorkflow.reduce((sum, w) => sum + w.successes, 0),
+        totalFailures: byWorkflow.reduce((sum, w) => sum + w.failures, 0),
+        totalWallTimeMs: byWorkflow.reduce((sum, w) => sum + w.wallTimeMs, 0),
+        totalCpuTimeMs: byWorkflow.reduce((sum, w) => sum + w.cpuTimeMs, 0),
+        byWorkflow,
+      };
+
+      return summary;
+    } catch (error) {
+      console.error('[CloudflareGraphQL] Workflows error:', error);
+      return this.emptyWorkflowsSummary();
+    }
+  }
+
+  /**
+   * Returns an empty WorkflowsSummary for error cases
+   */
+  private emptyWorkflowsSummary(): WorkflowsSummary {
+    return {
+      totalExecutions: 0,
+      totalSuccesses: 0,
+      totalFailures: 0,
+      totalWallTimeMs: 0,
+      totalCpuTimeMs: 0,
+      byWorkflow: [],
+    };
+  }
+
+  /**
+   * Get all metrics for the account
+   */
+  async getAllMetrics(period: TimePeriod): Promise<AccountUsage> {
+    // Run all queries in parallel for better performance
+    const [workers, d1, kv, r2, durableObjects, vectorize, aiGateway, pages] = await Promise.all([
+      this.getWorkersMetrics(period),
+      this.getD1Metrics(period),
+      this.getKVMetrics(period),
+      this.getR2Metrics(period),
+      this.getDOMetrics(period),
+      this.getVectorizeInfo(),
+      this.getAIGatewayMetrics(period),
+      this.getPagesMetrics(),
+    ]);
+
+    return {
+      period,
+      workers,
+      d1,
+      kv,
+      r2,
+      durableObjects,
+      vectorize,
+      aiGateway,
+      pages,
+    };
+  }
+
+  /**
+   * Calculate trend from current and previous values
+   */
+  private calculateTrend(
+    current: number,
+    previous: number
+  ): { trend: 'up' | 'down' | 'stable'; percentChange: number } {
+    if (previous === 0) {
+      return { trend: current > 0 ? 'up' : 'stable', percentChange: current > 0 ? 100 : 0 };
+    }
+
+    const percentChange = ((current - previous) / previous) * 100;
+
+    let trend: 'up' | 'down' | 'stable' = 'stable';
+    if (percentChange > 5) trend = 'up';
+    else if (percentChange < -5) trend = 'down';
+
+    return { trend, percentChange: Math.round(percentChange * 10) / 10 };
+  }
+
+  /**
+   * Get Workers sparkline data (daily data points for the period)
+   */
+  async getWorkersSparklineData(period: TimePeriod): Promise<{
+    requests: SparklineData;
+    errors: SparklineData;
+  }> {
+    const { startDate, endDate } = this.getDateRange(period);
+
+    const queryStr = `
+      query WorkersSparkline($accountTag: String!, $startDate: Date!, $endDate: Date!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            workersInvocationsAdaptive(
+              filter: {
+                date_geq: $startDate
+                date_leq: $endDate
+              }
+              limit: 10000
+              orderBy: [date_ASC]
+            ) {
+              dimensions {
+                date
+              }
+              sum {
+                requests
+                errors
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    interface SparklineResponse {
+      viewer?: {
+        accounts?: Array<{
+          workersInvocationsAdaptive?: Array<{
+            dimensions?: { date?: string };
+            sum?: { requests?: number; errors?: number };
+          }>;
+        }>;
+      };
+    }
+
+    const data = await this.query<SparklineResponse>(queryStr, {
+      accountTag: this.accountId,
+      startDate,
+      endDate,
+    });
+
+    const items = data?.viewer?.accounts?.[0]?.workersInvocationsAdaptive ?? [];
+
+    // Aggregate by date
+    const byDate = new Map<string, { requests: number; errors: number }>();
+    for (const item of items) {
+      const date = item.dimensions?.date;
+      if (!date) continue;
+
+      const existing = byDate.get(date) ?? { requests: 0, errors: 0 };
+      existing.requests += item.sum?.requests ?? 0;
+      existing.errors += item.sum?.errors ?? 0;
+      byDate.set(date, existing);
+    }
+
+    // Convert to sparkline points
+    const requestPoints: SparklinePoint[] = [];
+    const errorPoints: SparklinePoint[] = [];
+
+    const sortedDates = Array.from(byDate.keys()).sort();
+    for (const date of sortedDates) {
+      const vals = byDate.get(date)!;
+      requestPoints.push({ date, value: vals.requests });
+      errorPoints.push({ date, value: vals.errors });
+    }
+
+    // Calculate trends (compare first half to second half)
+    const midpoint = Math.floor(requestPoints.length / 2);
+    const firstHalfRequests = requestPoints.slice(0, midpoint).reduce((s, p) => s + p.value, 0);
+    const secondHalfRequests = requestPoints.slice(midpoint).reduce((s, p) => s + p.value, 0);
+    const firstHalfErrors = errorPoints.slice(0, midpoint).reduce((s, p) => s + p.value, 0);
+    const secondHalfErrors = errorPoints.slice(midpoint).reduce((s, p) => s + p.value, 0);
+
+    const requestsTrend = this.calculateTrend(secondHalfRequests, firstHalfRequests);
+    const errorsTrend = this.calculateTrend(secondHalfErrors, firstHalfErrors);
+
+    return {
+      requests: {
+        metricName: 'Workers Requests',
+        points: requestPoints,
+        ...requestsTrend,
+      },
+      errors: {
+        metricName: 'Workers Errors',
+        points: errorPoints,
+        ...errorsTrend,
+      },
+    };
+  }
+
+  /**
+   * Get D1 sparkline data (daily data points)
+   */
+  async getD1SparklineData(period: TimePeriod): Promise<SparklineData> {
+    const { startDate, endDate } = this.getDateRange(period);
+    const databases = await this.listD1Databases();
+
+    // Aggregate data from all databases by date
+    const byDate = new Map<string, number>();
+
+    for (const db of databases) {
+      const queryStr = `
+        query D1Sparkline($accountTag: String!, $databaseId: String!, $startDate: Date!, $endDate: Date!) {
+          viewer {
+            accounts(filter: { accountTag: $accountTag }) {
+              d1AnalyticsAdaptiveGroups(
+                filter: {
+                  databaseId: $databaseId
+                  date_geq: $startDate
+                  date_leq: $endDate
+                }
+                limit: 1000
+                orderBy: [date_ASC]
+              ) {
+                dimensions {
+                  date
+                }
+                sum {
+                  rowsRead
+                }
+              }
+            }
+          }
+        }
+      `;
+
+      interface D1SparklineResponse {
+        viewer?: {
+          accounts?: Array<{
+            d1AnalyticsAdaptiveGroups?: Array<{
+              dimensions?: { date?: string };
+              sum?: { rowsRead?: number };
+            }>;
+          }>;
+        };
+      }
+
+      const data = await this.query<D1SparklineResponse>(queryStr, {
+        accountTag: this.accountId,
+        databaseId: db.id,
+        startDate,
+        endDate,
+      });
+
+      const groups = data?.viewer?.accounts?.[0]?.d1AnalyticsAdaptiveGroups ?? [];
+      for (const g of groups) {
+        const date = g.dimensions?.date;
+        if (!date) continue;
+        byDate.set(date, (byDate.get(date) ?? 0) + (g.sum?.rowsRead ?? 0));
+      }
+    }
+
+    const points: SparklinePoint[] = Array.from(byDate.entries())
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([date, value]) => ({ date, value }));
+
+    const midpoint = Math.floor(points.length / 2);
+    const firstHalf = points.slice(0, midpoint).reduce((s, p) => s + p.value, 0);
+    const secondHalf = points.slice(midpoint).reduce((s, p) => s + p.value, 0);
+    const trend = this.calculateTrend(secondHalf, firstHalf);
+
+    return {
+      metricName: 'D1 Rows Read',
+      points,
+      ...trend,
+    };
+  }
+
+  /**
+   * Get KV sparkline data (daily data points)
+   */
+  async getKVSparklineData(period: TimePeriod): Promise<SparklineData> {
+    const { startDate, endDate } = this.getDateRange(period);
+    const namespaces = await this.listKVNamespaces();
+
+    const byDate = new Map<string, number>();
+
+    for (const ns of namespaces) {
+      const queryStr = `
+        query KVSparkline($accountTag: String!, $namespaceId: String!, $startDate: Date!, $endDate: Date!) {
+          viewer {
+            accounts(filter: { accountTag: $accountTag }) {
+              kvOperationsAdaptiveGroups(
+                filter: {
+                  namespaceId: $namespaceId
+                  date_geq: $startDate
+                  date_leq: $endDate
+                }
+                limit: 1000
+                orderBy: [date_ASC]
+              ) {
+                dimensions {
+                  date
+                  actionType
+                }
+                sum {
+                  requests
+                }
+              }
+            }
+          }
+        }
+      `;
+
+      interface KVSparklineResponse {
+        viewer?: {
+          accounts?: Array<{
+            kvOperationsAdaptiveGroups?: Array<{
+              dimensions?: { date?: string; actionType?: string };
+              sum?: { requests?: number };
+            }>;
+          }>;
+        };
+      }
+
+      const data = await this.query<KVSparklineResponse>(queryStr, {
+        accountTag: this.accountId,
+        namespaceId: this.formatUuidWithHyphens(ns.id),
+        startDate,
+        endDate,
+      });
+
+      const groups = data?.viewer?.accounts?.[0]?.kvOperationsAdaptiveGroups ?? [];
+      for (const g of groups) {
+        const date = g.dimensions?.date;
+        const actionType = g.dimensions?.actionType?.toLowerCase() ?? '';
+        // Only count read operations for sparkline
+        if (!date || (actionType !== 'read' && actionType !== 'get')) continue;
+        byDate.set(date, (byDate.get(date) ?? 0) + (g.sum?.requests ?? 0));
+      }
+    }
+
+    const points: SparklinePoint[] = Array.from(byDate.entries())
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([date, value]) => ({ date, value }));
+
+    const midpoint = Math.floor(points.length / 2);
+    const firstHalf = points.slice(0, midpoint).reduce((s, p) => s + p.value, 0);
+    const secondHalf = points.slice(midpoint).reduce((s, p) => s + p.value, 0);
+    const trend = this.calculateTrend(secondHalf, firstHalf);
+
+    return {
+      metricName: 'KV Reads',
+      points,
+      ...trend,
+    };
+  }
+
+  /**
+   * Get detailed Workers error breakdown with status codes and latency
+   */
+  async getWorkersErrorBreakdown(period: TimePeriod): Promise<WorkersErrorBreakdown[]> {
+    const { startDate, endDate } = this.getDateRange(period);
+
+    const queryStr = `
+      query WorkersErrorBreakdown($accountTag: String!, $startDate: Date!, $endDate: Date!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            workersInvocationsAdaptive(
+              filter: {
+                date_geq: $startDate
+                date_leq: $endDate
+              }
+              limit: 100
+            ) {
+              dimensions {
+                scriptName
+                status
+              }
+              sum {
+                requests
+                errors
+                subrequests
+              }
+              quantiles {
+                durationP50
+                durationP99
+                cpuTimeP50
+                cpuTimeP99
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    interface ErrorBreakdownResponse {
+      viewer?: {
+        accounts?: Array<{
+          workersInvocationsAdaptive?: Array<{
+            dimensions?: { scriptName?: string; status?: number };
+            sum?: { requests?: number; errors?: number; subrequests?: number };
+            quantiles?: {
+              durationP50?: number;
+              durationP99?: number;
+              cpuTimeP50?: number;
+              cpuTimeP99?: number;
+            };
+          }>;
+        }>;
+      };
+    }
+
+    const data = await this.query<ErrorBreakdownResponse>(queryStr, {
+      accountTag: this.accountId,
+      startDate,
+      endDate,
+    });
+
+    const items = data?.viewer?.accounts?.[0]?.workersInvocationsAdaptive ?? [];
+
+    // Aggregate by script
+    const byScript = new Map<
+      string,
+      {
+        totalRequests: number;
+        totalErrors: number;
+        errors4xx: number;
+        errors5xx: number;
+        subrequests: number;
+        latencyP50Ms: number;
+        latencyP99Ms: number;
+        cpuTimeP50Ms: number;
+        cpuTimeP99Ms: number;
+        count: number;
+      }
+    >();
+
+    for (const item of items) {
+      const scriptName = item.dimensions?.scriptName;
+      if (!scriptName) continue;
+
+      const status = item.dimensions?.status ?? 0;
+      const requests = item.sum?.requests ?? 0;
+      const errors = item.sum?.errors ?? 0;
+
+      const existing = byScript.get(scriptName) ?? {
+        totalRequests: 0,
+        totalErrors: 0,
+        errors4xx: 0,
+        errors5xx: 0,
+        subrequests: 0,
+        latencyP50Ms: 0,
+        latencyP99Ms: 0,
+        cpuTimeP50Ms: 0,
+        cpuTimeP99Ms: 0,
+        count: 0,
+      };
+
+      existing.totalRequests += requests;
+      existing.totalErrors += errors;
+      existing.subrequests += item.sum?.subrequests ?? 0;
+
+      // Categorise by status code
+      if (status >= 400 && status < 500) {
+        existing.errors4xx += requests;
+      } else if (status >= 500) {
+        existing.errors5xx += requests;
+      }
+
+      // Average latencies (we'll average them across all entries)
+      existing.latencyP50Ms += item.quantiles?.durationP50 ?? 0;
+      existing.latencyP99Ms += item.quantiles?.durationP99 ?? 0;
+      existing.cpuTimeP50Ms += item.quantiles?.cpuTimeP50 ?? 0;
+      existing.cpuTimeP99Ms += item.quantiles?.cpuTimeP99 ?? 0;
+      existing.count++;
+
+      byScript.set(scriptName, existing);
+    }
+
+    return Array.from(byScript.entries()).map(([scriptName, data]) => ({
+      scriptName,
+      totalRequests: data.totalRequests,
+      totalErrors: data.totalErrors,
+      errorRate:
+        data.totalRequests > 0
+          ? Math.round((data.totalErrors / data.totalRequests) * 10000) / 100
+          : 0,
+      errors4xx: data.errors4xx,
+      errors5xx: data.errors5xx,
+      latencyP50Ms: data.count > 0 ? Math.round(data.latencyP50Ms / data.count) : 0,
+      latencyP99Ms: data.count > 0 ? Math.round(data.latencyP99Ms / data.count) : 0,
+      cpuTimeP50Ms: data.count > 0 ? Math.round(data.cpuTimeP50Ms / data.count) : 0,
+      cpuTimeP99Ms: data.count > 0 ? Math.round(data.cpuTimeP99Ms / data.count) : 0,
+      subrequests: data.subrequests,
+    }));
+  }
+
+  /**
+   * Get Queues metrics via GraphQL
+   *
+   * Uses queueMessageOperationsAdaptiveGroups with actionType dimension.
+   * Per Cloudflare docs: https://developers.cloudflare.com/queues/observability/metrics/
+   * - actionType: WriteMessage (produced), ReadMessage/DeleteMessage (consumed)
+   * - count: number of operations
+   * - sum: billableOperations, bytes (NOT messages)
+   * - avg: lagTime, retryCount
+   *
+   * queueConsumerMetricsAdaptiveGroups only has avg.concurrency, not acked/retried.
+   */
+  async getQueuesMetrics(period: TimePeriod): Promise<QueuesMetrics[]> {
+    const { startDate, endDate } = this.getDateRange(period);
+
+    // First, list all queues via REST API
+    const queues = await this.listQueues();
+    if (queues.length === 0) return [];
+
+    const results: QueuesMetrics[] = [];
+
+    for (const queue of queues) {
+      // Build datetime range (ISO 8601 format for Time type)
+      const datetimeStart = `${startDate}T00:00:00Z`;
+      const datetimeEnd = `${endDate}T23:59:59Z`;
+
+      // Query message operations with actionType dimension (correct schema per CF docs)
+      const messageOpsQuery = `
+        query QueueMessageOperations($accountTag: String!, $queueId: String!, $datetimeStart: Time!, $datetimeEnd: Time!) {
+          viewer {
+            accounts(filter: { accountTag: $accountTag }) {
+              queueMessageOperationsAdaptiveGroups(
+                filter: {
+                  queueId: $queueId
+                  datetime_geq: $datetimeStart
+                  datetime_leq: $datetimeEnd
+                }
+                limit: 1000
+              ) {
+                count
+                dimensions {
+                  actionType
+                }
+                avg {
+                  lagTime
+                  retryCount
+                }
+              }
+            }
+          }
+        }
+      `;
+
+      // Query consumer concurrency (only metric available in queueConsumerMetricsAdaptiveGroups)
+      const consumerQuery = `
+        query QueueConsumerConcurrency($accountTag: String!, $queueId: String!, $datetimeStart: Time!, $datetimeEnd: Time!) {
+          viewer {
+            accounts(filter: { accountTag: $accountTag }) {
+              queueConsumerMetricsAdaptiveGroups(
+                filter: {
+                  queueId: $queueId
+                  datetime_geq: $datetimeStart
+                  datetime_leq: $datetimeEnd
+                }
+                limit: 100
+              ) {
+                avg {
+                  concurrency
+                }
+              }
+            }
+          }
+        }
+      `;
+
+      interface MessageOpsResponse {
+        viewer?: {
+          accounts?: Array<{
+            queueMessageOperationsAdaptiveGroups?: Array<{
+              count?: number;
+              dimensions?: { actionType?: string };
+              avg?: { lagTime?: number; retryCount?: number };
+            }>;
+          }>;
+        };
+      }
+
+      interface ConsumerResponse {
+        viewer?: {
+          accounts?: Array<{
+            queueConsumerMetricsAdaptiveGroups?: Array<{
+              avg?: { concurrency?: number };
+            }>;
+          }>;
+        };
+      }
+
+      try {
+        const [messageOpsData, consumerData] = await Promise.all([
+          this.query<MessageOpsResponse>(messageOpsQuery, {
+            accountTag: this.accountId,
+            queueId: queue.id,
+            datetimeStart,
+            datetimeEnd,
+          }),
+          this.query<ConsumerResponse>(consumerQuery, {
+            accountTag: this.accountId,
+            queueId: queue.id,
+            datetimeStart,
+            datetimeEnd,
+          }),
+        ]);
+
+        const opsGroups =
+          messageOpsData?.viewer?.accounts?.[0]?.queueMessageOperationsAdaptiveGroups ?? [];
+        const consumerGroups =
+          consumerData?.viewer?.accounts?.[0]?.queueConsumerMetricsAdaptiveGroups ?? [];
+
+        // Aggregate message operations by actionType
+        let produced = 0;
+        let consumed = 0;
+        let totalLagTime = 0;
+        let totalRetryCount = 0;
+        let opsCount = 0;
+
+        for (const g of opsGroups) {
+          const count = g.count ?? 0;
+          const actionType = g.dimensions?.actionType ?? '';
+
+          // WriteMessage = produced, ReadMessage/DeleteMessage = consumed
+          if (actionType === 'WriteMessage') {
+            produced += count;
+          } else if (actionType === 'ReadMessage' || actionType === 'DeleteMessage') {
+            consumed += count;
+          }
+
+          // Track averages for processing time estimate
+          totalLagTime += (g.avg?.lagTime ?? 0) * count;
+          totalRetryCount += (g.avg?.retryCount ?? 0) * count;
+          opsCount += count;
+        }
+
+        // Aggregate consumer concurrency (reserved for future concurrency metrics)
+        let _avgConcurrency = 0;
+        let _concurrencyCount = 0;
+        for (const g of consumerGroups) {
+          _avgConcurrency += g.avg?.concurrency ?? 0;
+          _concurrencyCount++;
+        }
+
+        // Calculate average lag time in ms (lagTime is in ms per CF docs)
+        const avgLagTimeMs = opsCount > 0 ? Math.round(totalLagTime / opsCount) : 0;
+
+        results.push({
+          queueId: queue.id,
+          queueName: queue.name,
+          messagesProduced: produced,
+          messagesConsumed: consumed,
+          messagesAcked: consumed, // Use consumed as acked (acked field doesn't exist)
+          messagesRetried: opsCount > 0 ? Math.round(totalRetryCount / opsCount) : 0,
+          messagesFailed: 0, // Not available in current schema (would need outcome dimension)
+          backlogSize: Math.max(0, produced - consumed), // Estimate from produced - consumed
+          avgProcessingTimeMs: avgLagTimeMs,
+        });
+      } catch (error) {
+        // Individual queue query failed - continue with others
+        console.warn(`[CloudflareGraphQL] Queue ${queue.name} query failed:`, error);
+        results.push({
+          queueId: queue.id,
+          queueName: queue.name,
+          messagesProduced: 0,
+          messagesConsumed: 0,
+          messagesAcked: 0,
+          messagesRetried: 0,
+          messagesFailed: 0,
+          backlogSize: 0,
+          avgProcessingTimeMs: 0,
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * List Queues via REST API
+   */
+  private async listQueues(): Promise<Array<{ id: string; name: string }>> {
+    try {
+      const response = await fetchWithRetry(
+        `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/queues`,
+        {
+          headers: {
+            Authorization: `Bearer ${this.apiToken}`,
+            'Content-Type': 'application/json',
+          },
+        }
+      );
+
+      if (!response.ok) {
+        console.error(`[CloudflareGraphQL] Queues list error: ${response.status}`);
+        return [];
+      }
+
+      interface QueuesListResponse {
+        result?: Array<{ queue_id: string; queue_name: string }>;
+        success?: boolean;
+      }
+
+      const data = (await response.json()) as QueuesListResponse;
+
+      if (!data.success || !data.result) {
+        return [];
+      }
+
+      return data.result.map((q) => ({ id: q.queue_id, name: q.queue_name }));
+    } catch (error) {
+      console.error('[CloudflareGraphQL] Queues list error:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get cache analytics for Workers (via CDN Cache API)
+   */
+  async getCacheAnalytics(period: TimePeriod): Promise<CacheAnalytics> {
+    const { startDate, endDate } = this.getDateRange(period);
+
+    const queryStr = `
+      query CacheAnalytics($accountTag: String!, $startDate: Date!, $endDate: Date!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            httpRequestsAdaptiveGroups(
+              filter: {
+                date_geq: $startDate
+                date_leq: $endDate
+              }
+              limit: 1000
+            ) {
+              dimensions {
+                cacheStatus
+              }
+              sum {
+                requests
+                bytes
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    interface CacheResponse {
+      viewer?: {
+        accounts?: Array<{
+          httpRequestsAdaptiveGroups?: Array<{
+            dimensions?: { cacheStatus?: string };
+            sum?: { requests?: number; bytes?: number };
+          }>;
+        }>;
+      };
+    }
+
+    const data = await this.query<CacheResponse>(queryStr, {
+      accountTag: this.accountId,
+      startDate,
+      endDate,
+    });
+
+    const groups = data?.viewer?.accounts?.[0]?.httpRequestsAdaptiveGroups ?? [];
+
+    let totalRequests = 0;
+    let cacheHits = 0;
+    let cacheMisses = 0;
+    let bandwidthSavedBytes = 0;
+
+    for (const g of groups) {
+      const status = g.dimensions?.cacheStatus?.toLowerCase() ?? '';
+      const requests = g.sum?.requests ?? 0;
+      const bytes = g.sum?.bytes ?? 0;
+
+      totalRequests += requests;
+
+      if (status === 'hit' || status === 'stale' || status === 'revalidated') {
+        cacheHits += requests;
+        bandwidthSavedBytes += bytes;
+      } else if (status === 'miss' || status === 'expired' || status === 'bypass') {
+        cacheMisses += requests;
+      }
+    }
+
+    return {
+      totalRequests,
+      cacheHits,
+      cacheMisses,
+      hitRate: totalRequests > 0 ? Math.round((cacheHits / totalRequests) * 10000) / 100 : 0,
+      bandwidthSavedBytes,
+    };
+  }
+
+  /**
+   * Query Cloudflare Analytics Engine via SQL API
+   * Used for Workers AI metrics from project Analytics Engine datasets
+   */
+  private async queryAnalyticsEngine(
+    sql: string
+  ): Promise<{ success: boolean; result?: AnalyticsEngineResult; error?: string }> {
+    try {
+      const response = await fetchWithRetry(
+        `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/analytics_engine/sql`,
+        {
+          method: 'POST',
+          headers: {
+            Authorization: `Bearer ${this.apiToken}`,
+            'Content-Type': 'text/plain',
+          },
+          body: sql,
+        }
+      );
+
+      if (!response.ok) {
+        const text = await response.text();
+        console.error(`[CloudflareGraphQL] Analytics Engine error: ${response.status}`, text);
+        return { success: false, error: `HTTP ${response.status}: ${text}` };
+      }
+
+      const result = (await response.json()) as AnalyticsEngineResult;
+      return { success: true, result };
+    } catch (error) {
+      console.error('[CloudflareGraphQL] Analytics Engine query error:', error);
+      return { success: false, error: String(error) };
+    }
+  }
+
+  /**
+   * Get Workers AI metrics from AI Gateway data.
+   * Iterates all gateways and aggregates workers-ai provider usage by project.
+   */
+  async getWorkersAIMetrics(period: TimePeriod): Promise<WorkersAISummary> {
+    const summary: WorkersAISummary = {
+      totalRequests: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCostUsd: 0,
+      byProject: {},
+      byModel: {},
+      metrics: [],
+    };
+
+    const aiGatewayMetrics = await this.getAIGatewayMetrics(period);
+
+    // Iterate all gateways and extract workers-ai provider data
+    for (const gateway of aiGatewayMetrics) {
+      const workersAIEntries = gateway.byModel?.filter((m) => m.provider === 'workers-ai');
+      if (!workersAIEntries || workersAIEntries.length === 0) continue;
+
+      // Use gateway ID as project name (capitalised)
+      const projectName = gateway.gatewayId
+        .split('-')
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(' ');
+
+      // Track models already seen for this project (dedup)
+      const existingModels = new Set(
+        summary.metrics.filter((m) => m.project === projectName).map((m) => m.model)
+      );
+
+      for (const entry of workersAIEntries) {
+        const model = entry.model || 'unknown';
+        if (existingModels.has(model)) continue;
+
+        summary.metrics.push({
+          project: projectName,
+          model,
+          requests: entry.requests,
+          inputTokens: entry.tokensIn,
+          outputTokens: entry.tokensOut,
+          costUsd: entry.costUsd,
+          isEstimated: false,
+        });
+
+        if (!summary.byModel[model]) {
+          summary.byModel[model] = { requests: 0, inputTokens: 0, outputTokens: 0, costUsd: 0 };
+        }
+        summary.byModel[model].requests += entry.requests;
+        summary.byModel[model].inputTokens += entry.tokensIn;
+        summary.byModel[model].outputTokens += entry.tokensOut;
+        summary.byModel[model].costUsd += entry.costUsd;
+
+        summary.totalRequests += entry.requests;
+        summary.totalInputTokens += entry.tokensIn;
+        summary.totalOutputTokens += entry.tokensOut;
+        summary.totalCostUsd += entry.costUsd;
+
+        if (!summary.byProject[projectName]) {
+          summary.byProject[projectName] = { requests: 0, costUsd: 0, isEstimated: false };
+        }
+        summary.byProject[projectName].requests += entry.requests;
+        summary.byProject[projectName].costUsd += entry.costUsd;
+      }
+    }
+
+    return summary;
+  }
+
+  /**
+   * Get all enhanced metrics including sparklines, error breakdown, and period comparison
+   */
+  async getAllEnhancedMetrics(period: TimePeriod): Promise<EnhancedAccountUsage> {
+    // Get base metrics and enhanced data in parallel
+    const [
+      baseMetrics,
+      workersSparkline,
+      d1Sparkline,
+      kvSparkline,
+      errorBreakdown,
+      queues,
+      cache,
+      previousMetrics,
+    ] = await Promise.all([
+      this.getAllMetrics(period),
+      this.getWorkersSparklineData(period),
+      this.getD1SparklineData(period),
+      this.getKVSparklineData(period),
+      this.getWorkersErrorBreakdown(period),
+      this.getQueuesMetrics(period),
+      this.getCacheAnalytics(period),
+      this.getAllMetrics(period === '24h' ? '7d' : period === '7d' ? '30d' : '30d'), // Get previous period for comparison
+    ]);
+
+    // Calculate period comparisons
+    const currentRequests = baseMetrics.workers.reduce((s, w) => s + w.requests, 0);
+    const previousRequests = previousMetrics.workers.reduce((s, w) => s + w.requests, 0);
+
+    const currentErrors = baseMetrics.workers.reduce((s, w) => s + w.errors, 0);
+    const previousErrors = previousMetrics.workers.reduce((s, w) => s + w.errors, 0);
+
+    const currentD1Rows = baseMetrics.d1.reduce((s, d) => s + d.rowsRead, 0);
+    const previousD1Rows = previousMetrics.d1.reduce((s, d) => s + d.rowsRead, 0);
+
+    return {
+      ...baseMetrics,
+      sparklines: {
+        workersRequests: workersSparkline.requests,
+        workersErrors: workersSparkline.errors,
+        d1RowsRead: d1Sparkline,
+        kvReads: kvSparkline,
+      },
+      errorBreakdown,
+      queues,
+      cache,
+      comparison: {
+        workersRequests: {
+          current: currentRequests,
+          previous: previousRequests,
+          ...this.calculateTrend(currentRequests, previousRequests),
+        },
+        workersErrors: {
+          current: currentErrors,
+          previous: previousErrors,
+          ...this.calculateTrend(currentErrors, previousErrors),
+        },
+        d1RowsRead: {
+          current: currentD1Rows,
+          previous: previousD1Rows,
+          ...this.calculateTrend(currentD1Rows, previousD1Rows),
+        },
+        totalCost: {
+          current: 0, // Will be calculated by costCalculator
+          previous: 0,
+          trend: 'stable',
+          percentChange: 0,
+        },
+      },
+    };
+  }
+
+  /**
+   * Get daily cost breakdown for interactive chart (task-18)
+   *
+   * Queries daily metrics for all resource types and calculates
+   * costs using the shared cost calculation engine.
+   *
+   * @param period - Time period or custom date range
+   * @returns Daily cost breakdown with totals
+   */
+  async getDailyCostBreakdown(
+    period: TimePeriod | { start: string; end: string }
+  ): Promise<DailyCostData> {
+    // Get date range
+    const { startDate, endDate } =
+      typeof period === 'string'
+        ? this.getDateRange(period)
+        : { startDate: period.start, endDate: period.end };
+
+    // Query all resource types in parallel
+    const [workersDaily, d1Daily, kvDaily, r2Daily, doDaily] = await Promise.all([
+      this.getWorkersDailyMetrics(startDate, endDate),
+      this.getD1DailyMetrics(startDate, endDate),
+      this.getKVDailyMetrics(startDate, endDate),
+      this.getR2DailyMetrics(startDate, endDate),
+      this.getDurableObjectsDailyMetrics(startDate, endDate),
+    ]);
+
+    // AI Gateway, Vectorize, Workers AI, and Queues don't have daily granularity in the API
+    // We'll estimate by distributing evenly across the period
+    const periodDays = this.getDayCount(startDate, endDate);
+    const aiGatewayTotal = await this.getAIGatewayRequests(startDate, endDate);
+    const vectorizeTotal = await this.getVectorizeQueries(startDate, endDate);
+
+    // Get Workers AI metrics (total tokens for period)
+    const workersAI = await this.getWorkersAIMetrics(typeof period === 'string' ? period : '30d');
+    const workersAITotalTokens = workersAI.totalInputTokens + workersAI.totalOutputTokens;
+
+    // Get Queues metrics (total messages consumed for period)
+    const queues = await this.getQueuesMetrics(typeof period === 'string' ? period : '30d');
+    const queuesTotalMessages = queues.reduce((sum, q) => sum + q.messagesConsumed, 0);
+
+    // Create a set of all dates in the period
+    const allDates = new Set<string>();
+    const addDates = (map: Map<string, unknown>) => {
+      Array.from(map.keys()).forEach((date) => allDates.add(date));
+    };
+
+    addDates(workersDaily);
+    addDates(d1Daily);
+    addDates(kvDaily);
+    addDates(r2Daily);
+    addDates(doDaily);
+
+    // Fill in missing dates in the range
+    const current = new Date(startDate);
+    const end = new Date(endDate);
+    while (current <= end) {
+      allDates.add(current.toISOString().split('T')[0]);
+      current.setDate(current.getDate() + 1);
+    }
+
+    // Calculate costs for each day
+    const days: DailyCostBreakdown[] = [];
+    const sortedDates = Array.from(allDates).sort();
+
+    for (const date of sortedDates) {
+      const workers = workersDaily.get(date) ?? { requests: 0, cpuMs: 0 };
+      const d1 = d1Daily.get(date) ?? { reads: 0, writes: 0 };
+      const kv = kvDaily.get(date) ?? { reads: 0, writes: 0, deletes: 0, lists: 0 };
+      const r2 = r2Daily.get(date) ?? { classA: 0, classB: 0 };
+      const dObjects = doDaily.get(date) ?? { requests: 0, gbSeconds: 0 };
+
+      // Distribute AI Gateway, Vectorize, Workers AI, and Queues evenly
+      const aiGatewayDaily = Math.round(aiGatewayTotal / periodDays);
+      const vectorizeDaily = Math.round(vectorizeTotal / periodDays);
+      const workersAIDaily = Math.round(workersAITotalTokens / periodDays);
+      const queuesDaily = Math.round(queuesTotalMessages / periodDays);
+
+      const usage: DailyUsageMetrics = {
+        workersRequests: workers.requests,
+        workersCpuMs: workers.cpuMs,
+        d1Reads: d1.reads,
+        d1Writes: d1.writes,
+        kvReads: kv.reads,
+        kvWrites: kv.writes,
+        kvDeletes: kv.deletes,
+        kvLists: kv.lists,
+        r2ClassA: r2.classA,
+        r2ClassB: r2.classB,
+        vectorizeQueries: vectorizeDaily,
+        aiGatewayRequests: aiGatewayDaily,
+        durableObjectsRequests: dObjects.requests,
+        durableObjectsGbSeconds: dObjects.gbSeconds,
+        workersAITokens: workersAIDaily,
+        queuesMessages: queuesDaily,
+      };
+
+      const costs = calculateDailyCosts(usage);
+      days.push({ date, ...costs });
+    }
+
+    // Calculate totals
+    const totals = days.reduce(
+      (acc, day) => ({
+        workers: acc.workers + day.workers,
+        d1: acc.d1 + day.d1,
+        kv: acc.kv + day.kv,
+        r2: acc.r2 + day.r2,
+        vectorize: acc.vectorize + day.vectorize,
+        aiGateway: acc.aiGateway + day.aiGateway,
+        durableObjects: acc.durableObjects + day.durableObjects,
+        workersAI: acc.workersAI + day.workersAI,
+        pages: acc.pages + day.pages,
+        queues: acc.queues + day.queues,
+        workflows: acc.workflows + day.workflows,
+        total: acc.total + day.total,
+      }),
+      {
+        workers: 0,
+        d1: 0,
+        kv: 0,
+        r2: 0,
+        vectorize: 0,
+        aiGateway: 0,
+        durableObjects: 0,
+        workersAI: 0,
+        pages: 0,
+        queues: 0,
+        workflows: 0,
+        total: 0,
+      }
+    );
+
+    return {
+      days,
+      totals,
+      period: { start: startDate, end: endDate },
+    };
+  }
+
+  /**
+   * Get number of days in a date range
+   */
+  private getDayCount(startDate: string, endDate: string): number {
+    const start = new Date(startDate);
+    const end = new Date(endDate);
+    return Math.ceil((end.getTime() - start.getTime()) / (1000 * 60 * 60 * 24)) + 1;
+  }
+
+  /**
+   * Get Workers daily metrics (requests + CPU time)
+   */
+  private async getWorkersDailyMetrics(
+    startDate: string,
+    endDate: string
+  ): Promise<Map<string, { requests: number; cpuMs: number }>> {
+    const queryStr = `
+      query WorkersDaily($accountTag: String!, $startDate: Date!, $endDate: Date!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            workersInvocationsAdaptive(
+              filter: {
+                date_geq: $startDate
+                date_leq: $endDate
+              }
+              limit: 10000
+              orderBy: [date_ASC]
+            ) {
+              dimensions {
+                date
+              }
+              sum {
+                requests
+              }
+              quantiles {
+                cpuTimeP50
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    interface Response {
+      viewer?: {
+        accounts?: Array<{
+          workersInvocationsAdaptive?: Array<{
+            dimensions?: { date?: string };
+            sum?: { requests?: number };
+            quantiles?: { cpuTimeP50?: number };
+          }>;
+        }>;
+      };
+    }
+
+    const data = await this.query<Response>(queryStr, {
+      accountTag: this.accountId,
+      startDate,
+      endDate,
+    });
+
+    const byDate = new Map<string, { requests: number; cpuMs: number }>();
+    const items = data?.viewer?.accounts?.[0]?.workersInvocationsAdaptive ?? [];
+
+    for (const item of items) {
+      const date = item.dimensions?.date;
+      if (!date) continue;
+
+      const existing = byDate.get(date) ?? { requests: 0, cpuMs: 0 };
+      existing.requests += item.sum?.requests ?? 0;
+      // Estimate total CPU time: P50 * requests (approximation)
+      const cpuP50 = item.quantiles?.cpuTimeP50 ?? 0;
+      existing.cpuMs += cpuP50 * (item.sum?.requests ?? 0);
+      byDate.set(date, existing);
+    }
+
+    return byDate;
+  }
+
+  /**
+   * Get D1 daily metrics (reads + writes)
+   */
+  private async getD1DailyMetrics(
+    startDate: string,
+    endDate: string
+  ): Promise<Map<string, { reads: number; writes: number }>> {
+    const databases = await this.listD1Databases();
+    const byDate = new Map<string, { reads: number; writes: number }>();
+
+    for (const db of databases) {
+      const queryStr = `
+        query D1Daily($accountTag: String!, $databaseId: String!, $startDate: Date!, $endDate: Date!) {
+          viewer {
+            accounts(filter: { accountTag: $accountTag }) {
+              d1AnalyticsAdaptiveGroups(
+                filter: {
+                  databaseId: $databaseId
+                  date_geq: $startDate
+                  date_leq: $endDate
+                }
+                limit: 1000
+                orderBy: [date_ASC]
+              ) {
+                dimensions {
+                  date
+                }
+                sum {
+                  rowsRead
+                  rowsWritten
+                }
+              }
+            }
+          }
+        }
+      `;
+
+      interface Response {
+        viewer?: {
+          accounts?: Array<{
+            d1AnalyticsAdaptiveGroups?: Array<{
+              dimensions?: { date?: string };
+              sum?: { rowsRead?: number; rowsWritten?: number };
+            }>;
+          }>;
+        };
+      }
+
+      const data = await this.query<Response>(queryStr, {
+        accountTag: this.accountId,
+        databaseId: db.id,
+        startDate,
+        endDate,
+      });
+
+      const groups = data?.viewer?.accounts?.[0]?.d1AnalyticsAdaptiveGroups ?? [];
+      for (const g of groups) {
+        const date = g.dimensions?.date;
+        if (!date) continue;
+
+        const existing = byDate.get(date) ?? { reads: 0, writes: 0 };
+        existing.reads += g.sum?.rowsRead ?? 0;
+        existing.writes += g.sum?.rowsWritten ?? 0;
+        byDate.set(date, existing);
+      }
+    }
+
+    return byDate;
+  }
+
+  /**
+   * Get KV daily metrics (reads, writes, deletes, lists)
+   */
+  private async getKVDailyMetrics(
+    startDate: string,
+    endDate: string
+  ): Promise<Map<string, { reads: number; writes: number; deletes: number; lists: number }>> {
+    const namespaces = await this.listKVNamespaces();
+    const byDate = new Map<
+      string,
+      { reads: number; writes: number; deletes: number; lists: number }
+    >();
+
+    for (const ns of namespaces) {
+      const queryStr = `
+        query KVDaily($accountTag: String!, $namespaceId: String!, $startDate: Date!, $endDate: Date!) {
+          viewer {
+            accounts(filter: { accountTag: $accountTag }) {
+              kvOperationsAdaptiveGroups(
+                filter: {
+                  namespaceId: $namespaceId
+                  date_geq: $startDate
+                  date_leq: $endDate
+                }
+                limit: 1000
+                orderBy: [date_ASC]
+              ) {
+                dimensions {
+                  date
+                  actionType
+                }
+                sum {
+                  requests
+                }
+              }
+            }
+          }
+        }
+      `;
+
+      interface Response {
+        viewer?: {
+          accounts?: Array<{
+            kvOperationsAdaptiveGroups?: Array<{
+              dimensions?: { date?: string; actionType?: string };
+              sum?: { requests?: number };
+            }>;
+          }>;
+        };
+      }
+
+      const data = await this.query<Response>(queryStr, {
+        accountTag: this.accountId,
+        namespaceId: this.formatUuidWithHyphens(ns.id),
+        startDate,
+        endDate,
+      });
+
+      const groups = data?.viewer?.accounts?.[0]?.kvOperationsAdaptiveGroups ?? [];
+      for (const g of groups) {
+        const date = g.dimensions?.date;
+        if (!date) continue;
+
+        const existing = byDate.get(date) ?? { reads: 0, writes: 0, deletes: 0, lists: 0 };
+        const requests = g.sum?.requests ?? 0;
+        const actionType = g.dimensions?.actionType?.toLowerCase() ?? '';
+
+        if (actionType === 'read') existing.reads += requests;
+        else if (actionType === 'write') existing.writes += requests;
+        else if (actionType === 'delete') existing.deletes += requests;
+        else if (actionType === 'list') existing.lists += requests;
+
+        byDate.set(date, existing);
+      }
+    }
+
+    return byDate;
+  }
+
+  /**
+   * Get R2 daily metrics (class A + class B operations)
+   */
+  private async getR2DailyMetrics(
+    startDate: string,
+    endDate: string
+  ): Promise<Map<string, { classA: number; classB: number }>> {
+    // R2 analytics via GraphQL
+    const queryStr = `
+      query R2Daily($accountTag: String!, $startDate: Date!, $endDate: Date!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            r2OperationsAdaptiveGroups(
+              filter: {
+                date_geq: $startDate
+                date_leq: $endDate
+              }
+              limit: 10000
+              orderBy: [date_ASC]
+            ) {
+              dimensions {
+                date
+                actionType
+              }
+              sum {
+                requests
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    interface Response {
+      viewer?: {
+        accounts?: Array<{
+          r2OperationsAdaptiveGroups?: Array<{
+            dimensions?: { date?: string; actionType?: string };
+            sum?: { requests?: number };
+          }>;
+        }>;
+      };
+    }
+
+    const data = await this.query<Response>(queryStr, {
+      accountTag: this.accountId,
+      startDate,
+      endDate,
+    });
+
+    const byDate = new Map<string, { classA: number; classB: number }>();
+    const groups = data?.viewer?.accounts?.[0]?.r2OperationsAdaptiveGroups ?? [];
+
+    // Class A operations: PUT, POST, DELETE, LIST, CreateMultipartUpload, etc.
+    // Class B operations: GET, HEAD
+    const classAActions = new Set([
+      'PUT',
+      'POST',
+      'DELETE',
+      'LIST',
+      'CreateMultipartUpload',
+      'UploadPart',
+      'CompleteMultipartUpload',
+      'AbortMultipartUpload',
+      'CopyObject',
+    ]);
+    const classBActions = new Set(['GET', 'HEAD']);
+
+    for (const g of groups) {
+      const date = g.dimensions?.date;
+      if (!date) continue;
+
+      const existing = byDate.get(date) ?? { classA: 0, classB: 0 };
+      const requests = g.sum?.requests ?? 0;
+      const actionType = (g.dimensions?.actionType ?? '').toUpperCase();
+
+      if (classAActions.has(actionType)) {
+        existing.classA += requests;
+      } else if (classBActions.has(actionType)) {
+        existing.classB += requests;
+      } else {
+        // Unknown action - assume class A (more expensive, conservative estimate)
+        existing.classA += requests;
+      }
+
+      byDate.set(date, existing);
+    }
+
+    return byDate;
+  }
+
+  /**
+   * Get Durable Objects daily metrics including duration (GB-seconds)
+   */
+  private async getDurableObjectsDailyMetrics(
+    startDate: string,
+    endDate: string
+  ): Promise<Map<string, { requests: number; gbSeconds: number }>> {
+    // Query 1: Invocation metrics per day
+    const invocationsQuery = `
+      query DODailyInvocations($accountTag: String!, $startDate: Date!, $endDate: Date!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            durableObjectsInvocationsAdaptiveGroups(
+              filter: {
+                date_geq: $startDate
+                date_leq: $endDate
+              }
+              limit: 10000
+              orderBy: [date_ASC]
+            ) {
+              dimensions {
+                date
+              }
+              sum {
+                requests
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    // Query 2: Duration metrics per day
+    // Note: duration field is already in GB-seconds (the billable unit)
+    const durationQuery = `
+      query DODailyDuration($accountTag: String!, $startDate: Date!, $endDate: Date!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            durableObjectsPeriodicGroups(
+              filter: {
+                date_geq: $startDate
+                date_leq: $endDate
+              }
+              limit: 10000
+              orderBy: [date_ASC]
+            ) {
+              dimensions {
+                date
+              }
+              sum {
+                duration
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    interface InvocationsResponse {
+      viewer?: {
+        accounts?: Array<{
+          durableObjectsInvocationsAdaptiveGroups?: Array<{
+            dimensions?: { date?: string };
+            sum?: { requests?: number };
+          }>;
+        }>;
+      };
+    }
+
+    interface DurationResponse {
+      viewer?: {
+        accounts?: Array<{
+          durableObjectsPeriodicGroups?: Array<{
+            dimensions?: { date?: string };
+            sum?: { duration?: number }; // GB-seconds (billable unit from Cloudflare)
+          }>;
+        }>;
+      };
+    }
+
+    // Execute both queries in parallel
+    const [invocationsData, durationData] = await Promise.all([
+      this.query<InvocationsResponse>(invocationsQuery, {
+        accountTag: this.accountId,
+        startDate,
+        endDate,
+      }),
+      this.query<DurationResponse>(durationQuery, {
+        accountTag: this.accountId,
+        startDate,
+        endDate,
+      }).catch(() => null),
+    ]);
+
+    const byDate = new Map<string, { requests: number; gbSeconds: number }>();
+
+    // Process invocation metrics
+    const invocationsGroups =
+      invocationsData?.viewer?.accounts?.[0]?.durableObjectsInvocationsAdaptiveGroups ?? [];
+    for (const g of invocationsGroups) {
+      const date = g.dimensions?.date;
+      if (!date) continue;
+
+      const existing = byDate.get(date) ?? { requests: 0, gbSeconds: 0 };
+      existing.requests += g.sum?.requests ?? 0;
+      byDate.set(date, existing);
+    }
+
+    // Process duration metrics - duration field is already in GB-seconds per day
+    // This is the official billable metric from Cloudflare, pre-calculated
+    const durationGroups = durationData?.viewer?.accounts?.[0]?.durableObjectsPeriodicGroups ?? [];
+    for (const g of durationGroups) {
+      const date = g.dimensions?.date;
+      if (!date) continue;
+
+      const existing = byDate.get(date) ?? { requests: 0, gbSeconds: 0 };
+      existing.gbSeconds += g.sum?.duration ?? 0;
+      byDate.set(date, existing);
+    }
+
+    return byDate;
+  }
+
+  /**
+   * Get total AI Gateway requests for a period (no daily granularity available)
+   */
+  private async getAIGatewayRequests(startDate: string, endDate: string): Promise<number> {
+    try {
+      // Use the range-based method instead of period-based
+      const dateRange: DateRange = { startDate, endDate };
+      const metrics = await this.getAIGatewayMetricsForRange(dateRange);
+      // Sum all gateway requests for the period
+      return metrics.reduce((sum, m) => sum + m.totalRequests, 0);
+    } catch {
+      return 0;
+    }
+  }
+
+  /**
+   * Get total Vectorize queried dimensions for a period
+   * Now uses GraphQL API (vectorizeV2QueriesAdaptiveGroups) for accurate data
+   */
+  private async getVectorizeQueries(startDate: string, endDate: string): Promise<number> {
+    try {
+      const metrics = await this.getVectorizeQueriesGraphQL({ startDate, endDate });
+      // Return queried dimensions (used for billing calculation)
+      return metrics.totalQueriedDimensions;
+    } catch (error) {
+      console.error('[CloudflareGraphQL] getVectorizeQueries error:', error);
+      // Fallback to rough estimate if GraphQL fails
+      const periodDays = this.getDayCount(startDate, endDate);
+      const indexCount = (await this.getVectorizeInfo()).length;
+      return indexCount * 100 * periodDays; // Rough estimate: 100 queries/day per index
+    }
+  }
+
+  /**
+   * Get Cloudflare account subscriptions and billing information
+   * Uses REST API endpoints:
+   * - GET /accounts/{id}/subscriptions
+   * - GET /accounts/{id}/billing/profile
+   */
+  async getAccountSubscriptions(): Promise<CloudflareAccountSubscriptions> {
+    // Workers Paid plan inclusions (free tier amounts per month)
+    // Based on Cloudflare pricing as of January 2025
+    const planInclusions: WorkersPaidPlanInclusions = {
+      // Workers
+      requestsIncluded: 10_000_000,
+      cpuTimeIncluded: 30_000_000, // ms
+      // D1
+      d1RowsReadIncluded: 25_000_000_000, // 25B
+      d1RowsWrittenIncluded: 50_000_000, // 50M
+      d1StorageIncluded: 5_000_000_000, // 5GB
+      // KV
+      kvReadsIncluded: 10_000_000,
+      kvWritesIncluded: 1_000_000,
+      kvDeletesIncluded: 1_000_000,
+      kvListsIncluded: 1_000_000,
+      kvStorageIncluded: 1_000_000_000, // 1GB
+      // R2 (separate subscription but related)
+      r2ClassAIncluded: 1_000_000,
+      r2ClassBIncluded: 10_000_000,
+      r2StorageIncluded: 10_000_000_000, // 10GB
+      r2EgressIncluded: 0, // Egress free to internet
+      // Durable Objects
+      doRequestsIncluded: 1_000_000,
+      doDurationIncluded: 400_000, // GB-seconds
+      doStorageIncluded: 1_000_000_000, // 1GB
+      // Vectorize
+      vectorizeQueriedDimensionsIncluded: 30_000_000,
+      vectorizeStoredDimensionsIncluded: 5_000_000,
+      // Workers AI
+      workersAINeuronsIncluded: 10_000, // neurons/day (gateway dependent)
+      // Queues
+      queuesOperationsIncluded: 1_000_000,
+    };
+
+    const subscriptions: CloudflareSubscription[] = [];
+    let billingProfile: CloudflareBillingProfile | null = null;
+    let hasWorkersPaid = false;
+    let hasR2Paid = false;
+    let hasAnalyticsEngine = false;
+    let monthlyBaseCost = 0;
+
+    // Fetch subscriptions
+    try {
+      const subscriptionsRes = await fetchWithRetry(
+        `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/subscriptions`,
+        {
+          headers: {
+            Authorization: `Bearer ${this.apiToken}`,
+            'Content-Type': 'application/json',
+          },
+        }
+      );
+
+      if (subscriptionsRes.ok) {
+        const data = (await subscriptionsRes.json()) as {
+          success: boolean;
+          result: Array<{
+            id: string;
+            rate_plan?: {
+              id: string;
+              public_name: string;
+              currency: string;
+            };
+            price: number;
+            frequency: string;
+            current_period_start: string | null;
+            current_period_end: string | null;
+            state: string;
+            zone?: { name: string } | null;
+            created_on: string;
+          }>;
+        };
+
+        if (data.success && data.result) {
+          for (const sub of data.result) {
+            const planName = sub.rate_plan?.public_name || 'Unknown';
+            const subscription: CloudflareSubscription = {
+              id: sub.id,
+              ratePlanId: sub.rate_plan?.id || '',
+              ratePlanName: planName,
+              price: sub.price || 0,
+              currency: sub.rate_plan?.currency || 'USD',
+              frequency: sub.frequency || 'monthly',
+              currentPeriodStart: sub.current_period_start,
+              currentPeriodEnd: sub.current_period_end,
+              state: sub.state || 'active',
+              zoneName: sub.zone?.name || null,
+              createdDate: sub.created_on,
+            };
+
+            subscriptions.push(subscription);
+
+            // Detect plan types
+            const lowerPlanName = planName.toLowerCase();
+            if (lowerPlanName.includes('workers paid')) {
+              hasWorkersPaid = true;
+            }
+            if (lowerPlanName.includes('r2') && !lowerPlanName.includes('free')) {
+              hasR2Paid = true;
+            }
+            if (lowerPlanName.includes('analytics engine')) {
+              hasAnalyticsEngine = true;
+            }
+
+            // Sum monthly costs (only for monthly frequency)
+            if (sub.frequency === 'monthly' && sub.price > 0) {
+              monthlyBaseCost += sub.price;
+            }
+          }
+        }
+      }
+    } catch (error) {
+      console.error('Failed to fetch Cloudflare subscriptions:', error);
+    }
+
+    // Fetch billing profile
+    try {
+      const billingRes = await fetchWithRetry(
+        `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/billing/profile`,
+        {
+          headers: {
+            Authorization: `Bearer ${this.apiToken}`,
+            'Content-Type': 'application/json',
+          },
+        }
+      );
+
+      if (billingRes.ok) {
+        const data = (await billingRes.json()) as {
+          success: boolean;
+          result: {
+            id: string;
+            first_name: string;
+            last_name: string;
+            company: string;
+            email: string;
+            account_type: string;
+            country: string;
+          };
+        };
+
+        if (data.success && data.result) {
+          billingProfile = {
+            id: data.result.id,
+            firstName: data.result.first_name || '',
+            lastName: data.result.last_name || '',
+            company: data.result.company || '',
+            billingEmail: data.result.email || '',
+            accountType: data.result.account_type || 'personal',
+            country: data.result.country || '',
+          };
+        }
+      }
+    } catch (error) {
+      console.error('Failed to fetch Cloudflare billing profile:', error);
+    }
+
+    return {
+      subscriptions,
+      billingProfile,
+      planInclusions,
+      hasWorkersPaid,
+      hasR2Paid,
+      hasAnalyticsEngine,
+      monthlyBaseCost,
+    };
+  }
+
+  // ============================================================================
+  // Workers AI Neurons via GraphQL (aiInferenceAdaptive)
+  // Discovered via GraphQL introspection - provides per-request neuron usage
+  // ============================================================================
+
+  /**
+   * Get Workers AI neuron metrics via GraphQL API
+   * Uses aiInferenceAdaptive dataset which provides per-request neuron usage
+   *
+   * @param dateRange - The date range to query
+   * @returns Array of neuron usage metrics by model
+   */
+  async getWorkersAINeuronsGraphQL(dateRange: DateRange): Promise<{
+    totalNeurons: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    byModel: Array<{
+      modelId: string;
+      neurons: number;
+      inputTokens: number;
+      outputTokens: number;
+      requestCount: number;
+    }>;
+  }> {
+    const { startDate, endDate } = dateRange;
+    const startDatetime = `${startDate}T00:00:00Z`;
+    const endDatetime = `${endDate}T23:59:59Z`;
+
+    const queryStr = `
+      query WorkersAINeurons($accountTag: String!, $startDatetime: Time!, $endDatetime: Time!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            aiInferenceAdaptive(
+              filter: {
+                datetime_gt: $startDatetime
+                datetime_lt: $endDatetime
+              }
+              limit: 1000
+            ) {
+              neurons
+              modelId
+              datetime
+              inputTokens
+              outputTokens
+            }
+          }
+        }
+      }
+    `;
+
+    interface WorkersAINeuronsResponse {
+      viewer?: {
+        accounts?: Array<{
+          aiInferenceAdaptive?: Array<{
+            neurons?: number;
+            modelId?: string;
+            datetime?: string;
+            inputTokens?: number;
+            outputTokens?: number;
+          }>;
+        }>;
+      };
+    }
+
+    const data = await this.query<WorkersAINeuronsResponse>(queryStr, {
+      accountTag: this.accountId,
+      startDatetime,
+      endDatetime,
+    });
+
+    const result = {
+      totalNeurons: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      byModel: [] as Array<{
+        modelId: string;
+        neurons: number;
+        inputTokens: number;
+        outputTokens: number;
+        requestCount: number;
+      }>,
+    };
+
+    const inferences = data?.viewer?.accounts?.[0]?.aiInferenceAdaptive;
+    if (!inferences?.length) {
+      return result;
+    }
+
+    // Aggregate by model
+    const modelMap = new Map<
+      string,
+      { neurons: number; inputTokens: number; outputTokens: number; requestCount: number }
+    >();
+
+    for (const inf of inferences) {
+      const modelId = inf.modelId || 'unknown';
+      const neurons = inf.neurons || 0;
+      const inputTokens = inf.inputTokens || 0;
+      const outputTokens = inf.outputTokens || 0;
+
+      result.totalNeurons += neurons;
+      result.totalInputTokens += inputTokens;
+      result.totalOutputTokens += outputTokens;
+
+      const existing = modelMap.get(modelId);
+      if (existing) {
+        existing.neurons += neurons;
+        existing.inputTokens += inputTokens;
+        existing.outputTokens += outputTokens;
+        existing.requestCount += 1;
+      } else {
+        modelMap.set(modelId, { neurons, inputTokens, outputTokens, requestCount: 1 });
+      }
+    }
+
+    result.byModel = Array.from(modelMap.entries()).map(([modelId, data]) => ({
+      modelId,
+      ...data,
+    }));
+
+    console.log(
+      `[CloudflareGraphQL] WorkersAINeurons: ${result.totalNeurons} neurons across ${result.byModel.length} models`
+    );
+    return result;
+  }
+
+  // ============================================================================
+  // Vectorize Queries via GraphQL (vectorizeV2QueriesAdaptiveGroups)
+  // Discovered via GraphQL introspection - provides query metrics per index
+  // ============================================================================
+
+  /**
+   * Get Vectorize query metrics via GraphQL API
+   * Uses vectorizeV2QueriesAdaptiveGroups dataset for V2 query metrics
+   *
+   * @param dateRange - The date range to query
+   * @returns Query metrics by index
+   */
+  async getVectorizeQueriesGraphQL(dateRange: DateRange): Promise<{
+    totalQueriedDimensions: number;
+    totalDurationMs: number;
+    totalServedVectors: number;
+    byIndex: Array<{
+      indexName: string;
+      queriedDimensions: number;
+      durationMs: number;
+      servedVectors: number;
+    }>;
+  }> {
+    const { startDate, endDate } = dateRange;
+    const startDatetime = `${startDate}T00:00:00Z`;
+    const endDatetime = `${endDate}T23:59:59Z`;
+
+    const queryStr = `
+      query VectorizeQueries($accountTag: String!, $startDatetime: Time!, $endDatetime: Time!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            vectorizeV2QueriesAdaptiveGroups(
+              filter: {
+                datetime_gt: $startDatetime
+                datetime_lt: $endDatetime
+              }
+              limit: 100
+            ) {
+              sum {
+                queriedVectorDimensions
+                requestDurationMs
+                servedVectorCount
+              }
+              dimensions {
+                indexName
+                operation
+                requestStatus
+                date
+                datetime
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    interface VectorizeQueriesResponse {
+      viewer?: {
+        accounts?: Array<{
+          vectorizeV2QueriesAdaptiveGroups?: Array<{
+            sum?: {
+              queriedVectorDimensions?: number;
+              requestDurationMs?: number;
+              servedVectorCount?: number;
+            };
+            dimensions?: {
+              indexName?: string;
+              operation?: string;
+              requestStatus?: string;
+              date?: string;
+              datetime?: string;
+            };
+          }>;
+        }>;
+      };
+    }
+
+    const data = await this.query<VectorizeQueriesResponse>(queryStr, {
+      accountTag: this.accountId,
+      startDatetime,
+      endDatetime,
+    });
+
+    const result = {
+      totalQueriedDimensions: 0,
+      totalDurationMs: 0,
+      totalServedVectors: 0,
+      byIndex: [] as Array<{
+        indexName: string;
+        queriedDimensions: number;
+        durationMs: number;
+        servedVectors: number;
+      }>,
+    };
+
+    const groups = data?.viewer?.accounts?.[0]?.vectorizeV2QueriesAdaptiveGroups;
+    if (!groups?.length) {
+      return result;
+    }
+
+    // Aggregate by index
+    const indexMap = new Map<
+      string,
+      { queriedDimensions: number; durationMs: number; servedVectors: number }
+    >();
+
+    for (const group of groups) {
+      const indexName = group.dimensions?.indexName || 'unknown';
+      const queriedDimensions = group.sum?.queriedVectorDimensions || 0;
+      const durationMs = group.sum?.requestDurationMs || 0;
+      const servedVectors = group.sum?.servedVectorCount || 0;
+
+      result.totalQueriedDimensions += queriedDimensions;
+      result.totalDurationMs += durationMs;
+      result.totalServedVectors += servedVectors;
+
+      const existing = indexMap.get(indexName);
+      if (existing) {
+        existing.queriedDimensions += queriedDimensions;
+        existing.durationMs += durationMs;
+        existing.servedVectors += servedVectors;
+      } else {
+        indexMap.set(indexName, { queriedDimensions, durationMs, servedVectors });
+      }
+    }
+
+    result.byIndex = Array.from(indexMap.entries()).map(([indexName, data]) => ({
+      indexName,
+      ...data,
+    }));
+
+    console.log(
+      `[CloudflareGraphQL] VectorizeQueries: ${result.totalQueriedDimensions} dimensions across ${result.byIndex.length} indexes`
+    );
+    return result;
+  }
+
+  // ============================================================================
+  // Vectorize Storage via GraphQL (vectorizeV2StorageAdaptiveGroups)
+  // Discovered via GraphQL introspection - provides storage metrics per index
+  // ============================================================================
+
+  /**
+   * Get Vectorize storage metrics via GraphQL API
+   * Uses vectorizeV2StorageAdaptiveGroups dataset for V2 storage metrics
+   *
+   * @param dateRange - The date range to query
+   * @returns Storage metrics by index
+   */
+  async getVectorizeStorageGraphQL(dateRange: DateRange): Promise<{
+    totalStoredDimensions: number;
+    totalVectorCount: number;
+    byIndex: Array<{
+      indexName: string;
+      storedDimensions: number;
+      vectorCount: number;
+    }>;
+  }> {
+    const { startDate, endDate } = dateRange;
+
+    // Storage API uses date filter, not datetime
+    const queryStr = `
+      query VectorizeStorage($accountTag: String!, $startDate: Date!, $endDate: Date!) {
+        viewer {
+          accounts(filter: { accountTag: $accountTag }) {
+            vectorizeV2StorageAdaptiveGroups(
+              filter: {
+                date_gt: $startDate
+                date_leq: $endDate
+              }
+              limit: 100
+            ) {
+              max {
+                storedVectorDimensions
+                vectorCount
+              }
+              dimensions {
+                date
+                datetime
+                indexName
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    interface VectorizeStorageResponse {
+      viewer?: {
+        accounts?: Array<{
+          vectorizeV2StorageAdaptiveGroups?: Array<{
+            max?: {
+              storedVectorDimensions?: number;
+              vectorCount?: number;
+            };
+            dimensions?: {
+              date?: string;
+              datetime?: string;
+              indexName?: string;
+            };
+          }>;
+        }>;
+      };
+    }
+
+    const data = await this.query<VectorizeStorageResponse>(queryStr, {
+      accountTag: this.accountId,
+      startDate,
+      endDate,
+    });
+
+    const result = {
+      totalStoredDimensions: 0,
+      totalVectorCount: 0,
+      byIndex: [] as Array<{
+        indexName: string;
+        storedDimensions: number;
+        vectorCount: number;
+      }>,
+    };
+
+    const groups = data?.viewer?.accounts?.[0]?.vectorizeV2StorageAdaptiveGroups;
+    if (!groups?.length) {
+      return result;
+    }
+
+    // Aggregate by index (using max values - storage is a point-in-time metric)
+    const indexMap = new Map<string, { storedDimensions: number; vectorCount: number }>();
+
+    for (const group of groups) {
+      const indexName = group.dimensions?.indexName || 'unknown';
+      const storedDimensions = group.max?.storedVectorDimensions || 0;
+      const vectorCount = group.max?.vectorCount || 0;
+
+      // For storage, we want the max across the period (not sum)
+      const existing = indexMap.get(indexName);
+      if (existing) {
+        existing.storedDimensions = Math.max(existing.storedDimensions, storedDimensions);
+        existing.vectorCount = Math.max(existing.vectorCount, vectorCount);
+      } else {
+        indexMap.set(indexName, { storedDimensions, vectorCount });
+      }
+    }
+
+    // Calculate totals from index maxes
+    for (const data of indexMap.values()) {
+      result.totalStoredDimensions += data.storedDimensions;
+      result.totalVectorCount += data.vectorCount;
+    }
+
+    result.byIndex = Array.from(indexMap.entries()).map(([indexName, data]) => ({
+      indexName,
+      ...data,
+    }));
+
+    console.log(
+      `[CloudflareGraphQL] VectorizeStorage: ${result.totalStoredDimensions} dimensions, ${result.totalVectorCount} vectors across ${result.byIndex.length} indexes`
+    );
+    return result;
+  }
+}