@pipeline-builder/api-server 4.4.3 → 4.4.4

package/lib/api/metrics.js

@@ -293,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. */
@@ -345,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) {
     // `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/**\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}\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}\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\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"]}
+//# 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVvdGEtcmVzZXJ2YXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXBpL3F1b3RhLXJlc2VydmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7QUFFdEMsT0FBTyxFQUNMLGNBQWMsRUFDZCxvQkFBb0IsRUFDcEIsWUFBWSxFQUNaLHNCQUFzQixFQUN0QixlQUFlLEdBSWhCLE1BQU0sNEJBQTRCLENBQUM7QUFrQ3BDOzs7Ozs7Ozs7Ozs7O0dBYUc7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLG9CQUFvQixDQUN4QyxJQUE2QixFQUM3QixJQUFxQyxFQUNyQyxPQUFrRDtJQUVsRCxNQUFNLEVBQUUsWUFBWSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLEdBQUcsSUFBSSxDQUFDO0lBQ3BELE1BQU0sV0FBVyxHQUFHLG9CQUFvQixDQUFDLEVBQUUsV0FBVyxFQUFFLElBQUksQ0FBQyxXQUFXLElBQUksZUFBZSxFQUFFLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsQ0FBQyxDQUFDO0lBRXhILDJFQUEyRTtJQUMzRSxtQkFBbUI7SUFDbkIsTUFBTSxXQUFXLEdBQUcsTUFBTSxZQUFZLENBQUMsWUFBWSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsV0FBVyxDQUFDLENBQUM7SUFDL0UsSUFBSSxXQUFXLENBQUMsUUFBUSxFQUFFLENBQUM7UUFDekIsSUFBSSxJQUFJLENBQUMsR0FBRztZQUFFLHNCQUFzQixDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsSUFBSSxFQUFFLFdBQVcsQ0FBQyxDQUFDO1FBQ2xFLE9BQU8sRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLFdBQVcsRUFBRSxDQUFDO0lBQzNDLENBQUM7SUFFRCxJQUFJLFFBQVEsR0FBRyxLQUFLLENBQUM7SUFDckIsSUFBSSxRQUFRLEdBQUcsS0FBSyxDQUFDO0lBQ3JCLE1BQU0sSUFBSSxHQUFjO1FBQ3RCLFdBQVc7UUFDWCxXQUFXO1FBQ1gsWUFBWSxFQUFFLEdBQUcsRUFBRSxHQUFHLFFBQVEsR0FBRyxJQUFJLENBQUMsQ0FBQyxDQUFDO1FBQ3hDLE1BQU0sRUFBRSxHQUFHLEVBQUU7WUFDWCxJQUFJLFFBQVE7Z0JBQUUsT0FBTztZQUNyQixRQUFRLEdBQUcsSUFBSSxDQUFDO1lBQ2hCLDBFQUEwRTtZQUMxRSxjQUFjLENBQUMsWUFBWSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsV0FBVyxFQUFFLE9BQU8sRUFBRSxDQUFDLEVBQUUsV0FBVyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNoRyxDQUFDO0tBQ0YsQ0FBQztJQUVGLElBQUksQ0FBQztRQUNILE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDO0lBQ3JELENBQUM7SUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1FBQ2YsTUFBTSxpQkFBaUIsR0FBSSxLQUFnRCxFQUFFLGlCQUFpQixLQUFLLElBQUksQ0FBQztRQUN4RyxJQUFJLENBQUMsUUFBUSxJQUFJLENBQUMsaUJBQWlCO1lBQUUsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ25ELElBQUksQ0FBQyxPQUFPO1lBQUUsTUFBTSxLQUFLLENBQUM7UUFDMUIsTUFBTSxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDckIsT0FBTyxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLENBQUM7SUFDckMsQ0FBQztBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuaW1wb3J0IHtcbiAgZGVjcmVtZW50UXVvdGEsXG4gIGdldFNlcnZpY2VBdXRoSGVhZGVyLFxuICByZXNlcnZlUXVvdGEsXG4gIHNlbmRRdW90YVJlc2VydmVEZW5pZWQsXG4gIHNlcnZpY2VJZGVudGl0eSxcbiAgdHlwZSBRdW90YVJlc2VydmVSZXN1bHQsXG4gIHR5cGUgUXVvdGFTZXJ2aWNlLFxuICB0eXBlIFF1b3RhVHlwZSxcbn0gZnJvbSAnQHBpcGVsaW5lLWJ1aWxkZXIvYXBpLWNvcmUnO1xuaW1wb3J0IHR5cGUgeyBSZXNwb25zZSB9IGZyb20gJ2V4cHJlc3MnO1xuXG4vKiogVGhlIHJlc2VydmVkIHF1b3RhIHNsb3QsIGhhbmRlZCB0byB0aGUgZ3VhcmRlZCBib2R5LiAqL1xuZXhwb3J0IGludGVyZmFjZSBRdW90YVNsb3Qge1xuICAvKiogTWludGVkIHNlcnZpY2UgdG9rZW4gdGhlIHJlc2VydmF0aW9uIHVzZWQg4oCUIHJldXNlIGl0IGZvciB0aGUgYm9keSdzIG93biBTMlMgY2FsbHMuICovXG4gIHJlYWRvbmx5IHNlcnZpY2VBdXRoOiBzdHJpbmc7XG4gIHJlYWRvbmx5IHJlc2VydmF0aW9uOiBRdW90YVJlc2VydmVSZXN1bHQ7XG4gIC8qKlxuICAgKiBUaGUgcmVzZXJ2ZWQgcmVzb3VyY2UgaGFzIGJlZW4gY29uc3VtZWQgKGUuZy4gdGhlIEFJIHByb3ZpZGVyIHN0YXJ0ZWRcbiAgICogcmVzcG9uZGluZykuIEZyb20gaGVyZSBvbiBhIGZhaWx1cmUgS0VFUFMgdGhlIHNsb3Qg4oCUIHRoZSBjb3N0IHdhcyBpbmN1cnJlZC5cbiAgICovXG4gIG1hcmtDb25zdW1lZCgpOiB2b2lkO1xuICAvKiogR2l2ZSB0aGUgc2xvdCBiYWNrIG5vdy4gSWRlbXBvdGVudDogcmVmdW5kcyBhdCBtb3N0IG9uY2UuICovXG4gIHJlZnVuZCgpOiB2b2lkO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFF1b3RhUmVzZXJ2YXRpb25PcHRpb25zIHtcbiAgcXVvdGFTZXJ2aWNlOiBRdW90YVNlcnZpY2U7XG4gIG9yZ0lkOiBzdHJpbmc7XG4gIHR5cGU6IFF1b3RhVHlwZTtcbiAgLyoqIFNpZ25lciBvZiB0aGUgcXVvdGEgc2VydmljZSB0b2tlbi4gRGVmYXVsdHMgdG8gdGhpcyBwcm9jZXNzIChgU0VSVklDRV9OQU1FYCkuICovXG4gIHNlcnZpY2VOYW1lPzogc3RyaW5nO1xuICBsb2dXYXJuOiAobWVzc2FnZTogc3RyaW5nLCBkYXRhPzogdW5rbm93bikgPT4gdm9pZDtcbiAgLyoqIFdoZW4gc2V0LCBhIGRlbmllZCByZXNlcnZhdGlvbiBpcyBhbnN3ZXJlZCBvbiBpdCAoNDI5LCBvciA1MDMgd2hlbiB1bmNvbmZpcm1hYmxlKS4gKi9cbiAgcmVzPzogUmVzcG9uc2U7XG59XG5cbmV4cG9ydCB0eXBlIFF1b3RhUmVzZXJ2YXRpb25PdXRjb21lPFQ+ID1cbiAgfCB7IHN0YXR1czogJ2RlbmllZCc7IHJlc2VydmF0aW9uOiBRdW90YVJlc2VydmVSZXN1bHQgfVxuICB8IHsgc3RhdHVzOiAnZG9uZSc7IHZhbHVlOiBUIH1cbiAgLyoqIE9ubHkgd2l0aCBhbiBgb25FcnJvcmAgaGFuZGxlcjogdGhlIGJvZHkgdGhyZXcgYW5kIHRoZSBoYW5kbGVyIGFuc3dlcmVkLiAqL1xuICB8IHsgc3RhdHVzOiAnZmFpbGVkJzsgZXJyb3I6IHVua25vd24gfTtcblxuLyoqXG4gKiBSZXNlcnZlIG9uZSBxdW90YSBzbG90LCBydW4gYGJvZHlgLCBhbmQgc2V0dGxlIHRoZSBzbG90IGJ5IE9ORSBydWxlOlxuICoga2VlcCBpdCBvbmNlIHRoZSByZXNvdXJjZSB3YXMgY29uc3VtZWQ7IHJlZnVuZCBpdCBpZiB0aGUgYm9keSBmYWlscyBmaXJzdC5cbiAqXG4gKiAtIERlbmllZCDihpIgYHsgc3RhdHVzOiAnZGVuaWVkJyB9YCAoYW5zd2VyZWQgb24gYHJlc2Agd2hlbiBnaXZlbik7IGBib2R5YCBuZXZlciBydW5zLlxuICogLSBgYm9keWAgcmVzb2x2ZXMg4oaSIHRoZSBzbG90IGlzIGtlcHQgKHVubGVzcyBgYm9keWAgY2FsbGVkIGBzbG90LnJlZnVuZCgpYCkuXG4gKiAtIGBib2R5YCB0aHJvd3Mg4oaSIHJlZnVuZGVkIHVubGVzcyBjb25zdW1lZCDigJQgbWFya2VkIHZpYSBgc2xvdC5tYXJrQ29uc3VtZWQoKWBcbiAqICAgb3Igc2lnbmFsbGVkIGJ5IHRoZSBlcnJvciBpdHNlbGYgY2FycnlpbmcgYHByb3ZpZGVyQ29udGFjdGVkID09PSB0cnVlYFxuICogICAoYW4gQUkgcm91bmQtdHJpcCB0aGF0IGNvbXBsZXRlZCBidXQgcHJvZHVjZWQgbm90aGluZyB1c2FibGUpLiBUaGUgZXJyb3IgaXNcbiAqICAgdGhlbiBwYXNzZWQgdG8gYG9uRXJyb3JgLCBvciByZXRocm93biB3aGVuIHRoZXJlIGlzIG5vbmUuXG4gKlxuICogVGhlIHJlc2VydmUgYW5kIHJlZnVuZCBhdXRoZW50aWNhdGUgd2l0aCBhIG1pbnRlZCBzZXJ2aWNlIHRva2VuLCBuZXZlciB0aGVcbiAqIGVuZC11c2VyIGJlYXJlcjogdGhlIHF1b3RhIGluY3JlbWVudCBlbmRwb2ludCByZWplY3RzIHVzZXIgcHJpbmNpcGFscy5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHdpdGhRdW90YVJlc2VydmF0aW9uPFQ+KFxuICBvcHRzOiBRdW90YVJlc2VydmF0aW9uT3B0aW9ucyxcbiAgYm9keTogKHNsb3Q6IFF1b3RhU2xvdCkgPT4gUHJvbWlzZTxUPixcbiAgb25FcnJvcj86IChlcnJvcjogdW5rbm93bikgPT4gdm9pZCB8IFByb21pc2U8dm9pZD4sXG4pOiBQcm9taXNlPFF1b3RhUmVzZXJ2YXRpb25PdXRjb21lPFQ+PiB7XG4gIGNvbnN0IHsgcXVvdGFTZXJ2aWNlLCBvcmdJZCwgdHlwZSwgbG9nV2FybiB9ID0gb3B0cztcbiAgY29uc3Qgc2VydmljZUF1dGggPSBnZXRTZXJ2aWNlQXV0aEhlYWRlcih7IHNlcnZpY2VOYW1lOiBvcHRzLnNlcnZpY2VOYW1lID8/IHNlcnZpY2VJZGVudGl0eSgpLCBvcmdJZCwgcm9sZTogJ21lbWJlcicgfSk7XG5cbiAgLy8gUmVzZXJ2ZSBhdG9taWNhbGx5IEJFRk9SRSBhbnkgd29yazogdHdvIGNvbmN1cnJlbnQgcmVxdWVzdHMgYXQgdGhlIGxpbWl0XG4gIC8vIGNhbid0IGJvdGggcGFzcy5cbiAgY29uc3QgcmVzZXJ2YXRpb24gPSBhd2FpdCByZXNlcnZlUXVvdGEocXVvdGFTZXJ2aWNlLCBvcmdJZCwgdHlwZSwgc2VydmljZUF1dGgpO1xuICBpZiAocmVzZXJ2YXRpb24uZXhjZWVkZWQpIHtcbiAgICBpZiAob3B0cy5yZXMpIHNlbmRRdW90YVJlc2VydmVEZW5pZWQob3B0cy5yZXMsIHR5cGUsIHJlc2VydmF0aW9uKTtcbiAgICByZXR1cm4geyBzdGF0dXM6ICdkZW5pZWQnLCByZXNlcnZhdGlvbiB9O1xuICB9XG5cbiAgbGV0IGNvbnN1bWVkID0gZmFsc2U7XG4gIGxldCByZWZ1bmRlZCA9IGZhbHNlO1xuICBjb25zdCBzbG90OiBRdW90YVNsb3QgPSB7XG4gICAgc2VydmljZUF1dGgsXG4gICAgcmVzZXJ2YXRpb24sXG4gICAgbWFya0NvbnN1bWVkOiAoKSA9PiB7IGNvbnN1bWVkID0gdHJ1ZTsgfSxcbiAgICByZWZ1bmQ6ICgpID0+IHtcbiAgICAgIGlmIChyZWZ1bmRlZCkgcmV0dXJuO1xuICAgICAgcmVmdW5kZWQgPSB0cnVlO1xuICAgICAgLy8gVGhlIHJlc2VydmVkIHJlc2V0QXQga2VlcHMgYSBwZXJpb2Qgcm9sbG92ZXIgZnJvbSBiZWluZyBkb3VibGUtY2hhcmdlZC5cbiAgICAgIGRlY3JlbWVudFF1b3RhKHF1b3RhU2VydmljZSwgb3JnSWQsIHR5cGUsIHNlcnZpY2VBdXRoLCBsb2dXYXJuLCAxLCByZXNlcnZhdGlvbi5xdW90YS5yZXNldEF0KTtcbiAgICB9LFxuICB9O1xuXG4gIHRyeSB7XG4gICAgcmV0dXJuIHsgc3RhdHVzOiAnZG9uZScsIHZhbHVlOiBhd2FpdCBib2R5KHNsb3QpIH07XG4gIH0gY2F0Y2ggKGVycm9yKSB7XG4gICAgY29uc3QgZXJyb3JTYXlzQ29uc3VtZWQgPSAoZXJyb3IgYXMgeyBwcm92aWRlckNvbnRhY3RlZD86IHVua25vd24gfSB8IG51bGwpPy5wcm92aWRlckNvbnRhY3RlZCA9PT0gdHJ1ZTtcbiAgICBpZiAoIWNvbnN1bWVkICYmICFlcnJvclNheXNDb25zdW1lZCkgc2xvdC5yZWZ1bmQoKTtcbiAgICBpZiAoIW9uRXJyb3IpIHRocm93IGVycm9yO1xuICAgIGF3YWl0IG9uRXJyb3IoZXJyb3IpO1xuICAgIHJldHVybiB7IHN0YXR1czogJ2ZhaWxlZCcsIGVycm9yIH07XG4gIH1cbn1cbiJdfQ==
+/**
+ * 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"]}

package/lib/api/server.js

@@ -1,7 +1,7 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { Server } from 'http';
-import { buildRouteTable, createLogger, errorMessage, installCrashHandlers, nextBackoffMs, resolveRedisConnection, retryForever, summarizeRouteTable, sleep, envInt } from '@pipeline-builder/api-core';
+import { buildRouteTable, createLogger, errorMessage, flushQuotaIncrements, installCrashHandlers, nextBackoffMs, resolveRedisConnection, retryForever, summarizeRouteTable, sleep, envInt } from '@pipeline-builder/api-core';
 import { Config } from '@pipeline-builder/pipeline-core';
 import { getConnection, closeConnection } from '@pipeline-builder/pipeline-data';
 import { setReady, isReady } from './readiness.js';
@@ -192,6 +192,9 @@ export async function startServer(app, options = {}) {
         // Close HTTP server
         server.close(async () => {
             logger.info('HTTP server closed');
+            // Every in-flight request has now finished and buffered its metering unit;
+            // send them before exiting (api-core quota-increment-batcher). Never rejects.
+            await flushQuotaIncrements();
             // Shutdown OpenTelemetry tracing
             await shutdownTracing().catch(err => logger.error('Error shutting down tracing', { error: err }));
             // Close database connection
@@ -258,4 +261,4 @@ export function runServer(app, options = {}) {
         process.exit(1);
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/api/server.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Server } from 'http';\nimport { buildRouteTable, createLogger, errorMessage, installCrashHandlers, nextBackoffMs, resolveRedisConnection, retryForever, summarizeRouteTable, sleep, envInt } from '@pipeline-builder/api-core';\nimport { Config } from '@pipeline-builder/pipeline-core';\nimport { getConnection, closeConnection } from '@pipeline-builder/pipeline-data';\nimport type { Express } from 'express';\nimport { setReady, isReady } from './readiness.js';\nimport { shutdownTracing } from './tracing.js';\nimport { SSEManager } from '../http/sse-connection-manager.js';\n\nconst logger = createLogger('server');\n\n\n// Dependency-supervisor cadence. Initial connect retries with capped backoff;\n// once connected, re-checks at a steady interval so a later outage flips the\n// service NotReady (draining traffic) and a recovery flips it back — without\n// ever exiting / restarting the process.\nconst READY_RETRY_BASE_MS = 1000;\nconst READY_RETRY_MAX_MS = 10000;\nconst READY_MONITOR_INTERVAL_MS = envInt('READINESS_MONITOR_INTERVAL_MS', 15_000, { min: 1 });\n\n/**\n * Establish and continuously monitor the service's datastore dependency,\n * flipping readiness state instead of crash-looping.\n *\n * - Establish phase: retry `onBeforeStart` (e.g. connectMongo) with capped\n *   backoff until it succeeds — a cold datastore must never exit the process.\n * - Monitor phase: poll `testDatabase` for the life of the process; flip\n *   ready/NotReady on transitions. While NotReady the readiness guard 503s\n *   business traffic and orchestrator readiness probes drain the instance.\n *\n * Runs in the background (the HTTP server is already listening). Stops when\n * `aborted()` returns true (graceful shutdown), so it never keeps a closing\n * process alive.\n */\nasync function superviseDependencies(\n  name: string,\n  onBeforeStart: (() => Promise<void>) | undefined,\n  testDatabase: (() => Promise<boolean>) | false | undefined,\n  aborted: () => boolean,\n): Promise<void> {\n  if (onBeforeStart) {\n    await retryForever(onBeforeStart, {\n      baseMs: READY_RETRY_BASE_MS,\n      maxMs: READY_RETRY_MAX_MS,\n      onAttemptFailed: (error, delayMs) => logger.warn(\n        `${name}: dependency init failed, retrying in ${delayMs}ms`,\n        { error: errorMessage(error) },\n      ),\n      shouldContinue: () => !aborted(),\n    });\n  }\n\n  // No datastore to gate on → ready as soon as we are listening.\n  if (testDatabase === false) {\n    if (aborted()) return; // shutdown began while we were initializing\n    setReady(true);\n    logger.info(`${name} ready (no datastore dependency)`);\n    return;\n  }\n\n  const probe = testDatabase ?? (() => getConnection().testConnection());\n  let waitDelay = READY_RETRY_BASE_MS;\n  while (!aborted()) {\n    let ok = false;\n    try {\n      ok = await probe();\n    } catch {\n      ok = false;\n    }\n\n    // A probe that was in flight when shutdown began must not flip the\n    // draining instance back to ready.\n    if (aborted()) break;\n    if (ok && !isReady()) {\n      setReady(true);\n      waitDelay = READY_RETRY_BASE_MS;\n      logger.info(`${name} ready — dependencies connected`);\n    } else if (!ok && isReady()) {\n      setReady(false);\n      logger.warn(`${name} degraded — dependency check failing (now NotReady)`);\n    }\n\n    // Steady cadence once ready; faster backoff while waiting so we flip to\n    // ready promptly when the datastore comes up.\n    if (isReady()) {\n      await sleep(READY_MONITOR_INTERVAL_MS);\n    } else {\n      await sleep(waitDelay);\n      waitDelay = nextBackoffMs(waitDelay, READY_RETRY_MAX_MS);\n    }\n  }\n}\n\n/**\n * Options for starting a server\n */\nexport interface StartServerOptions {\n  /** Service name for logging */\n  name?: string;\n  /** Port to listen on (default: from config) */\n  port?: number;\n  /** SSE manager for graceful shutdown */\n  sseManager?: SSEManager;\n  /** Shutdown timeout in milliseconds (default: 15000) */\n  shutdownTimeoutMs?: number;\n  /** Callback after server starts */\n  onStart?: (port: number) => void;\n  /** Callback before shutdown */\n  onShutdown?: () => Promise<void>;\n  /** Runs before database check (e.g., initialize external connections) */\n  onBeforeStart?: () => Promise<void>;\n  /** Custom database health check, or false to skip. Default: PostgreSQL testConnection */\n  testDatabase?: (() => Promise<boolean>) | false;\n  /** Custom database close, or false to skip. Default: PostgreSQL closeConnection */\n  closeDatabase?: (() => Promise<void>) | false;\n}\n\n/**\n * Result of starting a server\n */\nexport interface StartServerResult {\n  /** HTTP server instance */\n  server: Server;\n  /** Port the server is listening on */\n  port: number;\n  /** Function to manually trigger shutdown */\n  shutdown: () => Promise<void>;\n}\n\n/**\n * Start an Express server with graceful shutdown handling\n *\n * Features:\n * - Automatic database connection testing\n * - Graceful shutdown on SIGINT/SIGTERM\n * - SSE connection cleanup\n * - Configurable shutdown timeout\n *\n * @param app - Express application\n * @param options - Server options\n * @returns Server instance and control functions\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n *\n * app.post('/api/resource', requireAuth, handler);\n *\n * await startServer(app, {\n *   name: 'My Microservice',\n *   sseManager,\n *   onStart: (port) => console.log(`Listening on ${port}`),\n * });\n * ```\n */\nexport async function startServer(\n  app: Express,\n  options: StartServerOptions = {},\n): Promise<StartServerResult> {\n  const serverConfig = Config.get('server');\n  const {\n    name = 'Microservice',\n    sseManager,\n    shutdownTimeoutMs = 15000,\n    onStart,\n    onShutdown,\n    onBeforeStart,\n    testDatabase,\n    closeDatabase,\n  } = options;\n  const port = options.port ?? serverConfig.port;\n\n  // Validate auth configuration at server startup (not during CDK synthesis)\n  Config.validateAuth();\n  // Fail fast if this service has no internal signing key of its own, or no\n  // public bundle to verify its peers with. Without them it would mint\n  // tokens on an EPHEMERAL in-process key that no peer accepts, and reject every\n  // peer's token — i.e. silently lose all service-to-service traffic. Checked\n  // HERE rather than in `createApp` because it is a property of the running\n  // deployment, not of the app object: route-table builders and test suites\n  // assemble an app without ever signing anything.\n  for (const envVar of ['SERVICE_SIGNING_KEY_FILE', 'SERVICE_KEY_BUNDLE_FILE'] as const) {\n    if (!process.env[envVar]) {\n      throw new Error(`${envVar} environment variable is required (generate with deploy/bin/service-signing-keys.sh). Set it before starting the server.`);\n    }\n  }\n  // Fail fast on an unusable Redis configuration (throws RedisConfigError) — a\n  // Redis client is created lazily on first use, so without this a bad config\n  // would surface as request-time errors instead of a failed start.\n  resolveRedisConnection();\n\n  logger.info(`Starting ${name}...`);\n\n  // Mark NotReady synchronously, BEFORE the port opens, so no request slips\n  // through the readiness guard before the supervisor has run. The supervisor\n  // flips it true once dependencies connect.\n  setReady(false);\n\n  // Listen FIRST, then establish + monitor the datastore in the background,\n  // reporting NotReady until it connects. Testing the DB before listen and\n  // exiting on failure crash-loops the whole fleet during a cold-DB stampede:\n  // the process never opens its port, so /health (liveness), /ready and the\n  // readiness guard can't answer and the orchestrator only sees a dead pod.\n  // Opening the port first makes \"dependency down\" an observable state.\n  const server = app.listen(port, () => {\n    logger.info(`${name} listening on port: ${port}`);\n    logger.info(`Platform URL: ${serverConfig.platformUrl}`);\n    onStart?.(port);\n  });\n\n  // Shutdown handler (guarded against concurrent signals)\n  let shuttingDown = false;\n\n  // Background dependency supervisor — established + monitored after listen,\n  // stopped on shutdown so it never keeps a closing process alive. Guard the\n  // floating promise: every expected failure is handled inside, so a rejection\n  // here means a programming error — log it and leave the service NotReady\n  // rather than letting it become an unhandledRejection that crash-exits the\n  // process (which would defeat the whole \"never exit on dependency trouble\"\n  // goal).\n  superviseDependencies(name, onBeforeStart, testDatabase, () => shuttingDown).catch((error) => {\n    logger.error('Dependency supervisor crashed; service will remain NotReady', { error: errorMessage(error) });\n  });\n\n  const shutdown = async (signal?: string) => {\n    if (shuttingDown) return;\n    shuttingDown = true;\n\n    // Drain FIRST: report NotReady before anything else, so the load balancer /\n    // readiness probe stops sending new work while the rest of shutdown runs.\n    // `onShutdown` can take seconds; readiness left green across it keeps new\n    // requests arriving at a process that is already tearing itself down.\n    setReady(false);\n\n    if (signal) {\n      logger.info(`${signal} received, shutting down gracefully...`);\n    }\n\n    // Arm the force-exit BEFORE awaiting anything: a hung onShutdown (a stuck\n    // queue close, a Redis quit that never answers) would otherwise block forever\n    // with the timer never started, so the pod would ignore SIGTERM until SIGKILL.\n    setTimeout(() => {\n      logger.error('Forced shutdown after timeout');\n      process.exit(1);\n    }, shutdownTimeoutMs).unref();\n\n    // Custom shutdown callback\n    if (onShutdown) {\n      try {\n        await onShutdown();\n      } catch (error) {\n        logger.error('Error in onShutdown callback', { error });\n      }\n    }\n\n    // Close SSE connections\n    if (sseManager) {\n      sseManager.shutdown();\n      logger.info('SSE connections closed');\n    }\n\n    // Close HTTP server\n    server.close(async () => {\n      logger.info('HTTP server closed');\n\n      // Shutdown OpenTelemetry tracing\n      await shutdownTracing().catch(err => logger.error('Error shutting down tracing', { error: err }));\n\n      // Close database connection\n      if (closeDatabase !== false) {\n        try {\n          if (closeDatabase) {\n            await closeDatabase();\n          } else {\n            await closeConnection();\n          }\n          logger.info('Database connection closed');\n        } catch (error) {\n          logger.error('Error closing database', { error });\n        }\n      }\n\n      process.exit(0);\n    });\n  };\n\n  // Register signal handlers\n  process.once('SIGINT', () => void shutdown('SIGINT'));\n  process.once('SIGTERM', () => void shutdown('SIGTERM'));\n\n  return {\n    server,\n    port,\n    shutdown: () => shutdown(),\n  };\n}\n\n/**\n * Simple server start wrapper with error handling\n *\n * @param app - Express application\n * @param options - Server options\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n * app.post('/api/resource', handler);\n *\n * void runServer(app, { name: 'My Service', sseManager });\n * ```\n */\nexport function runServer(app: Express, options: StartServerOptions = {}): void {\n  // Route table of the fully assembled app (see api-core's route-table.ts): the\n  // same introspection the per-service coverage test asserts on, logged once at\n  // boot so an ungated or unaudited write route is visible in the running\n  // service, not only in CI.\n  logger.info('Route table built', summarizeRouteTable(buildRouteTable(app)));\n\n  // Last-resort fault handlers for the production entrypoint: an unhandled\n  // rejection / uncaught exception is logged (not silently fatal) then the\n  // process exits for the orchestrator to restart. No-op under NODE_ENV=test.\n  installCrashHandlers(logger);\n  startServer(app, options).catch((error) => {\n    // startServer now listens-first and supervises the DB in the background, so\n    // it only rejects on a genuinely fatal SETUP error (invalid auth config, a\n    // failed onStart, the port already in use). Log message + stack explicitly:\n    // an Error in winston metadata serializes to `{}` (message/stack are\n    // non-enumerable), which would otherwise hide the cause behind `{error:{}}`.\n    logger.error('Failed to start server', {\n      error: errorMessage(error),\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n    process.exit(1);\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/api/server.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Server } from 'http';\nimport { buildRouteTable, createLogger, errorMessage, flushQuotaIncrements, installCrashHandlers, nextBackoffMs, resolveRedisConnection, retryForever, summarizeRouteTable, sleep, envInt } from '@pipeline-builder/api-core';\nimport { Config } from '@pipeline-builder/pipeline-core';\nimport { getConnection, closeConnection } from '@pipeline-builder/pipeline-data';\nimport type { Express } from 'express';\nimport { setReady, isReady } from './readiness.js';\nimport { shutdownTracing } from './tracing.js';\nimport { SSEManager } from '../http/sse-connection-manager.js';\n\nconst logger = createLogger('server');\n\n\n// Dependency-supervisor cadence. Initial connect retries with capped backoff;\n// once connected, re-checks at a steady interval so a later outage flips the\n// service NotReady (draining traffic) and a recovery flips it back — without\n// ever exiting / restarting the process.\nconst READY_RETRY_BASE_MS = 1000;\nconst READY_RETRY_MAX_MS = 10000;\nconst READY_MONITOR_INTERVAL_MS = envInt('READINESS_MONITOR_INTERVAL_MS', 15_000, { min: 1 });\n\n/**\n * Establish and continuously monitor the service's datastore dependency,\n * flipping readiness state instead of crash-looping.\n *\n * - Establish phase: retry `onBeforeStart` (e.g. connectMongo) with capped\n *   backoff until it succeeds — a cold datastore must never exit the process.\n * - Monitor phase: poll `testDatabase` for the life of the process; flip\n *   ready/NotReady on transitions. While NotReady the readiness guard 503s\n *   business traffic and orchestrator readiness probes drain the instance.\n *\n * Runs in the background (the HTTP server is already listening). Stops when\n * `aborted()` returns true (graceful shutdown), so it never keeps a closing\n * process alive.\n */\nasync function superviseDependencies(\n  name: string,\n  onBeforeStart: (() => Promise<void>) | undefined,\n  testDatabase: (() => Promise<boolean>) | false | undefined,\n  aborted: () => boolean,\n): Promise<void> {\n  if (onBeforeStart) {\n    await retryForever(onBeforeStart, {\n      baseMs: READY_RETRY_BASE_MS,\n      maxMs: READY_RETRY_MAX_MS,\n      onAttemptFailed: (error, delayMs) => logger.warn(\n        `${name}: dependency init failed, retrying in ${delayMs}ms`,\n        { error: errorMessage(error) },\n      ),\n      shouldContinue: () => !aborted(),\n    });\n  }\n\n  // No datastore to gate on → ready as soon as we are listening.\n  if (testDatabase === false) {\n    if (aborted()) return; // shutdown began while we were initializing\n    setReady(true);\n    logger.info(`${name} ready (no datastore dependency)`);\n    return;\n  }\n\n  const probe = testDatabase ?? (() => getConnection().testConnection());\n  let waitDelay = READY_RETRY_BASE_MS;\n  while (!aborted()) {\n    let ok = false;\n    try {\n      ok = await probe();\n    } catch {\n      ok = false;\n    }\n\n    // A probe that was in flight when shutdown began must not flip the\n    // draining instance back to ready.\n    if (aborted()) break;\n    if (ok && !isReady()) {\n      setReady(true);\n      waitDelay = READY_RETRY_BASE_MS;\n      logger.info(`${name} ready — dependencies connected`);\n    } else if (!ok && isReady()) {\n      setReady(false);\n      logger.warn(`${name} degraded — dependency check failing (now NotReady)`);\n    }\n\n    // Steady cadence once ready; faster backoff while waiting so we flip to\n    // ready promptly when the datastore comes up.\n    if (isReady()) {\n      await sleep(READY_MONITOR_INTERVAL_MS);\n    } else {\n      await sleep(waitDelay);\n      waitDelay = nextBackoffMs(waitDelay, READY_RETRY_MAX_MS);\n    }\n  }\n}\n\n/**\n * Options for starting a server\n */\nexport interface StartServerOptions {\n  /** Service name for logging */\n  name?: string;\n  /** Port to listen on (default: from config) */\n  port?: number;\n  /** SSE manager for graceful shutdown */\n  sseManager?: SSEManager;\n  /** Shutdown timeout in milliseconds (default: 15000) */\n  shutdownTimeoutMs?: number;\n  /** Callback after server starts */\n  onStart?: (port: number) => void;\n  /** Callback before shutdown */\n  onShutdown?: () => Promise<void>;\n  /** Runs before database check (e.g., initialize external connections) */\n  onBeforeStart?: () => Promise<void>;\n  /** Custom database health check, or false to skip. Default: PostgreSQL testConnection */\n  testDatabase?: (() => Promise<boolean>) | false;\n  /** Custom database close, or false to skip. Default: PostgreSQL closeConnection */\n  closeDatabase?: (() => Promise<void>) | false;\n}\n\n/**\n * Result of starting a server\n */\nexport interface StartServerResult {\n  /** HTTP server instance */\n  server: Server;\n  /** Port the server is listening on */\n  port: number;\n  /** Function to manually trigger shutdown */\n  shutdown: () => Promise<void>;\n}\n\n/**\n * Start an Express server with graceful shutdown handling\n *\n * Features:\n * - Automatic database connection testing\n * - Graceful shutdown on SIGINT/SIGTERM\n * - SSE connection cleanup\n * - Configurable shutdown timeout\n *\n * @param app - Express application\n * @param options - Server options\n * @returns Server instance and control functions\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n *\n * app.post('/api/resource', requireAuth, handler);\n *\n * await startServer(app, {\n *   name: 'My Microservice',\n *   sseManager,\n *   onStart: (port) => console.log(`Listening on ${port}`),\n * });\n * ```\n */\nexport async function startServer(\n  app: Express,\n  options: StartServerOptions = {},\n): Promise<StartServerResult> {\n  const serverConfig = Config.get('server');\n  const {\n    name = 'Microservice',\n    sseManager,\n    shutdownTimeoutMs = 15000,\n    onStart,\n    onShutdown,\n    onBeforeStart,\n    testDatabase,\n    closeDatabase,\n  } = options;\n  const port = options.port ?? serverConfig.port;\n\n  // Validate auth configuration at server startup (not during CDK synthesis)\n  Config.validateAuth();\n  // Fail fast if this service has no internal signing key of its own, or no\n  // public bundle to verify its peers with. Without them it would mint\n  // tokens on an EPHEMERAL in-process key that no peer accepts, and reject every\n  // peer's token — i.e. silently lose all service-to-service traffic. Checked\n  // HERE rather than in `createApp` because it is a property of the running\n  // deployment, not of the app object: route-table builders and test suites\n  // assemble an app without ever signing anything.\n  for (const envVar of ['SERVICE_SIGNING_KEY_FILE', 'SERVICE_KEY_BUNDLE_FILE'] as const) {\n    if (!process.env[envVar]) {\n      throw new Error(`${envVar} environment variable is required (generate with deploy/bin/service-signing-keys.sh). Set it before starting the server.`);\n    }\n  }\n  // Fail fast on an unusable Redis configuration (throws RedisConfigError) — a\n  // Redis client is created lazily on first use, so without this a bad config\n  // would surface as request-time errors instead of a failed start.\n  resolveRedisConnection();\n\n  logger.info(`Starting ${name}...`);\n\n  // Mark NotReady synchronously, BEFORE the port opens, so no request slips\n  // through the readiness guard before the supervisor has run. The supervisor\n  // flips it true once dependencies connect.\n  setReady(false);\n\n  // Listen FIRST, then establish + monitor the datastore in the background,\n  // reporting NotReady until it connects. Testing the DB before listen and\n  // exiting on failure crash-loops the whole fleet during a cold-DB stampede:\n  // the process never opens its port, so /health (liveness), /ready and the\n  // readiness guard can't answer and the orchestrator only sees a dead pod.\n  // Opening the port first makes \"dependency down\" an observable state.\n  const server = app.listen(port, () => {\n    logger.info(`${name} listening on port: ${port}`);\n    logger.info(`Platform URL: ${serverConfig.platformUrl}`);\n    onStart?.(port);\n  });\n\n  // Shutdown handler (guarded against concurrent signals)\n  let shuttingDown = false;\n\n  // Background dependency supervisor — established + monitored after listen,\n  // stopped on shutdown so it never keeps a closing process alive. Guard the\n  // floating promise: every expected failure is handled inside, so a rejection\n  // here means a programming error — log it and leave the service NotReady\n  // rather than letting it become an unhandledRejection that crash-exits the\n  // process (which would defeat the whole \"never exit on dependency trouble\"\n  // goal).\n  superviseDependencies(name, onBeforeStart, testDatabase, () => shuttingDown).catch((error) => {\n    logger.error('Dependency supervisor crashed; service will remain NotReady', { error: errorMessage(error) });\n  });\n\n  const shutdown = async (signal?: string) => {\n    if (shuttingDown) return;\n    shuttingDown = true;\n\n    // Drain FIRST: report NotReady before anything else, so the load balancer /\n    // readiness probe stops sending new work while the rest of shutdown runs.\n    // `onShutdown` can take seconds; readiness left green across it keeps new\n    // requests arriving at a process that is already tearing itself down.\n    setReady(false);\n\n    if (signal) {\n      logger.info(`${signal} received, shutting down gracefully...`);\n    }\n\n    // Arm the force-exit BEFORE awaiting anything: a hung onShutdown (a stuck\n    // queue close, a Redis quit that never answers) would otherwise block forever\n    // with the timer never started, so the pod would ignore SIGTERM until SIGKILL.\n    setTimeout(() => {\n      logger.error('Forced shutdown after timeout');\n      process.exit(1);\n    }, shutdownTimeoutMs).unref();\n\n    // Custom shutdown callback\n    if (onShutdown) {\n      try {\n        await onShutdown();\n      } catch (error) {\n        logger.error('Error in onShutdown callback', { error });\n      }\n    }\n\n    // Close SSE connections\n    if (sseManager) {\n      sseManager.shutdown();\n      logger.info('SSE connections closed');\n    }\n\n    // Close HTTP server\n    server.close(async () => {\n      logger.info('HTTP server closed');\n\n      // Every in-flight request has now finished and buffered its metering unit;\n      // send them before exiting (api-core quota-increment-batcher). Never rejects.\n      await flushQuotaIncrements();\n\n      // Shutdown OpenTelemetry tracing\n      await shutdownTracing().catch(err => logger.error('Error shutting down tracing', { error: err }));\n\n      // Close database connection\n      if (closeDatabase !== false) {\n        try {\n          if (closeDatabase) {\n            await closeDatabase();\n          } else {\n            await closeConnection();\n          }\n          logger.info('Database connection closed');\n        } catch (error) {\n          logger.error('Error closing database', { error });\n        }\n      }\n\n      process.exit(0);\n    });\n  };\n\n  // Register signal handlers\n  process.once('SIGINT', () => void shutdown('SIGINT'));\n  process.once('SIGTERM', () => void shutdown('SIGTERM'));\n\n  return {\n    server,\n    port,\n    shutdown: () => shutdown(),\n  };\n}\n\n/**\n * Simple server start wrapper with error handling\n *\n * @param app - Express application\n * @param options - Server options\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n * app.post('/api/resource', handler);\n *\n * void runServer(app, { name: 'My Service', sseManager });\n * ```\n */\nexport function runServer(app: Express, options: StartServerOptions = {}): void {\n  // Route table of the fully assembled app (see api-core's route-table.ts): the\n  // same introspection the per-service coverage test asserts on, logged once at\n  // boot so an ungated or unaudited write route is visible in the running\n  // service, not only in CI.\n  logger.info('Route table built', summarizeRouteTable(buildRouteTable(app)));\n\n  // Last-resort fault handlers for the production entrypoint: an unhandled\n  // rejection / uncaught exception is logged (not silently fatal) then the\n  // process exits for the orchestrator to restart. No-op under NODE_ENV=test.\n  installCrashHandlers(logger);\n  startServer(app, options).catch((error) => {\n    // startServer now listens-first and supervises the DB in the background, so\n    // it only rejects on a genuinely fatal SETUP error (invalid auth config, a\n    // failed onStart, the port already in use). Log message + stack explicitly:\n    // an Error in winston metadata serializes to `{}` (message/stack are\n    // non-enumerable), which would otherwise hide the cause behind `{error:{}}`.\n    logger.error('Failed to start server', {\n      error: errorMessage(error),\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n    process.exit(1);\n  });\n}\n"]}

package/lib/testing/exports.json

@@ -2,9 +2,11 @@
   "package": "@pipeline-builder/api-server",
   "entries": {
     ".": {
+      "apiCallsQuota": "function",
       "applyWritePin": "function",
       "attachRequestContext": "function",
       "checkQuota": "function",
+      "clearQuotaCheckCache": "function",
       "combineHealthChecks": "function",
       "connectMongo": "function",
       "createApp": "function",
@@ -14,29 +16,40 @@
       "createProtectedRoute": "function",
       "createSharedRateLimitStore": "function",
       "currentTraceId": "function",
+      "deferredCheckQuota": "function",
       "getContext": "function",
       "getIdempotencyStore": "function",
       "getWritePinStore": "function",
+      "IDEMPOTENT_REPLAY_LOCAL": "value",
       "incCounter": "function",
+      "isIdempotentReplay": "function",
       "isReady": "function",
       "meterQuotaOnSuccess": "function",
       "mongoHealthCheck": "function",
       "NO_WRITE_PIN": "value",
       "observe": "function",
       "postgresHealthCheck": "function",
+      "QUOTA_CHECK_CACHE_TTL_MS": "value",
+      "QUOTA_CHECK_DENIED_CACHE_MS": "value",
       "rateLimitByOrg": "function",
       "readinessGuard": "function",
       "recordWriteForPin": "function",
       "redisHealthCheck": "function",
       "registerSecretRotationGauge": "function",
       "registerSseTicketChannel": "function",
+      "requestPath": "function",
       "requireOrgId": "function",
+      "reserveAiCallSlot": "function",
+      "reserveQuotaSlot": "function",
+      "resetGauge": "function",
       "runServer": "function",
+      "runWithSlot": "function",
       "setGauge": "function",
       "setReady": "function",
       "setWritePinStore": "function",
       "SSEManager": "class",
       "startServer": "function",
+      "withAiCallReservation": "function",
       "withQuotaReservation": "function",
       "withRoute": "function",
       "withSpan": "function",

package/package.json

@@ -35,9 +35,9 @@
     "@opentelemetry/instrumentation": "0.300.0",
     "@opentelemetry/resources": "3.0.0",
     "@opentelemetry/sdk-node": "0.300.0",
-    "@pipeline-builder/api-core": "5.2.3",
-    "@pipeline-builder/pipeline-core": "4.4.3",
-    "@pipeline-builder/pipeline-data": "4.3.3",
+    "@pipeline-builder/api-core": "5.2.4",
+    "@pipeline-builder/pipeline-core": "4.4.4",
+    "@pipeline-builder/pipeline-data": "4.3.4",
     "compression": "1.8.2",
     "cors": "2.8.6",
     "express": "5.3.0",
@@ -109,9 +109,10 @@
   "homepage": "https://mwashburn160.github.io/pipeline-builder/",
   "publishConfig": {
     "access": "public",
-    "registry": "https://registry.npmjs.org/"
+    "registry": "https://registry.npmjs.org/",
+    "provenance": true
   },
-  "version": "4.4.3",
+  "version": "4.4.4",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },