@pipeline-builder/api-core 5.2.2 → 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/index.d.ts

@@ -1,4 +1,5 @@
 export * from './crud-helpers.js';
+export { businessCalendar, responseDueAt, SUPPORT_TARGET_MEASURES, type BusinessCalendar, type SupportTargetKind, } from './support-calendar.js';
 export { requireVisibilityWriteAccess, checkVisibilityWriteAccess, checkWriteAccess, rejectForbiddenBulkRows, resolveVisibility, type VisibilityWriteTarget, type VisibilityWriteVerdict, type WriteAccess, type BulkWriteRow, } from './access-helpers.js';
 export { loadAndRestore, loadAndPurge, type RestorableService, type PurgeableService, type TombstoneAuthorizer, type TombstoneRouteOptions, } from './restore-helpers.js';
 export * from './sse-helpers.js';

package/lib/helpers/index.js

@@ -1,10 +1,11 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 export * from './crud-helpers.js';
+export { businessCalendar, responseDueAt, SUPPORT_TARGET_MEASURES, } from './support-calendar.js';
 export { requireVisibilityWriteAccess, checkVisibilityWriteAccess, checkWriteAccess, rejectForbiddenBulkRows, resolveVisibility, } from './access-helpers.js';
 export { loadAndRestore, loadAndPurge, } from './restore-helpers.js';
 export * from './sse-helpers.js';
 export * from './org-hierarchy.js';
 export { fetchParentOrgId, fetchOrgDescendants, fetchOrgNames, fetchOrgMembership, } from './org-hierarchy-http.js';
 export * from './content-disposition.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaGVscGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsT0FBTyxFQUNMLDRCQUE0QixFQUM1QiwwQkFBMEIsRUFDMUIsZ0JBQWdCLEVBQ2hCLHVCQUF1QixFQUN2QixpQkFBaUIsR0FLbEIsTUFBTSxxQkFBcUIsQ0FBQztBQUM3QixPQUFPLEVBQ0wsY0FBYyxFQUNkLFlBQVksR0FLYixNQUFNLHNCQUFzQixDQUFDO0FBQzlCLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxPQUFPLEVBQ0wsZ0JBQWdCLEVBQ2hCLG1CQUFtQixFQUNuQixhQUFhLEVBQ2Isa0JBQWtCLEdBQ25CLE1BQU0seUJBQXlCLENBQUM7QUFDakMsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5leHBvcnQgKiBmcm9tICcuL2NydWQtaGVscGVycy5qcyc7XG5leHBvcnQge1xuICByZXF1aXJlVmlzaWJpbGl0eVdyaXRlQWNjZXNzLFxuICBjaGVja1Zpc2liaWxpdHlXcml0ZUFjY2VzcyxcbiAgY2hlY2tXcml0ZUFjY2VzcyxcbiAgcmVqZWN0Rm9yYmlkZGVuQnVsa1Jvd3MsXG4gIHJlc29sdmVWaXNpYmlsaXR5LFxuICB0eXBlIFZpc2liaWxpdHlXcml0ZVRhcmdldCxcbiAgdHlwZSBWaXNpYmlsaXR5V3JpdGVWZXJkaWN0LFxuICB0eXBlIFdyaXRlQWNjZXNzLFxuICB0eXBlIEJ1bGtXcml0ZVJvdyxcbn0gZnJvbSAnLi9hY2Nlc3MtaGVscGVycy5qcyc7XG5leHBvcnQge1xuICBsb2FkQW5kUmVzdG9yZSxcbiAgbG9hZEFuZFB1cmdlLFxuICB0eXBlIFJlc3RvcmFibGVTZXJ2aWNlLFxuICB0eXBlIFB1cmdlYWJsZVNlcnZpY2UsXG4gIHR5cGUgVG9tYnN0b25lQXV0aG9yaXplcixcbiAgdHlwZSBUb21ic3RvbmVSb3V0ZU9wdGlvbnMsXG59IGZyb20gJy4vcmVzdG9yZS1oZWxwZXJzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vc3NlLWhlbHBlcnMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9vcmctaGllcmFyY2h5LmpzJztcbmV4cG9ydCB7XG4gIGZldGNoUGFyZW50T3JnSWQsXG4gIGZldGNoT3JnRGVzY2VuZGFudHMsXG4gIGZldGNoT3JnTmFtZXMsXG4gIGZldGNoT3JnTWVtYmVyc2hpcCxcbn0gZnJvbSAnLi9vcmctaGllcmFyY2h5LWh0dHAuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb250ZW50LWRpc3Bvc2l0aW9uLmpzJztcbiJdfQ==
