@pipeline-builder/api-server 4.4.2 → 4.4.4

package/lib/api/metrics.d.ts

@@ -24,6 +24,7 @@ export interface MetricHelpers {
     incCounter(name: string, labels?: Record<string, string>, value?: number): void;
     observe(name: string, labels: Record<string, string>, value: number): void;
     setGauge(name: string, labels: Record<string, string>, value: number): void;
+    resetGauge(name: string): void;
 }
 /**
  * Build `incCounter` / `observe` / `setGauge` over a caller-supplied registry.
@@ -45,12 +46,19 @@ export declare function createMetricHelpers(registry: Registry | (() => Registry
 /**
  * Increment a business counter, creating it on first use.
  *
+ * Every example below is a call that EXISTS, with the labels it really passes. That is
+ * deliberate: an invented example reads as an inventory of what the system measures, and
+ * a metrics survey later counted three names from this block — `pipelines_generated_total`,
+ * `quota_threshold_crossed_total`, `compliance_violations_found_total` — as live metrics
+ * missing a dashboard panel. Nothing emitted any of them. Illustrative names in a docstring
+ * about metric naming are indistinguishable from real ones, so there are none here.
+ *
  * @example
  * ```typescript
- * incCounter('pipelines_generated_total', { provider: 'anthropic' });
- * incCounter('plugin_builds_total', { status: 'completed' });
- * incCounter('quota_threshold_crossed_total', { type: 'aiCalls', tier: 'pro' });
- * incCounter('compliance_violations_found_total', { severity: 'critical' });
+ * incCounter('plugin_builds_total', { status: 'success', org_id: orgId });
+ * incCounter('compliance_scans_total', { outcome: 'started' });
+ * incCounter('plugin_vuln_findings_total', { trigger, severity }, count);
+ * incCounter('ai_tokens_total', { route: 'agent', kind: 'input' }, inputTokens);
  * ```
  */
 export declare function incCounter(name: string, labels?: Record<string, string>, value?: number): void;
