@pipeline-builder/api-core 5.2.3 → 5.2.4

package/lib/services/index.js

@@ -5,6 +5,7 @@ export { createCacheService, CacheService, } from './cache-service.js';
 export { withLeaderLock, createEnvRedisLock, leaderLockKey, DEFAULT_LEADER_LOCK_TTL_MS, } from './leader-lock.js';
 export { sendSystemNotification, SYSTEM_NOTIFY_PATH, } from './system-notification.js';
 export { createScheduler, } from './scheduler.js';
+export { assessVersionVulns, versionScanFacts, scanFreshness, scanWarnings, lastScannedAt, scanStaleHours, severityOf, maxSeverity, severityAtLeast, VULN_SEVERITIES, setVulnPolicyComplianceClientForTests, } from './version-vuln-policy.js';
 export { createComplianceClient, } from './compliance-client.js';
 export { pluginRunsOwnImage, pluginComplianceTags, derivePluginImageCompliance, PLUGIN_IMAGE_COMPLIANCE_FIELDS, } from '../utils/plugin-compliance.js';
 export * from './compliance-event-subscriber.js';
@@ -22,8 +23,11 @@ export { resetCircuitBreakers, } from './circuit-breaker.js';
 export { createEnvRedisDurableEventBus, } from './durable-event-bus.js';
 export { getErrorRetryDecision, } from './retry-strategy.js';
 export { nextBackoffMs, retryForever, } from './retry-forever.js';
-export { getQuotaServiceAuthHeader, createQuotaService, incrementQuota, reserveQuota, sendQuotaReserveDenied, decrementQuota, } from './quota.js';
+export { getQuotaServiceAuthHeader, createQuotaService, incrementQuota, reserveQuota, sendQuotaReserveDenied, decrementQuota, meteredQuotaTypeFor, callQuotaExemption, QUOTA_CHECK_TIMEOUT_MS, quotaAttributionFromRequest, } from './quota.js';
+export { aiCallWeight, parseAiModelWeights, MAX_AI_CALL_WEIGHT, } from './ai-call-weight.js';
+export { QuotaIncrementBatcher, flushQuotaIncrements, QUOTA_INCREMENT_FLUSH_MS, QUOTA_INCREMENT_BUFFER_MAX, MAX_GROUPS_PER_INCREMENT, } from './quota-increment-batcher.js';
 export { createRemoteAuditClient, wireAuthzDenialAuditor, recordAudit, } from './remote-audit-client.js';
+export { runWithAuditContext, currentAuditContext, auditContextFromRequest, auditAuthBlock, sanitizeCorrelationId, sanitizeUserAgent, AUDIT_CORRELATION_HEADERS, } from './audit-context.js';
 export { auditSpoolKey, createEnvRedisAuditSpool, } from './audit-spool.js';
 export { resolveRedisConnection, describeRedisConnection, createRedisClient, createEnvRedisClient, createRedisReadyGate, incrWindow, RedisConfigError, } from './env-redis.js';
 export { createRedisTokenRevocationStore, createEnvRedisTokenRevocationStore, publishTokenRevocation, publishSessionRevocation, publishCredentialRevocation, } from './token-revocation.js';
@@ -34,4 +38,5 @@ export { alertDeliveryConfig, canDeliverAnywhere, deadmanConfig, reportAlertDeli
 export { verifyPagerDutySignature, onCallInboundConfig, fetchRotaCoverage, parseOnCallWebhook, ackLatencySeconds, PAGERDUTY_API_URL, } from './pagerduty-inbound.js';
 export { sendPagerDutyEvent, pagerDutyConfig, resolveEventsEndpoint, PAGERDUTY_EVENTS_URL, } from './pagerduty.js';
 export { createEcosystemNotifyClient, ECOSYSTEM_NOTIFY_PATH, } from './ecosystem-notify-client.js';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nexport {\n  exchangeApiKey,\n  resetApiKeyExchangeCache,\n  ApiKeyRejectedError,\n  ApiKeyExchangeUnavailableError,\n} from './api-key-exchange.js';\nexport {\n  createCacheService,\n  type RedisCacheClient,\n  type CacheInvalidationMessage,\n  type CacheInvalidationBus,\n  type RedisInvalidationClient,\n  CacheService,\n} from './cache-service.js';\nexport {\n  withLeaderLock,\n  createEnvRedisLock,\n  leaderLockKey,\n  DEFAULT_LEADER_LOCK_TTL_MS,\n  type LockRedis,\n  type LeaderLockRun,\n  type LeaderLockOptions,\n  type LeaderLockAbortReason,\n} from './leader-lock.js';\nexport {\n  sendSystemNotification,\n  SYSTEM_NOTIFY_PATH,\n  type SystemNotification,\n} from './system-notification.js';\nexport {\n  createScheduler,\n  type SchedulerOptions,\n  type Scheduler,\n} from './scheduler.js';\nexport {\n  createComplianceClient,\n  type ComplianceCheckResult,\n  type ComplianceViolation,\n} from './compliance-client.js';\nexport {\n  pluginRunsOwnImage,\n  pluginComplianceTags,\n  derivePluginImageCompliance,\n  type PluginComplianceAttributes,\n  PLUGIN_IMAGE_COMPLIANCE_FIELDS,\n  type PluginImageRow,\n} from '../utils/plugin-compliance.js';\nexport * from './compliance-event-subscriber.js';\nexport {\n  type EntityEvent,\n  type EntityEventSubscriber,\n  entityEvents,\n} from './entity-events.js';\nexport {\n  destroySharedHttpAgents,\n  createSafeClient,\n  ResponseTooLargeError,\n  InternalHttpClient,\n} from './http-client.js';\nexport {\n  setPlatformJwksCache,\n  JwksUnavailableError,\n  UnknownKidError,\n  JwksCache,\n} from './jwks-cache.js';\n// Service-key internals stay internal. The package surface is the verify/inspect\n// side that platform's JWT options and the auth middleware need; key MATERIAL\n// handling (`signServiceJwt`, the bundle, the test reset hook) is reachable only\n// by deep import from inside api-core and its testing helpers.\nexport {\n  isServiceKid,\n  serviceIdentity,\n  verifyServiceJwt,\n} from './service-keys.js';\n// The breaker is wired by the shared HTTP client; services consume its EFFECT,\n// not the class. Only the operational surface is public.\nexport {\n  resetCircuitBreakers,\n} from './circuit-breaker.js';\nexport {\n  createEnvRedisDurableEventBus,\n  type EventSubscription,\n  type DurableEventBus,\n} from './durable-event-bus.js';\nexport {\n  getErrorRetryDecision,\n} from './retry-strategy.js';\nexport type {\n  RetryConfig,\n} from './retry-strategy.js';\nexport {\n  nextBackoffMs,\n  retryForever,\n} from './retry-forever.js';\nexport {\n  getQuotaServiceAuthHeader,\n  createQuotaService,\n  incrementQuota,\n  reserveQuota,\n  sendQuotaReserveDenied,\n  decrementQuota,\n  type QuotaReserveResult,\n  type QuotaService,\n} from './quota.js';\nexport {\n  createRemoteAuditClient,\n  wireAuthzDenialAuditor,\n  recordAudit,\n  type RemoteAuditEvent,\n  type RemoteAuditClient,\n} from './remote-audit-client.js';\nexport {\n  auditSpoolKey,\n  createEnvRedisAuditSpool,\n  type AuditSpool,\n} from './audit-spool.js';\nexport {\n  resolveRedisConnection,\n  describeRedisConnection,\n  createRedisClient,\n  createEnvRedisClient,\n  createRedisReadyGate,\n  incrWindow,\n  RedisConfigError,\n  type RedisEvalClient,\n} from './env-redis.js';\nexport {\n  createRedisTokenRevocationStore,\n  createEnvRedisTokenRevocationStore,\n  publishTokenRevocation,\n  publishSessionRevocation,\n  publishCredentialRevocation,\n} from './token-revocation.js';\nexport {\n  createMemorySseTicketStore,\n  createEnvSseTicketStore,\n  envSseTicketCaps,\n  type EnvSseTicketStoreConfig,\n  type SseTicketStore,\n  type SseTicketStoreConfig,\n} from './sse-ticket-store.js';\nexport {\n  wireServiceSecurity,\n} from './service-boot.js';\nexport {\n  createWebhookChannel,\n  createEmailChannel,\n  createChannelRegistry,\n  type NotificationPriority,\n  type NotificationMessage,\n  type ChannelTarget,\n  type DeliveryResult,\n  type NotificationChannel,\n} from './notification-channels.js';\nexport {\n  alertDeliveryConfig,\n  canDeliverAnywhere,\n  deadmanConfig,\n  reportAlertDeliveryPosture,\n  slackAlertsConfig,\n  startDeadmanHeartbeat,\n  stopDeadmanHeartbeat,\n  type DeadmanConfig,\n  type AlertDeliveryConfig,\n  type SlackAlertsConfig,\n} from './alert-delivery.js';\nexport {\n  verifyPagerDutySignature,\n  onCallInboundConfig,\n  fetchRotaCoverage,\n  parseOnCallWebhook,\n  ackLatencySeconds,\n  PAGERDUTY_API_URL,\n  type OnCallInboundConfig,\n  type OnCallWebhookEvent,\n  type OnCallWebhookEventType,\n  type RotaCoverage,\n} from './pagerduty-inbound.js';\nexport {\n  sendPagerDutyEvent,\n  pagerDutyConfig,\n  resolveEventsEndpoint,\n  PAGERDUTY_EVENTS_URL,\n  type OnCallProvider,\n  type PagerDutyAction,\n  type PagerDutyConfig,\n  type PagerDutyEvent,\n  type PagerDutyResult,\n  type PagerDutySeverity,\n} from './pagerduty.js';\nexport {\n  createEcosystemNotifyClient,\n  ECOSYSTEM_NOTIFY_PATH,\n  type EcosystemNotifyClient,\n} from './ecosystem-notify-client.js';\n"]}
+export { fetchOrgAIAccess, fetchOrgAIKey, assertOrgAIEnabled, requireOrgAIEnabled, resetOrgAICache, ORG_AI_ACCESS_PATH, ORG_AI_KEYS_PATH, } from './org-ai-client.js';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nexport {\n  exchangeApiKey,\n  resetApiKeyExchangeCache,\n  ApiKeyRejectedError,\n  ApiKeyExchangeUnavailableError,\n} from './api-key-exchange.js';\nexport {\n  createCacheService,\n  type RedisCacheClient,\n  type CacheInvalidationMessage,\n  type CacheInvalidationBus,\n  type RedisInvalidationClient,\n  CacheService,\n} from './cache-service.js';\nexport {\n  withLeaderLock,\n  createEnvRedisLock,\n  leaderLockKey,\n  DEFAULT_LEADER_LOCK_TTL_MS,\n  type LockRedis,\n  type LeaderLockRun,\n  type LeaderLockOptions,\n  type LeaderLockAbortReason,\n} from './leader-lock.js';\nexport {\n  sendSystemNotification,\n  SYSTEM_NOTIFY_PATH,\n  type SystemNotification,\n} from './system-notification.js';\nexport {\n  createScheduler,\n  type SchedulerOptions,\n  type Scheduler,\n} from './scheduler.js';\nexport {\n  assessVersionVulns,\n  versionScanFacts,\n  scanFreshness,\n  scanWarnings,\n  lastScannedAt,\n  scanStaleHours,\n  severityOf,\n  maxSeverity,\n  severityAtLeast,\n  VULN_SEVERITIES,\n  setVulnPolicyComplianceClientForTests,\n  type VulnSeverity,\n  type VulnWarning,\n  type ScannedRecord,\n  type VulnConsumptionPolicy,\n  type VulnAcceptance,\n  type VersionScanFacts,\n  type VersionVulnInput,\n  type VersionVulnAssessment,\n} from './version-vuln-policy.js';\nexport {\n  createComplianceClient,\n  type ComplianceCheckResult,\n  type ComplianceViolation,\n} from './compliance-client.js';\nexport {\n  pluginRunsOwnImage,\n  pluginComplianceTags,\n  derivePluginImageCompliance,\n  type PluginComplianceAttributes,\n  PLUGIN_IMAGE_COMPLIANCE_FIELDS,\n  type PluginImageRow,\n} from '../utils/plugin-compliance.js';\nexport * from './compliance-event-subscriber.js';\nexport {\n  type EntityEvent,\n  type EntityEventSubscriber,\n  entityEvents,\n} from './entity-events.js';\nexport {\n  destroySharedHttpAgents,\n  createSafeClient,\n  ResponseTooLargeError,\n  InternalHttpClient,\n} from './http-client.js';\nexport {\n  setPlatformJwksCache,\n  JwksUnavailableError,\n  UnknownKidError,\n  JwksCache,\n} from './jwks-cache.js';\n// Service-key internals stay internal. The package surface is the verify/inspect\n// side that platform's JWT options and the auth middleware need; key MATERIAL\n// handling (`signServiceJwt`, the bundle, the test reset hook) is reachable only\n// by deep import from inside api-core and its testing helpers.\nexport {\n  isServiceKid,\n  serviceIdentity,\n  verifyServiceJwt,\n} from './service-keys.js';\n// The breaker is wired by the shared HTTP client; services consume its EFFECT,\n// not the class. Only the operational surface is public.\nexport {\n  resetCircuitBreakers,\n} from './circuit-breaker.js';\nexport {\n  createEnvRedisDurableEventBus,\n  type EventSubscription,\n  type DurableEventBus,\n} from './durable-event-bus.js';\nexport {\n  getErrorRetryDecision,\n} from './retry-strategy.js';\nexport type {\n  RetryConfig,\n} from './retry-strategy.js';\nexport {\n  nextBackoffMs,\n  retryForever,\n} from './retry-forever.js';\nexport {\n  getQuotaServiceAuthHeader,\n  createQuotaService,\n  incrementQuota,\n  reserveQuota,\n  sendQuotaReserveDenied,\n  decrementQuota,\n  meteredQuotaTypeFor,\n  callQuotaExemption,\n  QUOTA_CHECK_TIMEOUT_MS,\n  quotaAttributionFromRequest,\n  type AiKeySource,\n  type AiLimitCode,\n  type CallQuotaExemption,\n  type QuotaReserveResult,\n  type QuotaTokenUsage,\n  type QuotaService,\n  type QuotaUsageAttribution,\n} from './quota.js';\nexport {\n  aiCallWeight,\n  parseAiModelWeights,\n  MAX_AI_CALL_WEIGHT,\n} from './ai-call-weight.js';\nexport {\n  QuotaIncrementBatcher,\n  flushQuotaIncrements,\n  QUOTA_INCREMENT_FLUSH_MS,\n  QUOTA_INCREMENT_BUFFER_MAX,\n  MAX_GROUPS_PER_INCREMENT,\n  type MeteredIncrementGroup,\n} from './quota-increment-batcher.js';\nexport {\n  createRemoteAuditClient,\n  wireAuthzDenialAuditor,\n  recordAudit,\n  type RemoteAuditEvent,\n  type RemoteAuditWireEvent,\n  type RemoteAuditClient,\n} from './remote-audit-client.js';\nexport {\n  runWithAuditContext,\n  currentAuditContext,\n  auditContextFromRequest,\n  auditAuthBlock,\n  sanitizeCorrelationId,\n  sanitizeUserAgent,\n  AUDIT_CORRELATION_HEADERS,\n  type AuditContext,\n  type AuditCorrelation,\n  type AuditJobContext,\n  type AuditAuthBlock,\n} from './audit-context.js';\nexport {\n  auditSpoolKey,\n  createEnvRedisAuditSpool,\n  type AuditSpool,\n} from './audit-spool.js';\nexport {\n  resolveRedisConnection,\n  describeRedisConnection,\n  createRedisClient,\n  createEnvRedisClient,\n  createRedisReadyGate,\n  incrWindow,\n  RedisConfigError,\n  type RedisEvalClient,\n} from './env-redis.js';\nexport {\n  createRedisTokenRevocationStore,\n  createEnvRedisTokenRevocationStore,\n  publishTokenRevocation,\n  publishSessionRevocation,\n  publishCredentialRevocation,\n} from './token-revocation.js';\nexport {\n  createMemorySseTicketStore,\n  createEnvSseTicketStore,\n  envSseTicketCaps,\n  type EnvSseTicketStoreConfig,\n  type SseTicketStore,\n  type SseTicketStoreConfig,\n} from './sse-ticket-store.js';\nexport {\n  wireServiceSecurity,\n} from './service-boot.js';\nexport {\n  createWebhookChannel,\n  createEmailChannel,\n  createChannelRegistry,\n  type NotificationPriority,\n  type NotificationMessage,\n  type ChannelTarget,\n  type DeliveryResult,\n  type NotificationChannel,\n} from './notification-channels.js';\nexport {\n  alertDeliveryConfig,\n  canDeliverAnywhere,\n  deadmanConfig,\n  reportAlertDeliveryPosture,\n  slackAlertsConfig,\n  startDeadmanHeartbeat,\n  stopDeadmanHeartbeat,\n  type DeadmanConfig,\n  type AlertDeliveryConfig,\n  type SlackAlertsConfig,\n} from './alert-delivery.js';\nexport {\n  verifyPagerDutySignature,\n  onCallInboundConfig,\n  fetchRotaCoverage,\n  parseOnCallWebhook,\n  ackLatencySeconds,\n  PAGERDUTY_API_URL,\n  type OnCallInboundConfig,\n  type OnCallWebhookEvent,\n  type OnCallWebhookEventType,\n  type RotaCoverage,\n} from './pagerduty-inbound.js';\nexport {\n  sendPagerDutyEvent,\n  pagerDutyConfig,\n  resolveEventsEndpoint,\n  PAGERDUTY_EVENTS_URL,\n  type OnCallProvider,\n  type PagerDutyAction,\n  type PagerDutyConfig,\n  type PagerDutyEvent,\n  type PagerDutyResult,\n  type PagerDutySeverity,\n} from './pagerduty.js';\nexport {\n  createEcosystemNotifyClient,\n  ECOSYSTEM_NOTIFY_PATH,\n  type EcosystemNotifyClient,\n} from './ecosystem-notify-client.js';\nexport {\n  fetchOrgAIAccess,\n  fetchOrgAIKey,\n  assertOrgAIEnabled,\n  requireOrgAIEnabled,\n  resetOrgAICache,\n  ORG_AI_ACCESS_PATH,\n  ORG_AI_KEYS_PATH,\n  type OrgAIAccess,\n} from './org-ai-client.js';\n"]}

package/lib/services/org-ai-client.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The org half of every AI call: is AI switched on for this organization, which
+ * providers has it configured its OWN key for, and — when the call is going to
+ * use one — the decrypted key.
+ *
+ * Platform holds both facts (the org's `aiEnabled` switch and its encrypted
+ * `aiProviderKeys`), so they are two INTERNAL reads on platform, gated by
+ * `requireInternalService` to the four AI callers (ask, pipeline, plugin,
+ * reporting) and by the mesh on the Istio targets:
+ *
+ *  - `GET /internal/ai/access/:orgId`         → `{ aiEnabled, providers: string[] }`
+ *  - `GET /internal/ai/keys/:orgId/:provider` → `{ provider, apiKey }` (audited on platform)
+ *
+ * KEY MATERIAL HANDLING. A key fetched here is held in process memory for at most
+ * {@link ORG_AI_KEY_TTL_MS} (so a rotated or cleared key stops being used within
+ * that window, and platform's read audit is not one row per model call), is never
+ * logged, never written to Redis or any shared cache, and never placed in an error
+ * message. Callers hand it straight to a model factory.
+ *
+ * FAILURE IS NOT A FALLBACK. An unreachable platform makes {@link fetchOrgAIAccess}
+ * throw an {@link AIConfigurationError} rather than answer "enabled, no org keys":
+ * that answer would silently bill the platform's key for an org that configured its
+ * own, and would run AI for an org whose administrators switched it off.
+ */
+import type { NextFunction, Request, Response } from 'express';
+/** Platform paths (exported for the platform route-coverage + mesh declarations). */
+export declare const ORG_AI_ACCESS_PATH = "/internal/ai/access";
+export declare const ORG_AI_KEYS_PATH = "/internal/ai/keys";
+/** How long an org's switch + configured-provider list is reused (default 30s). */
+export declare const ORG_AI_ACCESS_TTL_MS: number;
+/** How long a decrypted org key is held in memory (default 60s; 0 disables caching). */
+export declare const ORG_AI_KEY_TTL_MS: number;
+/** An org's AI posture, as platform reports it. */
+export interface OrgAIAccess {
+    /** False when the org's administrators switched AI features off. */
+    aiEnabled: boolean;
+    /** Provider ids the org has configured its OWN key for (catalog ids). */
+    providers: string[];
+}
+/**
+ * The org's AI switch and the providers it has its own key for. Cached
+ * {@link ORG_AI_ACCESS_TTL_MS}. Throws {@link AIConfigurationError} (503) when platform
+ * cannot answer — see the module comment for why that is not "enabled".
+ */
+export declare function fetchOrgAIAccess(orgId: string): Promise<OrgAIAccess>;
+/**
+ * The org's decrypted key for `provider`. Call ONLY after {@link fetchOrgAIAccess}
+ * listed the provider. Throws {@link AIConfigurationError} when the key cannot be
+ * loaded — the caller must then fail the request, never fall back to the platform key.
+ */
+export declare function fetchOrgAIKey(orgId: string, provider: string): Promise<string>;
+/** Throw {@link AIDisabledError} (403 `AI_DISABLED`) when the org switched AI off. */
+export declare function assertOrgAIEnabled(orgId: string): Promise<OrgAIAccess>;
+/**
+ * Route guard: refuse every AI entry point for an org whose administrators switched
+ * AI off (403 `AI_DISABLED`), or whose settings platform cannot confirm (503). Mount
+ * AFTER auth and BEFORE any quota reservation, so a disabled org is never charged.
+ */
+export declare function requireOrgAIEnabled(req: Request, res: Response, next: NextFunction): Promise<void>;
+/** Drop the cached org AI posture + keys (tests; an org whose settings just changed). */
+export declare function resetOrgAICache(orgId?: string): void;

package/lib/services/org-ai-client.js

@@ -0,0 +1,112 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createSafeClient } from './http-client.js';
+import { serviceIdentity } from './service-keys.js';
+import { AIConfigurationError, AIDisabledError } from '../errors/app-errors.js';
+import { getServiceAuthHeader } from '../middleware/service-tokens.js';
+import { ErrorCode } from '../types/error-codes.js';
+import { envInt } from '../utils/env.js';
+import { sendError } from '../utils/response.js';
+import { serviceEndpoint } from '../utils/service-registry.js';
+/** Platform paths (exported for the platform route-coverage + mesh declarations). */
+export const ORG_AI_ACCESS_PATH = '/internal/ai/access';
+export const ORG_AI_KEYS_PATH = '/internal/ai/keys';
+/** How long an org's switch + configured-provider list is reused (default 30s). */
+export const ORG_AI_ACCESS_TTL_MS = envInt('ORG_AI_ACCESS_TTL_MS', 30_000, { min: 0 });
+/** How long a decrypted org key is held in memory (default 60s; 0 disables caching). */
+export const ORG_AI_KEY_TTL_MS = envInt('ORG_AI_KEY_TTL_MS', 60_000, { min: 0, max: 300_000 });
+const accessCache = new Map();
+const keyCache = new Map();
+let client;
+function platform() {
+    client ??= createSafeClient({ ...serviceEndpoint('platform'), timeout: 5_000 });
+    return client;
+}
+/** A service token scoped to the org being asked about — platform binds the read to it. */
+function authFor(orgId) {
+    return { Authorization: getServiceAuthHeader({ serviceName: serviceIdentity(), orgId, role: 'member' }) };
+}
+/**
+ * The org's AI switch and the providers it has its own key for. Cached
+ * {@link ORG_AI_ACCESS_TTL_MS}. Throws {@link AIConfigurationError} (503) when platform
+ * cannot answer — see the module comment for why that is not "enabled".
+ */
+export async function fetchOrgAIAccess(orgId) {
+    const hit = accessCache.get(orgId);
+    if (hit && hit.expiresAt > Date.now())
+        return hit.value;
+    const response = await platform().get(`${ORG_AI_ACCESS_PATH}/${encodeURIComponent(orgId)}`, { headers: authFor(orgId) });
+    const body = response?.body;
+    const data = body?.data ?? body;
+    if (!response || response.statusCode !== 200 || typeof data?.aiEnabled !== 'boolean') {
+        throw new AIConfigurationError('The organization\'s AI settings could not be read, so no AI request was made. Try again shortly.');
+    }
+    const value = {
+        aiEnabled: data.aiEnabled,
+        providers: Array.isArray(data.providers) ? data.providers.filter((p) => typeof p === 'string') : [],
+    };
+    if (ORG_AI_ACCESS_TTL_MS > 0)
+        accessCache.set(orgId, { value, expiresAt: Date.now() + ORG_AI_ACCESS_TTL_MS });
+    return value;
+}
+/**
+ * The org's decrypted key for `provider`. Call ONLY after {@link fetchOrgAIAccess}
+ * listed the provider. Throws {@link AIConfigurationError} when the key cannot be
+ * loaded — the caller must then fail the request, never fall back to the platform key.
+ */
+export async function fetchOrgAIKey(orgId, provider) {
+    const cacheKey = `${orgId}\u0000${provider}`;
+    const hit = keyCache.get(cacheKey);
+    if (hit && hit.expiresAt > Date.now())
+        return hit.value;
+    const response = await platform().get(`${ORG_AI_KEYS_PATH}/${encodeURIComponent(orgId)}/${encodeURIComponent(provider)}`, { headers: authFor(orgId) });
+    const apiKey = response?.body?.data?.apiKey ?? response?.body?.apiKey;
+    if (!response || response.statusCode !== 200 || typeof apiKey !== 'string' || apiKey.length === 0) {
+        // Status only: the body is never echoed, and the key is never in a message.
+        throw new AIConfigurationError(`The organization's ${provider} API key could not be loaded, so the request was not sent. `
+            + 'It was NOT retried on the platform\'s key — re-save the key in Settings, or try again shortly.');
+    }
+    if (ORG_AI_KEY_TTL_MS > 0)
+        keyCache.set(cacheKey, { value: apiKey, expiresAt: Date.now() + ORG_AI_KEY_TTL_MS });
+    return apiKey;
+}
+/** Throw {@link AIDisabledError} (403 `AI_DISABLED`) when the org switched AI off. */
+export async function assertOrgAIEnabled(orgId) {
+    const access = await fetchOrgAIAccess(orgId);
+    if (!access.aiEnabled)
+        throw new AIDisabledError();
+    return access;
+}
+/**
+ * Route guard: refuse every AI entry point for an org whose administrators switched
+ * AI off (403 `AI_DISABLED`), or whose settings platform cannot confirm (503). Mount
+ * AFTER auth and BEFORE any quota reservation, so a disabled org is never charged.
+ */
+export async function requireOrgAIEnabled(req, res, next) {
+    const orgId = req.user?.organizationId;
+    if (!orgId) {
+        sendError(res, 403, 'No organization associated with this request', ErrorCode.INSUFFICIENT_PERMISSIONS);
+        return;
+    }
+    try {
+        await assertOrgAIEnabled(String(orgId));
+        next();
+    }
+    catch (err) {
+        const e = err;
+        sendError(res, e.statusCode ?? 503, e.message, e.code);
+    }
+}
+/** Drop the cached org AI posture + keys (tests; an org whose settings just changed). */
+export function resetOrgAICache(orgId) {
+    if (orgId === undefined) {
+        accessCache.clear();
+        keyCache.clear();
+        return;
+    }
+    accessCache.delete(orgId);
+    for (const k of keyCache.keys())
+        if (k.startsWith(`${orgId}\u0000`))
+            keyCache.delete(k);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-ai-client.js","sourceRoot":"","sources":["../../src/services/org-ai-client.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The org half of every AI call: is AI switched on for this organization, which\n * providers has it configured its OWN key for, and — when the call is going to\n * use one — the decrypted key.\n *\n * Platform holds both facts (the org's `aiEnabled` switch and its encrypted\n * `aiProviderKeys`), so they are two INTERNAL reads on platform, gated by\n * `requireInternalService` to the four AI callers (ask, pipeline, plugin,\n * reporting) and by the mesh on the Istio targets:\n *\n *  - `GET /internal/ai/access/:orgId`         → `{ aiEnabled, providers: string[] }`\n *  - `GET /internal/ai/keys/:orgId/:provider` → `{ provider, apiKey }` (audited on platform)\n *\n * KEY MATERIAL HANDLING. A key fetched here is held in process memory for at most\n * {@link ORG_AI_KEY_TTL_MS} (so a rotated or cleared key stops being used within\n * that window, and platform's read audit is not one row per model call), is never\n * logged, never written to Redis or any shared cache, and never placed in an error\n * message. Callers hand it straight to a model factory.\n *\n * FAILURE IS NOT A FALLBACK. An unreachable platform makes {@link fetchOrgAIAccess}\n * throw an {@link AIConfigurationError} rather than answer \"enabled, no org keys\":\n * that answer would silently bill the platform's key for an org that configured its\n * own, and would run AI for an org whose administrators switched it off.\n */\n\nimport type { NextFunction, Request, Response } from 'express';\nimport { createSafeClient } from './http-client.js';\nimport { serviceIdentity } from './service-keys.js';\nimport { AIConfigurationError, AIDisabledError } from '../errors/app-errors.js';\nimport { getServiceAuthHeader } from '../middleware/service-tokens.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { envInt } from '../utils/env.js';\nimport { sendError } from '../utils/response.js';\nimport { serviceEndpoint } from '../utils/service-registry.js';\n\n/** Platform paths (exported for the platform route-coverage + mesh declarations). */\nexport const ORG_AI_ACCESS_PATH = '/internal/ai/access';\nexport const ORG_AI_KEYS_PATH = '/internal/ai/keys';\n\n/** How long an org's switch + configured-provider list is reused (default 30s). */\nexport const ORG_AI_ACCESS_TTL_MS = envInt('ORG_AI_ACCESS_TTL_MS', 30_000, { min: 0 });\n/** How long a decrypted org key is held in memory (default 60s; 0 disables caching). */\nexport const ORG_AI_KEY_TTL_MS = envInt('ORG_AI_KEY_TTL_MS', 60_000, { min: 0, max: 300_000 });\n\n/** An org's AI posture, as platform reports it. */\nexport interface OrgAIAccess {\n  /** False when the org's administrators switched AI features off. */\n  aiEnabled: boolean;\n  /** Provider ids the org has configured its OWN key for (catalog ids). */\n  providers: string[];\n}\n\ninterface Cached<T> { value: T; expiresAt: number }\n\nconst accessCache = new Map<string, Cached<OrgAIAccess>>();\nconst keyCache = new Map<string, Cached<string>>();\n\nlet client: ReturnType<typeof createSafeClient> | undefined;\nfunction platform(): ReturnType<typeof createSafeClient> {\n  client ??= createSafeClient({ ...serviceEndpoint('platform'), timeout: 5_000 });\n  return client;\n}\n\n/** A service token scoped to the org being asked about — platform binds the read to it. */\nfunction authFor(orgId: string): Record<string, string> {\n  return { Authorization: getServiceAuthHeader({ serviceName: serviceIdentity(), orgId, role: 'member' }) };\n}\n\n/**\n * The org's AI switch and the providers it has its own key for. Cached\n * {@link ORG_AI_ACCESS_TTL_MS}. Throws {@link AIConfigurationError} (503) when platform\n * cannot answer — see the module comment for why that is not \"enabled\".\n */\nexport async function fetchOrgAIAccess(orgId: string): Promise<OrgAIAccess> {\n  const hit = accessCache.get(orgId);\n  if (hit && hit.expiresAt > Date.now()) return hit.value;\n\n  const response = await platform().get<{ data?: Partial<OrgAIAccess> } & Partial<OrgAIAccess>>(\n    `${ORG_AI_ACCESS_PATH}/${encodeURIComponent(orgId)}`, { headers: authFor(orgId) },\n  );\n  const body = response?.body;\n  const data = body?.data ?? body;\n  if (!response || response.statusCode !== 200 || typeof data?.aiEnabled !== 'boolean') {\n    throw new AIConfigurationError('The organization\\'s AI settings could not be read, so no AI request was made. Try again shortly.');\n  }\n  const value: OrgAIAccess = {\n    aiEnabled: data.aiEnabled,\n    providers: Array.isArray(data.providers) ? data.providers.filter((p): p is string => typeof p === 'string') : [],\n  };\n  if (ORG_AI_ACCESS_TTL_MS > 0) accessCache.set(orgId, { value, expiresAt: Date.now() + ORG_AI_ACCESS_TTL_MS });\n  return value;\n}\n\n/**\n * The org's decrypted key for `provider`. Call ONLY after {@link fetchOrgAIAccess}\n * listed the provider. Throws {@link AIConfigurationError} when the key cannot be\n * loaded — the caller must then fail the request, never fall back to the platform key.\n */\nexport async function fetchOrgAIKey(orgId: string, provider: string): Promise<string> {\n  const cacheKey = `${orgId}\\u0000${provider}`;\n  const hit = keyCache.get(cacheKey);\n  if (hit && hit.expiresAt > Date.now()) return hit.value;\n\n  const response = await platform().get<{ data?: { apiKey?: unknown }; apiKey?: unknown }>(\n    `${ORG_AI_KEYS_PATH}/${encodeURIComponent(orgId)}/${encodeURIComponent(provider)}`, { headers: authFor(orgId) },\n  );\n  const apiKey = response?.body?.data?.apiKey ?? response?.body?.apiKey;\n  if (!response || response.statusCode !== 200 || typeof apiKey !== 'string' || apiKey.length === 0) {\n    // Status only: the body is never echoed, and the key is never in a message.\n    throw new AIConfigurationError(\n      `The organization's ${provider} API key could not be loaded, so the request was not sent. `\n      + 'It was NOT retried on the platform\\'s key — re-save the key in Settings, or try again shortly.',\n    );\n  }\n  if (ORG_AI_KEY_TTL_MS > 0) keyCache.set(cacheKey, { value: apiKey, expiresAt: Date.now() + ORG_AI_KEY_TTL_MS });\n  return apiKey;\n}\n\n/** Throw {@link AIDisabledError} (403 `AI_DISABLED`) when the org switched AI off. */\nexport async function assertOrgAIEnabled(orgId: string): Promise<OrgAIAccess> {\n  const access = await fetchOrgAIAccess(orgId);\n  if (!access.aiEnabled) throw new AIDisabledError();\n  return access;\n}\n\n/**\n * Route guard: refuse every AI entry point for an org whose administrators switched\n * AI off (403 `AI_DISABLED`), or whose settings platform cannot confirm (503). Mount\n * AFTER auth and BEFORE any quota reservation, so a disabled org is never charged.\n */\nexport async function requireOrgAIEnabled(req: Request, res: Response, next: NextFunction): Promise<void> {\n  const orgId = req.user?.organizationId;\n  if (!orgId) {\n    sendError(res, 403, 'No organization associated with this request', ErrorCode.INSUFFICIENT_PERMISSIONS);\n    return;\n  }\n  try {\n    await assertOrgAIEnabled(String(orgId));\n    next();\n  } catch (err) {\n    const e = err as AIDisabledError | AIConfigurationError;\n    sendError(res, e.statusCode ?? 503, e.message, e.code);\n  }\n}\n\n/** Drop the cached org AI posture + keys (tests; an org whose settings just changed). */\nexport function resetOrgAICache(orgId?: string): void {\n  if (orgId === undefined) {\n    accessCache.clear();\n    keyCache.clear();\n    return;\n  }\n  accessCache.delete(orgId);\n  for (const k of keyCache.keys()) if (k.startsWith(`${orgId}\\u0000`)) keyCache.delete(k);\n}\n"]}

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"]}