@pipeline-builder/api-core 5.2.2 → 5.2.4

package/lib/services/quota-increment-batcher.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Per-pod aggregation of METERING increments (apiCalls / automationCalls).
+ *
+ * Metering used to be one POST to the quota service per successful request,
+ * and each POST was a conditional `findOneAndUpdate` on the org's hot document,
+ * a team counter update, a ledger insert and a threshold check. At the request
+ * rates the meter exists for, the quota service was doing more work than the
+ * request it was counting.
+ *
+ * Increments are now summed in memory per (org, quota type) and, inside that,
+ * per attribution group (principal, key, route pattern, pipeline), then sent
+ * every `QUOTA_INCREMENT_FLUSH_MS` (default 1000) as ONE metered increment per
+ * (org, type) carrying its groups. The quota service applies the sum atomically
+ * against the (pooled) cap with partial admission: the counter moves by as much
+ * as fits and never past the limit, and the rest is recorded as `overshoot` in
+ * the ledger (api/quota `incrementMetered`).
+ *
+ * Guarantees, and their limits:
+ *  - the counter may LAG real usage by up to one flush interval (plus the HTTP
+ *    hop); enforcement is unaffected beyond that lag, because the counter
+ *    still never exceeds the cap;
+ *  - the buffer is bounded (`QUOTA_INCREMENT_BUFFER_MAX` attribution groups).
+ *    Reaching it flushes immediately; only while a flush is already in flight
+ *    is a NEW group dropped, counted on `quota_increment_dropped_total`;
+ *  - a flush that fails is counted on `quota_increment_failures_total` (the
+ *    QuotaIncrementFailures alert) and NOT retried: the POST may have landed,
+ *    and a retry would double-count;
+ *  - graceful shutdown flushes: `runServer` awaits {@link flushQuotaIncrements}
+ *    after the HTTP server has drained, and a SIGTERM flush covers processes
+ *    with their own shutdown path.
+ *
+ * Reservations (aiCalls, pipelines, plugins …) never come through here — they
+ * need the synchronous answer and keep `reserveQuota`.
+ */
+import type { QuotaService, QuotaUsageAttribution } from './quota.js';
+import type { QuotaType } from '../types/common.js';
+/** Flush interval (ms). `0` disables batching: every increment is sent on its own. */
+export declare const QUOTA_INCREMENT_FLUSH_MS: number;
+/** Most attribution groups held between flushes, across every org. */
+export declare const QUOTA_INCREMENT_BUFFER_MAX: number;
+/** Most groups one metered increment carries (the quota service enforces the same bound). */
+export declare const MAX_GROUPS_PER_INCREMENT = 500;
+/** One attribution group of a metered increment: who spent `amount` units. */
+export interface MeteredIncrementGroup {
+    amount: number;
+    attribution?: Omit<QuotaUsageAttribution, 'requestId'>;
+}
+/** Sends one (org, type)'s groups. Resolves when the quota service answered (or not). */
+export type MeteredIncrementSender = (orgId: string, quotaType: QuotaType, groups: MeteredIncrementGroup[]) => Promise<void>;
+/** A per-pod increment aggregator over one sender. Exported for tests. */
+export declare class QuotaIncrementBatcher {
+    private readonly send;
+    private readonly opts;
+    private buffer;
+    private groupCount;
+    private inFlight;
+    private timer;
+    constructor(send: MeteredIncrementSender, opts?: {
+        flushMs: number;
+        maxGroups: number;
+    });
+    /** Units waiting for the next flush (tests, metrics). */
+    pendingUnits(): number;
+    /** Count `amount` units for (org, type). Never throws, never awaits. */
+    add(orgId: string, quotaType: QuotaType, attribution?: QuotaUsageAttribution, amount?: number): void;
+    /** Send everything buffered now. Resolves once every POST has settled. */
+    flush(): Promise<void>;
+    /** Stop the timer (tests; process teardown). Buffered units stay until {@link flush}. */
+    stop(): void;
+    private arm;
+    private dispatch;
+    private sendSafely;
+}
+/** The batcher feeding `quotaService.incrementMetered`. */
+export declare function batcherFor(quotaService: QuotaService, sender: MeteredIncrementSender): QuotaIncrementBatcher;
+/**
+ * Flush every pod-local batcher. Called by `runServer` once the HTTP server has
+ * stopped accepting and in-flight requests have finished (their `finish`
+ * meters are then all buffered). Never rejects.
+ */
+export declare function flushQuotaIncrements(): Promise<void>;