@@ -60,8 +68,8 @@ export declare function incCounter(name: string, labels?: Record<string, string>
  *
  * @example
  * ```typescript
- * observe('ai_generation_duration_seconds', { provider: 'anthropic', model: 'sonnet' }, durationSec);
- * observe('plugin_build_duration_seconds', { buildType: 'docker' }, durationSec);
+ * observe('ai_generation_duration_seconds', { route, provider: providerLabel }, durationSec);
+ * observe('plugin_build_duration_seconds', { org_id: orgId }, durationSec);
  * ```
  */
 export declare function observe(name: string, labels: Record<string, string>, value: number): void;
@@ -77,3 +85,11 @@ export declare function observe(name: string, labels: Record<string, string>, va
  * ```
  */
 export declare function setGauge(name: string, labels: Record<string, string>, value: number): void;
+/**
+ * Drop EVERY series of a business gauge. For a gauge that describes a SET — one
+ * series per configured entry — and is re-published whole: without the reset, a
+ * series for an entry that has since been deleted keeps its last value forever,
+ * and an alert on it keeps firing for something that no longer exists. Call it
+ * immediately before re-setting the current set. A gauge never set is a no-op.
+ */
+export declare function resetGauge(name: string): void;

package/lib/api/metrics.js

@@ -155,6 +155,77 @@ export function metricsHandler() {
         res.end(await register.metrics());
     };
 }
+// ---------------------------------------------------------------------------
+// Business / domain metrics
+//
+// Services should emit counters for the things operators actually care about
+// (pipelines generated, plugin builds completed, compliance violations,
+// AI tokens consumed) — not just HTTP traffic. The helpers below register
+// counters lazily on the shared registry so multiple services can call
+// `incCounter('plugin_builds_total', { status: 'completed' })` without
+// worrying about double-registration.
+//
+// Naming convention: `<domain>_<noun>_total` for counters, `_seconds` for
+// histograms — matches Prometheus best-practice.
+// ---------------------------------------------------------------------------
+/**
+ * Bucket distributions for histograms whose observations are nowhere near the
+ * sub-second-to-minutes default.
+ *
+ * THIS TABLE EXISTS BECAUSE THE DEFAULT SILENTLY BREAKS ALERTS. The default set
+ * below ends at a 300-second bucket, and `histogram_quantile` cannot interpolate
+ * past the last FINITE boundary — everything above it lands in `+Inf` and the
+ * quantile reads back as 300 forever. An alert of the form `> 300` on such a
+ * histogram can therefore never fire, and a p90 panel flat-lines at five
+ * minutes however bad things get. Nothing errors, nothing is missing from the
+ * scrape, and the dashboard looks healthy: the only symptom is an alert that
+ * stays quiet through an outage. `support_first_response_seconds` measures hours
+ * to days and had a threshold of twelve hours sitting above a ceiling of five
+ * minutes.
+ *
+ * So a histogram whose natural range is minutes-to-days declares its buckets
+ * here, and ALERT THRESHOLDS ARE PUT ON BOUNDARIES: a threshold inside a wide
+ * bucket is served by linear interpolation across that bucket, which is a guess,
+ * while a threshold ON a boundary is exact. For support that means 6h (the alert)
+ * and 8h (the sold target) are both boundaries, 24h is the operational guard
+ * from the standard/priority rule, and 96h covers the longest legitimate wait a
+ * business-day target allows — a priority case raised at 17:01 on a Friday.
+ *
+ * Add a metric here when its observations can exceed five minutes. The table is
+ * read on FIRST USE of each name by `createMetricHelpers`, so both registries
+ * (api-server's and platform's own) get the same distribution, which is the
+ * drift the factory exists to prevent.
+ */
+const HISTOGRAM_BUCKETS = {
+    // 15m, 1h, 2h, 4h, 6h, 8h, 12h, 24h, 48h, 96h.
+    support_first_response_seconds: [900, 3600, 7200, 14400, 21600, 28800, 43200, 86400, 172800, 345600],
+    // Submission-to-decision latency is a human review queue: hours to days.
+    // 15m, 1h, 4h, 12h, 1d, 2d, 4d, 7d, 14d.
+    ecosystem_decision_latency_seconds: [900, 3600, 14400, 43200, 86400, 172800, 345600, 604800, 1209600],
+    // Queue wait. `PluginQueueProcessingSlow` asserts p95 > 300, which the default
+    // ceiling of 300 made unfireable; 300 is a boundary here so the comparison is
+    // exact rather than interpolated.
+    plugin_job_wait_seconds: [1, 5, 15, 30, 60, 120, 300, 600, 1800, 3600],
+    // A container build. Minutes normally, far longer for a cold base image.
+    plugin_build_duration_seconds: [10, 30, 60, 120, 300, 600, 1200, 1800, 3600],
+    // A full image scan, which routinely passes five minutes on a large image.
+    plugin_vuln_scan_duration_seconds: [1, 5, 15, 30, 60, 120, 300, 600, 1200],
+    // Time from an incident being raised to a human acknowledging it. The default
+    // buckets end at 300s, and `histogram_quantile` cannot interpolate past the
+    // last finite boundary — so with them, any threshold above five minutes could
+    // never fire, which is every threshold worth setting here. Boundaries at 1m,
+    // 2m, 5m, 10m, 15m, 30m, 1h, 2h, 4h: 15m is exact because that is the
+    // escalation delay the alert compares against, and the range reaches 4h so a
+    // page nobody ever picked up is still counted rather than clipped.
+    oncall_page_ack_seconds: [60, 120, 300, 600, 900, 1800, 3600, 7200, 14400],
+    // CSAT, 1-5. Not a duration at all, and listed here for the same reason as
+    // the others: the default buckets are sub-second, so every rating would land
+    // in the same bucket and the quantile would be meaningless. One boundary per
+    // possible score makes `_sum / _count` an exact average and each bucket a
+    // real count. It rides the histogram rather than a counter-per-score so the
+    // average needs no PromQL arithmetic over five series.
+    support_satisfaction: [1, 2, 3, 4, 5],
+};
 /**
  * Build `incCounter` / `observe` / `setGauge` over a caller-supplied registry.
  *
@@ -197,10 +268,12 @@ export function createMetricHelpers(registry) {
                     name,
                     help: humanizeName(name),
                     labelNames: Object.keys(labels),
-                    // Default buckets target sub-second through several-minute observations.
-                    // Override by registering the histogram explicitly before first call
-                    // if you need a different bucket distribution.
-                    buckets: [0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60, 120, 300],
+                    // Default buckets target sub-second through several-minute
+                    // observations. Anything that can exceed five minutes MUST declare its
+                    // own distribution in `HISTOGRAM_BUCKETS` above — past the last finite
+                    // boundary a quantile reads back as that boundary, so a threshold
+                    // beyond it never fires.
+                    buckets: [...(HISTOGRAM_BUCKETS[name] ?? [0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60, 120, 300])],
                     registers: [registryOf()],
                 });
                 histograms.set(name, hist);
@@ -220,6 +293,9 @@ export function createMetricHelpers(registry) {
             }
             gauge.set(labels, value);
         },
+        resetGauge(name) {
+            gauges.get(name)?.reset();
+        },
     };
 }
 /** This service's own helpers, over the shared module-level registry. */
@@ -227,12 +303,19 @@ const businessMetrics = createMetricHelpers(register);
 /**
  * Increment a business counter, creating it on first use.
  *
+ * Every example below is a call that EXISTS, with the labels it really passes. That is
+ * deliberate: an invented example reads as an inventory of what the system measures, and
+ * a metrics survey later counted three names from this block — `pipelines_generated_total`,
+ * `quota_threshold_crossed_total`, `compliance_violations_found_total` — as live metrics
+ * missing a dashboard panel. Nothing emitted any of them. Illustrative names in a docstring
+ * about metric naming are indistinguishable from real ones, so there are none here.
+ *
  * @example
  * ```typescript
- * incCounter('pipelines_generated_total', { provider: 'anthropic' });
- * incCounter('plugin_builds_total', { status: 'completed' });
- * incCounter('quota_threshold_crossed_total', { type: 'aiCalls', tier: 'pro' });
- * incCounter('compliance_violations_found_total', { severity: 'critical' });
+ * incCounter('plugin_builds_total', { status: 'success', org_id: orgId });
+ * incCounter('compliance_scans_total', { outcome: 'started' });
+ * incCounter('plugin_vuln_findings_total', { trigger, severity }, count);
+ * incCounter('ai_tokens_total', { route: 'agent', kind: 'input' }, inputTokens);
  * ```
  */
 export function incCounter(name, labels = {}, value = 1) {
@@ -244,8 +327,8 @@ export function incCounter(name, labels = {}, value = 1) {
  *
  * @example
  * ```typescript
- * observe('ai_generation_duration_seconds', { provider: 'anthropic', model: 'sonnet' }, durationSec);
- * observe('plugin_build_duration_seconds', { buildType: 'docker' }, durationSec);
+ * observe('ai_generation_duration_seconds', { route, provider: providerLabel }, durationSec);
+ * observe('plugin_build_duration_seconds', { org_id: orgId }, durationSec);
  * ```
  */
 export function observe(name, labels, value) {
@@ -265,10 +348,20 @@ export function observe(name, labels, value) {
 export function setGauge(name, labels, value) {
     businessMetrics.setGauge(name, labels, value);
 }
+/**
+ * Drop EVERY series of a business gauge. For a gauge that describes a SET — one
+ * series per configured entry — and is re-published whole: without the reset, a
+ * series for an entry that has since been deleted keeps its last value forever,
+ * and an alert on it keeps firing for something that no longer exists. Call it
+ * immediately before re-setting the current set. A gauge never set is a no-op.
+ */
+export function resetGauge(name) {
+    businessMetrics.resetGauge(name);
+}
 function humanizeName(metricName) {
-    // `pipelines_generated_total` → "Pipelines generated total"
+    // `plugin_builds_total` → "Plugin builds total"
     return metricName
         .replace(/_/g, ' ')
         .replace(/^./, (c) => c.toUpperCase());
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metrics.js","sourceRoot":"","sources":["../../src/api/metrics.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { previousSecretStates, SECRET_ROTATION_PREVIOUS_GAUGE } from '@pipeline-builder/api-core';\nimport { Config } from '@pipeline-builder/pipeline-core';\nimport type { Request, Response, NextFunction } from 'express';\nimport { Registry, collectDefaultMetrics, Counter, Histogram, Gauge } from 'prom-client';\n\nconst SERVICE_NAME = (Config.getAny('observability') as { serviceName: string }).serviceName;\n\n/** Shared Prometheus registry */\nconst register = new Registry();\n\n// Set default labels for all metrics\nregister.setDefaultLabels({ service: SERVICE_NAME });\n\n// Collect default Node.js process metrics (CPU, memory, heap, event loop lag, GC)\ncollectDefaultMetrics({ register });\n\n/**\n * Register the `secret_rotation_previous_set{secret}` gauge on `registry`: 1\n * while a secret's `*_PREVIOUS` rotation value is still set, 0 otherwise. The\n * value is read from api-core's probe registry at scrape time, so it always\n * reflects the live process. Exported so platform (own registry) exposes the\n * identical series; the `SecretRotationPreviousLingering` alert keys on it.\n */\nexport function registerSecretRotationGauge(registry: Registry): Gauge<'secret'> {\n  return new Gauge({\n    name: SECRET_ROTATION_PREVIOUS_GAUGE,\n    help: '1 while a secret rotation previous value (e.g. SECRET_ENCRYPTION_KEY_PREVIOUS) or a retiring signing key is still accepted; see docs/runbooks/secret-rotation.md',\n    labelNames: ['secret'] as const,\n    registers: [registry],\n    collect() {\n      for (const { secret, previousSet } of previousSecretStates()) {\n        this.set({ secret }, previousSet ? 1 : 0);\n      }\n    },\n  });\n}\n\nregisterSecretRotationGauge(register);\n\n/** HTTP request duration histogram (seconds) */\nconst httpRequestDuration = new Histogram({\n  name: 'http_request_duration_seconds',\n  help: 'Duration of HTTP requests in seconds',\n  labelNames: ['method', 'route', 'status_code'] as const,\n  buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10],\n  registers: [register],\n});\n\n/** HTTP request counter */\nconst httpRequestsTotal = new Counter({\n  name: 'http_requests_total',\n  help: 'Total number of HTTP requests',\n  labelNames: ['method', 'route', 'status_code'] as const,\n  registers: [register],\n});\n\n/**\n * Per-org HTTP request counter — SAMPLED to keep Prometheus cardinality\n * under control. Cardinality of `org_id * method * route * status_code`\n * grows multiplicatively; with N orgs * 50 routes * 5 status_codes that's\n * 250×N series. We sample 1-in-N requests (configurable via\n * `HTTP_METRICS_ORG_SAMPLE_RATE`, default 0 = off).\n *\n * Operators answer \"what's org X's p99?\" via separate per-org histograms\n * scraped at a lower rate, OR via Loki LogQL queries against the\n * unsampled access-log stream. This counter is the fast-path \"noisy\n * neighbor detection\" — operators alert when one org's request rate\n * deviates from the fleet median.\n *\n * NOT a histogram: histogram label cardinality is even more sensitive\n * (each bucket is a separate series). If per-org latency percentiles are\n * needed later, add a separate histogram with a coarser bucket set and\n * lower sample rate.\n */\nconst httpRequestsByOrgTotal = new Counter({\n  name: 'http_requests_by_org_total',\n  help: 'Sampled per-org HTTP request count (sample rate via HTTP_METRICS_ORG_SAMPLE_RATE)',\n  labelNames: ['method', 'route', 'status_code', 'org_id'] as const,\n  registers: [register],\n});\n\n/**\n * Sample rate for the per-org counter. 1.0 = every request, 0.0 = disabled.\n * Parsed once at module load — operators tune by restarting the service.\n *\n * Defaults to 0 (OFF). `org_id` is an UNBOUNDED, tenant-identifying label and\n * prom-client counters never expire, so at 1.0 every service accumulates a\n * series per (org × route × status) for the process lifetime, and `/metrics` —\n * which is not auth-gated — enumerates every tenant id along with its request\n * volume and error rate to anyone who can reach the port.\n *\n * Turn it on deliberately (and ideally with a sample rate well under 1.0, plus\n * `METRICS_SCRAPE_TOKEN` set) when you actually want per-org noisy-neighbour\n * detection from metrics rather than from the access-log stream.\n */\nconst ORG_SAMPLE_RATE = (() => {\n  const raw = process.env.HTTP_METRICS_ORG_SAMPLE_RATE;\n  if (raw === undefined || raw === '') return 0;\n  const parsed = parseFloat(raw);\n  if (Number.isNaN(parsed) || parsed < 0 || parsed > 1) return 0;\n  return parsed;\n})();\n\n/**\n * Normalize an Express route path to prevent label cardinality explosion.\n *\n * Uses Express's matched route pattern (e.g. `/plugins/:id`) when available,\n * otherwise falls back to the raw path with UUID/numeric segments replaced.\n */\nfunction normalizeRoute(req: Request): string {\n  // Prefer Express matched route pattern\n  if (req.route?.path) {\n    return req.baseUrl + req.route.path;\n  }\n\n  // Fallback: replace UUIDs and numeric IDs with :id\n  return req.path\n    .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, ':id')\n    .replace(/\\/\\d+(?=\\/|$)/g, '/:id');\n}\n\n/**\n * Express middleware that records request duration and count.\n *\n * Must be registered before route handlers so `res.on('finish')` fires\n * after the response is sent.\n */\nexport function metricsMiddleware() {\n  return (req: Request, res: Response, next: NextFunction): void => {\n    // NOTE: no /metrics or /health skip needed here — both endpoints are\n    // registered in app-factory BEFORE this middleware (createHealthRouter and\n    // app.get('/metrics') both terminate the response), so neither ever reaches\n    // this handler.\n    const end = httpRequestDuration.startTimer();\n\n    res.on('finish', () => {\n      const route = normalizeRoute(req);\n      const labels = {\n        method: req.method,\n        route,\n        status_code: String(res.statusCode),\n      };\n\n      end(labels);\n      httpRequestsTotal.inc(labels);\n\n      // Per-org sampled counter. Skip when:\n      //   - no org context on the request (anonymous / health endpoints)\n      //   - sample rate is 0 (disabled)\n      //   - dice roll fails\n      // Using Math.random for the sampler — for unbiased low-rate sampling\n      // a deterministic per-request hash would be more uniform, but at the\n      // default rate of 1.0 every request lands so this is fine.\n      const orgId = req.user?.organizationId;\n      if (orgId && ORG_SAMPLE_RATE > 0 && Math.random() < ORG_SAMPLE_RATE) {\n        httpRequestsByOrgTotal.inc({ ...labels, org_id: orgId });\n      }\n    });\n\n    next();\n  };\n}\n\n/**\n * Express handler that returns Prometheus metrics in text exposition format.\n */\nexport function metricsHandler() {\n  return async (_req: Request, res: Response): Promise<void> => {\n    res.set('Content-Type', register.contentType);\n    res.end(await register.metrics());\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Business / domain metrics\n//\n// Services should emit counters for the things operators actually care about\n// (pipelines generated, plugin builds completed, compliance violations,\n// AI tokens consumed) — not just HTTP traffic. The helpers below register\n// counters lazily on the shared registry so multiple services can call\n// `incCounter('plugin_builds_total', { status: 'completed' })` without\n// worrying about double-registration.\n//\n// Naming convention: `<domain>_<noun>_total` for counters, `_seconds` for\n// histograms — matches Prometheus best-practice.\n// ---------------------------------------------------------------------------\n\n/** The lazy business-metric helpers, bound to one registry. */\nexport interface MetricHelpers {\n  incCounter(name: string, labels?: Record<string, string>, value?: number): void;\n  observe(name: string, labels: Record<string, string>, value: number): void;\n  setGauge(name: string, labels: Record<string, string>, value: number): void;\n}\n\n/**\n * Build `incCounter` / `observe` / `setGauge` over a caller-supplied registry.\n *\n * THE one implementation of the lazy counter/histogram/gauge maps. api-server's\n * own exports below are this factory over its module-level `register`; the\n * platform service — which runs its own Express setup instead of `createApp`,\n * and therefore owns a different registry — builds the identical helpers over\n * its own. Without the factory the two drift: they differ today only in the\n * histogram buckets, which is exactly the kind of difference nobody notices\n * until a dashboard reads wrong on one service.\n *\n * `registry` may be a thunk, for a registry that is injected after module load\n * (platform wires its own on app boot). The thunk is called on the FIRST use of\n * each metric name, never at import time, so building the helpers has no side\n * effect of its own.\n */\nexport function createMetricHelpers(registry: Registry | (() => Registry)): MetricHelpers {\n  const registryOf = (): Registry => (typeof registry === 'function' ? registry() : registry);\n  const counters = new Map<string, Counter<string>>();\n  const histograms = new Map<string, Histogram<string>>();\n  const gauges = new Map<string, Gauge<string>>();\n\n  return {\n    incCounter(name, labels = {}, value = 1) {\n      let counter = counters.get(name);\n      if (!counter) {\n        counter = new Counter({\n          name,\n          help: humanizeName(name),\n          labelNames: Object.keys(labels),\n          registers: [registryOf()],\n        });\n        counters.set(name, counter);\n      }\n      counter.inc(labels, value);\n    },\n\n    observe(name, labels, value) {\n      let hist = histograms.get(name);\n      if (!hist) {\n        hist = new Histogram({\n          name,\n          help: humanizeName(name),\n          labelNames: Object.keys(labels),\n          // Default buckets target sub-second through several-minute observations.\n          // Override by registering the histogram explicitly before first call\n          // if you need a different bucket distribution.\n          buckets: [0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60, 120, 300],\n          registers: [registryOf()],\n        });\n        histograms.set(name, hist);\n      }\n      hist.observe(labels, value);\n    },\n\n    setGauge(name, labels, value) {\n      let gauge = gauges.get(name);\n      if (!gauge) {\n        gauge = new Gauge({\n          name,\n          help: humanizeName(name),\n          labelNames: Object.keys(labels),\n          registers: [registryOf()],\n        });\n        gauges.set(name, gauge);\n      }\n      gauge.set(labels, value);\n    },\n  };\n}\n\n/** This service's own helpers, over the shared module-level registry. */\nconst businessMetrics = createMetricHelpers(register);\n\n/**\n * Increment a business counter, creating it on first use.\n *\n * @example\n * ```typescript\n * incCounter('pipelines_generated_total', { provider: 'anthropic' });\n * incCounter('plugin_builds_total', { status: 'completed' });\n * incCounter('quota_threshold_crossed_total', { type: 'aiCalls', tier: 'pro' });\n * incCounter('compliance_violations_found_total', { severity: 'critical' });\n * ```\n */\nexport function incCounter(name: string, labels: Record<string, string> = {}, value = 1): void {\n  businessMetrics.incCounter(name, labels, value);\n}\n\n/**\n * Record an observation on a business histogram, creating it on first use.\n * Use for durations, sizes, anything where percentiles matter.\n *\n * @example\n * ```typescript\n * observe('ai_generation_duration_seconds', { provider: 'anthropic', model: 'sonnet' }, durationSec);\n * observe('plugin_build_duration_seconds', { buildType: 'docker' }, durationSec);\n * ```\n */\nexport function observe(name: string, labels: Record<string, string>, value: number): void {\n  businessMetrics.observe(name, labels, value);\n}\n\n/**\n * Set the value of a business gauge, creating it on first use. Use for\n * point-in-time observations sampled by a scraper — queue depth, active\n * connection counts, in-flight requests.\n *\n * @example\n * ```typescript\n * setGauge('plugin_queue_jobs', { queue: 'plugin-build', state: 'waiting' }, 12);\n * setGauge('plugin_queue_jobs', { queue: 'plugin-build', state: 'active' }, 3);\n * ```\n */\nexport function setGauge(name: string, labels: Record<string, string>, value: number): void {\n  businessMetrics.setGauge(name, labels, value);\n}\n\nfunction humanizeName(metricName: string): string {\n  // `pipelines_generated_total` → \"Pipelines generated total\"\n  return metricName\n    .replace(/_/g, ' ')\n    .replace(/^./, (c) => c.toUpperCase());\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metrics.js","sourceRoot":"","sources":["../../src/api/metrics.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { previousSecretStates, SECRET_ROTATION_PREVIOUS_GAUGE } from '@pipeline-builder/api-core';\nimport { Config } from '@pipeline-builder/pipeline-core';\nimport type { Request, Response, NextFunction } from 'express';\nimport { Registry, collectDefaultMetrics, Counter, Histogram, Gauge } from 'prom-client';\n\nconst SERVICE_NAME = (Config.getAny('observability') as { serviceName: string }).serviceName;\n\n/** Shared Prometheus registry */\nconst register = new Registry();\n\n// Set default labels for all metrics\nregister.setDefaultLabels({ service: SERVICE_NAME });\n\n// Collect default Node.js process metrics (CPU, memory, heap, event loop lag, GC)\ncollectDefaultMetrics({ register });\n\n/**\n * Register the `secret_rotation_previous_set{secret}` gauge on `registry`: 1\n * while a secret's `*_PREVIOUS` rotation value is still set, 0 otherwise. The\n * value is read from api-core's probe registry at scrape time, so it always\n * reflects the live process. Exported so platform (own registry) exposes the\n * identical series; the `SecretRotationPreviousLingering` alert keys on it.\n */\nexport function registerSecretRotationGauge(registry: Registry): Gauge<'secret'> {\n  return new Gauge({\n    name: SECRET_ROTATION_PREVIOUS_GAUGE,\n    help: '1 while a secret rotation previous value (e.g. SECRET_ENCRYPTION_KEY_PREVIOUS) or a retiring signing key is still accepted; see docs/runbooks/secret-rotation.md',\n    labelNames: ['secret'] as const,\n    registers: [registry],\n    collect() {\n      for (const { secret, previousSet } of previousSecretStates()) {\n        this.set({ secret }, previousSet ? 1 : 0);\n      }\n    },\n  });\n}\n\nregisterSecretRotationGauge(register);\n\n/** HTTP request duration histogram (seconds) */\nconst httpRequestDuration = new Histogram({\n  name: 'http_request_duration_seconds',\n  help: 'Duration of HTTP requests in seconds',\n  labelNames: ['method', 'route', 'status_code'] as const,\n  buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10],\n  registers: [register],\n});\n\n/** HTTP request counter */\nconst httpRequestsTotal = new Counter({\n  name: 'http_requests_total',\n  help: 'Total number of HTTP requests',\n  labelNames: ['method', 'route', 'status_code'] as const,\n  registers: [register],\n});\n\n/**\n * Per-org HTTP request counter — SAMPLED to keep Prometheus cardinality\n * under control. Cardinality of `org_id * method * route * status_code`\n * grows multiplicatively; with N orgs * 50 routes * 5 status_codes that's\n * 250×N series. We sample 1-in-N requests (configurable via\n * `HTTP_METRICS_ORG_SAMPLE_RATE`, default 0 = off).\n *\n * Operators answer \"what's org X's p99?\" via separate per-org histograms\n * scraped at a lower rate, OR via Loki LogQL queries against the\n * unsampled access-log stream. This counter is the fast-path \"noisy\n * neighbor detection\" — operators alert when one org's request rate\n * deviates from the fleet median.\n *\n * NOT a histogram: histogram label cardinality is even more sensitive\n * (each bucket is a separate series). If per-org latency percentiles are\n * needed later, add a separate histogram with a coarser bucket set and\n * lower sample rate.\n */\nconst httpRequestsByOrgTotal = new Counter({\n  name: 'http_requests_by_org_total',\n  help: 'Sampled per-org HTTP request count (sample rate via HTTP_METRICS_ORG_SAMPLE_RATE)',\n  labelNames: ['method', 'route', 'status_code', 'org_id'] as const,\n  registers: [register],\n});\n\n/**\n * Sample rate for the per-org counter. 1.0 = every request, 0.0 = disabled.\n * Parsed once at module load — operators tune by restarting the service.\n *\n * Defaults to 0 (OFF). `org_id` is an UNBOUNDED, tenant-identifying label and\n * prom-client counters never expire, so at 1.0 every service accumulates a\n * series per (org × route × status) for the process lifetime, and `/metrics` —\n * which is not auth-gated — enumerates every tenant id along with its request\n * volume and error rate to anyone who can reach the port.\n *\n * Turn it on deliberately (and ideally with a sample rate well under 1.0, plus\n * `METRICS_SCRAPE_TOKEN` set) when you actually want per-org noisy-neighbour\n * detection from metrics rather than from the access-log stream.\n */\nconst ORG_SAMPLE_RATE = (() => {\n  const raw = process.env.HTTP_METRICS_ORG_SAMPLE_RATE;\n  if (raw === undefined || raw === '') return 0;\n  const parsed = parseFloat(raw);\n  if (Number.isNaN(parsed) || parsed < 0 || parsed > 1) return 0;\n  return parsed;\n})();\n\n/**\n * Normalize an Express route path to prevent label cardinality explosion.\n *\n * Uses Express's matched route pattern (e.g. `/plugins/:id`) when available,\n * otherwise falls back to the raw path with UUID/numeric segments replaced.\n */\nfunction normalizeRoute(req: Request): string {\n  // Prefer Express matched route pattern\n  if (req.route?.path) {\n    return req.baseUrl + req.route.path;\n  }\n\n  // Fallback: replace UUIDs and numeric IDs with :id\n  return req.path\n    .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, ':id')\n    .replace(/\\/\\d+(?=\\/|$)/g, '/:id');\n}\n\n/**\n * Express middleware that records request duration and count.\n *\n * Must be registered before route handlers so `res.on('finish')` fires\n * after the response is sent.\n */\nexport function metricsMiddleware() {\n  return (req: Request, res: Response, next: NextFunction): void => {\n    // NOTE: no /metrics or /health skip needed here — both endpoints are\n    // registered in app-factory BEFORE this middleware (createHealthRouter and\n    // app.get('/metrics') both terminate the response), so neither ever reaches\n    // this handler.\n    const end = httpRequestDuration.startTimer();\n\n    res.on('finish', () => {\n      const route = normalizeRoute(req);\n      const labels = {\n        method: req.method,\n        route,\n        status_code: String(res.statusCode),\n      };\n\n      end(labels);\n      httpRequestsTotal.inc(labels);\n\n      // Per-org sampled counter. Skip when:\n      //   - no org context on the request (anonymous / health endpoints)\n      //   - sample rate is 0 (disabled)\n      //   - dice roll fails\n      // Using Math.random for the sampler — for unbiased low-rate sampling\n      // a deterministic per-request hash would be more uniform, but at the\n      // default rate of 1.0 every request lands so this is fine.\n      const orgId = req.user?.organizationId;\n      if (orgId && ORG_SAMPLE_RATE > 0 && Math.random() < ORG_SAMPLE_RATE) {\n        httpRequestsByOrgTotal.inc({ ...labels, org_id: orgId });\n      }\n    });\n\n    next();\n  };\n}\n\n/**\n * Express handler that returns Prometheus metrics in text exposition format.\n */\nexport function metricsHandler() {\n  return async (_req: Request, res: Response): Promise<void> => {\n    res.set('Content-Type', register.contentType);\n    res.end(await register.metrics());\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Business / domain metrics\n//\n// Services should emit counters for the things operators actually care about\n// (pipelines generated, plugin builds completed, compliance violations,\n// AI tokens consumed) — not just HTTP traffic. The helpers below register\n// counters lazily on the shared registry so multiple services can call\n// `incCounter('plugin_builds_total', { status: 'completed' })` without\n// worrying about double-registration.\n//\n// Naming convention: `<domain>_<noun>_total` for counters, `_seconds` for\n// histograms — matches Prometheus best-practice.\n// ---------------------------------------------------------------------------\n\n/**\n * Bucket distributions for histograms whose observations are nowhere near the\n * sub-second-to-minutes default.\n *\n * THIS TABLE EXISTS BECAUSE THE DEFAULT SILENTLY BREAKS ALERTS. The default set\n * below ends at a 300-second bucket, and `histogram_quantile` cannot interpolate\n * past the last FINITE boundary — everything above it lands in `+Inf` and the\n * quantile reads back as 300 forever. An alert of the form `> 300` on such a\n * histogram can therefore never fire, and a p90 panel flat-lines at five\n * minutes however bad things get. Nothing errors, nothing is missing from the\n * scrape, and the dashboard looks healthy: the only symptom is an alert that\n * stays quiet through an outage. `support_first_response_seconds` measures hours\n * to days and had a threshold of twelve hours sitting above a ceiling of five\n * minutes.\n *\n * So a histogram whose natural range is minutes-to-days declares its buckets\n * here, and ALERT THRESHOLDS ARE PUT ON BOUNDARIES: a threshold inside a wide\n * bucket is served by linear interpolation across that bucket, which is a guess,\n * while a threshold ON a boundary is exact. For support that means 6h (the alert)\n * and 8h (the sold target) are both boundaries, 24h is the operational guard\n * from the standard/priority rule, and 96h covers the longest legitimate wait a\n * business-day target allows — a priority case raised at 17:01 on a Friday.\n *\n * Add a metric here when its observations can exceed five minutes. The table is\n * read on FIRST USE of each name by `createMetricHelpers`, so both registries\n * (api-server's and platform's own) get the same distribution, which is the\n * drift the factory exists to prevent.\n */\nconst HISTOGRAM_BUCKETS: Readonly<Record<string, readonly number[]>> = {\n  // 15m, 1h, 2h, 4h, 6h, 8h, 12h, 24h, 48h, 96h.\n  support_first_response_seconds: [900, 3600, 7200, 14400, 21600, 28800, 43200, 86400, 172800, 345600],\n  // Submission-to-decision latency is a human review queue: hours to days.\n  // 15m, 1h, 4h, 12h, 1d, 2d, 4d, 7d, 14d.\n  ecosystem_decision_latency_seconds: [900, 3600, 14400, 43200, 86400, 172800, 345600, 604800, 1209600],\n  // Queue wait. `PluginQueueProcessingSlow` asserts p95 > 300, which the default\n  // ceiling of 300 made unfireable; 300 is a boundary here so the comparison is\n  // exact rather than interpolated.\n  plugin_job_wait_seconds: [1, 5, 15, 30, 60, 120, 300, 600, 1800, 3600],\n  // A container build. Minutes normally, far longer for a cold base image.\n  plugin_build_duration_seconds: [10, 30, 60, 120, 300, 600, 1200, 1800, 3600],\n  // A full image scan, which routinely passes five minutes on a large image.\n  plugin_vuln_scan_duration_seconds: [1, 5, 15, 30, 60, 120, 300, 600, 1200],\n  // Time from an incident being raised to a human acknowledging it. The default\n  // buckets end at 300s, and `histogram_quantile` cannot interpolate past the\n  // last finite boundary — so with them, any threshold above five minutes could\n  // never fire, which is every threshold worth setting here. Boundaries at 1m,\n  // 2m, 5m, 10m, 15m, 30m, 1h, 2h, 4h: 15m is exact because that is the\n  // escalation delay the alert compares against, and the range reaches 4h so a\n  // page nobody ever picked up is still counted rather than clipped.\n  oncall_page_ack_seconds: [60, 120, 300, 600, 900, 1800, 3600, 7200, 14400],\n  // CSAT, 1-5. Not a duration at all, and listed here for the same reason as\n  // the others: the default buckets are sub-second, so every rating would land\n  // in the same bucket and the quantile would be meaningless. One boundary per\n  // possible score makes `_sum / _count` an exact average and each bucket a\n  // real count. It rides the histogram rather than a counter-per-score so the\n  // average needs no PromQL arithmetic over five series.\n  support_satisfaction: [1, 2, 3, 4, 5],\n};\n\n/** The lazy business-metric helpers, bound to one registry. */\nexport interface MetricHelpers {\n  incCounter(name: string, labels?: Record<string, string>, value?: number): void;\n  observe(name: string, labels: Record<string, string>, value: number): void;\n  setGauge(name: string, labels: Record<string, string>, value: number): void;\n  resetGauge(name: string): void;\n}\n\n/**\n * Build `incCounter` / `observe` / `setGauge` over a caller-supplied registry.\n *\n * THE one implementation of the lazy counter/histogram/gauge maps. api-server's\n * own exports below are this factory over its module-level `register`; the\n * platform service — which runs its own Express setup instead of `createApp`,\n * and therefore owns a different registry — builds the identical helpers over\n * its own. Without the factory the two drift: they differ today only in the\n * histogram buckets, which is exactly the kind of difference nobody notices\n * until a dashboard reads wrong on one service.\n *\n * `registry` may be a thunk, for a registry that is injected after module load\n * (platform wires its own on app boot). The thunk is called on the FIRST use of\n * each metric name, never at import time, so building the helpers has no side\n * effect of its own.\n */\nexport function createMetricHelpers(registry: Registry | (() => Registry)): MetricHelpers {\n  const registryOf = (): Registry => (typeof registry === 'function' ? registry() : registry);\n  const counters = new Map<string, Counter<string>>();\n  const histograms = new Map<string, Histogram<string>>();\n  const gauges = new Map<string, Gauge<string>>();\n\n  return {\n    incCounter(name, labels = {}, value = 1) {\n      let counter = counters.get(name);\n      if (!counter) {\n        counter = new Counter({\n          name,\n          help: humanizeName(name),\n          labelNames: Object.keys(labels),\n          registers: [registryOf()],\n        });\n        counters.set(name, counter);\n      }\n      counter.inc(labels, value);\n    },\n\n    observe(name, labels, value) {\n      let hist = histograms.get(name);\n      if (!hist) {\n        hist = new Histogram({\n          name,\n          help: humanizeName(name),\n          labelNames: Object.keys(labels),\n          // Default buckets target sub-second through several-minute\n          // observations. Anything that can exceed five minutes MUST declare its\n          // own distribution in `HISTOGRAM_BUCKETS` above — past the last finite\n          // boundary a quantile reads back as that boundary, so a threshold\n          // beyond it never fires.\n          buckets: [...(HISTOGRAM_BUCKETS[name] ?? [0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60, 120, 300])],\n          registers: [registryOf()],\n        });\n        histograms.set(name, hist);\n      }\n      hist.observe(labels, value);\n    },\n\n    setGauge(name, labels, value) {\n      let gauge = gauges.get(name);\n      if (!gauge) {\n        gauge = new Gauge({\n          name,\n          help: humanizeName(name),\n          labelNames: Object.keys(labels),\n          registers: [registryOf()],\n        });\n        gauges.set(name, gauge);\n      }\n      gauge.set(labels, value);\n    },\n\n    resetGauge(name) {\n      gauges.get(name)?.reset();\n    },\n  };\n}\n\n/** This service's own helpers, over the shared module-level registry. */\nconst businessMetrics = createMetricHelpers(register);\n\n/**\n * Increment a business counter, creating it on first use.\n *\n * Every example below is a call that EXISTS, with the labels it really passes. That is\n * deliberate: an invented example reads as an inventory of what the system measures, and\n * a metrics survey later counted three names from this block — `pipelines_generated_total`,\n * `quota_threshold_crossed_total`, `compliance_violations_found_total` — as live metrics\n * missing a dashboard panel. Nothing emitted any of them. Illustrative names in a docstring\n * about metric naming are indistinguishable from real ones, so there are none here.\n *\n * @example\n * ```typescript\n * incCounter('plugin_builds_total', { status: 'success', org_id: orgId });\n * incCounter('compliance_scans_total', { outcome: 'started' });\n * incCounter('plugin_vuln_findings_total', { trigger, severity }, count);\n * incCounter('ai_tokens_total', { route: 'agent', kind: 'input' }, inputTokens);\n * ```\n */\nexport function incCounter(name: string, labels: Record<string, string> = {}, value = 1): void {\n  businessMetrics.incCounter(name, labels, value);\n}\n\n/**\n * Record an observation on a business histogram, creating it on first use.\n * Use for durations, sizes, anything where percentiles matter.\n *\n * @example\n * ```typescript\n * observe('ai_generation_duration_seconds', { route, provider: providerLabel }, durationSec);\n * observe('plugin_build_duration_seconds', { org_id: orgId }, durationSec);\n * ```\n */\nexport function observe(name: string, labels: Record<string, string>, value: number): void {\n  businessMetrics.observe(name, labels, value);\n}\n\n/**\n * Set the value of a business gauge, creating it on first use. Use for\n * point-in-time observations sampled by a scraper — queue depth, active\n * connection counts, in-flight requests.\n *\n * @example\n * ```typescript\n * setGauge('plugin_queue_jobs', { queue: 'plugin-build', state: 'waiting' }, 12);\n * setGauge('plugin_queue_jobs', { queue: 'plugin-build', state: 'active' }, 3);\n * ```\n */\nexport function setGauge(name: string, labels: Record<string, string>, value: number): void {\n  businessMetrics.setGauge(name, labels, value);\n}\n\n/**\n * Drop EVERY series of a business gauge. For a gauge that describes a SET — one\n * series per configured entry — and is re-published whole: without the reset, a\n * series for an entry that has since been deleted keeps its last value forever,\n * and an alert on it keeps firing for something that no longer exists. Call it\n * immediately before re-setting the current set. A gauge never set is a no-op.\n */\nexport function resetGauge(name: string): void {\n  businessMetrics.resetGauge(name);\n}\n\nfunction humanizeName(metricName: string): string {\n  // `plugin_builds_total` → \"Plugin builds total\"\n  return metricName\n    .replace(/_/g, ' ')\n    .replace(/^./, (c) => c.toUpperCase());\n}\n"]}

package/lib/api/quota-reservation.d.ts

@@ -1,4 +1,4 @@
-import { type QuotaReserveResult, type QuotaService, type QuotaType } from '@pipeline-builder/api-core';
+import { type QuotaReserveResult, type QuotaService, type QuotaType, type QuotaUsageAttribution } from '@pipeline-builder/api-core';
 import type { Response } from 'express';
 /** The reserved quota slot, handed to the guarded body. */
 export interface QuotaSlot {
@@ -10,13 +10,27 @@ export interface QuotaSlot {
      * responding). From here on a failure KEEPS the slot — the cost was incurred.
      */
     markConsumed(): void;
-    /** Give the slot back now. Idempotent: refunds at most once. */
+    /**
+     * Give the slot back now. Idempotent: refunds at most once — and a NO-OP once
+     * {@link markConsumed} was called. A paid provider round-trip is never refunded,
+     * whatever path (a client abort, a later failure, an empty answer) asks for it
+     * afterwards; callers no longer need to guard `refund()` with their own
+     * "was the provider contacted" flag.
+     */
     refund(): void;
 }
 export interface QuotaReservationOptions {
     quotaService: QuotaService;
     orgId: string;
     type: QuotaType;
+    /** Units to reserve (default 1) — e.g. an AI model's weight. Refunds give back the same amount. */
+    amount?: number;
+    /**
+     * Usage-ledger attribution for the reserve AND its refund. Defaults to the
+     * ambient request context (principal + request id, no route) — pass it
+     * explicitly to record the route, the feature and the model.
+     */
+    attribution?: QuotaUsageAttribution;
     /** Signer of the quota service token. Defaults to this process (`SERVICE_NAME`). */
     serviceName?: string;
     logWarn: (message: string, data?: unknown) => void;
@@ -35,12 +49,37 @@ export type QuotaReservationOutcome<T> = {
     status: 'failed';
     error: unknown;
 };
+/** What {@link reserveQuotaSlot} hands back: a live slot, or the denial. */
+export type QuotaSlotReservation = {
+    status: 'denied';
+    reservation: QuotaReserveResult;
+} | {
+    status: 'reserved';
+    slot: QuotaSlot;
+};
+/**
+ * Reserve one slot (of `amount` units) and return its handle, WITHOUT running
+ * anything. The primitive under {@link withQuotaReservation}, for a caller whose
+ * gated work does not fit one callback — e.g. a tool inside an agent turn that
+ * settles its own slot. The caller owns settlement: `markConsumed()` once the
+ * resource is spent, `refund()` on every path that fails before that.
+ *
+ * Denied → `{ status: 'denied' }`, answered on `res` when given.
+ */
+export declare function reserveQuotaSlot(opts: QuotaReservationOptions): Promise<QuotaSlotReservation>;
+/**
+ * Run `body` against a reserved slot and settle it by ONE rule: keep it once
+ * the resource was consumed; refund it if the body fails first. Shared by
+ * {@link withQuotaReservation} and api-server's AI reservation.
+ */
+export declare function runWithSlot<T, S extends QuotaSlot>(slot: S, body: (slot: S) => Promise<T>, onError?: (error: unknown) => void | Promise<void>): Promise<QuotaReservationOutcome<T>>;
 /**
  * Reserve one quota slot, run `body`, and settle the slot by ONE rule:
  * keep it once the resource was consumed; refund it if the body fails first.
  *
  * - Denied → `{ status: 'denied' }` (answered on `res` when given); `body` never runs.
- * - `body` resolves → the slot is kept (unless `body` called `slot.refund()`).
+ * - `body` resolves → the slot is kept (unless `body` called `slot.refund()`
+ *   BEFORE marking it consumed — a refund after `markConsumed()` is ignored).
  * - `body` throws → refunded unless consumed — marked via `slot.markConsumed()`
  *   or signalled by the error itself carrying `providerContacted === true`
  *   (an AI round-trip that completed but produced nothing usable). The error is

package/lib/api/quota-reservation.js

@@ -2,25 +2,22 @@
 // SPDX-License-Identifier: Apache-2.0
 import { decrementQuota, getServiceAuthHeader, reserveQuota, sendQuotaReserveDenied, serviceIdentity, } from '@pipeline-builder/api-core';
 /**
- * Reserve one quota slot, run `body`, and settle the slot by ONE rule:
- * keep it once the resource was consumed; refund it if the body fails first.
- *
- * - Denied → `{ status: 'denied' }` (answered on `res` when given); `body` never runs.
- * - `body` resolves → the slot is kept (unless `body` called `slot.refund()`).
- * - `body` throws → refunded unless consumed — marked via `slot.markConsumed()`
- *   or signalled by the error itself carrying `providerContacted === true`
- *   (an AI round-trip that completed but produced nothing usable). The error is
- *   then passed to `onError`, or rethrown when there is none.
+ * Reserve one slot (of `amount` units) and return its handle, WITHOUT running
+ * anything. The primitive under {@link withQuotaReservation}, for a caller whose
+ * gated work does not fit one callback — e.g. a tool inside an agent turn that
+ * settles its own slot. The caller owns settlement: `markConsumed()` once the
+ * resource is spent, `refund()` on every path that fails before that.
  *
- * The reserve and refund authenticate with a minted service token, never the
- * end-user bearer: the quota increment endpoint rejects user principals.
+ * Denied → `{ status: 'denied' }`, answered on `res` when given.
  */
-export async function withQuotaReservation(opts, body, onError) {
-    const { quotaService, orgId, type, logWarn } = opts;
+export async function reserveQuotaSlot(opts) {
+    const { quotaService, orgId, type, logWarn, attribution } = opts;
+    const amount = opts.amount ?? 1;
     const serviceAuth = getServiceAuthHeader({ serviceName: opts.serviceName ?? serviceIdentity(), orgId, role: 'member' });
     // Reserve atomically BEFORE any work: two concurrent requests at the limit
-    // can't both pass.
-    const reservation = await reserveQuota(quotaService, orgId, type, serviceAuth);
+    // can't both pass. Attribution defaults to the ambient request context
+    // (principal + request id) inside the quota client.
+    const reservation = await reserveQuota(quotaService, orgId, type, serviceAuth, amount, attribution);
     if (reservation.exceeded) {
         if (opts.res)
             sendQuotaReserveDenied(opts.res, type, reservation);
@@ -33,19 +30,28 @@ export async function withQuotaReservation(opts, body, onError) {
         reservation,
         markConsumed: () => { consumed = true; },
         refund: () => {
-            if (refunded)
+            if (refunded || consumed)
                 return;
             refunded = true;
             // The reserved resetAt keeps a period rollover from being double-charged.
-            decrementQuota(quotaService, orgId, type, serviceAuth, logWarn, 1, reservation.quota.resetAt);
+            decrementQuota(quotaService, orgId, type, serviceAuth, logWarn, amount, reservation.quota.resetAt, attribution);
         },
     };
+    return { status: 'reserved', slot };
+}
+/**
+ * Run `body` against a reserved slot and settle it by ONE rule: keep it once
+ * the resource was consumed; refund it if the body fails first. Shared by
+ * {@link withQuotaReservation} and api-server's AI reservation.
+ */
+export async function runWithSlot(slot, body, onError) {
     try {
         return { status: 'done', value: await body(slot) };
     }
     catch (error) {
+        // `refund()` is itself a no-op once the slot was marked consumed.
         const errorSaysConsumed = error?.providerContacted === true;
-        if (!consumed && !errorSaysConsumed)
+        if (!errorSaysConsumed)
             slot.refund();
         if (!onError)
             throw error;
@@ -53,4 +59,25 @@ export async function withQuotaReservation(opts, body, onError) {
         return { status: 'failed', error };
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Reserve one quota slot, run `body`, and settle the slot by ONE rule:
+ * keep it once the resource was consumed; refund it if the body fails first.
+ *
+ * - Denied → `{ status: 'denied' }` (answered on `res` when given); `body` never runs.
+ * - `body` resolves → the slot is kept (unless `body` called `slot.refund()`
+ *   BEFORE marking it consumed — a refund after `markConsumed()` is ignored).
+ * - `body` throws → refunded unless consumed — marked via `slot.markConsumed()`
+ *   or signalled by the error itself carrying `providerContacted === true`
+ *   (an AI round-trip that completed but produced nothing usable). The error is
+ *   then passed to `onError`, or rethrown when there is none.
+ *
+ * The reserve and refund authenticate with a minted service token, never the
+ * end-user bearer: the quota increment endpoint rejects user principals.
+ */
+export async function withQuotaReservation(opts, body, onError) {
+    const reserved = await reserveQuotaSlot(opts);
+    if (reserved.status === 'denied')
+        return reserved;
+    return runWithSlot(reserved.slot, body, onError);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota-reservation.js","sourceRoot":"","sources":["../../src/api/quota-reservation.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,YAAY,EACZ,sBAAsB,EACtB,eAAe,GAKhB,MAAM,4BAA4B,CAAC;AAqDpC;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,IAA6B;IAClE,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC;IACjE,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC;IAChC,MAAM,WAAW,GAAG,oBAAoB,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,IAAI,eAAe,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;IAExH,2EAA2E;IAC3E,uEAAuE;IACvE,oDAAoD;IACpD,MAAM,WAAW,GAAG,MAAM,YAAY,CAAC,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;IACpG,IAAI,WAAW,CAAC,QAAQ,EAAE,CAAC;QACzB,IAAI,IAAI,CAAC,GAAG;YAAE,sBAAsB,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;QAClE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;IAC3C,CAAC;IAED,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,MAAM,IAAI,GAAc;QACtB,WAAW;QACX,WAAW;QACX,YAAY,EAAE,GAAG,EAAE,GAAG,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC;QACxC,MAAM,EAAE,GAAG,EAAE;YACX,IAAI,QAAQ,IAAI,QAAQ;gBAAE,OAAO;YACjC,QAAQ,GAAG,IAAI,CAAC;YAChB,0EAA0E;YAC1E,cAAc,CAAC,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,KAAK,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QAClH,CAAC;KACF,CAAC;IACF,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;AACtC,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,IAAO,EACP,IAA6B,EAC7B,OAAkD;IAElD,IAAI,CAAC;QACH,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;IACrD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,kEAAkE;QAClE,MAAM,iBAAiB,GAAI,KAAgD,EAAE,iBAAiB,KAAK,IAAI,CAAC;QACxG,IAAI,CAAC,iBAAiB;YAAE,IAAI,CAAC,MAAM,EAAE,CAAC;QACtC,IAAI,CAAC,OAAO;YAAE,MAAM,KAAK,CAAC;QAC1B,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC;QACrB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;IACrC,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,IAA6B,EAC7B,IAAqC,EACrC,OAAkD;IAElD,MAAM,QAAQ,GAAG,MAAM,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAC9C,IAAI,QAAQ,CAAC,MAAM,KAAK,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAClD,OAAO,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AACnD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  decrementQuota,\n  getServiceAuthHeader,\n  reserveQuota,\n  sendQuotaReserveDenied,\n  serviceIdentity,\n  type QuotaReserveResult,\n  type QuotaService,\n  type QuotaType,\n  type QuotaUsageAttribution,\n} from '@pipeline-builder/api-core';\nimport type { Response } from 'express';\n\n/** The reserved quota slot, handed to the guarded body. */\nexport interface QuotaSlot {\n  /** Minted service token the reservation used — reuse it for the body's own S2S calls. */\n  readonly serviceAuth: string;\n  readonly reservation: QuotaReserveResult;\n  /**\n   * The reserved resource has been consumed (e.g. the AI provider started\n   * responding). From here on a failure KEEPS the slot — the cost was incurred.\n   */\n  markConsumed(): void;\n  /**\n   * Give the slot back now. Idempotent: refunds at most once — and a NO-OP once\n   * {@link markConsumed} was called. A paid provider round-trip is never refunded,\n   * whatever path (a client abort, a later failure, an empty answer) asks for it\n   * afterwards; callers no longer need to guard `refund()` with their own\n   * \"was the provider contacted\" flag.\n   */\n  refund(): void;\n}\n\nexport interface QuotaReservationOptions {\n  quotaService: QuotaService;\n  orgId: string;\n  type: QuotaType;\n  /** Units to reserve (default 1) — e.g. an AI model's weight. Refunds give back the same amount. */\n  amount?: number;\n  /**\n   * Usage-ledger attribution for the reserve AND its refund. Defaults to the\n   * ambient request context (principal + request id, no route) — pass it\n   * explicitly to record the route, the feature and the model.\n   */\n  attribution?: QuotaUsageAttribution;\n  /** Signer of the quota service token. Defaults to this process (`SERVICE_NAME`). */\n  serviceName?: string;\n  logWarn: (message: string, data?: unknown) => void;\n  /** When set, a denied reservation is answered on it (429, or 503 when unconfirmable). */\n  res?: Response;\n}\n\nexport type QuotaReservationOutcome<T> =\n  | { status: 'denied'; reservation: QuotaReserveResult }\n  | { status: 'done'; value: T }\n  /** Only with an `onError` handler: the body threw and the handler answered. */\n  | { status: 'failed'; error: unknown };\n\n/** What {@link reserveQuotaSlot} hands back: a live slot, or the denial. */\nexport type QuotaSlotReservation =\n  | { status: 'denied'; reservation: QuotaReserveResult }\n  | { status: 'reserved'; slot: QuotaSlot };\n\n/**\n * Reserve one slot (of `amount` units) and return its handle, WITHOUT running\n * anything. The primitive under {@link withQuotaReservation}, for a caller whose\n * gated work does not fit one callback — e.g. a tool inside an agent turn that\n * settles its own slot. The caller owns settlement: `markConsumed()` once the\n * resource is spent, `refund()` on every path that fails before that.\n *\n * Denied → `{ status: 'denied' }`, answered on `res` when given.\n */\nexport async function reserveQuotaSlot(opts: QuotaReservationOptions): Promise<QuotaSlotReservation> {\n  const { quotaService, orgId, type, logWarn, attribution } = opts;\n  const amount = opts.amount ?? 1;\n  const serviceAuth = getServiceAuthHeader({ serviceName: opts.serviceName ?? serviceIdentity(), orgId, role: 'member' });\n\n  // Reserve atomically BEFORE any work: two concurrent requests at the limit\n  // can't both pass. Attribution defaults to the ambient request context\n  // (principal + request id) inside the quota client.\n  const reservation = await reserveQuota(quotaService, orgId, type, serviceAuth, amount, attribution);\n  if (reservation.exceeded) {\n    if (opts.res) sendQuotaReserveDenied(opts.res, type, reservation);\n    return { status: 'denied', reservation };\n  }\n\n  let consumed = false;\n  let refunded = false;\n  const slot: QuotaSlot = {\n    serviceAuth,\n    reservation,\n    markConsumed: () => { consumed = true; },\n    refund: () => {\n      if (refunded || consumed) return;\n      refunded = true;\n      // The reserved resetAt keeps a period rollover from being double-charged.\n      decrementQuota(quotaService, orgId, type, serviceAuth, logWarn, amount, reservation.quota.resetAt, attribution);\n    },\n  };\n  return { status: 'reserved', slot };\n}\n\n/**\n * Run `body` against a reserved slot and settle it by ONE rule: keep it once\n * the resource was consumed; refund it if the body fails first. Shared by\n * {@link withQuotaReservation} and api-server's AI reservation.\n */\nexport async function runWithSlot<T, S extends QuotaSlot>(\n  slot: S,\n  body: (slot: S) => Promise<T>,\n  onError?: (error: unknown) => void | Promise<void>,\n): Promise<QuotaReservationOutcome<T>> {\n  try {\n    return { status: 'done', value: await body(slot) };\n  } catch (error) {\n    // `refund()` is itself a no-op once the slot was marked consumed.\n    const errorSaysConsumed = (error as { providerContacted?: unknown } | null)?.providerContacted === true;\n    if (!errorSaysConsumed) slot.refund();\n    if (!onError) throw error;\n    await onError(error);\n    return { status: 'failed', error };\n  }\n}\n\n/**\n * Reserve one quota slot, run `body`, and settle the slot by ONE rule:\n * keep it once the resource was consumed; refund it if the body fails first.\n *\n * - Denied → `{ status: 'denied' }` (answered on `res` when given); `body` never runs.\n * - `body` resolves → the slot is kept (unless `body` called `slot.refund()`\n *   BEFORE marking it consumed — a refund after `markConsumed()` is ignored).\n * - `body` throws → refunded unless consumed — marked via `slot.markConsumed()`\n *   or signalled by the error itself carrying `providerContacted === true`\n *   (an AI round-trip that completed but produced nothing usable). The error is\n *   then passed to `onError`, or rethrown when there is none.\n *\n * The reserve and refund authenticate with a minted service token, never the\n * end-user bearer: the quota increment endpoint rejects user principals.\n */\nexport async function withQuotaReservation<T>(\n  opts: QuotaReservationOptions,\n  body: (slot: QuotaSlot) => Promise<T>,\n  onError?: (error: unknown) => void | Promise<void>,\n): Promise<QuotaReservationOutcome<T>> {\n  const reserved = await reserveQuotaSlot(opts);\n  if (reserved.status === 'denied') return reserved;\n  return runWithSlot(reserved.slot, body, onError);\n}\n"]}