+//# 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/helpers/support-calendar.d.ts

@@ -0,0 +1,69 @@
+/** How a level's target is measured. */
+export type SupportTargetKind = 
+/** N working days, ending at the close of the Nth. */
+{
+    kind: 'business-days';
+    days: number;
+}
+/** N hours of wall clock, with no calendar applied at all. */
+ | {
+    kind: 'elapsed-hours';
+    hours: number;
+};
+/**
+ * The measure behind each level's published target.
+ *
+ * Premium is `elapsed-hours` on purpose, and that is the whole of its 24×7
+ * claim: its clock does not stop for nights, weekends or holidays, so no
+ * calendar is consulted. It is also why premium is the one level whose target
+ * the wall-clock histogram can check directly.
+ */
+export declare const SUPPORT_TARGET_MEASURES: Readonly<Record<string, SupportTargetKind>>;
+/** The resolved business calendar. */
+export interface BusinessCalendar {
+    /** IANA zone. Never a fixed abbreviation — see {@link businessCalendar}. */
+    timeZone: string;
+    /** Working weekdays, 0 = Sunday … 6 = Saturday. */
+    days: readonly number[];
+    /** The hour (0–23) at which a working day CLOSES, in `timeZone`. */
+    endHour: number;
+    /** Non-working dates, `YYYY-MM-DD` in `timeZone`. */
+    holidays: ReadonlySet<string>;
+}
+/**
+ * The instant a first response is due, or null for a level with no target.
+ *
+ * For a business-day target: the close of the Nth working day AFTER the one the
+ * case was opened on. A case opened on a Friday with a next-business-day target
+ * is due at Monday's close, not Saturday's — Saturday is not a working day, so
+ * it is not counted. A case opened ON a non-working day starts counting from the
+ * next working day, which is the reading that favours the customer and is the
+ * only one that can be explained in a sentence.
+ *
+ * The day of opening is never itself the deadline, however early the case
+ * arrives. "Next business day" has to mean tomorrow, not "later today" — a case
+ * opened at 09:01 and one opened at 16:59 are owed the same thing, and anything
+ * else turns the target into an hours clock by the back door.
+ */
+export declare function responseDueAt(openedAt: Date, level: string, cal?: BusinessCalendar): Date | null;
+/**
+ * The configured calendar.
+ *
+ * `SUPPORT_BUSINESS_HOURS_TZ` takes an **IANA zone**, default
+ * `America/New_York`, and NOT a fixed abbreviation like `EST`. `EST` is
+ * permanently UTC−5, so an `EST` setting would put the desk an hour out for the
+ * eight months of the year that are EDT — the same reason
+ * `ASK_SCHEDULE_TIMEZONE` takes an IANA zone for its cron windows. An
+ * unrecognised zone falls back to UTC rather than throwing, because a bad
+ * timezone must not stop cases being opened; it is validated here so the
+ * fallback is deliberate rather than an exception thrown from `Intl` deep inside
+ * a request.
+ *
+ * Every stored timestamp stays UTC. The zone is applied only to derive a
+ * deadline.
+ *
+ * Holidays are an explicit operator-maintained list rather than a library: a
+ * library pulls both a dependency and a holiday POLICY that cannot be explained
+ * to a customer disputing a deadline.
+ */
+export declare function businessCalendar(): BusinessCalendar;