@pipeline-builder/api-core 5.2.2 → 5.2.4

package/lib/services/index.d.ts

@@ -3,6 +3,7 @@ export { createCacheService, type RedisCacheClient, type CacheInvalidationMessag
 export { withLeaderLock, createEnvRedisLock, leaderLockKey, DEFAULT_LEADER_LOCK_TTL_MS, type LockRedis, type LeaderLockRun, type LeaderLockOptions, type LeaderLockAbortReason, } from './leader-lock.js';
 export { sendSystemNotification, SYSTEM_NOTIFY_PATH, type SystemNotification, } from './system-notification.js';
 export { createScheduler, type SchedulerOptions, type Scheduler, } from './scheduler.js';
+export { assessVersionVulns, versionScanFacts, scanFreshness, scanWarnings, lastScannedAt, scanStaleHours, severityOf, maxSeverity, severityAtLeast, VULN_SEVERITIES, setVulnPolicyComplianceClientForTests, type VulnSeverity, type VulnWarning, type ScannedRecord, type VulnConsumptionPolicy, type VulnAcceptance, type VersionScanFacts, type VersionVulnInput, type VersionVulnAssessment, } from './version-vuln-policy.js';
 export { createComplianceClient, type ComplianceCheckResult, type ComplianceViolation, } from './compliance-client.js';
 export { pluginRunsOwnImage, pluginComplianceTags, derivePluginImageCompliance, type PluginComplianceAttributes, PLUGIN_IMAGE_COMPLIANCE_FIELDS, type PluginImageRow, } from '../utils/plugin-compliance.js';
 export * from './compliance-event-subscriber.js';
@@ -15,12 +16,19 @@ export { createEnvRedisDurableEventBus, type EventSubscription, type DurableEven
 export { getErrorRetryDecision, } from './retry-strategy.js';
 export type { RetryConfig, } from './retry-strategy.js';
 export { nextBackoffMs, retryForever, } from './retry-forever.js';
-export { getQuotaServiceAuthHeader, createQuotaService, incrementQuota, reserveQuota, sendQuotaReserveDenied, decrementQuota, type QuotaReserveResult, type QuotaService, } from './quota.js';
-export { createRemoteAuditClient, wireAuthzDenialAuditor, recordAudit, type RemoteAuditEvent, type RemoteAuditClient, } from './remote-audit-client.js';
+export { getQuotaServiceAuthHeader, createQuotaService, incrementQuota, reserveQuota, sendQuotaReserveDenied, decrementQuota, meteredQuotaTypeFor, callQuotaExemption, QUOTA_CHECK_TIMEOUT_MS, quotaAttributionFromRequest, type AiKeySource, type AiLimitCode, type CallQuotaExemption, type QuotaReserveResult, type QuotaTokenUsage, type QuotaService, type QuotaUsageAttribution, } 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, type MeteredIncrementGroup, } from './quota-increment-batcher.js';
+export { createRemoteAuditClient, wireAuthzDenialAuditor, recordAudit, type RemoteAuditEvent, type RemoteAuditWireEvent, type RemoteAuditClient, } from './remote-audit-client.js';
+export { runWithAuditContext, currentAuditContext, auditContextFromRequest, auditAuthBlock, sanitizeCorrelationId, sanitizeUserAgent, AUDIT_CORRELATION_HEADERS, type AuditContext, type AuditCorrelation, type AuditJobContext, type AuditAuthBlock, } from './audit-context.js';
 export { auditSpoolKey, createEnvRedisAuditSpool, type AuditSpool, } from './audit-spool.js';
 export { resolveRedisConnection, describeRedisConnection, createRedisClient, createEnvRedisClient, createRedisReadyGate, incrWindow, RedisConfigError, type RedisEvalClient, } from './env-redis.js';
 export { createRedisTokenRevocationStore, createEnvRedisTokenRevocationStore, publishTokenRevocation, publishSessionRevocation, publishCredentialRevocation, } from './token-revocation.js';
 export { createMemorySseTicketStore, createEnvSseTicketStore, envSseTicketCaps, type EnvSseTicketStoreConfig, type SseTicketStore, type SseTicketStoreConfig, } from './sse-ticket-store.js';
 export { wireServiceSecurity, } from './service-boot.js';
 export { createWebhookChannel, createEmailChannel, createChannelRegistry, type NotificationPriority, type NotificationMessage, type ChannelTarget, type DeliveryResult, type NotificationChannel, } from './notification-channels.js';
+export { alertDeliveryConfig, canDeliverAnywhere, deadmanConfig, reportAlertDeliveryPosture, slackAlertsConfig, startDeadmanHeartbeat, stopDeadmanHeartbeat, type DeadmanConfig, type AlertDeliveryConfig, type SlackAlertsConfig, } from './alert-delivery.js';
+export { verifyPagerDutySignature, onCallInboundConfig, fetchRotaCoverage, parseOnCallWebhook, ackLatencySeconds, PAGERDUTY_API_URL, type OnCallInboundConfig, type OnCallWebhookEvent, type OnCallWebhookEventType, type RotaCoverage, } from './pagerduty-inbound.js';
+export { sendPagerDutyEvent, pagerDutyConfig, resolveEventsEndpoint, PAGERDUTY_EVENTS_URL, type OnCallProvider, type PagerDutyAction, type PagerDutyConfig, type PagerDutyEvent, type PagerDutyResult, type PagerDutySeverity, } from './pagerduty.js';
 export { createEcosystemNotifyClient, ECOSYSTEM_NOTIFY_PATH, type EcosystemNotifyClient, } from './ecosystem-notify-client.js';
+export { fetchOrgAIAccess, fetchOrgAIKey, assertOrgAIEnabled, requireOrgAIEnabled, resetOrgAICache, ORG_AI_ACCESS_PATH, ORG_AI_KEYS_PATH, type OrgAIAccess, } from './org-ai-client.js';

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,13 +23,20 @@ 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';
 export { createMemorySseTicketStore, createEnvSseTicketStore, envSseTicketCaps, } from './sse-ticket-store.js';
 export { wireServiceSecurity, } from './service-boot.js';
 export { createWebhookChannel, createEmailChannel, createChannelRegistry, } from './notification-channels.js';
+export { alertDeliveryConfig, canDeliverAnywhere, deadmanConfig, reportAlertDeliveryPosture, slackAlertsConfig, startDeadmanHeartbeat, stopDeadmanHeartbeat, } from './alert-delivery.js';
+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":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EACL,cAAc,EACd,wBAAwB,EACxB,mBAAmB,EACnB,8BAA8B,GAC/B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,kBAAkB,EAKlB,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,0BAA0B,GAK3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,sBAAsB,EACtB,kBAAkB,GAEnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,eAAe,GAGhB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,sBAAsB,GAGvB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,2BAA2B,EAE3B,8BAA8B,GAE/B,MAAM,+BAA+B,CAAC;AACvC,cAAc,kCAAkC,CAAC;AACjD,OAAO,EAGL,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EACf,SAAS,GACV,MAAM,iBAAiB,CAAC;AACzB,iFAAiF;AACjF,8EAA8E;AAC9E,iFAAiF;AACjF,+DAA+D;AAC/D,OAAO,EACL,YAAY,EACZ,eAAe,EACf,gBAAgB,GACjB,MAAM,mBAAmB,CAAC;AAC3B,+EAA+E;AAC/E,yDAAyD;AACzD,OAAO,EACL,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,6BAA6B,GAG9B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,qBAAqB,GACtB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EACL,aAAa,EACb,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,yBAAyB,EACzB,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,sBAAsB,EACtB,cAAc,GAGf,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,WAAW,GAGZ,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,aAAa,EACb,wBAAwB,GAEzB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,UAAU,EACV,gBAAgB,GAEjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,+BAA+B,EAC/B,kCAAkC,EAClC,sBAAsB,EACtB,wBAAwB,EACxB,2BAA2B,GAC5B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,0BAA0B,EAC1B,uBAAuB,EACvB,gBAAgB,GAIjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,qBAAqB,GAMtB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,2BAA2B,EAC3B,qBAAqB,GAEtB,MAAM,8BAA8B,CAAC","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  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":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EACL,cAAc,EACd,wBAAwB,EACxB,mBAAmB,EACnB,8BAA8B,GAC/B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,kBAAkB,EAKlB,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,0BAA0B,GAK3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,sBAAsB,EACtB,kBAAkB,GAEnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,eAAe,GAGhB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,aAAa,EACb,cAAc,EACd,UAAU,EACV,WAAW,EACX,eAAe,EACf,eAAe,EACf,qCAAqC,GAStC,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,sBAAsB,GAGvB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,2BAA2B,EAE3B,8BAA8B,GAE/B,MAAM,+BAA+B,CAAC;AACvC,cAAc,kCAAkC,CAAC;AACjD,OAAO,EAGL,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EACf,SAAS,GACV,MAAM,iBAAiB,CAAC;AACzB,iFAAiF;AACjF,8EAA8E;AAC9E,iFAAiF;AACjF,+DAA+D;AAC/D,OAAO,EACL,YAAY,EACZ,eAAe,EACf,gBAAgB,GACjB,MAAM,mBAAmB,CAAC;AAC3B,+EAA+E;AAC/E,yDAAyD;AACzD,OAAO,EACL,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,6BAA6B,GAG9B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,qBAAqB,GACtB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EACL,aAAa,EACb,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,yBAAyB,EACzB,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,sBAAsB,EACtB,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,EACtB,2BAA2B,GAQ5B,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,wBAAwB,EACxB,0BAA0B,EAC1B,wBAAwB,GAEzB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,WAAW,GAIZ,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,uBAAuB,EACvB,cAAc,EACd,qBAAqB,EACrB,iBAAiB,EACjB,yBAAyB,GAK1B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,aAAa,EACb,wBAAwB,GAEzB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,UAAU,EACV,gBAAgB,GAEjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,+BAA+B,EAC/B,kCAAkC,EAClC,sBAAsB,EACtB,wBAAwB,EACxB,2BAA2B,GAC5B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,0BAA0B,EAC1B,uBAAuB,EACvB,gBAAgB,GAIjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,qBAAqB,GAMtB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACb,0BAA0B,EAC1B,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,GAIrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,wBAAwB,EACxB,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,GAKlB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,oBAAoB,GAOrB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,2BAA2B,EAC3B,qBAAqB,GAEtB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,kBAAkB,EAClB,gBAAgB,GAEjB,MAAM,oBAAoB,CAAC","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/pagerduty-inbound.d.ts

@@ -0,0 +1,101 @@
+export declare const PAGERDUTY_API_URL = "https://api.pagerduty.com";
+/**
+ * Verify a PagerDuty v3 webhook signature.
+ *
+ * The scheme: `X-PagerDuty-Signature: v1=<lowercase hex>`, an HMAC-SHA256 over
+ * the RAW request body. Three properties of it are easy to get wrong and each
+ * one is a hole:
+ *
+ *  - THE RAW BODY, not a re-serialized object. `JSON.stringify(req.body)` after
+ *    a JSON parser has run produces different bytes (key order, whitespace,
+ *    number formatting), so every signature fails and the obvious "fix" is to
+ *    stop checking. The route therefore mounts `express.raw`.
+ *  - MULTIPLE SIGNATURES. The header may carry several comma-separated `v1=`
+ *    values, which is how PagerDuty rotates a secret without downtime. Checking
+ *    only the first breaks during their rotation, so ANY match is accepted —
+ *    the same overlap this repo already runs for its own relay token.
+ *  - CONSTANT TIME. Compared with `timingSafeEqual` on equal-length buffers,
+ *    because a byte-at-a-time comparison leaks the expected digest to anyone
+ *    who can post here repeatedly.
+ *
+ * NO SECRET MEANS NO. An unverified webhook that moves an audit record and a
+ * metric is a way for anyone who learns the URL to assert that a page was
+ * handled — the one lie that would make the whole feature report coverage it
+ * does not have. Fails closed.
+ */
+export declare function verifyPagerDutySignature(rawBody: Buffer | string, header: string | undefined, secret: string): boolean;
+export interface OnCallInboundConfig {
+    webhookSecret: string;
+    apiToken: string;
+    apiUrl: string;
+    /** How far ahead the rota check looks. The gap alert is only as useful as this. */
+    lookaheadHours: number;
+    /** Escalation policy ids to check coverage for; empty means the whole account. */
+    escalationPolicyIds: string[];
+    timeoutMs: number;
+}
+export declare function onCallInboundConfig(): OnCallInboundConfig;
+export interface RotaCoverage {
+    /** Whether the question could be answered at all. */
+    known: boolean;
+    /** Distinct on-call entries covering any part of the window. */
+    entries: number;
+    /** Seconds of the lookahead window with nobody on call, 0 when fully covered. */
+    uncoveredSeconds: number;
+}
+/**
+ * Ask the provider whether anyone is on call across the lookahead window.
+ *
+ * WHAT THIS CAN AND CANNOT CONCLUDE, because the difference decides whether the
+ * alert built on it is honest. `GET /oncalls?since&until` returns the on-call
+ * entries OVERLAPPING a window; it does not return the holes. Reconstructing
+ * exact holes would mean stitching every entry's interval, and an entry's
+ * `start`/`end` are null for an always-on policy — so a precise
+ * "uncovered seconds" is not available from this endpoint without a lot of
+ * arithmetic that would be wrong in the always-on case.
+ *
+ * So this answers the question it CAN answer exactly: is the window covered at
+ * all. Zero entries over the next N hours means nobody is scheduled, which is
+ * the failure worth paging about and the one a rota maintainer actually makes.
+ * `uncoveredSeconds` is therefore the whole window or nothing, and it is a
+ * deliberate under-report rather than a guess — a partial hole reads as covered
+ * here, and claiming otherwise would be inventing precision.
+ *
+ * `known: false` when there is no API token or the call fails, and the caller
+ * must publish NOTHING in that case. A gauge of 0 would say "fully covered",
+ * which is exactly the lie this check exists to prevent.
+ */
+export declare function fetchRotaCoverage(cfg?: OnCallInboundConfig): Promise<RotaCoverage>;
+/** The webhook events this system acts on. Everything else is counted and dropped. */
+export type OnCallWebhookEventType = 'incident.acknowledged' | 'incident.escalated' | 'incident.resolved' | 'incident.unacknowledged';
+export interface OnCallWebhookEvent {
+    eventType: string;
+    /** Provider incident id — the join back to what we sent. */
+    incidentId?: string;
+    /** Our own `dedup_key`, when the provider echoes it. */
+    dedupKey?: string;
+    /** Who acted, as the provider knows them. An id and an email, never a session. */
+    agentId?: string;
+    agentSummary?: string;
+    /** When the incident was created, for the ack-latency measurement. */
+    createdAt?: string;
+    occurredAt?: string;
+}
+/**
+ * Reduce a v3 webhook body to the fields this system uses.
+ *
+ * Returns `null` for anything that is not a recognised incident event, which
+ * the caller COUNTS rather than drops silently — an unrecognised event type is
+ * usually a subscription configured wider than the handler, and a count is how
+ * that becomes visible instead of being inferred from nothing happening.
+ */
+export declare function parseOnCallWebhook(body: unknown): OnCallWebhookEvent | null;
+/**
+ * Seconds between the incident being raised and this event.
+ *
+ * Returns `undefined` rather than 0 when either timestamp is missing or the
+ * arithmetic is nonsense: a 0 would land in the first histogram bucket and read
+ * as an instant acknowledgement, which is the most flattering possible lie
+ * about response time.
+ */
+export declare function ackLatencySeconds(event: OnCallWebhookEvent): number | undefined;