@dcdr/contracts 2.2.0 → 2.3.0

package/dist/provider.catalog.contract.js

@@ -0,0 +1,765 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderModelRegistry = exports.PROVIDER_MODEL_E2E_OVERRIDES = exports.ProviderModelE2EStatus = exports.PROVIDER_MODEL_IDS_BY_PROVIDER_AND_TYPE = exports.PROVIDER_MODEL_CATALOG = exports.PROVIDER_MODEL_DEFINITIONS_BY_PROVIDER = exports.DcdrPublicModelCategory = exports.ProviderModelParameterSupportStatus = exports.PromptParameterKey = exports.ProviderModelPreferredApi = exports.ProviderModelRuntimeSupportStatus = void 0;
+exports.formatDcdrVirtualModelId = formatDcdrVirtualModelId;
+exports.parseDcdrVirtualModelId = parseDcdrVirtualModelId;
+const intent_contract_1 = require("./intent.contract");
+const provider_contract_1 = require("./provider.contract");
+const anthropic_contract_1 = require("./catalog/anthropic.contract");
+const clip_contract_1 = require("./catalog/clip.contract");
+const cohere_contract_1 = require("./catalog/cohere.contract");
+const dcdr_contract_1 = require("./catalog/dcdr.contract");
+const gemini_contract_1 = require("./catalog/gemini.contract");
+const grok_contract_1 = require("./catalog/grok.contract");
+const http_tool_contract_1 = require("./catalog/http-tool.contract");
+const mistral_contract_1 = require("./catalog/mistral.contract");
+const ocr_contract_1 = require("./catalog/ocr.contract");
+const office_contract_1 = require("./catalog/office.contract");
+const ollama_contract_1 = require("./catalog/ollama.contract");
+const openai_compatible_contract_1 = require("./catalog/openai-compatible.contract");
+const openai_contract_1 = require("./catalog/openai.contract");
+const rules_contract_1 = require("./catalog/rules.contract");
+/** Runtime-level support status for a (provider, modelId) pair. */
+var ProviderModelRuntimeSupportStatus;
+(function (ProviderModelRuntimeSupportStatus) {
+    /** Supported by this runtime (intended to work). */
+    ProviderModelRuntimeSupportStatus["SUPPORTED"] = "SUPPORTED";
+    /** Explicitly not supported by this runtime (do not attempt provider calls). */
+    ProviderModelRuntimeSupportStatus["NOT_SUPPORTED"] = "NOT_SUPPORTED";
+    /** Known failing in current runtime; keep visible but treat as unstable. */
+    ProviderModelRuntimeSupportStatus["FAILING"] = "FAILING";
+    /** Under active implementation/curation; not yet reliable. */
+    ProviderModelRuntimeSupportStatus["IN_PROGRESS"] = "IN_PROGRESS";
+})(ProviderModelRuntimeSupportStatus || (exports.ProviderModelRuntimeSupportStatus = ProviderModelRuntimeSupportStatus = {}));
+/** Canonical provider API surface preferred by the runtime for a model family. */
+var ProviderModelPreferredApi;
+(function (ProviderModelPreferredApi) {
+    ProviderModelPreferredApi["CHAT_COMPLETIONS"] = "CHAT_COMPLETIONS";
+    ProviderModelPreferredApi["RESPONSES"] = "RESPONSES";
+})(ProviderModelPreferredApi || (exports.ProviderModelPreferredApi = ProviderModelPreferredApi = {}));
+/** Generic prompt/runtime parameter keys that can be exposed to users (UI) and adapters. */
+var PromptParameterKey;
+(function (PromptParameterKey) {
+    PromptParameterKey["TEMPERATURE"] = "temperature";
+    PromptParameterKey["TOP_P"] = "top_p";
+    PromptParameterKey["TOP_K"] = "top_k";
+    PromptParameterKey["MAX_TOKENS"] = "max_tokens";
+    PromptParameterKey["ENABLE_THINKING"] = "enable_thinking";
+    PromptParameterKey["RESPONSE_FORMAT"] = "response_format";
+    PromptParameterKey["PRESENCE_PENALTY"] = "presence_penalty";
+    PromptParameterKey["FREQUENCY_PENALTY"] = "frequency_penalty";
+})(PromptParameterKey || (exports.PromptParameterKey = PromptParameterKey = {}));
+/** Runtime-level parameter support status for a specific model. */
+var ProviderModelParameterSupportStatus;
+(function (ProviderModelParameterSupportStatus) {
+    ProviderModelParameterSupportStatus["SUPPORTED"] = "SUPPORTED";
+    /** Parameter is not supported and should not be sent. */
+    ProviderModelParameterSupportStatus["NOT_SUPPORTED"] = "NOT_SUPPORTED";
+    /** Only provider default is supported; runtime should avoid sending custom values. */
+    ProviderModelParameterSupportStatus["DEFAULT_ONLY"] = "DEFAULT_ONLY";
+})(ProviderModelParameterSupportStatus || (exports.ProviderModelParameterSupportStatus = ProviderModelParameterSupportStatus = {}));
+/**
+ * Product-level managed categories for public customer models.
+ *
+ * Purpose
+ * - Provide a stable grouping/filtering abstraction for customer-facing UIs.
+ * - Avoid exposing a flat provider/model list by default.
+ */
+var DcdrPublicModelCategory;
+(function (DcdrPublicModelCategory) {
+    /** Maximum quality / strongest reasoning; typically expensive. */
+    DcdrPublicModelCategory["BEST"] = "BEST";
+    /** Best balance between quality and cost; recommended default for production chat. */
+    DcdrPublicModelCategory["SMART"] = "SMART";
+    /** Low latency; good for interactive chat/support. */
+    DcdrPublicModelCategory["FAST"] = "FAST";
+    /** Lowest cost; good for high-volume simple tasks. */
+    DcdrPublicModelCategory["ECONOMY"] = "ECONOMY";
+    /** Internal/local/company-managed models (self-hosted, Office, etc.). */
+    DcdrPublicModelCategory["PRIVATE"] = "PRIVATE";
+})(DcdrPublicModelCategory || (exports.DcdrPublicModelCategory = DcdrPublicModelCategory = {}));
+const DEFAULT_TOKEN_PRICING_UPDATED_AT = Date.UTC(2026, 2, 27);
+const DEFAULT_AUDIO_PRICING_UPDATED_AT = Date.UTC(2026, 4, 22);
+const PRICING_FALLBACK_RULES_BY_PROVIDER = {
+    [provider_contract_1.IntentProvider.DCDR]: [],
+    [provider_contract_1.IntentProvider.OPEN_AI]: openai_contract_1.OPENAI_PROVIDER_PRICING_FALLBACK_RULES,
+    [provider_contract_1.IntentProvider.ANTHROPIC]: anthropic_contract_1.ANTHROPIC_PROVIDER_PRICING_FALLBACK_RULES,
+    [provider_contract_1.IntentProvider.GEMINI]: [],
+    [provider_contract_1.IntentProvider.GROK]: [],
+    [provider_contract_1.IntentProvider.MISTRAL]: [],
+    [provider_contract_1.IntentProvider.COHERE]: [],
+    [provider_contract_1.IntentProvider.OFFICE]: [],
+    [provider_contract_1.IntentProvider.OLLAMA]: [],
+    [provider_contract_1.IntentProvider.OPEN_AI_COMPATIBLE]: [],
+    [provider_contract_1.IntentProvider.OCR]: [],
+    [provider_contract_1.IntentProvider.CLIP]: [],
+    [provider_contract_1.IntentProvider.HTTP_TOOL]: [],
+    [provider_contract_1.IntentProvider.RULES]: [],
+};
+const PROVIDER_CATALOG_MODULE_BUILD_ARGS = {
+    pricingPerMillionTokens,
+    pricingAudioMinutesPerMinute,
+    catalogEnums: {
+        runtimeSupportStatus: ProviderModelRuntimeSupportStatus,
+        preferredApi: ProviderModelPreferredApi,
+        promptParameterKey: PromptParameterKey,
+        parameterSupportStatus: ProviderModelParameterSupportStatus,
+        publicModelCategory: DcdrPublicModelCategory,
+        get e2eStatus() {
+            return ProviderModelE2EStatus;
+        },
+    },
+};
+const DCDR_VIRTUAL_PROVIDER_PREFIX_BY_PROVIDER = {
+    [provider_contract_1.IntentProvider.OPEN_AI]: "openai",
+    [provider_contract_1.IntentProvider.ANTHROPIC]: "anthropic",
+    [provider_contract_1.IntentProvider.GEMINI]: "gemini",
+    [provider_contract_1.IntentProvider.GROK]: "grok",
+    [provider_contract_1.IntentProvider.MISTRAL]: "mistral",
+    [provider_contract_1.IntentProvider.OFFICE]: "office",
+};
+const DCDR_VIRTUAL_PROVIDER_BY_PREFIX = {
+    openai: provider_contract_1.IntentProvider.OPEN_AI,
+    anthropic: provider_contract_1.IntentProvider.ANTHROPIC,
+    gemini: provider_contract_1.IntentProvider.GEMINI,
+    grok: provider_contract_1.IntentProvider.GROK,
+    xai: provider_contract_1.IntentProvider.GROK,
+    mistral: provider_contract_1.IntentProvider.MISTRAL,
+    office: provider_contract_1.IntentProvider.OFFICE,
+};
+/**
+ * Formats a DCDR virtual provider model id as `provider/model`.
+ *
+ * Returns an empty string for unsupported provider prefixes.
+ */
+function formatDcdrVirtualModelId(provider, modelId) {
+    const prefix = DCDR_VIRTUAL_PROVIDER_PREFIX_BY_PROVIDER[provider];
+    if (!prefix)
+        return "";
+    const id = String(modelId ?? "").trim();
+    if (!id)
+        return "";
+    return `${prefix}/${id}`;
+}
+/**
+ * Parses a DCDR virtual provider model id of the form `provider/model`.
+ *
+ * Returns null when the id is not a valid DCDR virtual model id.
+ */
+function parseDcdrVirtualModelId(prefixedModelId) {
+    const raw = String(prefixedModelId ?? "").trim();
+    if (!raw)
+        return null;
+    const idx = raw.indexOf("/");
+    if (idx <= 0 || idx >= raw.length - 1)
+        return null;
+    const prefix = raw.slice(0, idx).trim().toLowerCase();
+    const modelId = raw.slice(idx + 1).trim();
+    if (!prefix || !modelId)
+        return null;
+    const provider = DCDR_VIRTUAL_PROVIDER_BY_PREFIX[prefix];
+    if (!provider)
+        return null;
+    return { provider, modelId, prefixedModelId: raw };
+}
+/**
+ * Builds a virtual provider model list for `IntentProvider.DCDR`.
+ *
+ * Goal
+ * - Allow DCDR to reference any model that DCDR runtime explicitly supports.
+ *
+ * Rules
+ * - For hosted providers (OpenAI/Anthropic/Gemini/Grok/Mistral): include only models marked `runtimeSupport.status=SUPPORTED`.
+ * - For `OFFICE`: include all declared models (local/runtime-managed; support is deployment-dependent).
+ * - Stable deterministic ordering: provider order then model declaration order.
+ */
+function buildDcdrVirtualProviderModelDefinitions(modelsByProvider) {
+    const providers = [
+        provider_contract_1.IntentProvider.OPEN_AI,
+        provider_contract_1.IntentProvider.ANTHROPIC,
+        provider_contract_1.IntentProvider.GEMINI,
+        provider_contract_1.IntentProvider.GROK,
+        provider_contract_1.IntentProvider.MISTRAL,
+        provider_contract_1.IntentProvider.OFFICE,
+    ];
+    const out = [];
+    for (const provider of providers) {
+        const defs = modelsByProvider[provider] ?? [];
+        for (const def of defs) {
+            const isOffice = provider === provider_contract_1.IntentProvider.OFFICE;
+            const isSupported = def.runtimeSupport?.status ===
+                ProviderModelRuntimeSupportStatus.SUPPORTED;
+            if (!isOffice && !isSupported)
+                continue;
+            const prefixedId = formatDcdrVirtualModelId(provider, def.id);
+            if (!prefixedId)
+                continue;
+            out.push({
+                ...def,
+                id: prefixedId,
+                publicForCustomers: false,
+            });
+        }
+    }
+    return out;
+}
+/**
+ * Canonical provider model catalog (single source of truth).
+ */
+const PROVIDER_MODEL_DEFINITIONS_BY_PROVIDER_RAW = {
+    [provider_contract_1.IntentProvider.DCDR]: (0, dcdr_contract_1.buildDcdrProviderModelDefinitions)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.OPEN_AI]: (0, openai_contract_1.buildOpenAIProviderModelDefinitions)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.GEMINI]: (0, gemini_contract_1.buildGeminiProviderModelDefinitions)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.GROK]: (0, grok_contract_1.buildGrokProviderModelDefinitions)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.ANTHROPIC]: (0, anthropic_contract_1.buildAnthropicProviderModelDefinitions)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.MISTRAL]: (0, mistral_contract_1.buildMistralProviderModelDefinitions)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.COHERE]: (0, cohere_contract_1.buildCohereProviderModelDefinitions)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.OFFICE]: (0, office_contract_1.buildOfficeProviderModelDefinitions)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.OLLAMA]: (0, ollama_contract_1.buildOllamaProviderModelDefinitions)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.OPEN_AI_COMPATIBLE]: (0, openai_compatible_contract_1.buildOpenAICompatibleProviderModelDefinitions)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.OCR]: (0, ocr_contract_1.buildOcrProviderModelDefinitions)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.CLIP]: (0, clip_contract_1.buildClipProviderModelDefinitions)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.HTTP_TOOL]: (0, http_tool_contract_1.buildHttpToolProviderModelDefinitions)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.RULES]: (0, rules_contract_1.buildRulesProviderModelDefinitions)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+};
+/**
+ * Token usage coverage overrides derived from provider E2E curation runs.
+ *
+ * Notes
+ * - This is intended to be filled iteratively (in batches) as we validate token usage reporting
+ *   for all `runtimeSupport.status=SUPPORTED` chat models.
+ * - These overrides only apply when a model definition omits `tokenUsageCovered`.
+ *   (Public customer models still require `tokenUsageCovered=true` on the definition itself.)
+ */
+const TOKEN_USAGE_COVERAGE_BY_PROVIDER_AND_ID = {
+    [provider_contract_1.IntentProvider.OPEN_AI]: {
+        "gpt-5.5-2026-04-23": true,
+        "gpt-5.5-pro": true,
+        "gpt-5.5-pro-2026-04-23": true,
+        "gpt-5.4-2026-03-05": true,
+        "gpt-5.4-mini-2026-03-17": true,
+        "gpt-5.4-nano-2026-03-17": true,
+        "gpt-5.4-pro": true,
+        "gpt-5.4-pro-2026-03-05": true,
+        "gpt-5.3-chat-latest": true,
+        "gpt-5.3-codex": true,
+        "gpt-5.2": true,
+        "gpt-5.2-2025-12-11": true,
+        "gpt-5.2-chat-latest": true,
+        "gpt-5.2-codex": true,
+        "gpt-5.2-pro": true,
+        "gpt-5.2-pro-2025-12-11": true,
+        "gpt-5.1": true,
+        "gpt-5.1-2025-11-13": true,
+        "gpt-5.1-chat-latest": true,
+        "gpt-5.1-codex": true,
+        "gpt-5.1-codex-max": true,
+        "gpt-5.1-codex-mini": true,
+        "gpt-5": true,
+        "gpt-5-2025-08-07": true,
+        "gpt-5-chat-latest": true,
+        "gpt-5-codex": true,
+        "gpt-5-mini": true,
+        "gpt-5-mini-2025-08-07": true,
+        "gpt-5-nano": true,
+        "gpt-5-nano-2025-08-07": true,
+        "gpt-5-pro": true,
+        "gpt-5-pro-2025-10-06": true,
+        "gpt-4.1": true,
+        "gpt-4.1-2025-04-14": true,
+        "gpt-4.1-mini": true,
+        "gpt-4.1-mini-2025-04-14": true,
+        "gpt-4.1-nano": true,
+        "gpt-4.1-nano-2025-04-14": true,
+        "gpt-4o": true,
+        "gpt-4o-2024-08-06": true,
+        "gpt-4o-2024-11-20": true,
+        "gpt-4o-mini": true,
+        "gpt-4o-mini-2024-07-18": true,
+        "gpt-4o-2024-05-13": true,
+        "gpt-4-turbo": true,
+        "gpt-4-turbo-2024-04-09": true,
+        "gpt-4": true,
+        "gpt-4-0613": true,
+        "gpt-3.5-turbo": true,
+        "gpt-3.5-turbo-0125": true,
+        "gpt-3.5-turbo-1106": true,
+        "gpt-3.5-turbo-16k": true,
+        "o4-mini": true,
+        "o4-mini-2025-04-16": true,
+        "o3-pro": true,
+        "o3-pro-2025-06-10": true,
+        o3: true,
+        "o3-2025-04-16": true,
+        "o3-mini": true,
+        "o3-mini-2025-01-31": true,
+        "o1-pro": true,
+        "o1-pro-2025-03-19": true,
+        o1: true,
+        "o1-2024-12-17": true,
+    },
+    [provider_contract_1.IntentProvider.GEMINI]: {
+        "gemini-3.1-pro-preview-customtools": true,
+        "gemini-3.1-flash-lite-preview": true,
+        "gemini-3.1-flash-lite": true,
+        "gemini-3.1-flash-image-preview": true,
+        "gemini-3-pro-preview": false,
+        "gemini-2.5-flash-image": true,
+        "gemini-flash-latest": true,
+        "gemini-flash-lite-latest": true,
+        "gemini-pro-latest": true,
+    },
+    [provider_contract_1.IntentProvider.ANTHROPIC]: {
+        "claude-opus-4-6": true,
+        "claude-opus-4-5-20251101": true,
+        "claude-opus-4-1-20250805": true,
+        "claude-sonnet-4-5-20250929": true,
+        "claude-haiku-4-5-20251001": true,
+    },
+    [provider_contract_1.IntentProvider.OFFICE]: {},
+};
+function getTokenUsageCoveredOverride(provider, modelId) {
+    return TOKEN_USAGE_COVERAGE_BY_PROVIDER_AND_ID[provider]?.[modelId];
+}
+/** Normalizes catalog entries so optional flags become required (fail-closed). */
+function normalizeProviderModelDefinitions(modelsByProvider) {
+    const out = {};
+    let globalDefaultCount = 0;
+    const categoryDefaultCounts = new Map();
+    const categoriesWithPublicModels = new Set();
+    const assertTier = (provider, modelId, field, value) => {
+        if (!Number.isFinite(value)) {
+            throw new Error(`Provider model catalog: ${provider}/${modelId} ${field} must be a finite number (1..5).`);
+        }
+        const n = Math.trunc(value);
+        if (n !== value || n < 1 || n > 5) {
+            throw new Error(`Provider model catalog: ${provider}/${modelId} ${field} must be an integer in range 1..5.`);
+        }
+    };
+    const assertNoLegacyManagedFields = (provider, modelId, def) => {
+        const d = def;
+        const legacyFields = [
+            "publicDisplayName",
+            "isRecommendedDefault",
+            "default",
+        ];
+        for (const f of legacyFields) {
+            if (Object.prototype.hasOwnProperty.call(d, f)) {
+                throw new Error(`Provider model catalog: ${provider}/${modelId} must not include legacy field '${f}'.`);
+            }
+        }
+    };
+    const assertNonEmptyStringArray = (provider, modelId, field, value) => {
+        if (!Array.isArray(value) || value.length === 0) {
+            throw new Error(`Provider model catalog: ${provider}/${modelId} ${field} must be a non-empty string array.`);
+        }
+        for (const v of value) {
+            if (typeof v !== "string" || !v.trim()) {
+                throw new Error(`Provider model catalog: ${provider}/${modelId} ${field} must contain only non-empty strings.`);
+            }
+        }
+    };
+    for (const provider of Object.values(provider_contract_1.IntentProvider)) {
+        const defs = modelsByProvider[provider] ?? [];
+        const ids = new Set();
+        out[provider] = defs.map((def) => {
+            assertNoLegacyManagedFields(provider, def.id, def);
+            if (ids.has(def.id)) {
+                throw new Error(`Provider model catalog: duplicate modelId '${def.id}' for provider ${provider}.`);
+            }
+            ids.add(def.id);
+            const tokenUsageCoveredOverride = getTokenUsageCoveredOverride(provider, def.id);
+            const normalized = {
+                ...def,
+                publicForCustomers: def.publicForCustomers === true,
+                tokenUsageCovered: def.tokenUsageCovered ?? tokenUsageCoveredOverride,
+            };
+            if (normalized.publicForCustomers) {
+                if (normalized.tokenUsageCovered !== true) {
+                    throw new Error(`Provider model catalog: ${provider}/${normalized.id} tokenUsageCovered=true is required for publicForCustomers models.`);
+                }
+                if (!normalized.publicName?.trim()) {
+                    throw new Error(`Provider model catalog: ${provider}/${normalized.id} publicName is required for publicForCustomers models.`);
+                }
+                if (!normalized.primaryCategory) {
+                    throw new Error(`Provider model catalog: ${provider}/${normalized.id} primaryCategory is required for publicForCustomers models.`);
+                }
+                if (!Array.isArray(normalized.categories) ||
+                    normalized.categories.length === 0) {
+                    throw new Error(`Provider model catalog: ${provider}/${normalized.id} categories is required for publicForCustomers models.`);
+                }
+                if (!normalized.categories.includes(normalized.primaryCategory)) {
+                    throw new Error(`Provider model catalog: ${provider}/${normalized.id} categories must include primaryCategory (${normalized.primaryCategory}).`);
+                }
+                categoriesWithPublicModels.add(normalized.primaryCategory);
+                if (typeof normalized.isRecommended !== "boolean") {
+                    throw new Error(`Provider model catalog: ${provider}/${normalized.id} isRecommended is required for publicForCustomers models.`);
+                }
+                if (typeof normalized.isGlobalDefault !== "boolean") {
+                    throw new Error(`Provider model catalog: ${provider}/${normalized.id} isGlobalDefault is required for publicForCustomers models.`);
+                }
+                if (typeof normalized.isCategoryDefault !== "boolean") {
+                    throw new Error(`Provider model catalog: ${provider}/${normalized.id} isCategoryDefault is required for publicForCustomers models.`);
+                }
+                if (normalized.isGlobalDefault)
+                    globalDefaultCount += 1;
+                if (normalized.isCategoryDefault) {
+                    const c = normalized.primaryCategory;
+                    const prev = categoryDefaultCounts.get(c) ?? 0;
+                    categoryDefaultCounts.set(c, prev + 1);
+                }
+                assertTier(provider, normalized.id, "qualityTier", normalized.qualityTier ?? Number.NaN);
+                assertTier(provider, normalized.id, "speedTier", normalized.speedTier ?? Number.NaN);
+                assertTier(provider, normalized.id, "costTier", normalized.costTier ?? Number.NaN);
+                assertNonEmptyStringArray(provider, normalized.id, "recommendedUseCases", normalized.recommendedUseCases ?? []);
+            }
+            return normalized;
+        });
+    }
+    if (globalDefaultCount !== 1) {
+        throw new Error(`Provider model catalog: expected exactly one public model with isGlobalDefault=true, found ${globalDefaultCount}.`);
+    }
+    for (const c of categoriesWithPublicModels) {
+        const count = categoryDefaultCounts.get(c) ?? 0;
+        if (count <= 0) {
+            throw new Error(`Provider model catalog: expected at least one public model with isCategoryDefault=true for primaryCategory ${c}.`);
+        }
+    }
+    return out;
+}
+/**
+ * Canonical provider model catalog (after enrichment passes).
+ */
+exports.PROVIDER_MODEL_DEFINITIONS_BY_PROVIDER = (() => {
+    const base = fillMissingPricingFromBaseModels(PROVIDER_MODEL_DEFINITIONS_BY_PROVIDER_RAW);
+    const normalized = normalizeProviderModelDefinitions(base);
+    return {
+        ...normalized,
+        [provider_contract_1.IntentProvider.DCDR]: buildDcdrVirtualProviderModelDefinitions(normalized),
+    };
+})();
+const _PROVIDER_MODEL_INDEXES = buildProviderModelCatalogAndTypeIndex(exports.PROVIDER_MODEL_DEFINITIONS_BY_PROVIDER);
+/**
+ * Canonical lookup: provider -> modelId -> model definition.
+ */
+exports.PROVIDER_MODEL_CATALOG = _PROVIDER_MODEL_INDEXES.catalog;
+/**
+ * Primary listing structure (no duplicated metadata): provider -> intent type -> model IDs.
+ */
+exports.PROVIDER_MODEL_IDS_BY_PROVIDER_AND_TYPE = _PROVIDER_MODEL_INDEXES.idsByType;
+/**
+ * E2E model status used by provider test suites.
+ *
+ * Notes
+ * - This is an opt-in testing mechanism; it does not affect runtime behavior.
+ * - Use `LEGACY` to explicitly skip obsolete/retired model IDs while still keeping them
+ *   discoverable in the catalog for historical compatibility.
+ */
+var ProviderModelE2EStatus;
+(function (ProviderModelE2EStatus) {
+    /** Model should be exercised by E2E suites (when provider is implemented and credentials exist). */
+    ProviderModelE2EStatus["ACTIVE"] = "ACTIVE";
+    /** Model is considered legacy/obsolete and may be skipped by E2E suites. */
+    ProviderModelE2EStatus["LEGACY"] = "LEGACY";
+})(ProviderModelE2EStatus || (exports.ProviderModelE2EStatus = ProviderModelE2EStatus = {}));
+/**
+ * Optional provider-model overrides consumed by the provider E2E matrix tests.
+ */
+exports.PROVIDER_MODEL_E2E_OVERRIDES = {
+    [provider_contract_1.IntentProvider.DCDR]: (0, dcdr_contract_1.buildDcdrProviderModelE2EOverrides)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.OPEN_AI]: (0, openai_contract_1.buildOpenAIProviderModelE2EOverrides)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.GEMINI]: (0, gemini_contract_1.buildGeminiProviderModelE2EOverrides)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.GROK]: (0, grok_contract_1.buildGrokProviderModelE2EOverrides)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.ANTHROPIC]: (0, anthropic_contract_1.buildAnthropicProviderModelE2EOverrides)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.MISTRAL]: (0, mistral_contract_1.buildMistralProviderModelE2EOverrides)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.COHERE]: (0, cohere_contract_1.buildCohereProviderModelE2EOverrides)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.OFFICE]: (0, office_contract_1.buildOfficeProviderModelE2EOverrides)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.OLLAMA]: (0, ollama_contract_1.buildOllamaProviderModelE2EOverrides)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.OPEN_AI_COMPATIBLE]: (0, openai_compatible_contract_1.buildOpenAICompatibleProviderModelE2EOverrides)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.OCR]: (0, ocr_contract_1.buildOcrProviderModelE2EOverrides)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.CLIP]: (0, clip_contract_1.buildClipProviderModelE2EOverrides)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.HTTP_TOOL]: (0, http_tool_contract_1.buildHttpToolProviderModelE2EOverrides)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+    [provider_contract_1.IntentProvider.RULES]: (0, rules_contract_1.buildRulesProviderModelE2EOverrides)(PROVIDER_CATALOG_MODULE_BUILD_ARGS),
+};
+function pricingPerMillionTokens(args) {
+    return {
+        currency: "USD",
+        sourceUrl: args.sourceUrl,
+        updatedAt: args.updatedAt ?? DEFAULT_TOKEN_PRICING_UPDATED_AT,
+        confidence: args.confidence ?? "official",
+        notes: args.notes,
+        components: [
+            {
+                kind: "tokens",
+                unit: "per_million_tokens",
+                input: args.input,
+                outputUsd: args.output,
+                cachedInput: args.cachedInput,
+                cachedOutput: args.cachedOutput,
+                tiers: args.tiers,
+            },
+        ],
+    };
+}
+/**
+ * Gemini token pricing helper.
+ *
+ * Notes
+ * - Uses the Gemini Developer API pricing page as the canonical source.
+ * - Pricing tables sometimes vary by modality (text vs audio) and/or prompt size (<=200k vs >200k tokens).
+ *   We represent those as `tiers` with a human-readable condition.
+ */
+function pricingAudioMinutesPerMinute(args) {
+    return {
+        currency: "USD",
+        sourceUrl: args.sourceUrl,
+        updatedAt: args.updatedAt ?? DEFAULT_AUDIO_PRICING_UPDATED_AT,
+        confidence: args.confidence ?? "official",
+        notes: args.notes,
+        components: [
+            {
+                kind: "audio_minutes",
+                unit: "per_minute",
+                input: args.input,
+                notes: args.notes,
+            },
+        ],
+    };
+}
+function clonePricingAsApproxFromBase(args) {
+    const base = args.basePricing;
+    const relation = args.relation ?? "base";
+    const extraNote = relation === "fallback"
+        ? `Inherited pricing from fallback model: ${args.baseId}`
+        : `Inherited pricing from base model: ${args.baseId}`;
+    const notes = base.notes ? `${base.notes} | ${extraNote}` : extraNote;
+    return {
+        currency: base.currency,
+        sourceUrl: base.sourceUrl,
+        updatedAt: base.updatedAt,
+        confidence: "approx",
+        notes,
+        components: base.components.map((c) => ({ ...c })),
+    };
+}
+function tryGetBaseModelIdFromVersionedId(modelId) {
+    const id = String(modelId || "").trim();
+    if (!id)
+        return null;
+    // Common vendor patterns:
+    // - OpenAI: gpt-4o-2024-11-20
+    // - OpenAI: gpt-5.4-mini-2026-03-17
+    // - Anthropic: claude-haiku-4-5-20251001
+    const m1 = id.match(/^(.*)-\d{4}-\d{2}-\d{2}$/);
+    if (m1?.[1])
+        return m1[1];
+    const m2 = id.match(/^(.*)-\d{8}$/);
+    if (m2?.[1])
+        return m2[1];
+    return null;
+}
+/**
+ * Fills pricing gaps by inheriting pricing from the base model when a vendor exposes
+ * versioned/dated aliases that share the same pricing.
+ *
+ * Notes
+ * - Inherited pricing is marked as `confidence: "approx"`.
+ * - Only applies when a base model is present in the same provider list.
+ */
+function fillMissingPricingFromBaseModels(modelsByProvider) {
+    const out = {};
+    for (const provider of Object.values(provider_contract_1.IntentProvider)) {
+        const defs = modelsByProvider[provider] ?? [];
+        const pricingById = {};
+        for (const def of defs) {
+            if (def.pricing)
+                pricingById[def.id] = def.pricing;
+        }
+        const fallbacks = PRICING_FALLBACK_RULES_BY_PROVIDER[provider] ?? [];
+        out[provider] = defs.map((def) => {
+            if (def.pricing)
+                return def;
+            const baseId = tryGetBaseModelIdFromVersionedId(def.id);
+            if (baseId) {
+                const basePricing = pricingById[baseId];
+                if (basePricing) {
+                    return {
+                        ...def,
+                        pricing: clonePricingAsApproxFromBase({
+                            modelId: def.id,
+                            baseId,
+                            basePricing,
+                            relation: "base",
+                        }),
+                    };
+                }
+            }
+            for (const rule of fallbacks) {
+                if (!rule.match.test(def.id))
+                    continue;
+                const fallbackPricing = pricingById[rule.baseModelId];
+                if (!fallbackPricing)
+                    continue;
+                return {
+                    ...def,
+                    pricing: clonePricingAsApproxFromBase({
+                        modelId: def.id,
+                        baseId: rule.baseModelId,
+                        basePricing: fallbackPricing,
+                        relation: "fallback",
+                    }),
+                };
+            }
+            return def;
+        });
+    }
+    return out;
+}
+function buildProviderModelCatalogAndTypeIndex(modelsByProvider) {
+    const intentTypes = Object.values(intent_contract_1.IntentType);
+    const catalog = {};
+    const idsByType = {};
+    for (const provider of Object.values(provider_contract_1.IntentProvider)) {
+        catalog[provider] = {};
+        const perType = {};
+        for (const t of intentTypes)
+            perType[t] = [];
+        idsByType[provider] = perType;
+        const defs = modelsByProvider[provider] ?? [];
+        for (const def of defs) {
+            catalog[provider][def.id] = def;
+            for (const t of def.types) {
+                idsByType[provider][t].push(def.id);
+            }
+        }
+    }
+    return { catalog, idsByType };
+}
+/**
+ * Static utility class for querying the provider model catalog.
+ *
+ * Designed for client consumption: `ProviderModelRegistry.listProvidersSupportingType(...)`.
+ */
+class ProviderModelRegistry {
+    /** Canonical catalog view: provider -> modelId -> definition. */
+    static catalog = exports.PROVIDER_MODEL_CATALOG;
+    /** Primary listing view: provider -> intent type -> model IDs. */
+    static idsByProviderAndType = exports.PROVIDER_MODEL_IDS_BY_PROVIDER_AND_TYPE;
+    /** Source-of-truth definitions in declared order (useful for UI display). */
+    static definitionsByProvider = exports.PROVIDER_MODEL_DEFINITIONS_BY_PROVIDER;
+    /** Returns the model definition if present; otherwise null. */
+    static getModelDefinition(provider, modelId) {
+        return ProviderModelRegistry.catalog[provider]?.[modelId] ?? null;
+    }
+    /** Lists all model IDs for a provider (stable order as declared in the catalog). */
+    static listProviderModelIds(provider) {
+        return (ProviderModelRegistry.definitionsByProvider[provider] ?? []).map((m) => m.id);
+    }
+    /** Lists all model definitions for a provider (stable order as declared in the catalog). */
+    static listProviderModels(provider, options) {
+        const defs = ProviderModelRegistry.definitionsByProvider[provider] ?? [];
+        if (!options?.onlyPublicForCustomers)
+            return defs;
+        return defs.filter((m) => m.publicForCustomers === true);
+    }
+    /**
+     * Lists all public customer models across all providers.
+     *
+     * Notes
+     * - Uses the catalog declared order (provider order, then per-provider declaration order).
+     * - This is a UI/helper surface only; execution still uses provider+modelId.
+     */
+    static listPublicCustomerModels(options) {
+        const out = [];
+        for (const provider of Object.values(provider_contract_1.IntentProvider)) {
+            const defs = ProviderModelRegistry.listProviderModels(provider, {
+                onlyPublicForCustomers: true,
+            });
+            for (const def of defs) {
+                const model = def;
+                if (options?.primaryCategory &&
+                    model.primaryCategory !== options.primaryCategory) {
+                    continue;
+                }
+                if (options?.includeCategories?.length) {
+                    const include = options.includeCategories;
+                    const hasAny = include.some((c) => model.categories.includes(c));
+                    if (!hasAny)
+                        continue;
+                }
+                out.push({ provider, modelId: model.id, model });
+            }
+        }
+        return out;
+    }
+    /**
+     * Groups all public customer models by their primaryCategory.
+     *
+     * Intended for the "simple UI" mode where the UI shows high-level DCDR groups.
+     */
+    static listPublicCustomerModelsByPrimaryCategory() {
+        const out = {};
+        for (const c of Object.values(DcdrPublicModelCategory)) {
+            out[c] = [];
+        }
+        for (const item of ProviderModelRegistry.listPublicCustomerModels()) {
+            out[item.model.primaryCategory].push(item);
+        }
+        return out;
+    }
+    /** Lists model IDs for a provider that support a given IntentType. */
+    static listProviderModelIdsForType(provider, type) {
+        return ProviderModelRegistry.idsByProviderAndType[provider]?.[type] ?? [];
+    }
+    /** Lists model definitions for a provider that support a given IntentType. */
+    static listProviderModelsForType(provider, type) {
+        const ids = ProviderModelRegistry.listProviderModelIdsForType(provider, type);
+        return ids
+            .map((id) => ProviderModelRegistry.getModelDefinition(provider, id))
+            .filter((m) => m !== null);
+    }
+    /** Returns true if the provider has at least one model for the given IntentType. */
+    static providerSupportsType(provider, type) {
+        return (ProviderModelRegistry.listProviderModelIdsForType(provider, type).length >
+            0);
+    }
+    /** Returns true if the model supports the given IntentType (based on the catalog). */
+    static modelSupportsType(provider, modelId, type) {
+        const def = ProviderModelRegistry.getModelDefinition(provider, modelId);
+        if (!def)
+            return false;
+        return def.types.includes(type);
+    }
+    /** Lists all providers that have at least one model supporting the given IntentType. */
+    static listProvidersSupportingType(type) {
+        return Object.values(provider_contract_1.IntentProvider).filter((p) => ProviderModelRegistry.providerSupportsType(p, type));
+    }
+    /** Returns all model IDs across all providers for a given type. */
+    static listAllModelIdsForType(type) {
+        const out = [];
+        for (const provider of Object.values(provider_contract_1.IntentProvider)) {
+            for (const modelId of ProviderModelRegistry.listProviderModelIdsForType(provider, type)) {
+                out.push({ provider, modelId });
+            }
+        }
+        return out;
+    }
+    /** Convenience: get unified pricing if present (or null if not set/unknown). */
+    static getModelPricing(provider, modelId) {
+        return (ProviderModelRegistry.getModelDefinition(provider, modelId)?.pricing ??
+            null);
+    }
+    /** Get a specific pricing component from a model by kind (or null if absent). */
+    static getPricingComponent(provider, modelId, kind) {
+        const pricing = ProviderModelRegistry.getModelPricing(provider, modelId);
+        if (!pricing)
+            return null;
+        const found = pricing.components.find((c) => c.kind === kind);
+        return found ?? null;
+    }
+    /** Convenience: token pricing (per MTok) if present. */
+    static getTokenPricing(provider, modelId) {
+        return ProviderModelRegistry.getPricingComponent(provider, modelId, "tokens");
+    }
+}
+exports.ProviderModelRegistry = ProviderModelRegistry;