package/lib/services/quota-increment-batcher.js

@@ -0,0 +1,166 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { runConcurrent } from '../utils/concurrency.js';
+import { envInt } from '../utils/env.js';
+import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+const logger = createLogger('quota-increment-batcher');
+/** Flush interval (ms). `0` disables batching: every increment is sent on its own. */
+export const QUOTA_INCREMENT_FLUSH_MS = envInt('QUOTA_INCREMENT_FLUSH_MS', 1000, { min: 0, max: 60_000 });
+/** Most attribution groups held between flushes, across every org. */
+export const QUOTA_INCREMENT_BUFFER_MAX = envInt('QUOTA_INCREMENT_BUFFER_MAX', 10_000, { min: 1 });
+/** Most groups one metered increment carries (the quota service enforces the same bound). */
+export const MAX_GROUPS_PER_INCREMENT = 500;
+/** Concurrent POSTs per flush. */
+const FLUSH_CONCURRENCY = 8;
+/** The attribution a group aggregates on — everything but the per-request id. */
+function groupAttribution(a) {
+    if (!a)
+        return undefined;
+    const { requestId: _requestId, ...rest } = a;
+    return Object.keys(rest).length > 0 ? rest : undefined;
+}
+function groupKey(a) {
+    return a ? JSON.stringify([a.principalType, a.principalId, a.keyId, a.route, a.pipelineId]) : '';
+}
+/** A per-pod increment aggregator over one sender. Exported for tests. */
+export class QuotaIncrementBatcher {
+    send;
+    opts;
+    buffer = new Map();
+    groupCount = 0;
+    inFlight = null;
+    timer = null;
+    constructor(send, opts = { flushMs: QUOTA_INCREMENT_FLUSH_MS, maxGroups: QUOTA_INCREMENT_BUFFER_MAX }) {
+        this.send = send;
+        this.opts = opts;
+    }
+    /** Units waiting for the next flush (tests, metrics). */
+    pendingUnits() {
+        let n = 0;
+        for (const s of this.buffer.values())
+            for (const g of s.groups.values())
+                n += g.amount;
+        return n;
+    }
+    /** Count `amount` units for (org, type). Never throws, never awaits. */
+    add(orgId, quotaType, attribution, amount = 1) {
+        const attr = groupAttribution(attribution);
+        if (this.opts.flushMs === 0) {
+            this.dispatch(orgId, quotaType, [{ amount, ...(attr && { attribution: attr }) }]);
+            return;
+        }
+        const seriesKey = `${orgId}\u0000${quotaType}`;
+        const key = groupKey(attr);
+        const existing = this.buffer.get(seriesKey)?.groups.get(key);
+        if (existing) {
+            existing.amount += amount;
+            return;
+        }
+        if (this.groupCount >= this.opts.maxGroups) {
+            if (this.inFlight) {
+                emitCounter('quota_increment_dropped_total', { quotaType }, amount);
+                return;
+            }
+            void this.flush();
+        }
+        let series = this.buffer.get(seriesKey);
+        if (!series) {
+            series = { orgId, quotaType, groups: new Map() };
+            this.buffer.set(seriesKey, series);
+        }
+        series.groups.set(key, { amount, ...(attr && { attribution: attr }) });
+        this.groupCount += 1;
+        this.arm();
+    }
+    /** Send everything buffered now. Resolves once every POST has settled. */
+    async flush() {
+        if (this.buffer.size === 0)
+            return this.inFlight ?? undefined;
+        const batch = [...this.buffer.values()];
+        this.buffer = new Map();
+        this.groupCount = 0;
+        const previous = this.inFlight;
+        const run = (async () => {
+            await runConcurrent(batch, FLUSH_CONCURRENCY, async (series) => {
+                const groups = [...series.groups.values()];
+                for (let i = 0; i < groups.length; i += MAX_GROUPS_PER_INCREMENT) {
+                    await this.sendSafely(series.orgId, series.quotaType, groups.slice(i, i + MAX_GROUPS_PER_INCREMENT));
+                }
+            });
+            if (previous)
+                await previous;
+        })();
+        this.inFlight = run;
+        try {
+            await run;
+        }
+        finally {
+            if (this.inFlight === run)
+                this.inFlight = null;
+        }
+    }
+    /** Stop the timer (tests; process teardown). Buffered units stay until {@link flush}. */
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+    arm() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => { void this.flush(); }, this.opts.flushMs);
+        this.timer.unref?.();
+        armShutdownFlush();
+    }
+    dispatch(orgId, quotaType, groups) {
+        void this.sendSafely(orgId, quotaType, groups);
+    }
+    async sendSafely(orgId, quotaType, groups) {
+        try {
+            await this.send(orgId, quotaType, groups);
+        }
+        catch (err) {
+            logger.warn('Metered quota increment failed', { orgId, quotaType, error: String(err) });
+            emitCounter('quota_increment_failures_total', { reason: 'exception', quotaType });
+        }
+    }
+}
+/** One batcher per quota client, so a test's fake client never shares a buffer. */
+const batchers = new WeakMap();
+/** The live batchers, for the shutdown flush (a WeakMap cannot be iterated). */
+const live = new Set();
+/** The batcher feeding `quotaService.incrementMetered`. */
+export function batcherFor(quotaService, sender) {
+    let b = batchers.get(quotaService);
+    if (!b) {
+        b = new QuotaIncrementBatcher(sender);
+        batchers.set(quotaService, b);
+        live.add(b);
+    }
+    return b;
+}
+/**
+ * Flush every pod-local batcher. Called by `runServer` once the HTTP server has
+ * stopped accepting and in-flight requests have finished (their `finish`
+ * meters are then all buffered). Never rejects.
+ */
+export async function flushQuotaIncrements() {
+    await Promise.all([...live].map((b) => b.flush().catch(() => undefined)));
+}
+let shutdownArmed = false;
+/**
+ * SIGTERM flush for processes that don't shut down through `runServer`.
+ *
+ * Armed only when the process ALREADY handles SIGTERM (every service registers
+ * its shutdown at startup, before the first request is metered): adding the
+ * first listener would switch off Node's default exit-on-SIGTERM for a process
+ * that relied on it (a CLI, a test worker).
+ */
+function armShutdownFlush() {
+    if (shutdownArmed || process.listenerCount('SIGTERM') === 0)
+        return;
+    shutdownArmed = true;
+    process.once('SIGTERM', () => { void flushQuotaIncrements(); });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota-increment-batcher.js","sourceRoot":"","sources":["../../src/services/quota-increment-batcher.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Per-pod aggregation of METERING increments (apiCalls / automationCalls).\n *\n * Metering used to be one POST to the quota service per successful request,\n * and each POST was a conditional `findOneAndUpdate` on the org's hot document,\n * a team counter update, a ledger insert and a threshold check. At the request\n * rates the meter exists for, the quota service was doing more work than the\n * request it was counting.\n *\n * Increments are now summed in memory per (org, quota type) and, inside that,\n * per attribution group (principal, key, route pattern, pipeline), then sent\n * every `QUOTA_INCREMENT_FLUSH_MS` (default 1000) as ONE metered increment per\n * (org, type) carrying its groups. The quota service applies the sum atomically\n * against the (pooled) cap with partial admission: the counter moves by as much\n * as fits and never past the limit, and the rest is recorded as `overshoot` in\n * the ledger (api/quota `incrementMetered`).\n *\n * Guarantees, and their limits:\n *  - the counter may LAG real usage by up to one flush interval (plus the HTTP\n *    hop); enforcement is unaffected beyond that lag, because the counter\n *    still never exceeds the cap;\n *  - the buffer is bounded (`QUOTA_INCREMENT_BUFFER_MAX` attribution groups).\n *    Reaching it flushes immediately; only while a flush is already in flight\n *    is a NEW group dropped, counted on `quota_increment_dropped_total`;\n *  - a flush that fails is counted on `quota_increment_failures_total` (the\n *    QuotaIncrementFailures alert) and NOT retried: the POST may have landed,\n *    and a retry would double-count;\n *  - graceful shutdown flushes: `runServer` awaits {@link flushQuotaIncrements}\n *    after the HTTP server has drained, and a SIGTERM flush covers processes\n *    with their own shutdown path.\n *\n * Reservations (aiCalls, pipelines, plugins …) never come through here — they\n * need the synchronous answer and keep `reserveQuota`.\n */\n\nimport type { QuotaService, QuotaUsageAttribution } from './quota.js';\nimport type { QuotaType } from '../types/common.js';\nimport { runConcurrent } from '../utils/concurrency.js';\nimport { envInt } from '../utils/env.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('quota-increment-batcher');\n\n/** Flush interval (ms). `0` disables batching: every increment is sent on its own. */\nexport const QUOTA_INCREMENT_FLUSH_MS = envInt('QUOTA_INCREMENT_FLUSH_MS', 1000, { min: 0, max: 60_000 });\n\n/** Most attribution groups held between flushes, across every org. */\nexport const QUOTA_INCREMENT_BUFFER_MAX = envInt('QUOTA_INCREMENT_BUFFER_MAX', 10_000, { min: 1 });\n\n/** Most groups one metered increment carries (the quota service enforces the same bound). */\nexport const MAX_GROUPS_PER_INCREMENT = 500;\n\n/** Concurrent POSTs per flush. */\nconst FLUSH_CONCURRENCY = 8;\n\n/** One attribution group of a metered increment: who spent `amount` units. */\nexport interface MeteredIncrementGroup {\n  amount: number;\n  attribution?: Omit<QuotaUsageAttribution, 'requestId'>;\n}\n\n/** Sends one (org, type)'s groups. Resolves when the quota service answered (or not). */\nexport type MeteredIncrementSender = (orgId: string, quotaType: QuotaType, groups: MeteredIncrementGroup[]) => Promise<void>;\n\ninterface PendingSeries {\n  orgId: string;\n  quotaType: QuotaType;\n  groups: Map<string, MeteredIncrementGroup>;\n}\n\n/** The attribution a group aggregates on — everything but the per-request id. */\nfunction groupAttribution(a: QuotaUsageAttribution | undefined): MeteredIncrementGroup['attribution'] {\n  if (!a) return undefined;\n  const { requestId: _requestId, ...rest } = a;\n  return Object.keys(rest).length > 0 ? rest : undefined;\n}\n\nfunction groupKey(a: MeteredIncrementGroup['attribution']): string {\n  return a ? JSON.stringify([a.principalType, a.principalId, a.keyId, a.route, a.pipelineId]) : '';\n}\n\n/** A per-pod increment aggregator over one sender. Exported for tests. */\nexport class QuotaIncrementBatcher {\n  private buffer = new Map<string, PendingSeries>();\n  private groupCount = 0;\n  private inFlight: Promise<void> | null = null;\n  private timer: NodeJS.Timeout | null = null;\n\n  constructor(\n    private readonly send: MeteredIncrementSender,\n    private readonly opts: { flushMs: number; maxGroups: number } = { flushMs: QUOTA_INCREMENT_FLUSH_MS, maxGroups: QUOTA_INCREMENT_BUFFER_MAX },\n  ) {}\n\n  /** Units waiting for the next flush (tests, metrics). */\n  pendingUnits(): number {\n    let n = 0;\n    for (const s of this.buffer.values()) for (const g of s.groups.values()) n += g.amount;\n    return n;\n  }\n\n  /** Count `amount` units for (org, type). Never throws, never awaits. */\n  add(orgId: string, quotaType: QuotaType, attribution?: QuotaUsageAttribution, amount: number = 1): void {\n    const attr = groupAttribution(attribution);\n    if (this.opts.flushMs === 0) {\n      this.dispatch(orgId, quotaType, [{ amount, ...(attr && { attribution: attr }) }]);\n      return;\n    }\n    const seriesKey = `${orgId}\\u0000${quotaType}`;\n    const key = groupKey(attr);\n    const existing = this.buffer.get(seriesKey)?.groups.get(key);\n    if (existing) {\n      existing.amount += amount;\n      return;\n    }\n    if (this.groupCount >= this.opts.maxGroups) {\n      if (this.inFlight) {\n        emitCounter('quota_increment_dropped_total', { quotaType }, amount);\n        return;\n      }\n      void this.flush();\n    }\n    let series = this.buffer.get(seriesKey);\n    if (!series) {\n      series = { orgId, quotaType, groups: new Map() };\n      this.buffer.set(seriesKey, series);\n    }\n    series.groups.set(key, { amount, ...(attr && { attribution: attr }) });\n    this.groupCount += 1;\n    this.arm();\n  }\n\n  /** Send everything buffered now. Resolves once every POST has settled. */\n  async flush(): Promise<void> {\n    if (this.buffer.size === 0) return this.inFlight ?? undefined;\n    const batch = [...this.buffer.values()];\n    this.buffer = new Map();\n    this.groupCount = 0;\n    const previous = this.inFlight;\n    const run = (async () => {\n      await runConcurrent(batch, FLUSH_CONCURRENCY, async (series) => {\n        const groups = [...series.groups.values()];\n        for (let i = 0; i < groups.length; i += MAX_GROUPS_PER_INCREMENT) {\n          await this.sendSafely(series.orgId, series.quotaType, groups.slice(i, i + MAX_GROUPS_PER_INCREMENT));\n        }\n      });\n      if (previous) await previous;\n    })();\n    this.inFlight = run;\n    try {\n      await run;\n    } finally {\n      if (this.inFlight === run) this.inFlight = null;\n    }\n  }\n\n  /** Stop the timer (tests; process teardown). Buffered units stay until {@link flush}. */\n  stop(): void {\n    if (this.timer) clearInterval(this.timer);\n    this.timer = null;\n  }\n\n  private arm(): void {\n    if (this.timer) return;\n    this.timer = setInterval(() => { void this.flush(); }, this.opts.flushMs);\n    this.timer.unref?.();\n    armShutdownFlush();\n  }\n\n  private dispatch(orgId: string, quotaType: QuotaType, groups: MeteredIncrementGroup[]): void {\n    void this.sendSafely(orgId, quotaType, groups);\n  }\n\n  private async sendSafely(orgId: string, quotaType: QuotaType, groups: MeteredIncrementGroup[]): Promise<void> {\n    try {\n      await this.send(orgId, quotaType, groups);\n    } catch (err) {\n      logger.warn('Metered quota increment failed', { orgId, quotaType, error: String(err) });\n      emitCounter('quota_increment_failures_total', { reason: 'exception', quotaType });\n    }\n  }\n}\n\n/** One batcher per quota client, so a test's fake client never shares a buffer. */\nconst batchers = new WeakMap<QuotaService, QuotaIncrementBatcher>();\n\n/** The live batchers, for the shutdown flush (a WeakMap cannot be iterated). */\nconst live = new Set<QuotaIncrementBatcher>();\n\n/** The batcher feeding `quotaService.incrementMetered`. */\nexport function batcherFor(quotaService: QuotaService, sender: MeteredIncrementSender): QuotaIncrementBatcher {\n  let b = batchers.get(quotaService);\n  if (!b) {\n    b = new QuotaIncrementBatcher(sender);\n    batchers.set(quotaService, b);\n    live.add(b);\n  }\n  return b;\n}\n\n/**\n * Flush every pod-local batcher. Called by `runServer` once the HTTP server has\n * stopped accepting and in-flight requests have finished (their `finish`\n * meters are then all buffered). Never rejects.\n */\nexport async function flushQuotaIncrements(): Promise<void> {\n  await Promise.all([...live].map((b) => b.flush().catch(() => undefined)));\n}\n\nlet shutdownArmed = false;\n\n/**\n * SIGTERM flush for processes that don't shut down through `runServer`.\n *\n * Armed only when the process ALREADY handles SIGTERM (every service registers\n * its shutdown at startup, before the first request is metered): adding the\n * first listener would switch off Node's default exit-on-SIGTERM for a process\n * that relied on it (a CLI, a test worker).\n */\nfunction armShutdownFlush(): void {\n  if (shutdownArmed || process.listenerCount('SIGTERM') === 0) return;\n  shutdownArmed = true;\n  process.once('SIGTERM', () => { void flushQuotaIncrements(); });\n}\n"]}

package/lib/services/quota.d.ts

@@ -1,6 +1,107 @@
-import type { Response } from 'express';
-import type { QuotaType, QuotaCheckResult } from '../types/common.js';
+import type { Request, Response } from 'express';
+import { type MeteredIncrementGroup } from './quota-increment-batcher.js';
+import type { PrincipalType, QuotaType, QuotaCheckResult } from '../types/common.js';
+import { ErrorCode } from '../types/error-codes.js';
 import { type QuotaTier } from '../types/quota-tiers.js';
+/**
+ * Budget for one `check` of a COUNTER quota (`QUOTA_CHECK_TIMEOUT_MS`, default
+ * 300), with no retry.
+ *
+ * The check is a read gate that FAILS OPEN, run ahead of the request it gates:
+ * the old 5 s timeout × 2 attempts meant a slow quota service added up to 10 s
+ * to every metered request and then let it through anyway. A short budget turns
+ * the same incident into a ≤ 300 ms fail-open (counted on
+ * `quota_fail_open_total`, which alerts) — and with the per-pod check cache in
+ * front (api-server `checkQuota`) a healthy service is asked at most once per
+ * org/type per cache TTL.
+ *
+ * `storageBytes` keeps the client timeout and one retry: it is a MEASURED read
+ * (the quota service walks the org's registry namespace on a cold cache) behind
+ * the registry's fail-CLOSED push gate, where a premature timeout refuses a push.
+ */
+export declare const QUOTA_CHECK_TIMEOUT_MS: number;
+/** Who / what spent (or got back) a quota unit. All fields optional. */
+export interface QuotaUsageAttribution {
+    principalType?: PrincipalType;
+    /** The user id or service-account id behind the call (the token's `sub`). */
+    principalId?: string;
+    /** The revocable credential: the access key the token derives from, else its `jti`. */
+    keyId?: string;
+    /** `METHOD /route/:pattern` — the matched route PATTERN, never the raw URL (no ids, no query). */
+    route?: string;
+    /** The pipeline the call was made for (`:pipelineId` param or `X-Pipeline-Id` header). */
+    pipelineId?: string;
+    requestId?: string;
+    /**
+     * AI calls only: which product surface spent the unit — `ask`, `agent`,
+     * `agent-tool:<name>`, `pipeline-generate`, `plugin-generate`,
+     * `report-summary`. Set by api-server's `withAiCallReservation`.
+     */
+    feature?: string;
+    /** AI calls only: the model id the reservation was resolved to (never a key). */
+    model?: string;
+    /** AI calls only: whose key served the call — `platform`, `org` or `request` (BYOK). */
+    keySource?: AiKeySource;
+}
+/** Whose key serves an AI call (mirrors ai-core `KeySource`). Only `platform` spends `aiCalls`. */
+export type AiKeySource = 'platform' | 'org' | 'request';
+/** Token counts an AI call reports after it settles (see {@link QuotaService.reportUsage}). */
+export interface QuotaTokenUsage {
+    tokensIn: number;
+    tokensOut: number;
+}
+/**
+ * Attribution for the request being served: the verified principal, the matched
+ * route pattern, the pipeline (`:pipelineId` param or a sanitized
+ * `X-Pipeline-Id` header) and the request id. Read off `req` directly rather than
+ * the ambient audit context because the metering middleware runs in a `finish`
+ * listener, where the request's async scope is no longer guaranteed.
+ */
+export declare function quotaAttributionFromRequest(req: Request): QuotaUsageAttribution;
+/**
+ * The quota type a metered request actually spends.
+ *
+ * `apiCalls` is the PEOPLE's budget — an interactive session. A request made by
+ * a NON-INTERACTIVE credential spends `automationCalls` instead, never both, so
+ * a fleet of self-mutating pipelines can't exhaust the console for the humans
+ * in the same org:
+ *  - an org SERVICE ACCOUNT (`principalType: 'service_account'` —
+ *    platform-automation, pipeline-register, reporting-ingest, registry-push);
+ *  - a PERSONAL ACCESS KEY: the exchanged key token (`token_use: 'api_key'`)
+ *    and anything minted while holding one (`parentKeyId`). A PAT in a CI job
+ *    is automation whoever owns it — billing it as a person let one script
+ *    lock its owner's teammates out of the console. CI should still use a
+ *    service-account key (it survives the person leaving); either way the
+ *    traffic now lands on `automationCalls`.
+ * Every other type is returned unchanged: an AI call or a pipeline creation
+ * costs the same whoever makes it.
+ *
+ * `meterQuotaOnSuccess` and `checkQuota` call this themselves, so a service
+ * mounts both with `'apiCalls'` and the split happens per request.
+ */
+export declare function meteredQuotaTypeFor(req: Pick<Request, 'user'>, quotaType: QuotaType): QuotaType;
+/** Why a request is not metered/checked against apiCalls (see {@link callQuotaExemption}). */
+export type CallQuotaExemption = 'service' | 'impersonation' | 'on_behalf';
+/**
+ * Whether the apiCalls/automationCalls meter AND check skip this (verified)
+ * request, and why. One function for both halves, so the gate never refuses a
+ * call the meter would not bill:
+ *  - `service` — an internal service principal: peer traffic is caused by a
+ *    user action the originating service already metered;
+ *  - `impersonation` — a sysadmin impersonation session (`impersonatorId`).
+ *    Vendor staff looking at a tenant's console must neither spend the tenant's
+ *    budget nor be locked out by it while diagnosing an exhausted org; the
+ *    session is audited on its own trail;
+ *  - `on_behalf` — a user token FORWARDED by an internal service as part of a
+ *    request already metered where it arrived (the ask agent's tools,
+ *    pipeline's placeholder-plugin confirm), proven by a signed marker the
+ *    user cannot forge (middleware/on-behalf.ts).
+ * Applies to the CALL budgets only: reservation-gated quotas (pipelines,
+ * plugins …) are charged whoever asks. `aiCalls` mirrors the impersonation half
+ * on its own (api-server `withAiCallReservation` skips the slot when the
+ * session is an impersonation; the call is still audited).
+ */
+export declare function callQuotaExemption(req: Request): CallQuotaExemption | undefined;
 /**
  * Service-principal `Authorization` header for a quota call made on behalf of
  * `orgId` by the CURRENT service (`SERVICE_NAME`, the same identity the health
@@ -30,6 +131,16 @@ export interface QuotaReserveResult {
      * 503 instead of a misleading 429 "quota exceeded".
      */
     unavailable?: boolean;
+    /**
+     * Set when an `aiCalls` reservation was refused by one of the org's OPTIONAL
+     * AI controls rather than the period cap: {@link ErrorCode.AI_MEMBER_SHARE_EXCEEDED}
+     * (the caller's per-member share is spent) or
+     * {@link ErrorCode.AI_TOKEN_BUDGET_EXCEEDED} (the org's per-period token
+     * budget is spent). Paired with `exceeded: true` and the quota service's
+     * `message`; {@link sendQuotaReserveDenied} relays both.
+     */
+    code?: AiLimitCode;
+    message?: string;
     quota: {
         type: QuotaType;
         limit: number;
@@ -38,14 +149,32 @@ export interface QuotaReserveResult {
         resetAt?: string;
     };
 }
+/** The 429 codes an `aiCalls` reservation answers when an optional org AI control refuses it. */
+export type AiLimitCode = ErrorCode.AI_MEMBER_SHARE_EXCEEDED | ErrorCode.AI_TOKEN_BUDGET_EXCEEDED;
 /**
  * Quota service client interface.
  */
 export interface QuotaService {
     /** Check if quota is available (fail-open on error). */
     check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult>;
-    /** Increment quota usage. Returns a promise so callers can optionally handle errors. */
-    increment(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<void>;
+    /**
+     * Increment quota usage. Returns a promise so callers can optionally handle
+     * errors. `attribution` defaults to the ambient request context.
+     */
+    increment(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, attribution?: QuotaUsageAttribution): Promise<void>;
+    /**
+     * METERED increment of a pre-aggregated batch (the per-pod batcher's flush,
+     * see `quota-increment-batcher.ts`): the sum of `groups` is applied with
+     * PARTIAL admission — the counter moves by as much as fits under the cap and
+     * the remainder is recorded as `overshoot` — and each group's attribution is
+     * written to the usage ledger. Never a 429. Resolves with what was counted,
+     * or `null` when the quota service did not answer ok (counted on
+     * `quota_increment_failures_total`).
+     */
+    incrementMetered(orgId: string, quotaType: QuotaType, authHeader: string, groups: MeteredIncrementGroup[]): Promise<{
+        counted: number;
+        overshoot: number;
+    } | null>;
     /**
      * Atomic reserve  the same atomic check+increment as `increment`, but
      * parses the response so callers can see whether the slot was actually
@@ -56,7 +185,7 @@ export interface QuotaService {
      * unreachable, timeout, open circuit, non-ok, or a non-quota 429 — unless
      * `QUOTA_RESERVE_FAIL_OPEN=true` (see the policy note at the top of this file).
      */
-    reserve(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<QuotaReserveResult>;
+    reserve(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, attribution?: QuotaUsageAttribution): Promise<QuotaReserveResult>;
     /**
      * Roll back a previously reserved slot. Fire-and-forget — never throws.
      * Pass `resetAtSnapshot` (the `quota.resetAt` observed when the slot was
@@ -64,7 +193,16 @@ export interface QuotaService {
      * between reserve and rollback, the server skips the decrement so it doesn't
      * steal capacity from the new period.
      */
-    decrement(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, resetAtSnapshot?: string, requestId?: string): Promise<void>;
+    decrement(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, resetAtSnapshot?: string, attribution?: QuotaUsageAttribution): Promise<void>;
+    /**
+     * Record what an AI call COST after it settled — its token counts — in the
+     * usage ledger, without moving any counter (a zero-unit ledger row carrying
+     * `tokensIn` / `tokensOut` under the call's attribution). Also how a call that
+     * spent NO `aiCalls` unit (a BYOK key, an impersonation session, a weight-0
+     * model) still shows up in the usage breakdown. Fire-and-forget — never throws.
+     * Optional so test doubles need not implement it.
+     */
+    reportUsage?(orgId: string, quotaType: QuotaType, authHeader: string, tokens: QuotaTokenUsage, attribution?: QuotaUsageAttribution): Promise<void>;
     /**
      * Get the org's quota `QuotaTier`. Used by the plugin-build queue partitioning
      * to route a build to the right per-tier queue. Fail-open returns `DEFAULT_TIER`
@@ -116,20 +254,26 @@ export interface QuotaServiceConfig {
  */
 export declare function createQuotaService(config?: QuotaServiceConfig): QuotaService;
 /**
- * Fire-and-forget quota METERING increment with standardized error logging.
+ * Fire-and-forget quota METERING increment.
+ *
+ * Buffered: the unit joins the pod's per-(org, type) aggregate and is sent with
+ * the next flush (`QUOTA_INCREMENT_FLUSH_MS`, see quota-increment-batcher.ts)
+ * as one metered increment — partial admission against the cap, the excess
+ * recorded as `overshoot`. The counter therefore lags by at most one flush
+ * interval. Only the request meter uses this; reservations stay synchronous.
  *
  * Authenticates as the calling SERVICE ({@link getQuotaServiceAuthHeader}), never
- * with the end user's token: `/quotas/:orgId/increment` is service-principal /
- * system-admin only, so a forwarded user JWT was always rejected (403) and the
- * metered quota (e.g. `apiCalls`, and the `api_pack` bundle raising it) never
- * moved.
+ * with the end user's token: `/quotas/:orgId/increment` is service-principal
+ * only, so a forwarded user JWT was always rejected (403) and the metered quota
+ * (e.g. `apiCalls`, and the `api_pack` bundle raising it) never moved.
  *
  * @param quotaService - Quota service client
  * @param orgId - Organization ID whose counter is incremented
  * @param quotaType - Quota type to increment
  * @param logWarn - Logging function for warnings
+ * @param attribution - Who spent the unit (defaults to the ambient request context)
  */
-export declare function incrementQuota(quotaService: QuotaService, orgId: string, quotaType: QuotaType, logWarn: (message: string, data?: unknown) => void): void;
+export declare function incrementQuota(quotaService: QuotaService, orgId: string, quotaType: QuotaType, logWarn: (message: string, data?: unknown) => void, attribution?: QuotaUsageAttribution): void;
 /**
  * Atomic reserve helper for the "reserve + commit / rollback" pattern.
  * Use for expensive resources (pipelines, plugins, AI calls) where the
@@ -151,7 +295,7 @@ export declare function incrementQuota(quotaService: QuotaService, orgId: string
  * }
  * ```
  */
-export declare function reserveQuota(quotaService: QuotaService, orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<QuotaReserveResult>;
+export declare function reserveQuota(quotaService: QuotaService, orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, attribution?: QuotaUsageAttribution): Promise<QuotaReserveResult>;
 /**
  * Answer a DENIED reservation (`reservation.exceeded === true`).
  *
@@ -166,4 +310,4 @@ export declare function sendQuotaReserveDenied(res: Response, quotaType: QuotaTy
  * Logs on failure but never throws  the action that needed the rollback
  * has already failed, no point compounding the error.
  */
-export declare function decrementQuota(quotaService: QuotaService, orgId: string, quotaType: QuotaType, authHeader: string, logWarn: (message: string, data?: unknown) => void, amount?: number, resetAtSnapshot?: string): void;
+export declare function decrementQuota(quotaService: QuotaService, orgId: string, quotaType: QuotaType, authHeader: string, logWarn: (message: string, data?: unknown) => void, amount?: number, resetAtSnapshot?: string, attribution?: QuotaUsageAttribution): void;