@tokcalc/mcp-server 0.1.1 → 0.1.3

package/src/lib/benchmark-schema.ts

@@ -0,0 +1,263 @@
+/**
+ * Benchmark provenance schema for tokcalc.
+ *
+ * Based on the Perplexity research brief which specified:
+ * "Do not build a single scalar called 'tokens/sec.' A valid observed record
+ * should always preserve the workload, serving software, engine flags, hardware
+ * topology, model revision, quantization, and metric definition."
+ *
+ * This file defines:
+ *   1. The BenchmarkRecord type (50+ fields across 7 categories)
+ *   2. A confidence tier system (official → community → unverified)
+ *   3. Parser interface for ingesting raw benchmark artifacts
+ *
+ * Design principle: tokcalc retains separate estimate types:
+ *   - Theoretical model (what we have now — physics formulas)
+ *   - Observed benchmark (this file — real measured data)
+ *   - Calibrated estimate (theory adjusted by observed data — future)
+ *   - User-provided run (user uploads their benchmark — future)
+ */
+
+/* ============================================================
+   CONFIDENCE TIERS
+   ============================================================ */
+
+export type ConfidenceTier =
+  | "official_audited"      // MLPerf submission, official vendor benchmark
+  | "official_reproducible" // vLLM/SGLang/TRT-LLM docs example with full config
+  | "community_reproducible" // User ran it with documented config + raw artifact
+  | "community_unverified"   // User-reported number without raw artifact
+  | "derived";               // Computed from other records (e.g., calibration)
+
+export type VerificationStatus =
+  | "unreviewed"
+  | "schema_valid"
+  | "reproduced"
+  | "curated"
+  | "rejected";
+
+/* ============================================================
+   CORE BENCHMARK RECORD
+   ============================================================ */
+
+export interface BenchmarkRecord {
+  /* ---- Core identity and provenance ---- */
+  benchmark_id: string;
+  source_name: "vllm" | "sglang" | "tensorrt_llm" | "mlperf" | "llmperf" | "community" | "manual_curated";
+  source_url: string;
+  source_license: string;
+  ingestion_method: "official_api" | "official_repo" | "uploaded_raw_artifact" | "manual_curated";
+  retrieved_at: string;           // ISO 8601
+  benchmark_started_at?: string;  // ISO 8601
+  raw_artifact_url?: string;
+  artifact_sha256?: string;
+  parser_name?: string;
+  parser_version?: string;
+  confidence_tier: ConfidenceTier;
+  verification_status: VerificationStatus;
+
+  /* ---- Model identity ---- */
+  model_id: string;
+  model_display_name: string;
+  model_repository?: string;
+  model_revision: string;         // commit hash / version / date
+  architecture?: "dense" | "moe" | "vlm" | "encoder" | "decoder_only";
+  parameter_count_b?: number;
+  context_window_tokens?: number;
+  quantization_format: string;   // FP16, FP8, GGUF Q4_K_M, AWQ, etc.
+  weight_dtype?: string;          // float16, bfloat16, float8_e4m3, int8, etc.
+  kv_cache_dtype?: string;       // "float16" by default
+
+  /* ---- Hardware and topology ---- */
+  accelerator_vendor: "NVIDIA" | "AMD" | "Intel" | "Apple" | "Google" | "Groq" | "Cerebras" | string;
+  accelerator_model: string;
+  gpu_count: number;
+  memory_per_gpu_gb: number;
+  host_cpu?: string;
+  host_memory_gb?: number;
+  interconnect?: string;
+  topology?: string;
+  cloud_provider?: string;
+  instance_type?: string;
+  region?: string;
+  driver_version?: string;
+  cuda_rocm_metal_version?: string;
+
+  /* ---- Serving stack and configuration ---- */
+  serving_engine: "vLLM" | "SGLang" | "TensorRT-LLM" | "TGI" | "llama.cpp" | "MLX" | string;
+  engine_version: string;
+  engine_command?: string;
+  engine_config?: {
+    tensor_parallel_size?: number;
+    pipeline_parallel_size?: number;
+    max_model_len?: number;
+    max_num_seqs?: number;
+    max_num_batched_tokens?: number;
+    prefix_cache_enabled?: boolean;
+    speculative_decoding?: {
+      enabled: boolean;
+      draft_model?: string;
+      acceptance_rate?: number;
+    };
+    chunked_prefill_enabled?: boolean;
+    attention_backend?: string;
+  };
+
+  /* ---- Workload definition ---- */
+  workload_type: "offline" | "online_poisson" | "fixed_rate" | "closed_loop" | "trace_replay" | "synthetic";
+  dataset_name?: string;
+  request_count: number;
+  concurrency: number;
+  arrival_rate_rps?: number;
+  input_tokens_mean: number;
+  input_tokens_p50?: number;
+  input_tokens_p95?: number;
+  input_tokens_p99?: number;
+  output_tokens_mean: number;
+  output_tokens_p50?: number;
+  output_tokens_p95?: number;
+  output_tokens_p99?: number;
+  shared_prefix_tokens_mean?: number;
+  shared_prefix_hit_rate?: number;
+  streaming_enabled: boolean;
+  sampling_config?: {
+    temperature?: number;
+    top_p?: number;
+    max_tokens?: number;
+    seed?: number;
+  };
+
+  /* ---- Observed metrics ---- */
+  successful_requests: number;
+  failed_requests: number;
+  request_throughput_rps?: number;
+  output_token_throughput_tps: number;       // THE key metric
+  total_token_throughput_tps?: number;
+  ttft_mean_ms?: number;
+  ttft_p50_ms?: number;
+  ttft_p95_ms?: number;
+  ttft_p99_ms?: number;
+  itl_mean_ms?: number;
+  itl_p50_ms?: number;
+  itl_p95_ms?: number;
+  itl_p99_ms?: number;
+  tpot_mean_ms?: number;                     // Time per output token (vLLM's term)
+  e2e_latency_p50_ms?: number;
+  e2e_latency_p95_ms?: number;
+  e2e_latency_p99_ms?: number;
+  gpu_memory_peak_gb?: number;
+  gpu_utilization_mean_pct?: number;
+  power_mean_w?: number;
+  energy_per_output_token_j?: number;
+
+  /* ---- Comparability and display ---- */
+  metric_definition_version: string;
+  slo_ttft_ms?: number;
+  slo_itl_ms?: number;
+  slo_e2e_ms?: number;
+  comparability_group?: string;
+  normalization_notes?: string;
+  known_limitations?: string;
+  citation_text: string;
+  attribution_required: boolean;
+  commercial_redistribution_allowed: "yes" | "no" | "unknown" | "contract_required";
+}
+
+/* ============================================================
+   CALIBRATION RESULT — compares theoretical vs observed
+   ============================================================ */
+
+export interface CalibrationResult {
+  /** What tokcalc's formulas predicted */
+  estimated: {
+    decodeTokensPerSec: number;
+    aggregateTokensPerSec: number;
+    prefillTokensPerSec: number;
+    ttftMs: number;
+    itlMs: number;
+    modelSizeGb: number;
+  };
+  /** What the benchmark actually measured */
+  observed: {
+    outputTokenThroughputTps?: number;
+    ttftMeanMs?: number;
+    ttftP95Ms?: number;
+    itlMeanMs?: number;
+    itlP95Ms?: number;
+    gpuMemoryPeakGb?: number;
+  };
+  /** Calibration error (observed - estimated) / estimated × 100 */
+  calibrationErrors: {
+    throughputErrorPct?: number;   // positive = observed was faster than predicted
+    ttftErrorPct?: number;          // positive = observed TTFT was longer than predicted
+    itlErrorPct?: number;
+    memoryErrorPct?: number;
+  };
+  /** Does the observed data validate or contradict our model? */
+  verdict: "validated" | "underestimated" | "overestimated" | "insufficient_data";
+}
+
+/* ============================================================
+   PARSER INTERFACE
+   ============================================================ */
+
+export interface BenchmarkParser {
+  name: string;
+  version: string;
+  /** Detect if raw text looks like this engine's output */
+  detect(rawText: string): boolean;
+  /** Parse raw text into a BenchmarkRecord */
+  parse(rawText: string): BenchmarkRecord | null;
+  /** Human-readable format name */
+  formatLabel: string;
+}
+
+/* ============================================================
+   HELPER: generate UUID (no dependency)
+   ============================================================ */
+
+export function generateBenchmarkId(): string {
+  // RFC 4122 v4 UUID — no dependency needed
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === "x" ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+
+/* ============================================================
+   HELPER: format calibration verdict for display
+   ============================================================ */
+
+export function formatCalibrationVerdict(verdict: CalibrationResult["verdict"]): {
+  label: string;
+  color: string;
+  description: string;
+} {
+  switch (verdict) {
+    case "validated":
+      return {
+        label: "Validated",
+        color: "text-emerald-500",
+        description: "Observed benchmark matches theoretical estimate within ±20%. Formula is accurate for this config.",
+      };
+    case "underestimated":
+      return {
+        label: "Underestimated",
+        color: "text-amber-500",
+        description: "Real performance was BETTER than tokcalc predicted. Formula may be too conservative.",
+      };
+    case "overestimated":
+      return {
+        label: "Overestimated",
+        color: "text-red-500",
+        description: "Real performance was WORSE than tokcalc predicted. Formula may be too optimistic.",
+      };
+    case "insufficient_data":
+      return {
+        label: "Insufficient data",
+        color: "text-muted-foreground",
+        description: "Not enough observed metrics to calibrate against the theoretical estimate.",
+      };
+  }
+}

package/src/lib/db.ts

@@ -0,0 +1,13 @@
+import { PrismaClient } from '@prisma/client'
+
+const globalForPrisma = globalThis as unknown as {
+  prisma: PrismaClient | undefined
+}
+
+export const db =
+  globalForPrisma.prisma ??
+  new PrismaClient({
+    log: ['query'],
+  })
+
+if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = db

package/src/lib/engine-presets.ts

@@ -0,0 +1,183 @@
+/**
+ * Engine-aware presets for tokcalc.
+ *
+ * When the user picks an inference engine (vLLM, SGLang, TRT-LLM, llama.cpp),
+ * the calculator adjusts:
+ *   1. Efficiency factors (ETA_MEM, ETA_COMPUTE) — each engine has different
+ *      real-world utilization due to kernel optimizations, scheduler design, etc.
+ *   2. Default continuous batching multiplier — vLLM/SGLang have it on by
+ *      default (2.0×), llama.cpp doesn't (1.0×)
+ *   3. Supported quantizations — filters the quant dropdown to only show
+ *      formats the selected engine supports
+ *   4. Engine-specific notes — helps users understand trade-offs
+ *
+ * Per Perplexity research (Prompt #2):
+ *   "There is no universally best engine; workload shape matters."
+ *   "comparisons emphasize that throughput leadership varies with workload,
+ *    structured output, prefix reuse, and operational maturity"
+ */
+
+import type { Quantization } from "./token-calc";
+
+export type EngineId = "vllm" | "sglang" | "trtllm" | "llamacpp" | "generic";
+
+export interface EnginePreset {
+  id: EngineId;
+  name: string;
+  shortName: string;
+  description: string;
+  /** Memory bandwidth utilization (real-world) — replaces ETA_MEM when engine is selected */
+  etaMem: number;
+  /** Compute utilization — replaces ETA_COMPUTE */
+  etaCompute: number;
+  /** Default continuous batching multiplier when engine is selected */
+  defaultBatchingMultiplier: number;
+  /** Which quantization formats this engine supports */
+  supportedQuants: Quantization[];
+  /** Engine-specific notes shown in UI */
+  notes: string;
+  /** Source URL for the engine */
+  sourceUrl: string;
+  /** Whether continuous batching is on by default in this engine */
+  batchingOnByDefault: boolean;
+  /** Whether prefix caching is on by default */
+  prefixCacheOnByDefault: boolean;
+  /** Key features of this engine */
+  features: string[];
+}
+
+export const ENGINE_PRESETS: EnginePreset[] = [
+  {
+    id: "vllm",
+    name: "vLLM",
+    shortName: "vLLM",
+    description: "High-throughput LLM serving with PagedAttention + continuous batching. The most popular open-source serving engine.",
+    etaMem: 0.65,        // Default — PagedAttention reduces waste to <4%
+    etaCompute: 0.50,    // Default
+    defaultBatchingMultiplier: 2.0,  // vLLM enables continuous batching by default
+    supportedQuants: ["fp32", "fp16", "bf16", "int8", "fp8", "gptq4", "awq4", "int4"],
+    notes: "PagedAttention + continuous batching ON by default. Real-world throughput is 2-4× naive batching. Supports FP8 natively on H100/H200. GGUF not supported — use llama.cpp for that.",
+    sourceUrl: "https://docs.vllm.ai",
+    batchingOnByDefault: true,
+    prefixCacheOnByDefault: true,  // APC (Automatic Prefix Caching)
+    features: [
+      "PagedAttention (KV cache memory management)",
+      "Continuous batching (iteration-level scheduling)",
+      "Automatic prefix caching (APC)",
+      "Tensor parallelism (up to 8×)",
+      "Speculative decoding",
+      "FP8 native on H100/H200",
+    ],
+  },
+  {
+    id: "sglang",
+    name: "SGLang",
+    shortName: "SGLang",
+    description: "High-performance serving with RadixAttention (prefix-tree KV cache) + structured generation. Best for agent workloads with repeated prefixes.",
+    etaMem: 0.68,        // Slightly higher — RadixAttention is more efficient than APC
+    etaCompute: 0.52,
+    defaultBatchingMultiplier: 2.0,  // Continuous batching on by default
+    supportedQuants: ["fp32", "fp16", "bf16", "int8", "fp8", "gptq4", "awq4"],
+    notes: "RadixAttention provides automatic prefix reuse without explicit cache management. Better for agent/RAG workloads with shared system prompts. Slightly higher memory efficiency than vLLM for prefix-heavy workloads.",
+    sourceUrl: "https://github.com/sgl-project/sglang",
+    batchingOnByDefault: true,
+    prefixCacheOnByDefault: true,  // RadixAttention IS the prefix cache
+    features: [
+      "RadixAttention (prefix-tree KV cache)",
+      "Continuous batching",
+      "Structured generation (JSON mode)",
+      "Tensor parallelism",
+      "Speculative decoding",
+      "PD disaggregation (experimental)",
+    ],
+  },
+  {
+    id: "trtllm",
+    name: "TensorRT-LLM",
+    shortName: "TRT-LLM",
+    description: "NVIDIA-optimized inference engine. Best raw throughput on NVIDIA GPUs with quantized models. Requires model compilation.",
+    etaMem: 0.70,        // NVIDIA-optimized kernels achieve higher utilization
+    etaCompute: 0.55,
+    defaultBatchingMultiplier: 2.0,
+    supportedQuants: ["fp32", "fp16", "bf16", "int8", "fp8", "nvfp4", "int4"],
+    notes: "NVIDIA-optimized kernels achieve 5-10% higher utilization than vLLM on same hardware. NVFP4 native on Blackwell (B200/B300). Requires model compilation (TRT engine build) — slower to iterate than vLLM. Inflight batching is TRT-LLM's version of continuous batching.",
+    sourceUrl: "https://github.com/NVIDIA/TensorRT-LLM",
+    batchingOnByDefault: true,  // Inflight batching
+    prefixCacheOnByDefault: true,
+    features: [
+      "NVIDIA-optimized kernels (FlashAttention, fused MLP)",
+      "Inflight batching (continuous batching equivalent)",
+      "FP8 + NVFP4 native on H100/H200/B200",
+      "Model compilation (TRT engine build)",
+      "Tensor parallelism",
+      "Plugin system for custom layers",
+    ],
+  },
+  {
+    id: "llamacpp",
+    name: "llama.cpp",
+    shortName: "llama.cpp",
+    description: "C++ inference engine for CPU, Apple Silicon, and consumer GPUs. Best for local/edge deployment. GGUF format.",
+    etaMem: 0.55,        // Lower — CPU/GPU mixed, less optimized than vLLM
+    etaCompute: 0.40,    // Lower — CPU-bound on non-GPU paths
+    defaultBatchingMultiplier: 1.0,  // No continuous batching by default
+    supportedQuants: ["fp32", "fp16", "bf16", "int8", "gguf-q2k", "gguf-q3km", "gguf-q4km", "gguf-q5km", "gguf-q6k", "gguf-q8", "int4"],
+    notes: "Best for local/edge: Mac M-series (MLX backend), consumer GPUs (CUDA), CPU-only machines. Supports all GGUF quantization variants (Q2_K through Q8_0). No continuous batching — throughput is single-stream only. KV cache is contiguous (not paged).",
+    sourceUrl: "https://github.com/ggml-org/llama.cpp",
+    batchingOnByDefault: false,
+    prefixCacheOnByDefault: false,
+    features: [
+      "GGUF format (Q2_K through Q8_0)",
+      "CPU inference (no GPU needed)",
+      "Apple Silicon (Metal backend)",
+      "Consumer GPU support (CUDA)",
+      "Lowest memory footprint",
+      "No server needed (CLI + server mode)",
+    ],
+  },
+  {
+    id: "generic",
+    name: "Generic (engine-agnostic)",
+    shortName: "Generic",
+    description: "No specific engine selected. Uses conservative default efficiency factors. Best when you don't know which engine you'll use yet.",
+    etaMem: 0.65,        // Default — same as current ETA_MEM
+    etaCompute: 0.50,    // Default
+    defaultBatchingMultiplier: 1.5,  // Conservative default
+    supportedQuants: [
+      "fp32", "fp16", "bf16", "int8", "int4",
+      "gguf-q2k", "gguf-q3km", "gguf-q4km", "gguf-q5km", "gguf-q6k", "gguf-q8",
+      "gptq4", "awq4", "exl2-6bpw", "fp8", "nvfp4",
+    ],
+    notes: "Conservative estimates. When you know your engine, select it for more accurate results. Each engine has different real-world utilization due to kernel optimizations and scheduler design.",
+    sourceUrl: "",
+    batchingOnByDefault: false,
+    prefixCacheOnByDefault: false,
+    features: [],
+  },
+];
+
+export const ENGINE_MAP: Record<EngineId, EnginePreset> = Object.fromEntries(
+  ENGINE_PRESETS.map((e) => [e.id, e]),
+) as Record<EngineId, EnginePreset>;
+
+/**
+ * Get the engine preset by ID (defaults to "generic").
+ */
+export function getEngine(id: EngineId | string | undefined): EnginePreset {
+  return ENGINE_MAP[id as EngineId] || ENGINE_MAP.generic;
+}
+
+/**
+ * Check if a quantization format is supported by an engine.
+ */
+export function isQuantSupported(engine: EngineId, quant: Quantization): boolean {
+  const preset = getEngine(engine);
+  return preset.supportedQuants.includes(quant);
+}
+
+/**
+ * Get the list of quantizations supported by an engine, as Quantization[].
+ */
+export function getSupportedQuants(engine: EngineId): Quantization[] {
+  return getEngine(engine).supportedQuants;
+}

package/src/lib/price-schema.ts

@@ -0,0 +1,141 @@
+/**
+ * Price record type for live cloud GPU pricing.
+ *
+ * Based on the Perplexity research brief (Prompt #3):
+ * "Use an append-only historical model. A price should never be overwritten
+ * without retaining the prior record."
+ *
+ * Phase 1: Azure Retail Prices API (unauthenticated, easiest)
+ * Phase 2: Vast.ai marketplace API (dynamic spot pricing)
+ * Phase 3: AWS / GCP / OCI official APIs (authenticated)
+ */
+
+export type PriceProvider =
+  | "azure"
+  | "aws"
+  | "gcp"
+  | "oci"
+  | "vast_ai"
+  | "runpod"
+  | "lambda"
+  | "modal"
+  | "tensor"
+  | "default";
+
+export type PurchaseOption =
+  | "on_demand"
+  | "spot"
+  | "reserved"
+  | "savings_plan"
+  | "marketplace"
+  | "serverless";
+
+export type BillingUnit =
+  | "instance_hour"
+  | "gpu_hour"
+  | "gpu_second";
+
+export interface PriceRecord {
+  id: string;
+  provider: PriceProvider;
+  productFamily: "cloud_vm" | "gpu_marketplace";
+
+  /** Cloud SKU identifier (e.g., "Standard_ND96isr_H100_v5") */
+  providerSku: string;
+  providerSkuName: string;
+
+  /** GPU info extracted from the SKU */
+  acceleratorVendor?: string;
+  acceleratorModel?: string;
+  acceleratorCount?: number;
+  acceleratorMemoryGb?: number;
+
+  /** Region/zone */
+  region?: string;
+  locationLabel?: string;
+
+  purchaseOption: PurchaseOption;
+  billingUnit: BillingUnit;
+
+  /** Price in USD */
+  amount: number;
+  currency: "USD";
+
+  /** Per-GPU derived price (if instance-level, divide by GPU count) */
+  derivedPricePerGpuHour?: number;
+  isDerived: boolean;
+  derivationFormula?: string;
+
+  /** Validity window */
+  effectiveFrom?: string;
+  effectiveTo?: string;
+  retrievedAt: string;
+
+  /** Provenance */
+  sourceType: "official_api" | "official_price_page" | "manual_verified";
+  sourceUrl: string;
+
+  /** Display confidence */
+  confidence: "high" | "medium" | "low";
+}
+
+/**
+ * Match a GPU from tokcalc's catalog to a cloud provider's SKU.
+ * Returns the best guess based on GPU name + VRAM.
+ */
+export function matchGpuToCloudSku(
+  gpuName: string,
+  gpuVramGb: number,
+  provider: PriceProvider,
+): { sku: string; skuName: string } | null {
+  const name = gpuName.toLowerCase();
+
+  // Azure SKU patterns
+  if (provider === "azure") {
+    if (name.includes("h100")) return { sku: "Standard_ND96isr_H100_v5", skuName: "ND H100 v5 (96 GPU = 8× H100)" };
+    if (name.includes("h200")) return { sku: "Standard_ND-H200-v5", skuName: "ND H200 v5" };
+    if (name.includes("a100") && gpuVramGb >= 80) return { sku: "Standard_ND96asr_v4", skuName: "ND A100 v4 (8× A100 80GB)" };
+    if (name.includes("a100") && gpuVramGb < 80) return { sku: "Standard_ND96amsr_A100_v4", skuName: "ND A100 v4 (40GB)" };
+    if (name.includes("v100")) return { sku: "Standard_NC24ads_A100_v4", skuName: "NC A100 v4" };
+    if (name.includes("t4")) return { sku: "Standard_NC4as_T4_v3", skuName: "NC T4 v3" };
+    if (name.includes("l40s") || name.includes("l40")) return { sku: "Standard_NDm_A100_v4", skuName: "NDm L40S" };
+  }
+
+  // AWS SKU patterns
+  if (provider === "aws") {
+    if (name.includes("h100")) return { sku: "p5.48xlarge", skuName: "p5.48xlarge (8× H100)" };
+    if (name.includes("h200")) return { sku: "p5e.48xlarge", skuName: "p5e.48xlarge (8× H200)" };
+    if (name.includes("b200")) return { sku: "p6.48xlarge", skuName: "p6.48xlarge (8× B200)" };
+    if (name.includes("a100") && gpuVramGb >= 80) return { sku: "p4de.24xlarge", skuName: "p4de.24xlarge (8× A100 80GB)" };
+    if (name.includes("a100") && gpuVramGb < 80) return { sku: "p4d.24xlarge", skuName: "p4d.24xlarge (8× A100 40GB)" };
+    if (name.includes("l40s")) return { sku: "g6.48xlarge", skuName: "g6.48xlarge (8× L40S)" };
+    if (name.includes("l4")) return { sku: "g6.xlarge", skuName: "g6.xlarge (1× L4)" };
+    if (name.includes("t4")) return { sku: "g4dn.12xlarge", skuName: "g4dn.12xlarge (4× T4)" };
+  }
+
+  return null;
+}
+
+/**
+ * Format a price record for display in the UI.
+ */
+export function formatPriceRecord(r: PriceRecord): {
+  displayPrice: string;
+  isLive: boolean;
+  ageLabel: string;
+} {
+  const perGpu = r.derivedPricePerGpuHour ?? r.amount;
+  const displayPrice = `$${perGpu.toFixed(2)}/hr`;
+
+  // "Live" if retrieved within last 24 hours
+  const ageMs = Date.now() - new Date(r.retrievedAt).getTime();
+  const isLive = ageMs < 24 * 60 * 60 * 1000;
+
+  let ageLabel: string;
+  if (ageMs < 60 * 1000) ageLabel = "just now";
+  else if (ageMs < 60 * 60 * 1000) ageLabel = `${Math.floor(ageMs / 60000)}m ago`;
+  else if (ageMs < 24 * 60 * 60 * 1000) ageLabel = `${Math.floor(ageMs / 3600000)}h ago`;
+  else ageLabel = `${Math.floor(ageMs / 86400000)}d ago`;
+
+  return { displayPrice, isLive, ageLabel };
+}