manifest/dist/backend/model-discovery/anthropic-subscription-probe.js

Self-hosted Manifest LLM router with embedded server, SQLite database, and dashboard

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.extractFamily = extractFamily;
exports.filterBySubscriptionAccess = filterBySubscriptionAccess;
const common_1 = require("@nestjs/common");
const logger = new common_1.Logger('AnthropicSubscriptionProbe');
const ANTHROPIC_MESSAGES_URL = 'https://api.anthropic.com/v1/messages';
const PROBE_TIMEOUT_MS = 5000;
const FAMILY_RE = /^claude-(?:\d+(?:-\d+)*-)?([a-z]+)/i;
function extractFamily(modelId) {
    const match = FAMILY_RE.exec(modelId);
    return match?.[1] ?? null;
}
async function probeModel(apiKey, modelId) {
    try {
        const controller = new AbortController();
        const timeout = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
        const res = await fetch(ANTHROPIC_MESSAGES_URL, {
            method: 'POST',
            headers: {
                Authorization: `Bearer ${apiKey}`,
                'Content-Type': 'application/json',
                'anthropic-version': '2023-06-01',
                'anthropic-beta': 'oauth-2025-04-20',
            },
            body: JSON.stringify({
                model: modelId,
                max_tokens: 1,
                system: [
                    {
                        type: 'text',
                        text: "You are a Claude agent, built on Anthropic's Claude Agent SDK.",
                        cache_control: { type: 'ephemeral' },
                    },
                ],
                messages: [{ role: 'user', content: '.' }],
            }),
            signal: controller.signal,
        });
        clearTimeout(timeout);
        if (res.ok)
            return true;
        if (res.status === 400)
            return false;
        return true;
    }
    catch {
        return true;
    }
}
async function filterBySubscriptionAccess(models, apiKey) {
    const familyMap = new Map();
    const noFamily = [];
    for (const model of models) {
        const family = extractFamily(model.id);
        if (!family) {
            noFamily.push(model);
            continue;
        }
        const group = familyMap.get(family) ?? [];
        group.push(model);
        familyMap.set(family, group);
    }
    const families = [...familyMap.keys()];
    const probeResults = await Promise.all(families.map(async (family) => {
        const representative = familyMap.get(family)[0];
        const accessible = await probeModel(apiKey, representative.id);
        if (!accessible) {
            logger.log(`Anthropic subscription: ${family} models not accessible (probed ${representative.id})`);
        }
        return { family, accessible };
    }));
    const accessibleFamilies = new Set(probeResults.filter((r) => r.accessible).map((r) => r.family));
    const blockedFamilies = families.filter((f) => !accessibleFamilies.has(f));
    if (blockedFamilies.length > 0) {
        logger.log(`Anthropic subscription: accessible families=[${[...accessibleFamilies].join(', ')}], ` +
            `blocked families=[${blockedFamilies.join(', ')}]`);
    }
    const filtered = models.filter((model) => {
        const family = extractFamily(model.id);
        if (!family)
            return true;
        return accessibleFamilies.has(family);
    });
    return filtered;
}
//# sourceMappingURL=anthropic-subscription-probe.js.map