@tokcalc/mcp-server 0.1.3 → 0.2.0-alpha.1

package/src/lib/benchmark-schema.ts

@@ -1,263 +0,0 @@
-/**
- * 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

@@ -1,13 +0,0 @@
-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

@@ -1,183 +0,0 @@
-/**
- * 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

@@ -1,141 +0,0 @@
-/**
- * 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 };
-}