@pipeline-builder/api-core 5.2.3 → 5.2.4

package/lib/constants/ai-providers.d.ts

@@ -1,25 +1,6 @@
-/** Metadata for a single AI model. */
-export interface AIModelInfo {
-    /** Model identifier used in API calls (e.g. "claude-sonnet-5"). */
-    id: string;
-    /** Human-readable display name (e.g. "Claude Sonnet 5"). */
-    name: string;
-}
-/** Metadata for an AI provider with its available models. */
-export interface AIProviderInfo {
-    /** Provider identifier (e.g. "anthropic", "openai", "google"). */
-    id: string;
-    /** Human-readable display name (e.g. "Anthropic"). */
-    name: string;
-    /** Models available for this provider. */
-    models: AIModelInfo[];
-}
-/**
- * Standard AI provider catalog — single source of truth for all supported
- * providers and their models. Used by both backend services and frontend
- * components.
- */
-export declare const AI_PROVIDER_CATALOG: Record<string, AIProviderInfo>;
+import { type AIModelInfo, type AIProviderInfo } from '../types/ai-catalog.js';
+export { AI_PROVIDER_CATALOG, AI_PROVIDER_NAMES, AI_PROVIDER_MODELS, AI_KEY_PROVIDER_IDS, isKeylessProviderId } from '../types/ai-catalog.js';
+export type { AIModelInfo, AIProviderInfo } from '../types/ai-catalog.js';
 /**
  * Environment variable names for each AI provider's API key.
  * Used by backend services to initialize the provider registry.

package/lib/constants/ai-providers.js

@@ -1,60 +1,10 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-// Catalog
-/**
- * Standard AI provider catalog — single source of truth for all supported
- * providers and their models. Used by both backend services and frontend
- * components.
- */
-export const AI_PROVIDER_CATALOG = {
-    'anthropic': {
-        id: 'anthropic',
-        name: 'Anthropic',
-        models: [
-            { id: 'claude-sonnet-5', name: 'Claude Sonnet 5' },
-            { id: 'claude-opus-5', name: 'Claude Opus 5' },
-            { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5' },
-        ],
-    },
-    'openai': {
-        id: 'openai',
-        name: 'OpenAI',
-        models: [
-            { id: 'gpt-5.6-sol', name: 'GPT-5.6 Sol' },
-            { id: 'gpt-5.6-terra', name: 'GPT-5.6 Terra' },
-            { id: 'gpt-5.6-luna', name: 'GPT-5.6 Luna' },
-        ],
-    },
-    'google': {
-        id: 'google',
-        name: 'Google',
-        models: [
-            { id: 'gemini-3.7-flash', name: 'Gemini 3.7 Flash' },
-            { id: 'gemini-3.1-pro-preview', name: 'Gemini 3.1 Pro' },
-        ],
-    },
-    'xai': {
-        id: 'xai',
-        name: 'xAI (Grok)',
-        models: [
-            { id: 'grok-4.6', name: 'Grok 4.6' },
-            { id: 'grok-4.5', name: 'Grok 4.5' },
-            { id: 'grok-4.3', name: 'Grok 4.3' },
-        ],
-    },
-    'amazon-bedrock': {
-        id: 'amazon-bedrock',
-        name: 'Amazon Bedrock',
-        // Bedrock ids are region-scoped cross-region inference profiles; the `us.`
-        // prefix targets US regions — swap the prefix (eu./apac./…) to match your
-        // deploy region, and confirm availability in the Bedrock console.
-        models: [
-            { id: 'us.anthropic.claude-sonnet-4-5-20250929-v1:0', name: 'Claude Sonnet 4.5' },
-            { id: 'us.amazon.nova-pro-v1:0', name: 'Amazon Nova Pro' },
-            { id: 'us.amazon.nova-lite-v1:0', name: 'Amazon Nova Lite' },
-        ],
-    },
-};
+import { AI_PROVIDER_CATALOG } from '../types/ai-catalog.js';
+// The catalog itself is data-only and lives in `types/ai-catalog.ts` (the
+// browser-safe `./ai-catalog` subpath); re-exported here so server code keeps one
+// import site for everything AI-provider.
+export { AI_PROVIDER_CATALOG, AI_PROVIDER_NAMES, AI_PROVIDER_MODELS, AI_KEY_PROVIDER_IDS, isKeylessProviderId } from '../types/ai-catalog.js';
 /**
  * Environment variable names for each AI provider's API key.
  * Used by backend services to initialize the provider registry.
@@ -126,4 +76,4 @@ export function getAIProviderModels(providerId) {
     }
     return AI_PROVIDER_CATALOG[providerId]?.models ?? [];
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai-providers.js","sourceRoot":"","sources":["../../src/constants/ai-providers.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n// Types\n\n/** Metadata for a single AI model. */\nexport interface AIModelInfo {\n  /** Model identifier used in API calls (e.g. \"claude-sonnet-5\"). */\n  id: string;\n  /** Human-readable display name (e.g. \"Claude Sonnet 5\"). */\n  name: string;\n}\n\n/** Metadata for an AI provider with its available models. */\nexport interface AIProviderInfo {\n  /** Provider identifier (e.g. \"anthropic\", \"openai\", \"google\"). */\n  id: string;\n  /** Human-readable display name (e.g. \"Anthropic\"). */\n  name: string;\n  /** Models available for this provider. */\n  models: AIModelInfo[];\n}\n\n// Catalog\n\n/**\n * Standard AI provider catalog — single source of truth for all supported\n * providers and their models. Used by both backend services and frontend\n * components.\n */\nexport const AI_PROVIDER_CATALOG: Record<string, AIProviderInfo> = {\n  'anthropic': {\n    id: 'anthropic',\n    name: 'Anthropic',\n    models: [\n      { id: 'claude-sonnet-5', name: 'Claude Sonnet 5' },\n      { id: 'claude-opus-5', name: 'Claude Opus 5' },\n      { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5' },\n    ],\n  },\n  'openai': {\n    id: 'openai',\n    name: 'OpenAI',\n    models: [\n      { id: 'gpt-5.6-sol', name: 'GPT-5.6 Sol' },\n      { id: 'gpt-5.6-terra', name: 'GPT-5.6 Terra' },\n      { id: 'gpt-5.6-luna', name: 'GPT-5.6 Luna' },\n    ],\n  },\n  'google': {\n    id: 'google',\n    name: 'Google',\n    models: [\n      { id: 'gemini-3.7-flash', name: 'Gemini 3.7 Flash' },\n      { id: 'gemini-3.1-pro-preview', name: 'Gemini 3.1 Pro' },\n    ],\n  },\n  'xai': {\n    id: 'xai',\n    name: 'xAI (Grok)',\n    models: [\n      { id: 'grok-4.6', name: 'Grok 4.6' },\n      { id: 'grok-4.5', name: 'Grok 4.5' },\n      { id: 'grok-4.3', name: 'Grok 4.3' },\n    ],\n  },\n  'amazon-bedrock': {\n    id: 'amazon-bedrock',\n    name: 'Amazon Bedrock',\n    // Bedrock ids are region-scoped cross-region inference profiles; the `us.`\n    // prefix targets US regions — swap the prefix (eu./apac./…) to match your\n    // deploy region, and confirm availability in the Bedrock console.\n    models: [\n      { id: 'us.anthropic.claude-sonnet-4-5-20250929-v1:0', name: 'Claude Sonnet 4.5' },\n      { id: 'us.amazon.nova-pro-v1:0', name: 'Amazon Nova Pro' },\n      { id: 'us.amazon.nova-lite-v1:0', name: 'Amazon Nova Lite' },\n    ],\n  },\n};\n\n/**\n * Environment variable names for each AI provider's API key.\n * Used by backend services to initialize the provider registry.\n */\nexport const AI_PROVIDER_ENV_VARS: Record<string, string> = {\n  'anthropic': 'ANTHROPIC_API_KEY',\n  'openai': 'OPENAI_API_KEY',\n  'google': 'GOOGLE_GENERATIVE_AI_API_KEY',\n  'xai': 'XAI_API_KEY',\n  'amazon-bedrock': 'AWS_ACCESS_KEY_ID',\n};\n\n/**\n * Provider id for a self-hosted, OpenAI-compatible endpoint — a Docker model image\n * (Ollama, Docker Model Runner, vLLM) or any other server that speaks the OpenAI\n * chat API. Unlike the fixed providers above, this one is NOT in the static catalog:\n * its endpoint and model list are deployment-defined and resolved from env at\n * runtime by {@link getOpenAICompatibleProvider}.\n */\nexport const OPENAI_COMPATIBLE_PROVIDER_ID = 'openai-compatible';\n\n/**\n * Parse a `id[|Display Name][,id2[|Name2]]` env string into model metadata. The\n * id/name separator is `|` (NOT `:`) because model ids commonly contain colons —\n * e.g. Ollama tags (`qwen2.5-coder:7b`) and Bedrock inference profiles.\n */\nfunction parseModelList(raw: string): AIModelInfo[] {\n  return raw\n    .split(',')\n    .map((s) => s.trim())\n    .filter(Boolean)\n    .map((entry) => {\n      const idx = entry.indexOf('|');\n      const id = (idx === -1 ? entry : entry.slice(0, idx)).trim();\n      const name = (idx === -1 ? '' : entry.slice(idx + 1)).trim() || id;\n      return { id, name };\n    })\n    .filter((m) => m.id.length > 0);\n}\n\n/**\n * Resolve the OpenAI-compatible (local / self-hosted) provider from env, or `null`\n * when no endpoint is configured. Enabled by `OPENAI_COMPATIBLE_BASE_URL`; the model\n * list comes from `OPENAI_COMPATIBLE_MODELS` (comma list of `id[|Display Name]`),\n * falling back to `OPENAI_COMPATIBLE_MODEL`, then a generic `local` id. The display\n * name is overridable via `OPENAI_COMPATIBLE_NAME`.\n *\n * @returns Provider info for the configured local endpoint, or null if unset\n */\nexport function getOpenAICompatibleProvider(): AIProviderInfo | null {\n  const baseURL = process.env.OPENAI_COMPATIBLE_BASE_URL;\n  if (!baseURL) return null;\n  const raw = process.env.OPENAI_COMPATIBLE_MODELS ?? process.env.OPENAI_COMPATIBLE_MODEL ?? 'local|Local model';\n  const models = parseModelList(raw);\n  return {\n    id: OPENAI_COMPATIBLE_PROVIDER_ID,\n    name: process.env.OPENAI_COMPATIBLE_NAME || 'Local model (OpenAI-compatible)',\n    models: models.length > 0 ? models : [{ id: 'local', name: 'Local model' }],\n  };\n}\n\n// Helpers\n\n/**\n * Get the model list for a given provider ID.\n *\n * @param providerId - Provider identifier (e.g. \"anthropic\")\n * @returns Array of models, or empty array if the provider is unknown\n */\nexport function getAIProviderModels(providerId: string): AIModelInfo[] {\n  if (providerId === OPENAI_COMPATIBLE_PROVIDER_ID) {\n    return getOpenAICompatibleProvider()?.models ?? [];\n  }\n  return AI_PROVIDER_CATALOG[providerId]?.models ?? [];\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/errors/app-errors.d.ts

@@ -31,3 +31,17 @@ export declare class ValidationError extends AppError {
 export declare class ConflictError extends AppError {
     constructor(message: string, code?: ErrorCode, details?: Record<string, unknown>);
 }
+/** 403 — the organization's administrators switched AI features off. */
+export declare class AIDisabledError extends AppError {
+    constructor(message?: string);
+}
+/**
+ * An AI request could not be served AS ASKED — the org's own provider key could not
+ * be loaded, a bring-your-own key named a keyless provider, nothing is configured.
+ * The message is written by us and names configuration, never a secret, so it is
+ * safe to show; `handleAIError` surfaces it verbatim with this status. Thrown
+ * INSTEAD of silently serving the request on the platform's key.
+ */
+export declare class AIConfigurationError extends AppError {
+    constructor(message: string, statusCode?: number, code?: ErrorCode);
+}

package/lib/errors/app-errors.js

@@ -50,4 +50,24 @@ export class ConflictError extends AppError {
         this.name = 'ConflictError';
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+/** 403 — the organization's administrators switched AI features off. */
+export class AIDisabledError extends AppError {
+    constructor(message = 'AI features are turned off for this organization. An organization administrator can turn them back on in Settings.') {
+        super(getStatusForErrorCode(ErrorCode.AI_DISABLED), ErrorCode.AI_DISABLED, message);
+        this.name = 'AIDisabledError';
+    }
+}
+/**
+ * An AI request could not be served AS ASKED — the org's own provider key could not
+ * be loaded, a bring-your-own key named a keyless provider, nothing is configured.
+ * The message is written by us and names configuration, never a secret, so it is
+ * safe to show; `handleAIError` surfaces it verbatim with this status. Thrown
+ * INSTEAD of silently serving the request on the platform's key.
+ */
+export class AIConfigurationError extends AppError {
+    constructor(message, statusCode = 503, code = ErrorCode.SERVICE_UNAVAILABLE) {
+        super(statusCode, code, message);
+        this.name = 'AIConfigurationError';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/helpers/sse-helpers.d.ts

@@ -1,4 +1,5 @@
 import type { Request, Response } from 'express';
+import { ErrorCode } from '../types/error-codes.js';
 /**
  * Set the four standard SSE response headers (does NOT flush — the caller flushes
  * after any additional per-endpoint setup like `res.setTimeout`). The single
@@ -41,9 +42,38 @@ export interface SseStream {
  * client-disconnect signal (see {@link clientAbortSignal}).
  */
 export declare function initSSEStream(_req: Request, res: Response, timeoutMs: number): SseStream;
+/** How an AI failure is answered: an HTTP status, a code, and a message WE wrote. */
+export interface AIErrorResponse {
+    status: number;
+    code: ErrorCode;
+    /** Safe to show: never raw provider response text. */
+    message: string;
+    /** Seconds, from the provider's own `Retry-After` when it sent one. */
+    retryAfterSeconds?: number;
+}
+/**
+ * Classify an AI failure into the response a caller sends.
+ *
+ * Provider failures are matched on the provider's HTTP STATUS (`APICallError.statusCode`),
+ * never on message text, and answered with a sentence of ours: a provider's error body
+ * can carry account ids, request ids, quota details or an echo of the prompt, and none
+ * of it belongs in a response or an SSE frame. The full error still goes to the
+ * caller's log line.
+ *
+ *  - 429 → 429 (with the provider's `Retry-After`): the provider is rate limiting.
+ *  - 529 / 5xx → 503 (with `Retry-After`): the provider is overloaded or down.
+ *  - 401 / 403 → 502: the provider refused the credential (a BYO or org key is wrong).
+ *  - a timeout signal → 504.
+ *  - an {@link AppError} (AIDisabledError, AIConfigurationError, …) → its own status and message.
+ *  - otherwise the configuration messages the registry writes (they name env vars,
+ *    never values) keep their text; anything else gets `fallbackMessage`.
+ */
+export declare function classifyAIError(error: unknown, fallbackMessage: string): AIErrorResponse;
 /**
- * Classify AI generation errors and send the appropriate HTTP response or SSE event.
- * If headers are already sent (streaming), writes an SSE error event and ends the response.
+ * Answer an AI generation failure: an HTTP error before the stream started, or an
+ * SSE `error` event (then end) once it has. Takes the ERROR, not its message — the
+ * provider status is what decides the answer (see {@link classifyAIError}); a string
+ * is still accepted for the registry's configuration messages.
  */
-export declare function handleAIError(res: Response, message: string, fallbackMessage: string): void;
+export declare function handleAIError(res: Response, error: unknown, fallbackMessage: string): void;
 export {};

package/lib/helpers/sse-helpers.js

@@ -1,6 +1,8 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import { sendBadRequest, sendInternalError } from '../utils/response.js';
+import { AppError } from '../errors/app-errors.js';
+import { ErrorCode } from '../types/error-codes.js';
+import { errorMessage, sendError } from '../utils/response.js';
 /**
  * Set the four standard SSE response headers (does NOT flush — the caller flushes
  * after any additional per-endpoint setup like `res.setTimeout`). The single
@@ -60,28 +62,98 @@ export function initSSEStream(_req, res, timeoutMs) {
         },
     };
 }
+/** `Retry-After` as seconds — either form the header allows (delta-seconds or an HTTP date). */
+function retryAfterSeconds(headers) {
+    const raw = headers?.['retry-after'] ?? headers?.['Retry-After'];
+    if (!raw)
+        return undefined;
+    const asNumber = Number(raw);
+    if (Number.isFinite(asNumber) && asNumber >= 0)
+        return Math.ceil(asNumber);
+    const at = Date.parse(raw);
+    return Number.isNaN(at) ? undefined : Math.max(0, Math.ceil((at - Date.now()) / 1000));
+}
+/** True for an abort that came from a TIMEOUT signal rather than a client disconnect. */
+function isTimeout(error) {
+    const e = error;
+    return e?.name === 'TimeoutError' || e?.cause?.name === 'TimeoutError';
+}
 /**
- * Classify AI generation errors and send the appropriate HTTP response or SSE event.
- * If headers are already sent (streaming), writes an SSE error event and ends the response.
+ * Classify an AI failure into the response a caller sends.
+ *
+ * Provider failures are matched on the provider's HTTP STATUS (`APICallError.statusCode`),
+ * never on message text, and answered with a sentence of ours: a provider's error body
+ * can carry account ids, request ids, quota details or an echo of the prompt, and none
+ * of it belongs in a response or an SSE frame. The full error still goes to the
+ * caller's log line.
+ *
+ *  - 429 → 429 (with the provider's `Retry-After`): the provider is rate limiting.
+ *  - 529 / 5xx → 503 (with `Retry-After`): the provider is overloaded or down.
+ *  - 401 / 403 → 502: the provider refused the credential (a BYO or org key is wrong).
+ *  - a timeout signal → 504.
+ *  - an {@link AppError} (AIDisabledError, AIConfigurationError, …) → its own status and message.
+ *  - otherwise the configuration messages the registry writes (they name env vars,
+ *    never values) keep their text; anything else gets `fallbackMessage`.
  */
-export function handleAIError(res, message, fallbackMessage) {
-    if (!res.headersSent) {
-        if (message.includes('not configured') || message.includes('API key')) {
-            // Surface the ORIGINAL message. It names the MISSING CONFIGURATION —
-            // "no provider API key is set and OPENAI_COMPATIBLE_BASE_URL is unset",
-            // or which env var a named provider wants — never a secret VALUE, so it
-            // is safe to show and it is the only thing that makes this error
-            // actionable. The generic replacement also mis-described the common case:
-            // it said "for the requested provider" when no provider was requested at
-            // all, pointing operators at a provider bug instead of at configuration.
-            return sendInternalError(res, message);
+export function classifyAIError(error, fallbackMessage) {
+    if (error instanceof AppError) {
+        return { status: error.statusCode, code: error.code, message: error.message };
+    }
+    const providerStatus = typeof error?.statusCode === 'number'
+        ? error.statusCode
+        : undefined;
+    if (providerStatus !== undefined) {
+        const retryAfter = retryAfterSeconds(error.responseHeaders);
+        const withRetry = retryAfter !== undefined ? { retryAfterSeconds: retryAfter } : {};
+        if (providerStatus === 429) {
+            return { status: 429, code: ErrorCode.RATE_LIMIT_EXCEEDED, message: 'The AI provider is rate limiting requests. Try again shortly.', ...withRetry };
         }
-        if (message.includes('not available for provider')) {
-            return sendBadRequest(res, message);
+        if (providerStatus === 529 || providerStatus >= 500) {
+            return { status: 503, code: ErrorCode.SERVICE_UNAVAILABLE, message: 'The AI provider is temporarily unavailable. Try again shortly.', ...withRetry };
         }
-        return sendInternalError(res, fallbackMessage, { details: message });
+        if (providerStatus === 401 || providerStatus === 403) {
+            return { status: 502, code: ErrorCode.INTERNAL_ERROR, message: 'The AI provider rejected the API key used for this request. Check the key in Settings, or the one you supplied.' };
+        }
+        return { status: 502, code: ErrorCode.INTERNAL_ERROR, message: fallbackMessage };
+    }
+    if (isTimeout(error)) {
+        return { status: 504, code: ErrorCode.SERVICE_UNAVAILABLE, message: 'The AI provider did not respond in time. Try again, or ask for something smaller.' };
+    }
+    const message = typeof error === 'string' ? error : errorMessage(error);
+    if (message.includes('not configured') || message.includes('API key')) {
+        // Surface the ORIGINAL message. Only the registry's own configuration errors
+        // reach here (a provider's response carries a status and was handled above):
+        // they name the MISSING CONFIGURATION — "no provider API key is set and
+        // OPENAI_COMPATIBLE_BASE_URL is unset", or which env var a named provider
+        // wants — never a secret VALUE, and are the only thing that makes this error
+        // actionable.
+        return { status: 500, code: ErrorCode.INTERNAL_ERROR, message };
+    }
+    if (message.includes('not available for provider')) {
+        return { status: 400, code: ErrorCode.VALIDATION_ERROR, message };
+    }
+    return { status: 500, code: ErrorCode.INTERNAL_ERROR, message: fallbackMessage };
+}
+/**
+ * Answer an AI generation failure: an HTTP error before the stream started, or an
+ * SSE `error` event (then end) once it has. Takes the ERROR, not its message — the
+ * provider status is what decides the answer (see {@link classifyAIError}); a string
+ * is still accepted for the registry's configuration messages.
+ */
+export function handleAIError(res, error, fallbackMessage) {
+    const answer = classifyAIError(error, fallbackMessage);
+    if (!res.headersSent) {
+        if (answer.retryAfterSeconds !== undefined)
+            res.setHeader('Retry-After', String(answer.retryAfterSeconds));
+        return sendError(res, answer.status, answer.message, answer.code);
     }
-    res.write(`data: ${JSON.stringify({ type: 'error', message })}\n\n`);
+    res.write(`data: ${JSON.stringify({
+        type: 'error',
+        message: answer.message,
+        code: answer.code,
+        status: answer.status,
+        ...(answer.retryAfterSeconds !== undefined ? { retryAfterSeconds: answer.retryAfterSeconds } : {}),
+    })}\n\n`);
     res.end();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse-helpers.js","sourceRoot":"","sources":["../../src/helpers/sse-helpers.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAGtC,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEzE;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,GAAa;IAC3C,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,mBAAmB,CAAC,CAAC;IACnD,GAAG,CAAC,SAAS,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;IAC3C,GAAG,CAAC,SAAS,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;IAC1C,GAAG,CAAC,SAAS,CAAC,mBAAmB,EAAE,IAAI,CAAC,CAAC;AAC3C,CAAC;AAQD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAqB;IACrD,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;IACzC,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;QACnB,IAAI,CAAC,GAAG,CAAC,gBAAgB;YAAE,UAAU,CAAC,KAAK,EAAE,CAAC;IAChD,CAAC,CAAC,CAAC;IACH,OAAO,UAAU,CAAC,MAAM,CAAC;AAC3B,CAAC;AAeD;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,IAAa,EAAE,GAAa,EAAE,SAAiB;IAC3E,eAAe,CAAC,GAAG,CAAC,CAAC;IACrB,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IAC1B,GAAG,CAAC,YAAY,EAAE,CAAC;IACnB,MAAM,MAAM,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC;IACtC,MAAM,IAAI,GAAG,CAAC,KAAc,EAAQ,EAAE;QACpC,IAAI,MAAM,CAAC,OAAO;YAAE,OAAO;QAC3B,GAAG,CAAC,KAAK,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAClD,CAAC,CAAC;IACF,OAAO;QACL,MAAM;QACN,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO;QAC7B,IAAI;QACJ,IAAI,EAAE,CAAC,KAAe,EAAQ,EAAE;YAC9B,IAAI,MAAM,CAAC,OAAO;gBAAE,OAAO;YAC3B,IAAI,KAAK,KAAK,SAAS;gBAAE,IAAI,CAAC,KAAK,CAAC,CAAC;YACrC,GAAG,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;QAChC,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,GAAa,EAAE,OAAe,EAAE,eAAuB;IACnF,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;QACrB,IAAI,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;YACtE,qEAAqE;YACrE,wEAAwE;YACxE,wEAAwE;YACxE,iEAAiE;YACjE,0EAA0E;YAC1E,yEAAyE;YACzE,yEAAyE;YACzE,OAAO,iBAAiB,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;QACzC,CAAC;QACD,IAAI,OAAO,CAAC,QAAQ,CAAC,4BAA4B,CAAC,EAAE,CAAC;YACnD,OAAO,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC;QACD,OAAO,iBAAiB,CAAC,GAAG,EAAE,eAAe,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;IACvE,CAAC;IACD,GAAG,CAAC,KAAK,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC;IACrE,GAAG,CAAC,GAAG,EAAE,CAAC;AACZ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Request, Response } from 'express';\nimport { sendBadRequest, sendInternalError } from '../utils/response.js';\n\n/**\n * Set the four standard SSE response headers (does NOT flush — the caller flushes\n * after any additional per-endpoint setup like `res.setTimeout`). The single\n * source of truth for the `text/event-stream` + no-cache + keep-alive +\n * `X-Accel-Buffering: no` (disable nginx buffering) block.\n */\nexport function writeSseHeaders(res: Response): void {\n  res.setHeader('Content-Type', 'text/event-stream');\n  res.setHeader('Cache-Control', 'no-cache');\n  res.setHeader('Connection', 'keep-alive');\n  res.setHeader('X-Accel-Buffering', 'no');\n}\n\n/** The slice of an Express/Node response needed to observe a client disconnect. */\ninterface ClosableResponse {\n  on(event: 'close', listener: () => void): unknown;\n  readonly writableFinished: boolean;\n}\n\n/**\n * An AbortSignal that fires when the client disconnects before the response\n * finished — cancels a provider call (avoids wasted spend) and tells the route\n * to stop writing.\n *\n * Disconnect is detected on the RESPONSE: `res` emits 'close' when the\n * underlying connection goes away, and `writableFinished` tells an early close\n * (client gone) from the normal close after `res.end()`. The request's own\n * 'close' is not a disconnect signal — on current Node it fires once the request\n * BODY has been consumed (express.json() does that before the handler runs), so\n * a disconnect would never be observed.\n */\nexport function clientAbortSignal(res: ClosableResponse): AbortSignal {\n  const controller = new AbortController();\n  res.on('close', () => {\n    if (!res.writableFinished) controller.abort();\n  });\n  return controller.signal;\n}\n\n/** An open SSE response. */\nexport interface SseStream {\n  /** Aborted when the client disconnects before the stream finished. */\n  readonly signal: AbortSignal;\n  /** True once the client has disconnected. */\n  aborted(): boolean;\n  /** Write one `data:` frame carrying `event` as JSON. A no-op after a disconnect. */\n  send(event: unknown): void;\n  /** Write the terminal `data: [DONE]` frame (preceded by `event`, when given).\n   *  A no-op after a disconnect. The caller still ends the response. */\n  done(event?: unknown): void;\n}\n\n/**\n * Set SSE response headers, flush, and return the stream's writer plus its\n * client-disconnect signal (see {@link clientAbortSignal}).\n */\nexport function initSSEStream(_req: Request, res: Response, timeoutMs: number): SseStream {\n  writeSseHeaders(res);\n  res.setTimeout(timeoutMs);\n  res.flushHeaders();\n  const signal = clientAbortSignal(res);\n  const send = (event: unknown): void => {\n    if (signal.aborted) return;\n    res.write(`data: ${JSON.stringify(event)}\\n\\n`);\n  };\n  return {\n    signal,\n    aborted: () => signal.aborted,\n    send,\n    done: (event?: unknown): void => {\n      if (signal.aborted) return;\n      if (event !== undefined) send(event);\n      res.write('data: [DONE]\\n\\n');\n    },\n  };\n}\n\n/**\n * Classify AI generation errors and send the appropriate HTTP response or SSE event.\n * If headers are already sent (streaming), writes an SSE error event and ends the response.\n */\nexport function handleAIError(res: Response, message: string, fallbackMessage: string): void {\n  if (!res.headersSent) {\n    if (message.includes('not configured') || message.includes('API key')) {\n      // Surface the ORIGINAL message. It names the MISSING CONFIGURATION —\n      // \"no provider API key is set and OPENAI_COMPATIBLE_BASE_URL is unset\",\n      // or which env var a named provider wants — never a secret VALUE, so it\n      // is safe to show and it is the only thing that makes this error\n      // actionable. The generic replacement also mis-described the common case:\n      // it said \"for the requested provider\" when no provider was requested at\n      // all, pointing operators at a provider bug instead of at configuration.\n      return sendInternalError(res, message);\n    }\n    if (message.includes('not available for provider')) {\n      return sendBadRequest(res, message);\n    }\n    return sendInternalError(res, fallbackMessage, { details: message });\n  }\n  res.write(`data: ${JSON.stringify({ type: 'error', message })}\\n\\n`);\n  res.end();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse-helpers.js","sourceRoot":"","sources":["../../src/helpers/sse-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Request, Response } from 'express';\nimport { AppError } from '../errors/app-errors.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { errorMessage, sendError } from '../utils/response.js';\n\n/**\n * Set the four standard SSE response headers (does NOT flush — the caller flushes\n * after any additional per-endpoint setup like `res.setTimeout`). The single\n * source of truth for the `text/event-stream` + no-cache + keep-alive +\n * `X-Accel-Buffering: no` (disable nginx buffering) block.\n */\nexport function writeSseHeaders(res: Response): void {\n  res.setHeader('Content-Type', 'text/event-stream');\n  res.setHeader('Cache-Control', 'no-cache');\n  res.setHeader('Connection', 'keep-alive');\n  res.setHeader('X-Accel-Buffering', 'no');\n}\n\n/** The slice of an Express/Node response needed to observe a client disconnect. */\ninterface ClosableResponse {\n  on(event: 'close', listener: () => void): unknown;\n  readonly writableFinished: boolean;\n}\n\n/**\n * An AbortSignal that fires when the client disconnects before the response\n * finished — cancels a provider call (avoids wasted spend) and tells the route\n * to stop writing.\n *\n * Disconnect is detected on the RESPONSE: `res` emits 'close' when the\n * underlying connection goes away, and `writableFinished` tells an early close\n * (client gone) from the normal close after `res.end()`. The request's own\n * 'close' is not a disconnect signal — on current Node it fires once the request\n * BODY has been consumed (express.json() does that before the handler runs), so\n * a disconnect would never be observed.\n */\nexport function clientAbortSignal(res: ClosableResponse): AbortSignal {\n  const controller = new AbortController();\n  res.on('close', () => {\n    if (!res.writableFinished) controller.abort();\n  });\n  return controller.signal;\n}\n\n/** An open SSE response. */\nexport interface SseStream {\n  /** Aborted when the client disconnects before the stream finished. */\n  readonly signal: AbortSignal;\n  /** True once the client has disconnected. */\n  aborted(): boolean;\n  /** Write one `data:` frame carrying `event` as JSON. A no-op after a disconnect. */\n  send(event: unknown): void;\n  /** Write the terminal `data: [DONE]` frame (preceded by `event`, when given).\n   *  A no-op after a disconnect. The caller still ends the response. */\n  done(event?: unknown): void;\n}\n\n/**\n * Set SSE response headers, flush, and return the stream's writer plus its\n * client-disconnect signal (see {@link clientAbortSignal}).\n */\nexport function initSSEStream(_req: Request, res: Response, timeoutMs: number): SseStream {\n  writeSseHeaders(res);\n  res.setTimeout(timeoutMs);\n  res.flushHeaders();\n  const signal = clientAbortSignal(res);\n  const send = (event: unknown): void => {\n    if (signal.aborted) return;\n    res.write(`data: ${JSON.stringify(event)}\\n\\n`);\n  };\n  return {\n    signal,\n    aborted: () => signal.aborted,\n    send,\n    done: (event?: unknown): void => {\n      if (signal.aborted) return;\n      if (event !== undefined) send(event);\n      res.write('data: [DONE]\\n\\n');\n    },\n  };\n}\n\n/** How an AI failure is answered: an HTTP status, a code, and a message WE wrote. */\nexport interface AIErrorResponse {\n  status: number;\n  code: ErrorCode;\n  /** Safe to show: never raw provider response text. */\n  message: string;\n  /** Seconds, from the provider's own `Retry-After` when it sent one. */\n  retryAfterSeconds?: number;\n}\n\n/** The fields of an ai-sdk `APICallError` this classifier reads (duck-typed: api-core does not depend on `ai`). */\ninterface ProviderCallError {\n  statusCode?: unknown;\n  responseHeaders?: Record<string, string | undefined>;\n}\n\n/** `Retry-After` as seconds — either form the header allows (delta-seconds or an HTTP date). */\nfunction retryAfterSeconds(headers: Record<string, string | undefined> | undefined): number | undefined {\n  const raw = headers?.['retry-after'] ?? headers?.['Retry-After'];\n  if (!raw) return undefined;\n  const asNumber = Number(raw);\n  if (Number.isFinite(asNumber) && asNumber >= 0) return Math.ceil(asNumber);\n  const at = Date.parse(raw);\n  return Number.isNaN(at) ? undefined : Math.max(0, Math.ceil((at - Date.now()) / 1000));\n}\n\n/** True for an abort that came from a TIMEOUT signal rather than a client disconnect. */\nfunction isTimeout(error: unknown): boolean {\n  const e = error as { name?: unknown; cause?: { name?: unknown } } | null;\n  return e?.name === 'TimeoutError' || e?.cause?.name === 'TimeoutError';\n}\n\n/**\n * Classify an AI failure into the response a caller sends.\n *\n * Provider failures are matched on the provider's HTTP STATUS (`APICallError.statusCode`),\n * never on message text, and answered with a sentence of ours: a provider's error body\n * can carry account ids, request ids, quota details or an echo of the prompt, and none\n * of it belongs in a response or an SSE frame. The full error still goes to the\n * caller's log line.\n *\n *  - 429 → 429 (with the provider's `Retry-After`): the provider is rate limiting.\n *  - 529 / 5xx → 503 (with `Retry-After`): the provider is overloaded or down.\n *  - 401 / 403 → 502: the provider refused the credential (a BYO or org key is wrong).\n *  - a timeout signal → 504.\n *  - an {@link AppError} (AIDisabledError, AIConfigurationError, …) → its own status and message.\n *  - otherwise the configuration messages the registry writes (they name env vars,\n *    never values) keep their text; anything else gets `fallbackMessage`.\n */\nexport function classifyAIError(error: unknown, fallbackMessage: string): AIErrorResponse {\n  if (error instanceof AppError) {\n    return { status: error.statusCode, code: error.code, message: error.message };\n  }\n  const providerStatus = typeof (error as ProviderCallError | null)?.statusCode === 'number'\n    ? (error as ProviderCallError).statusCode as number\n    : undefined;\n  if (providerStatus !== undefined) {\n    const retryAfter = retryAfterSeconds((error as ProviderCallError).responseHeaders);\n    const withRetry = retryAfter !== undefined ? { retryAfterSeconds: retryAfter } : {};\n    if (providerStatus === 429) {\n      return { status: 429, code: ErrorCode.RATE_LIMIT_EXCEEDED, message: 'The AI provider is rate limiting requests. Try again shortly.', ...withRetry };\n    }\n    if (providerStatus === 529 || providerStatus >= 500) {\n      return { status: 503, code: ErrorCode.SERVICE_UNAVAILABLE, message: 'The AI provider is temporarily unavailable. Try again shortly.', ...withRetry };\n    }\n    if (providerStatus === 401 || providerStatus === 403) {\n      return { status: 502, code: ErrorCode.INTERNAL_ERROR, message: 'The AI provider rejected the API key used for this request. Check the key in Settings, or the one you supplied.' };\n    }\n    return { status: 502, code: ErrorCode.INTERNAL_ERROR, message: fallbackMessage };\n  }\n  if (isTimeout(error)) {\n    return { status: 504, code: ErrorCode.SERVICE_UNAVAILABLE, message: 'The AI provider did not respond in time. Try again, or ask for something smaller.' };\n  }\n\n  const message = typeof error === 'string' ? error : errorMessage(error);\n  if (message.includes('not configured') || message.includes('API key')) {\n    // Surface the ORIGINAL message. Only the registry's own configuration errors\n    // reach here (a provider's response carries a status and was handled above):\n    // they name the MISSING CONFIGURATION — \"no provider API key is set and\n    // OPENAI_COMPATIBLE_BASE_URL is unset\", or which env var a named provider\n    // wants — never a secret VALUE, and are the only thing that makes this error\n    // actionable.\n    return { status: 500, code: ErrorCode.INTERNAL_ERROR, message };\n  }\n  if (message.includes('not available for provider')) {\n    return { status: 400, code: ErrorCode.VALIDATION_ERROR, message };\n  }\n  return { status: 500, code: ErrorCode.INTERNAL_ERROR, message: fallbackMessage };\n}\n\n/**\n * Answer an AI generation failure: an HTTP error before the stream started, or an\n * SSE `error` event (then end) once it has. Takes the ERROR, not its message — the\n * provider status is what decides the answer (see {@link classifyAIError}); a string\n * is still accepted for the registry's configuration messages.\n */\nexport function handleAIError(res: Response, error: unknown, fallbackMessage: string): void {\n  const answer = classifyAIError(error, fallbackMessage);\n  if (!res.headersSent) {\n    if (answer.retryAfterSeconds !== undefined) res.setHeader('Retry-After', String(answer.retryAfterSeconds));\n    return sendError(res, answer.status, answer.message, answer.code);\n  }\n  res.write(`data: ${JSON.stringify({\n    type: 'error',\n    message: answer.message,\n    code: answer.code,\n    status: answer.status,\n    ...(answer.retryAfterSeconds !== undefined ? { retryAfterSeconds: answer.retryAfterSeconds } : {}),\n  })}\\n\\n`);\n  res.end();\n}\n"]}

package/lib/middleware/auth.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 import jwt from 'jsonwebtoken';
 import { refuseForAssurance } from './assurance.js';
+import { runDeferredQuotaCheck } from './deferred-quota-check.js';
 import { hasValidIdentityClaims, verifyBearerToken } from './jwt-verify.js';
 import { recordAuthzDenial } from './permission-gates.js';
 import { checkRevocation, isImpersonationWriteBlocked, needsRevocationCheck } from './revocation.js';
@@ -170,11 +171,13 @@ async function verifyAndAttach(options, rawToken, req, res, next) {
             checkRevocation(decoded).then((refusal) => {
                 if (refusal)
                     return sendError(res, HttpStatus.UNAUTHORIZED, refusal, ErrorCode.TOKEN_REVOKED);
-                next();
+                runDeferredQuotaCheck(req, res, next);
             }).catch(next);
             return;
         }
-        next();
+        // The apiCalls check a mount armed (api-server `apiCallsQuota`) runs here,
+        // now that tenancy is JWT-authoritative; a plain next() where none was armed.
+        runDeferredQuotaCheck(req, res, next);
     }
     catch (error) {
         if (error instanceof jwt.TokenExpiredError) {
@@ -196,4 +199,4 @@ async function verifyAndAttach(options, rawToken, req, res, next) {
         return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication failed', ErrorCode.UNAUTHORIZED);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireAuth`: bearer / access-key authentication, the checks every\n * verified request passes, and the tenant identity it attaches.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { refuseForAssurance } from './assurance.js';\nimport { hasValidIdentityClaims, verifyBearerToken } from './jwt-verify.js';\nimport { recordAuthzDenial } from './permission-gates.js';\nimport { checkRevocation, isImpersonationWriteBlocked, needsRevocationCheck } from './revocation.js';\nimport { tagRouteGate } from './route-table.js';\nimport { isServiceTokenDenied, serviceNameOf } from './service-tokens.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { JwksUnavailableError, UnknownKidError } from '../services/jwks-cache.js';\nimport { ServiceKeyError, serviceIdentity } from '../services/service-keys.js';\nimport { type AssuranceLevel } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport type { HttpRequest } from '../types/http.js';\nimport { isOpaqueApiKey } from '../utils/api-key.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { getIdentity, type RequestIdentity } from '../utils/identity.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('auth-middleware');\nexport interface RequireAuthOptions {\n  /**\n   * Allow x-org-id/x-org-name headers to override the JWT's organization fields.\n   *\n   * When enabled, the `x-org-id`/`x-org-name` headers override the caller's org\n   * — but ONLY for a verified SYS-ADMIN (`isSuperAdmin` claim). For any ordinary\n   * authenticated user the headers are ignored, so enabling this can never let a\n   * normal user impersonate another tenant's org. Use for cross-org admin tooling\n   * (e.g. a sysadmin managing a given org's billing). If unsure, leave it disabled.\n   */\n  allowOrgHeaderOverride?: boolean;\n  /**\n   * Demand that the whole SESSION be at least this assurance level.\n   *\n   * `minAssurance: 2` means the person authenticated with a second factor — a\n   * passkey with user verification, a password plus an authenticator code, or\n   * SSO through an IdP the org marked as enforcing MFA. A weaker token gets\n   * **401 `MFA_REQUIRED`**, which the client answers by sending the person to\n   * enrolment or to a stronger sign-in; refreshing cannot help, because `aal`\n   * lives on the session slot and a refresh never raises it.\n   *\n   * This is the SESSION-level counterpart to {@link requireStepUp}, which stays\n   * a fresh, per-action confirmation. Use both on the most dangerous routes.\n   *\n   * MACHINES NEVER SATISFY IT. A service principal, an org service account and\n   * an exchanged access key all get **403 `HUMAN_SESSION_REQUIRED`** — there is\n   * no person behind them to have presented a factor, so \"assurance\" is not a\n   * question their credential can answer. That is deliberately not a silent\n   * pass-through for internal services: a route that demands MFA is a route a\n   * human is doing something dangerous on.\n   */\n  minAssurance?: AssuranceLevel;\n  /**\n   * With {@link minAssurance}, additionally bound how long ago that sign-in\n   * happened (seconds, compared against the token's `auth_time`). A session that\n   * is MFA-grade but older than this gets **401 `REAUTH_REQUIRED`**. Ignored\n   * without `minAssurance` — \"how recent\" is only meaningful once \"how strong\"\n   * is being asked.\n   */\n  maxAge?: number;\n}\n\n/** JWT auth middleware. Use directly or call with options. */\nexport function requireAuth(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void;\nexport function requireAuth(\n  options?: RequireAuthOptions,\n): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireAuth(\n  reqOrOptions?: Request | RequireAuthOptions,\n  res?: Response,\n  next?: NextFunction,\n): void | ((req: Request, res: Response, next: NextFunction) => void) {\n  if (reqOrOptions && res && next && 'headers' in reqOrOptions) {\n    return _requireAuth({}, reqOrOptions as Request, res, next);\n  }\n\n  const options = (reqOrOptions as RequireAuthOptions) || {};\n  const gate = tagRouteGate((req: Request, resInner: Response, nextInner: NextFunction) => {\n    _requireAuth(options, req, resInner, nextInner);\n  }, { kind: 'auth' });\n  if (options.minAssurance) {\n    tagRouteGate(gate, { kind: 'assurance', minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) });\n  }\n  return gate;\n}\ntagRouteGate(requireAuth, { kind: 'auth' });\n\nfunction _requireAuth(\n  options: RequireAuthOptions,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  const authHeader = req.headers.authorization;\n\n  if (!authHeader) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authorization header required', ErrorCode.TOKEN_MISSING);\n  }\n\n  const parts = authHeader.split(' ');\n  if (parts.length !== 2 || parts[0] !== 'Bearer') {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid authorization format. Use: Bearer <token>', ErrorCode.TOKEN_INVALID);\n  }\n\n  // An OPAQUE ACCESS KEY (`pb_pat_…` / `pb_sa_…`) carries no claims and no\n  // signature, so it cannot be verified here. Trade it at platform for a\n  // short-lived JWT (cached in-process until it expires) and then verify that\n  // JWT on the normal path — services never read a key hash. See\n  // `services/api-key-exchange.ts`.\n  if (isOpaqueApiKey(parts[1])) {\n    void resolveApiKey(options, parts[1], req, res, next);\n    return;\n  }\n\n  // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n  // Express's error middleware — verification itself never rejects (it maps\n  // every failure to a response).\n  void verifyAndAttach(options, parts[1], req, res, next).catch(next);\n}\n\n/**\n * Exchange an opaque key for a JWT, then continue on the normal verification\n * path. A refused key is a 401; an unreachable platform is a 503 (never a pass —\n * an unverifiable credential is not an identity).\n */\nasync function resolveApiKey(\n  options: RequireAuthOptions,\n  key: string,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): Promise<void> {\n  // Loaded LAZILY, on the first key ever presented. A static import would put\n  // the HTTP client (and platform's address) into the import graph of every\n  // module that merely uses `requireAuth`, which both widens the boot graph and\n  // breaks any test that mocks `http-client.js` with a partial module.\n  const { exchangeApiKey, ApiKeyExchangeUnavailableError } = await import('../services/api-key-exchange.js');\n  let token: string;\n  try {\n    token = await exchangeApiKey(key);\n  } catch (error) {\n    if (error instanceof ApiKeyExchangeUnavailableError) {\n      return sendError(\n        res, HttpStatus.SERVICE_UNAVAILABLE,\n        'Access-key verification is temporarily unavailable; please retry',\n        ErrorCode.SERVICE_UNAVAILABLE,\n      );\n    }\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid or revoked access key', ErrorCode.TOKEN_INVALID);\n  }\n  await verifyAndAttach(options, token, req, res, next);\n}\n\nasync function verifyAndAttach(\n  options: RequireAuthOptions,\n  rawToken: string,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): Promise<void> {\n  try {\n    // Two chains, one entry point (see `verifyBearerToken`): a user token must\n    // be ES256 signed by platform and verified against its published JWKS; an\n    // internal service token must be ES256 signed by that service's OWN key and\n    // declare itself a service principal. Both pin the algorithm (no\n    // alg-confusion, no `alg:none`) and both apply the optional issuer/audience\n    // binding.\n    const decoded = await verifyBearerToken(rawToken);\n\n    if (decoded.type !== 'access') {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Only access tokens can be used for API requests', ErrorCode.TOKEN_INVALID);\n    }\n\n    if (!decoded.sub || !decoded.role || !hasValidIdentityClaims(decoded)) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token missing required fields', ErrorCode.TOKEN_INVALID);\n    }\n\n    // Service-token kill-switch: reject a service principal whose service has\n    // been added to the denylist. Otherwise the only way to invalidate a\n    // service's tokens before their (short) TTL is rotating that service's\n    // signing key; this cuts one compromised/rogue service off immediately. O(1) Set lookup, zero cost when the denylist\n    // is empty (the default), so it never taxes the S2S hot path unless armed.\n    if (isServiceTokenDenied(decoded)) {\n      emitCounter('service_token_denied_total', { service: serviceNameOf(decoded) ?? 'unknown' });\n      logger.warn('Rejected denylisted service token', { sub: decoded.sub });\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Service token revoked', ErrorCode.TOKEN_REVOKED);\n    }\n\n    req.user = { ...decoded };\n\n    // READ-ONLY IMPERSONATION. The token names the operator AND says it may only\n    // look: every service refuses a state change under it, not only platform —\n    // a support session that could write to plugin/compliance/billing is not\n    // read-only. Checked before any other gate so no route can forget it.\n    if (isImpersonationWriteBlocked(req.method, decoded)) {\n      if (req.method) recordAuthzDenial(req, 'impersonation-read-only');\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        'Write requests are disabled during read-only impersonation. Stop impersonating to make changes.',\n        ErrorCode.IMPERSONATION_READ_ONLY,\n      );\n    }\n\n    // BOOTSTRAP-ADMIN ENROLMENT SESSION. Such a token exists so\n    // the install's only admin can enrol a factor; it is `aal: 1` and must not\n    // reach anything else. Platform — which owns the exception and knows which\n    // of its own routes `init-platform.sh` calls — allows an explicit few before\n    // this point (see its own `requireAuth`); in EVERY other service the answer\n    // is simply no, so the reach restriction holds without a per-service\n    // allowlist to keep in sync.\n    if (decoded.mfaEnrollmentPending === true) {\n      emitCounter('mfa_enforcement_refused_total', { service: serviceIdentity(), reason: 'bootstrap_session' });\n      recordAuthzDenial(req, 'mfa-enrolment');\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        'Finish setting up two-factor authentication before using the rest of Pipeline Builder',\n        ErrorCode.MFA_ENROLLMENT_REQUIRED,\n      );\n    }\n\n    // Session-level assurance (`requireAuth({ minAssurance, maxAge })`).\n    if (options.minAssurance\n      && refuseForAssurance({ minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) }, decoded, req, res)) return;\n\n    // The x-org-id/x-org-name override lets a SYS-ADMIN act on a chosen org\n    // (cross-org admin tooling). It is gated on the verified `isSuperAdmin` claim\n    // here so that even a route which mistakenly enables `allowOrgHeaderOverride`\n    // can NEVER let an ordinary authenticated user spoof another tenant's org via\n    // the header — defence-in-depth against the cross-tenant break this caused.\n    if (options.allowOrgHeaderOverride && decoded.isSuperAdmin === true) {\n      const headerOrgId = getHeaderString(req.headers['x-org-id']);\n      const headerOrgName = getHeaderString(req.headers['x-org-name']);\n      if (headerOrgId) req.user.organizationId = headerOrgId;\n      if (headerOrgName) req.user.organizationName = headerOrgName;\n    }\n\n    // Re-derive the request's tenant identity from the NOW-verified JWT.\n    //\n    // `attachRequestContext` runs as a global middleware BEFORE this per-route\n    // `requireAuth`, so it captured `req.context.identity` while `req.user` was\n    // still undefined — at which point `getIdentity` falls back to the raw,\n    // client-settable `x-org-id`/`x-user-id` headers. Every downstream tenant-\n    // authority consumer (requireOrgId, withTenantContext's RLS scope, checkQuota,\n    // withRoute, and the idempotency namespace) reads `req.context.identity`, so\n    // that frozen header-derived value — not the JWT — was governing tenancy on\n    // any non-nginx path. Recomputing here, at the single post-verification choke\n    // point, makes `getIdentity` prefer the verified `req.user` (see identity.ts)\n    // so tenancy is JWT-authoritative. The nginx `x-org-id` overwrite stays as\n    // defence-in-depth. Guarded on `req.context` so services/paths that never\n    // attach a context (or run requireAuth pre-context) are unaffected.\n    const reqCtx = (req as Request & { context?: { identity: RequestIdentity } }).context;\n    if (reqCtx) {\n      reqCtx.identity = getIdentity(req as unknown as HttpRequest);\n    }\n\n    // Session invalidation (token-version store + impersonation-session\n    // liveness). No store registered ⇒ only impersonation sessions are checked.\n    if (needsRevocationCheck(decoded)) {\n      // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n      // Express's error middleware — this `next()` runs in a microtask, outside\n      // the surrounding try/catch. The check itself never rejects.\n      checkRevocation(decoded).then((refusal) => {\n        if (refusal) return sendError(res, HttpStatus.UNAUTHORIZED, refusal, ErrorCode.TOKEN_REVOKED);\n        next();\n      }).catch(next);\n      return;\n    }\n\n    next();\n  } catch (error) {\n    if (error instanceof jwt.TokenExpiredError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token has expired', ErrorCode.TOKEN_EXPIRED);\n    }\n\n    // The signing keys couldn't be fetched, so the token's validity is UNKNOWN.\n    // Fail CLOSED with a retryable 503 — never a pass, and never a 401 that\n    // would send a legitimate client off to re-authenticate over our outage.\n    // Same reasoning for the SERVICE chain: no readable key bundle means no way\n    // to tell a peer's token from a forgery, so the request is refused with a\n    // retryable 503 rather than admitted or bounced to re-authenticate.\n    if (error instanceof JwksUnavailableError || error instanceof ServiceKeyError) {\n      logger.warn('Rejecting request: token signing keys unavailable', { error: error.message });\n      return sendError(\n        res, HttpStatus.SERVICE_UNAVAILABLE,\n        'Token verification is temporarily unavailable; please retry',\n        ErrorCode.SERVICE_UNAVAILABLE,\n      );\n    }\n\n    if (error instanceof UnknownKidError || error instanceof jwt.JsonWebTokenError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid token', ErrorCode.TOKEN_INVALID);\n    }\n\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication failed', ErrorCode.UNAUTHORIZED);\n  }\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireAuth`: bearer / access-key authentication, the checks every\n * verified request passes, and the tenant identity it attaches.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { refuseForAssurance } from './assurance.js';\nimport { runDeferredQuotaCheck } from './deferred-quota-check.js';\nimport { hasValidIdentityClaims, verifyBearerToken } from './jwt-verify.js';\nimport { recordAuthzDenial } from './permission-gates.js';\nimport { checkRevocation, isImpersonationWriteBlocked, needsRevocationCheck } from './revocation.js';\nimport { tagRouteGate } from './route-table.js';\nimport { isServiceTokenDenied, serviceNameOf } from './service-tokens.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { JwksUnavailableError, UnknownKidError } from '../services/jwks-cache.js';\nimport { ServiceKeyError, serviceIdentity } from '../services/service-keys.js';\nimport { type AssuranceLevel } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport type { HttpRequest } from '../types/http.js';\nimport { isOpaqueApiKey } from '../utils/api-key.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { getIdentity, type RequestIdentity } from '../utils/identity.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('auth-middleware');\nexport interface RequireAuthOptions {\n  /**\n   * Allow x-org-id/x-org-name headers to override the JWT's organization fields.\n   *\n   * When enabled, the `x-org-id`/`x-org-name` headers override the caller's org\n   * — but ONLY for a verified SYS-ADMIN (`isSuperAdmin` claim). For any ordinary\n   * authenticated user the headers are ignored, so enabling this can never let a\n   * normal user impersonate another tenant's org. Use for cross-org admin tooling\n   * (e.g. a sysadmin managing a given org's billing). If unsure, leave it disabled.\n   */\n  allowOrgHeaderOverride?: boolean;\n  /**\n   * Demand that the whole SESSION be at least this assurance level.\n   *\n   * `minAssurance: 2` means the person authenticated with a second factor — a\n   * passkey with user verification, a password plus an authenticator code, or\n   * SSO through an IdP the org marked as enforcing MFA. A weaker token gets\n   * **401 `MFA_REQUIRED`**, which the client answers by sending the person to\n   * enrolment or to a stronger sign-in; refreshing cannot help, because `aal`\n   * lives on the session slot and a refresh never raises it.\n   *\n   * This is the SESSION-level counterpart to {@link requireStepUp}, which stays\n   * a fresh, per-action confirmation. Use both on the most dangerous routes.\n   *\n   * MACHINES NEVER SATISFY IT. A service principal, an org service account and\n   * an exchanged access key all get **403 `HUMAN_SESSION_REQUIRED`** — there is\n   * no person behind them to have presented a factor, so \"assurance\" is not a\n   * question their credential can answer. That is deliberately not a silent\n   * pass-through for internal services: a route that demands MFA is a route a\n   * human is doing something dangerous on.\n   */\n  minAssurance?: AssuranceLevel;\n  /**\n   * With {@link minAssurance}, additionally bound how long ago that sign-in\n   * happened (seconds, compared against the token's `auth_time`). A session that\n   * is MFA-grade but older than this gets **401 `REAUTH_REQUIRED`**. Ignored\n   * without `minAssurance` — \"how recent\" is only meaningful once \"how strong\"\n   * is being asked.\n   */\n  maxAge?: number;\n}\n\n/** JWT auth middleware. Use directly or call with options. */\nexport function requireAuth(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void;\nexport function requireAuth(\n  options?: RequireAuthOptions,\n): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireAuth(\n  reqOrOptions?: Request | RequireAuthOptions,\n  res?: Response,\n  next?: NextFunction,\n): void | ((req: Request, res: Response, next: NextFunction) => void) {\n  if (reqOrOptions && res && next && 'headers' in reqOrOptions) {\n    return _requireAuth({}, reqOrOptions as Request, res, next);\n  }\n\n  const options = (reqOrOptions as RequireAuthOptions) || {};\n  const gate = tagRouteGate((req: Request, resInner: Response, nextInner: NextFunction) => {\n    _requireAuth(options, req, resInner, nextInner);\n  }, { kind: 'auth' });\n  if (options.minAssurance) {\n    tagRouteGate(gate, { kind: 'assurance', minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) });\n  }\n  return gate;\n}\ntagRouteGate(requireAuth, { kind: 'auth' });\n\nfunction _requireAuth(\n  options: RequireAuthOptions,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  const authHeader = req.headers.authorization;\n\n  if (!authHeader) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authorization header required', ErrorCode.TOKEN_MISSING);\n  }\n\n  const parts = authHeader.split(' ');\n  if (parts.length !== 2 || parts[0] !== 'Bearer') {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid authorization format. Use: Bearer <token>', ErrorCode.TOKEN_INVALID);\n  }\n\n  // An OPAQUE ACCESS KEY (`pb_pat_…` / `pb_sa_…`) carries no claims and no\n  // signature, so it cannot be verified here. Trade it at platform for a\n  // short-lived JWT (cached in-process until it expires) and then verify that\n  // JWT on the normal path — services never read a key hash. See\n  // `services/api-key-exchange.ts`.\n  if (isOpaqueApiKey(parts[1])) {\n    void resolveApiKey(options, parts[1], req, res, next);\n    return;\n  }\n\n  // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n  // Express's error middleware — verification itself never rejects (it maps\n  // every failure to a response).\n  void verifyAndAttach(options, parts[1], req, res, next).catch(next);\n}\n\n/**\n * Exchange an opaque key for a JWT, then continue on the normal verification\n * path. A refused key is a 401; an unreachable platform is a 503 (never a pass —\n * an unverifiable credential is not an identity).\n */\nasync function resolveApiKey(\n  options: RequireAuthOptions,\n  key: string,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): Promise<void> {\n  // Loaded LAZILY, on the first key ever presented. A static import would put\n  // the HTTP client (and platform's address) into the import graph of every\n  // module that merely uses `requireAuth`, which both widens the boot graph and\n  // breaks any test that mocks `http-client.js` with a partial module.\n  const { exchangeApiKey, ApiKeyExchangeUnavailableError } = await import('../services/api-key-exchange.js');\n  let token: string;\n  try {\n    token = await exchangeApiKey(key);\n  } catch (error) {\n    if (error instanceof ApiKeyExchangeUnavailableError) {\n      return sendError(\n        res, HttpStatus.SERVICE_UNAVAILABLE,\n        'Access-key verification is temporarily unavailable; please retry',\n        ErrorCode.SERVICE_UNAVAILABLE,\n      );\n    }\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid or revoked access key', ErrorCode.TOKEN_INVALID);\n  }\n  await verifyAndAttach(options, token, req, res, next);\n}\n\nasync function verifyAndAttach(\n  options: RequireAuthOptions,\n  rawToken: string,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): Promise<void> {\n  try {\n    // Two chains, one entry point (see `verifyBearerToken`): a user token must\n    // be ES256 signed by platform and verified against its published JWKS; an\n    // internal service token must be ES256 signed by that service's OWN key and\n    // declare itself a service principal. Both pin the algorithm (no\n    // alg-confusion, no `alg:none`) and both apply the optional issuer/audience\n    // binding.\n    const decoded = await verifyBearerToken(rawToken);\n\n    if (decoded.type !== 'access') {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Only access tokens can be used for API requests', ErrorCode.TOKEN_INVALID);\n    }\n\n    if (!decoded.sub || !decoded.role || !hasValidIdentityClaims(decoded)) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token missing required fields', ErrorCode.TOKEN_INVALID);\n    }\n\n    // Service-token kill-switch: reject a service principal whose service has\n    // been added to the denylist. Otherwise the only way to invalidate a\n    // service's tokens before their (short) TTL is rotating that service's\n    // signing key; this cuts one compromised/rogue service off immediately. O(1) Set lookup, zero cost when the denylist\n    // is empty (the default), so it never taxes the S2S hot path unless armed.\n    if (isServiceTokenDenied(decoded)) {\n      emitCounter('service_token_denied_total', { service: serviceNameOf(decoded) ?? 'unknown' });\n      logger.warn('Rejected denylisted service token', { sub: decoded.sub });\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Service token revoked', ErrorCode.TOKEN_REVOKED);\n    }\n\n    req.user = { ...decoded };\n\n    // READ-ONLY IMPERSONATION. The token names the operator AND says it may only\n    // look: every service refuses a state change under it, not only platform —\n    // a support session that could write to plugin/compliance/billing is not\n    // read-only. Checked before any other gate so no route can forget it.\n    if (isImpersonationWriteBlocked(req.method, decoded)) {\n      if (req.method) recordAuthzDenial(req, 'impersonation-read-only');\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        'Write requests are disabled during read-only impersonation. Stop impersonating to make changes.',\n        ErrorCode.IMPERSONATION_READ_ONLY,\n      );\n    }\n\n    // BOOTSTRAP-ADMIN ENROLMENT SESSION. Such a token exists so\n    // the install's only admin can enrol a factor; it is `aal: 1` and must not\n    // reach anything else. Platform — which owns the exception and knows which\n    // of its own routes `init-platform.sh` calls — allows an explicit few before\n    // this point (see its own `requireAuth`); in EVERY other service the answer\n    // is simply no, so the reach restriction holds without a per-service\n    // allowlist to keep in sync.\n    if (decoded.mfaEnrollmentPending === true) {\n      emitCounter('mfa_enforcement_refused_total', { service: serviceIdentity(), reason: 'bootstrap_session' });\n      recordAuthzDenial(req, 'mfa-enrolment');\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        'Finish setting up two-factor authentication before using the rest of Pipeline Builder',\n        ErrorCode.MFA_ENROLLMENT_REQUIRED,\n      );\n    }\n\n    // Session-level assurance (`requireAuth({ minAssurance, maxAge })`).\n    if (options.minAssurance\n      && refuseForAssurance({ minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) }, decoded, req, res)) return;\n\n    // The x-org-id/x-org-name override lets a SYS-ADMIN act on a chosen org\n    // (cross-org admin tooling). It is gated on the verified `isSuperAdmin` claim\n    // here so that even a route which mistakenly enables `allowOrgHeaderOverride`\n    // can NEVER let an ordinary authenticated user spoof another tenant's org via\n    // the header — defence-in-depth against the cross-tenant break this caused.\n    if (options.allowOrgHeaderOverride && decoded.isSuperAdmin === true) {\n      const headerOrgId = getHeaderString(req.headers['x-org-id']);\n      const headerOrgName = getHeaderString(req.headers['x-org-name']);\n      if (headerOrgId) req.user.organizationId = headerOrgId;\n      if (headerOrgName) req.user.organizationName = headerOrgName;\n    }\n\n    // Re-derive the request's tenant identity from the NOW-verified JWT.\n    //\n    // `attachRequestContext` runs as a global middleware BEFORE this per-route\n    // `requireAuth`, so it captured `req.context.identity` while `req.user` was\n    // still undefined — at which point `getIdentity` falls back to the raw,\n    // client-settable `x-org-id`/`x-user-id` headers. Every downstream tenant-\n    // authority consumer (requireOrgId, withTenantContext's RLS scope, checkQuota,\n    // withRoute, and the idempotency namespace) reads `req.context.identity`, so\n    // that frozen header-derived value — not the JWT — was governing tenancy on\n    // any non-nginx path. Recomputing here, at the single post-verification choke\n    // point, makes `getIdentity` prefer the verified `req.user` (see identity.ts)\n    // so tenancy is JWT-authoritative. The nginx `x-org-id` overwrite stays as\n    // defence-in-depth. Guarded on `req.context` so services/paths that never\n    // attach a context (or run requireAuth pre-context) are unaffected.\n    const reqCtx = (req as Request & { context?: { identity: RequestIdentity } }).context;\n    if (reqCtx) {\n      reqCtx.identity = getIdentity(req as unknown as HttpRequest);\n    }\n\n    // Session invalidation (token-version store + impersonation-session\n    // liveness). No store registered ⇒ only impersonation sessions are checked.\n    if (needsRevocationCheck(decoded)) {\n      // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n      // Express's error middleware — this `next()` runs in a microtask, outside\n      // the surrounding try/catch. The check itself never rejects.\n      checkRevocation(decoded).then((refusal) => {\n        if (refusal) return sendError(res, HttpStatus.UNAUTHORIZED, refusal, ErrorCode.TOKEN_REVOKED);\n        runDeferredQuotaCheck(req, res, next);\n      }).catch(next);\n      return;\n    }\n\n    // The apiCalls check a mount armed (api-server `apiCallsQuota`) runs here,\n    // now that tenancy is JWT-authoritative; a plain next() where none was armed.\n    runDeferredQuotaCheck(req, res, next);\n  } catch (error) {\n    if (error instanceof jwt.TokenExpiredError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token has expired', ErrorCode.TOKEN_EXPIRED);\n    }\n\n    // The signing keys couldn't be fetched, so the token's validity is UNKNOWN.\n    // Fail CLOSED with a retryable 503 — never a pass, and never a 401 that\n    // would send a legitimate client off to re-authenticate over our outage.\n    // Same reasoning for the SERVICE chain: no readable key bundle means no way\n    // to tell a peer's token from a forgery, so the request is refused with a\n    // retryable 503 rather than admitted or bounced to re-authenticate.\n    if (error instanceof JwksUnavailableError || error instanceof ServiceKeyError) {\n      logger.warn('Rejecting request: token signing keys unavailable', { error: error.message });\n      return sendError(\n        res, HttpStatus.SERVICE_UNAVAILABLE,\n        'Token verification is temporarily unavailable; please retry',\n        ErrorCode.SERVICE_UNAVAILABLE,\n      );\n    }\n\n    if (error instanceof UnknownKidError || error instanceof jwt.JsonWebTokenError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid token', ErrorCode.TOKEN_INVALID);\n    }\n\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication failed', ErrorCode.UNAUTHORIZED);\n  }\n}\n\n"]}