import { MODELS } from "./models.generated.js";
import { CUSTOM_MODELS } from "./models.custom.js";
const modelRegistry = new Map();
// Initialize registry from auto-generated MODELS (models.dev catalog)
for (const [provider, models] of Object.entries(MODELS)) {
    const providerModels = new Map();
    for (const [id, model] of Object.entries(models)) {
        providerModels.set(id, model);
    }
    modelRegistry.set(provider, providerModels);
}
// Merge manually-maintained custom providers that are NOT in models.dev.
// Custom models are additive — they never overwrite generated entries.
// See: https://github.com/defconxt/NERF/issues/2339
for (const [provider, models] of Object.entries(CUSTOM_MODELS)) {
    if (!modelRegistry.has(provider)) {
        modelRegistry.set(provider, new Map());
    }
    const providerModels = modelRegistry.get(provider);
    for (const [id, model] of Object.entries(models)) {
        if (!providerModels.has(id)) {
            providerModels.set(id, model);
        }
    }
}
const CAPABILITY_PATCHES = [
    // GPT-5.x supports xhigh thinking and OpenAI service tiers
    {
        match: (m) => m.id.includes("gpt-5.2") || m.id.includes("gpt-5.3") || m.id.includes("gpt-5.4"),
        caps: { supportsXhigh: true, supportsServiceTier: true },
    },
    // Anthropic Opus 4.6 supports xhigh thinking
    {
        match: (m) => m.api === "anthropic-messages" && (m.id.includes("opus-4-6") || m.id.includes("opus-4.6")),
        caps: { supportsXhigh: true },
    },
];
/**
 * Apply capability patches to a list of models.
 *
 * Models constructed outside the static pi-ai registry (custom models from
 * models.json, extension-registered models, discovered models) do not pass
 * through the module-init patch loop. Call this function after assembling
 * any model list to ensure capabilities are set correctly.
 *
 * Explicit `capabilities` already set on a model take precedence over patches.
 */
export function applyCapabilityPatches(models) {
    return models.map((model) => {
        for (const patch of CAPABILITY_PATCHES) {
            if (patch.match(model)) {
                return {
                    ...model,
                    capabilities: { ...patch.caps, ...model.capabilities },
                };
            }
        }
        return model;
    });
}
// Apply patches to the static registry at module load
for (const [, providerModels] of modelRegistry) {
    for (const [id, model] of providerModels) {
        for (const patch of CAPABILITY_PATCHES) {
            if (patch.match(model)) {
                providerModels.set(id, {
                    ...model,
                    capabilities: { ...patch.caps, ...model.capabilities },
                });
                break;
            }
        }
    }
}
export function getModel(provider, modelId) {
    const providerModels = modelRegistry.get(provider);
    return providerModels?.get(modelId);
}
export function getProviders() {
    return Array.from(modelRegistry.keys());
}
export function getModels(provider) {
    const models = modelRegistry.get(provider);
    return models ? Array.from(models.values()) : [];
}
export function calculateCost(model, usage) {
    usage.cost.input = (model.cost.input / 1000000) * usage.input;
    usage.cost.output = (model.cost.output / 1000000) * usage.output;
    usage.cost.cacheRead = (model.cost.cacheRead / 1000000) * usage.cacheRead;
    usage.cost.cacheWrite = (model.cost.cacheWrite / 1000000) * usage.cacheWrite;
    usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
    return usage.cost;
}
/**
 * Check if a model supports xhigh thinking level.
 *
 * Reads from `model.capabilities.supportsXhigh` — set via CAPABILITY_PATCHES
 * for generated models or declared directly in custom model definitions.
 * Do not add model-ID or provider-name checks here; update CAPABILITY_PATCHES instead.
 */
export function supportsXhigh(model) {
    return model.capabilities?.supportsXhigh ?? false;
}
/**
 * Check if two models are equal by comparing both their id and provider.
 * Returns false if either model is null or undefined.
 */
export function modelsAreEqual(a, b) {
    if (!a || !b)
        return false;
    return a.id === b.id && a.provider === b.provider;
}
//# sourceMappingURL=models.js.map