@pellux/goodvibes-sdk 0.18.14 → 0.18.16

package/dist/_internal/platform/providers/model-catalog-synthetic.d.ts

@@ -0,0 +1,33 @@
+import type { BenchmarkEntry } from '@pellux/goodvibes-sdk/platform/providers/model-benchmarks';
+import type { CatalogModel } from './model-catalog.js';
+import type { CanonicalModel, SyntheticTier } from './synthetic.js';
+export interface MinimalModelDefinition {
+    id: string;
+    provider: string;
+    registryKey: string;
+    displayName: string;
+    description: string;
+    capabilities: {
+        toolCalling: boolean;
+        codeEditing: boolean;
+        reasoning: boolean;
+        multimodal: boolean;
+    };
+    contextWindow: number;
+    selectable: boolean;
+    tier: 'free' | 'standard' | 'premium' | 'subscription';
+    reasoningEffort?: string[];
+}
+export interface SyntheticModelInfo {
+    backendCount: number;
+    keyedBackendCount: number;
+    tier: SyntheticTier;
+    bestCompositeScore: number | null;
+}
+export declare function nameToSlug(name: string): string;
+export declare function normalizeModelName(name: string): string;
+export declare function buildSyntheticCanonicalModels(models: readonly CatalogModel[]): CanonicalModel[];
+export declare function getSyntheticModelInfo(modelId: string, canonicalModels: readonly CanonicalModel[], getBenchmarks: (modelName: string) => BenchmarkEntry | undefined): SyntheticModelInfo | null;
+export declare function getSyntheticBackendModelIds(canonicalModels: readonly CanonicalModel[]): Set<string>;
+export declare function getSyntheticModelDefinitions(models: readonly CatalogModel[], canonicalModels: readonly CanonicalModel[]): MinimalModelDefinition[];
+//# sourceMappingURL=model-catalog-synthetic.d.ts.map

package/dist/_internal/platform/providers/model-catalog-synthetic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-catalog-synthetic.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/model-catalog-synthetic.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2DAA2D,CAAC;AAEhG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAoB,cAAc,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEtF,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE;QACZ,WAAW,EAAE,OAAO,CAAC;QACrB,WAAW,EAAE,OAAO,CAAC;QACrB,SAAS,EAAE,OAAO,CAAC;QACnB,UAAU,EAAE,OAAO,CAAC;KACrB,CAAC;IACF,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,GAAG,cAAc,CAAC;IACvD,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,IAAI,EAAE,aAAa,CAAC;IACpB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAID,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C;AASD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMvD;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,cAAc,EAAE,CAgF/F;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,eAAe,EAAE,SAAS,cAAc,EAAE,EAC1C,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,cAAc,GAAG,SAAS,GAC/D,kBAAkB,GAAG,IAAI,CAoB3B;AAED,wBAAgB,2BAA2B,CAAC,eAAe,EAAE,SAAS,cAAc,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAEnG;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,SAAS,YAAY,EAAE,EAC/B,eAAe,EAAE,SAAS,cAAc,EAAE,GACzC,sBAAsB,EAAE,CAkC1B"}

package/dist/_internal/platform/providers/model-catalog-synthetic.js

@@ -0,0 +1,153 @@
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { compositeScore } from '@pellux/goodvibes-sdk/platform/providers/model-benchmarks';
+const MAX_FAMILY_UNIQUE_NAMES = 20;
+export function nameToSlug(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+function hasConfiguredEnvVar(envVars) {
+    return envVars.some((envVar) => {
+        const value = process.env[envVar];
+        return typeof value === 'string' && value.length > 0;
+    });
+}
+export function normalizeModelName(name) {
+    let normalized = name.toLowerCase();
+    normalized = normalized.replace(/\b(instruct|chat|latest|preview|free|turbo|fast|base|pt|online|standard|default|it|bf16|fp8|fp16|awq|gptq|gguf|bnb|qlora|lora)\b/g, ' ');
+    normalized = normalized.replace(/\b(?:(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[0-2])|(0[1-9]|1[0-2])(0[1-9]|[12][0-9]|3[01]))\b/g, ' ');
+    normalized = normalized.replace(/\b(?:20[2-3][0-9](?:0[1-9]|1[0-2])(?:0[1-9]|[12][0-9]|3[01])|20[2-3][0-9](?:0[1-9]|1[0-2])|[2-3][0-9](?:0[1-9]|1[0-2]))\b/g, ' ');
+    return nameToSlug(normalized);
+}
+export function buildSyntheticCanonicalModels(models) {
+    const byFamily = new Map();
+    for (const model of models) {
+        if (!model.family)
+            continue;
+        const bucket = byFamily.get(model.family);
+        if (bucket) {
+            bucket.push(model);
+        }
+        else {
+            byFamily.set(model.family, [model]);
+        }
+    }
+    const canonicalGroups = new Map();
+    for (const [family, group] of byFamily) {
+        const uniqueNames = new Set(group.map((model) => normalizeModelName(model.name)));
+        const isBroad = uniqueNames.size > MAX_FAMILY_UNIQUE_NAMES;
+        if (isBroad) {
+            const byName = new Map();
+            for (const model of group) {
+                const key = normalizeModelName(model.name);
+                const bucket = byName.get(key);
+                if (bucket) {
+                    bucket.push(model);
+                }
+                else {
+                    byName.set(key, [model]);
+                }
+            }
+            for (const [slug, nameGroup] of byName) {
+                const canonicalId = canonicalGroups.has(slug) ? `${family}-${slug}` : slug;
+                const existing = canonicalGroups.get(canonicalId);
+                if (existing) {
+                    existing.push(...nameGroup);
+                }
+                else {
+                    canonicalGroups.set(canonicalId, [...nameGroup]);
+                }
+            }
+            continue;
+        }
+        const existing = canonicalGroups.get(family);
+        if (existing) {
+            existing.push(...group);
+        }
+        else {
+            canonicalGroups.set(family, [...group]);
+        }
+    }
+    const canonical = [];
+    for (const [canonicalId, group] of canonicalGroups) {
+        const allBackends = group.map((model) => ({
+            providerName: model.providerId,
+            modelId: model.id,
+            registryKey: `${model.providerId}:${model.id}`,
+            contextWindow: model.contextWindow,
+            maxOutputTokens: model.maxOutputTokens,
+            envVars: model.providerEnvVars.length > 0 ? model.providerEnvVars : undefined,
+        }));
+        const keyedBackends = allBackends.filter((backend) => {
+            const vars = backend.envVars;
+            if (!vars || vars.length === 0)
+                return true;
+            return hasConfiguredEnvVar(vars);
+        });
+        const distinctProviders = new Set(keyedBackends.map((backend) => backend.providerName)).size;
+        if (distinctProviders < 2)
+            continue;
+        const tierPriority = { free: 2, subscription: 1, paid: 0 };
+        const tier = group.reduce((best, model) => (tierPriority[model.tier] ?? 0) > (tierPriority[best] ?? 0) ? model.tier : best, group[0].tier);
+        canonical.push({
+            id: canonicalId,
+            tier,
+            backends: allBackends,
+            backendCount: allBackends.length,
+            keyedBackendCount: distinctProviders,
+        });
+    }
+    return canonical;
+}
+export function getSyntheticModelInfo(modelId, canonicalModels, getBenchmarks) {
+    const canonical = canonicalModels.find((model) => model.id === modelId);
+    if (!canonical)
+        return null;
+    let bestCompositeScore = null;
+    for (const backend of canonical.backends) {
+        const benchmark = getBenchmarks(backend.modelId);
+        if (!benchmark)
+            continue;
+        const score = compositeScore(benchmark.benchmarks);
+        if (score != null && (bestCompositeScore == null || score > bestCompositeScore)) {
+            bestCompositeScore = score;
+        }
+    }
+    return {
+        backendCount: canonical.backendCount,
+        keyedBackendCount: canonical.keyedBackendCount,
+        tier: canonical.tier,
+        bestCompositeScore,
+    };
+}
+export function getSyntheticBackendModelIds(canonicalModels) {
+    return new Set(canonicalModels.flatMap((canonical) => canonical.backends.map((backend) => backend.modelId)));
+}
+export function getSyntheticModelDefinitions(models, canonicalModels) {
+    const definitions = canonicalModels.map((canonical) => {
+        const bestBackend = canonical.backends.reduce((best, backend) => ((backend.contextWindow ?? 0) > (best.contextWindow ?? 0) ? backend : best), canonical.backends[0]);
+        const catalogMatch = models.find((model) => canonical.backends.some((backend) => backend.modelId === model.id));
+        const displayName = catalogMatch?.name ?? canonical.id;
+        const hasReasoning = catalogMatch?.reasoning === true;
+        return {
+            id: canonical.id,
+            provider: 'synthetic',
+            registryKey: `synthetic:${canonical.id}`,
+            displayName,
+            description: `Synthetic failover model — ${canonical.backendCount} provider${canonical.backendCount !== 1 ? 's' : ''} available`,
+            capabilities: {
+                toolCalling: true,
+                codeEditing: true,
+                reasoning: hasReasoning,
+                multimodal: false,
+            },
+            contextWindow: bestBackend?.contextWindow ?? 128_000,
+            selectable: true,
+            tier: canonical.tier === 'free' ? 'free' : canonical.tier === 'subscription' ? 'subscription' : 'standard',
+            ...(hasReasoning ? { reasoningEffort: ['instant', 'low', 'medium', 'high'] } : {}),
+        };
+    });
+    logger.debug('[model-catalog] getSyntheticModelDefinitions', {
+        count: definitions.length,
+        sampleIds: definitions.slice(0, 20).map((definition) => definition.id),
+    });
+    return definitions;
+}

package/dist/_internal/platform/providers/model-catalog.d.ts

@@ -0,0 +1,73 @@
+import type { ProviderRegistry } from './registry.js';
+import type { ModelLimitsService } from './model-limits.js';
+import type { MinimalModelDefinition } from './model-catalog-synthetic.js';
+export interface CatalogProvider {
+    id: string;
+    name: string;
+    envVars: string[];
+    baseUrl: string;
+    requiresKey?: boolean;
+}
+export interface CatalogModelPricing {
+    input: number;
+    output: number;
+}
+export interface CatalogModel {
+    id: string;
+    name: string;
+    family?: string;
+    provider: string;
+    providerId: string;
+    providerEnvVars: string[];
+    pricing: CatalogModelPricing;
+    tier: 'free' | 'paid' | 'subscription';
+    contextWindow?: number;
+    maxOutputTokens?: number;
+    reasoning?: boolean;
+}
+export interface PricingCatalog {
+    fetchedAt: number;
+    models: CatalogModel[];
+}
+export declare function getCostFromPricingCatalog(modelId: string, catalog: Pick<PricingCatalog, 'models'>, modelLimitsService?: Pick<ModelLimitsService, 'getPricingForModel'>, opts?: {
+    debug?: boolean;
+}): CatalogModelPricing;
+export declare function normalizeModelId(modelId: string): string;
+export declare function hasKeyForProvider(provider: CatalogProvider): boolean;
+export interface CatalogModelEntry {
+    id: string;
+    displayName: string;
+    provider: string;
+    context: number;
+    tier: 'free' | 'paid' | 'subscription';
+}
+export interface CatalogModelChange {
+    model: CatalogModel;
+    changes: string[];
+}
+export interface CatalogDiff {
+    added: CatalogModel[];
+    removed: CatalogModel[];
+    changed: CatalogModelChange[];
+}
+export interface ModelCatalog {
+    getModel(modelId: string): CatalogModelEntry | null;
+    findLargerContextModels(minContext: number, tier?: 'free' | 'paid' | 'subscription', limit?: number): CatalogModelEntry[];
+}
+type ModelCatalogRegistry = Pick<ProviderRegistry, 'listModels' | 'getContextWindowForModel'>;
+export declare class RegistryBackedCatalog implements ModelCatalog {
+    private readonly registry;
+    private entriesCache;
+    private entriesCacheVersion;
+    constructor(registry: ModelCatalogRegistry);
+    private getEntries;
+    getModel(modelId: string): CatalogModelEntry | null;
+    findLargerContextModels(minContext: number, tier?: 'free' | 'paid' | 'subscription', limit?: number): CatalogModelEntry[];
+}
+export declare function createModelCatalog(registry: ModelCatalogRegistry): ModelCatalog;
+export declare function getCatalogModelDefinitionsFrom(models: readonly CatalogModel[]): MinimalModelDefinition[];
+export type { MinimalModelDefinition, SyntheticModelInfo } from './model-catalog-synthetic.js';
+export { fetchCatalog, getCatalogCachePath, getCatalogTmpPath, isCatalogCacheStale, loadCatalogCache, saveCatalogCache, } from './model-catalog-cache.js';
+export { buildSyntheticCanonicalModels, getSyntheticBackendModelIds, getSyntheticModelDefinitions, getSyntheticModelInfo, nameToSlug, normalizeModelName, } from './model-catalog-synthetic.js';
+export { diffCatalogs, filterRelevantChanges, formatChangeNotifications, notifyCatalogChanges, } from './model-catalog-notifications.js';
+//# sourceMappingURL=model-catalog.d.ts.map

package/dist/_internal/platform/providers/model-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-catalog.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/model-catalog.ts"],"names":[],"mappings":"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"}

package/dist/_internal/platform/providers/model-catalog.js

@@ -0,0 +1,116 @@
+export function getCostFromPricingCatalog(modelId, catalog, modelLimitsService, opts = {}) {
+    if (modelId.endsWith(':free')) {
+        return { input: 0, output: 0 };
+    }
+    const exact = catalog.models.find((model) => model.id === modelId);
+    if (exact) {
+        if (exact.tier === 'free')
+            return { input: 0, output: 0 };
+        return { input: exact.pricing.input, output: exact.pricing.output };
+    }
+    for (const model of catalog.models) {
+        if (modelId.startsWith(model.id) || modelId.includes(model.id)) {
+            if (model.tier === 'free')
+                return { input: 0, output: 0 };
+            return { input: model.pricing.input, output: model.pricing.output };
+        }
+    }
+    if (catalog.models.length === 0) {
+        const slashIdx = modelId.indexOf('/');
+        const provider = slashIdx !== -1 ? modelId.slice(0, slashIdx) : '';
+        const orPricing = modelLimitsService?.getPricingForModel(modelId, provider) ?? null;
+        if (orPricing) {
+            return { input: orPricing.prompt * 1_000_000, output: orPricing.completion * 1_000_000 };
+        }
+    }
+    if (opts.debug) {
+        console.debug(`[cost-tracker] model not in catalog: ${modelId}`);
+    }
+    return { input: 0, output: 0 };
+}
+export function normalizeModelId(modelId) {
+    let id = modelId;
+    if (id.startsWith('coding-'))
+        id = id.slice('coding-'.length);
+    const slashIdx = id.lastIndexOf('/');
+    if (slashIdx !== -1)
+        id = id.slice(slashIdx + 1);
+    if (id.endsWith(':free'))
+        id = id.slice(0, -':free'.length);
+    if (id.endsWith('-free'))
+        id = id.slice(0, -'-free'.length);
+    return id;
+}
+export function hasKeyForProvider(provider) {
+    if (provider.requiresKey === false || provider.envVars.length === 0)
+        return true;
+    return provider.envVars.some((envVar) => {
+        const value = process.env[envVar];
+        return typeof value === 'string' && value.length > 0;
+    });
+}
+export class RegistryBackedCatalog {
+    registry;
+    entriesCache = null;
+    entriesCacheVersion = -1;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    getEntries() {
+        const models = this.registry.listModels();
+        if (this.entriesCache !== null && models.length === this.entriesCacheVersion) {
+            return this.entriesCache;
+        }
+        this.entriesCacheVersion = models.length;
+        this.entriesCache = models.map((model) => ({
+            id: model.id,
+            displayName: model.displayName,
+            provider: model.provider,
+            context: this.registry.getContextWindowForModel(model),
+            tier: (model.tier ?? 'paid'),
+        }));
+        return this.entriesCache;
+    }
+    getModel(modelId) {
+        return this.getEntries().find((entry) => entry.id === modelId) ?? null;
+    }
+    findLargerContextModels(minContext, tier, limit = 3) {
+        return this.getEntries()
+            .filter((entry) => entry.context > minContext && (tier === undefined || entry.tier === tier))
+            .sort((a, b) => b.context - a.context)
+            .slice(0, limit);
+    }
+}
+export function createModelCatalog(registry) {
+    return new RegistryBackedCatalog(registry);
+}
+export function getCatalogModelDefinitionsFrom(models) {
+    return models.map((model) => {
+        const providerLower = model.provider.toLowerCase();
+        const isFree = model.tier === 'free';
+        const isGoogle = providerLower.includes('google') || providerLower.includes('gemini');
+        const isAnthropic = providerLower.includes('anthropic');
+        const isOpenAI = providerLower.includes('openai');
+        const hasReasoning = model.reasoning === true || isAnthropic || isOpenAI || isGoogle;
+        return {
+            id: model.id,
+            provider: model.providerId,
+            registryKey: `${model.providerId}:${model.id}`,
+            displayName: model.name,
+            description: `${model.name} — sourced from model catalog.`,
+            capabilities: {
+                toolCalling: true,
+                codeEditing: true,
+                reasoning: hasReasoning,
+                multimodal: isGoogle || isOpenAI,
+            },
+            contextWindow: model.contextWindow ?? (isGoogle ? 1_000_000 : isAnthropic ? 200_000 : 128_000),
+            selectable: true,
+            tier: model.tier === 'subscription' ? 'subscription' : isFree ? 'free' : model.pricing.input >= 3 ? 'premium' : 'standard',
+            ...(hasReasoning ? { reasoningEffort: ['instant', 'low', 'medium', 'high'] } : {}),
+        };
+    });
+}
+export { fetchCatalog, getCatalogCachePath, getCatalogTmpPath, isCatalogCacheStale, loadCatalogCache, saveCatalogCache, } from './model-catalog-cache.js';
+export { buildSyntheticCanonicalModels, getSyntheticBackendModelIds, getSyntheticModelDefinitions, getSyntheticModelInfo, nameToSlug, normalizeModelName, } from './model-catalog-synthetic.js';
+export { diffCatalogs, filterRelevantChanges, formatChangeNotifications, notifyCatalogChanges, } from './model-catalog-notifications.js';

package/dist/_internal/platform/providers/model-limits.d.ts

@@ -0,0 +1,23 @@
+import type { ModelDefinition, TokenLimits } from './registry.js';
+export interface ModelLimitsServiceOptions {
+    readonly cachePath: string;
+}
+export declare function getModelLimitsCachePath(cacheDir: string): string;
+export declare class ModelLimitsService {
+    private readonly options;
+    private cachedData;
+    private cachedOrMap;
+    constructor(options: ModelLimitsServiceOptions);
+    private ensureOpenRouterMap;
+    private resolveTokenLimits;
+    getPricingForModel(modelId: string, provider: string): {
+        prompt: number;
+        completion: number;
+    } | null;
+    getTokenLimitsForModel(modelDef: ModelDefinition): Required<TokenLimits>;
+    getContextWindowForModel(modelDef: ModelDefinition): number;
+    getToolResultMaxCharsForModel(model: ModelDefinition | null | undefined): number;
+    refresh(): Promise<number>;
+    init(): void;
+}
+//# sourceMappingURL=model-limits.d.ts.map

package/dist/_internal/platform/providers/model-limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-limits.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/model-limits.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AA4ClE,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEhE;AA6GD,qBAAa,kBAAkB;IAIjB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,OAAO,CAAC,UAAU,CAAiC;IACnD,OAAO,CAAC,WAAW,CAAiD;gBAEvC,OAAO,EAAE,yBAAyB;IAE/D,OAAO,CAAC,mBAAmB;IAQ3B,OAAO,CAAC,kBAAkB;IA4B1B,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAWpG,sBAAsB,CAAC,QAAQ,EAAE,eAAe,GAAG,QAAQ,CAAC,WAAW,CAAC;IAIxE,wBAAwB,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM;IAc3D,6BAA6B,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM;IAK1E,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAiChC,IAAI,IAAI,IAAI;CASb"}

package/dist/_internal/platform/providers/model-limits.js

@@ -0,0 +1,236 @@
+import { dirname, join } from 'node:path';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+const OPENROUTER_MODELS_URL = 'https://openrouter.ai/api/v1/models';
+const FETCH_TIMEOUT_MS = 15_000;
+const CACHE_TTL_MS = 86_400_000;
+const DEFAULT_TOKEN_LIMITS = {
+    maxOutputTokens: 8192,
+    maxToolResultTokens: 50_000,
+    maxToolCalls: 128,
+    maxReasoningTokens: 16384,
+};
+export function getModelLimitsCachePath(cacheDir) {
+    return join(cacheDir, 'model-limits.json');
+}
+function loadCachedLimits(cachePath) {
+    try {
+        const raw = readFileSync(cachePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== 1)
+            return null;
+        return parsed;
+    }
+    catch (error) {
+        const message = summarizeError(error);
+        if (message.includes('ENOENT') || message.includes('no such file')) {
+            logger.debug('[model-limits] No cache file found (first run)');
+        }
+        else {
+            logger.warn('[model-limits] Cache load failed (corrupted?)', { error: message });
+        }
+        return null;
+    }
+}
+function saveCachedLimits(cache, cachePath) {
+    try {
+        mkdirSync(dirname(cachePath), { recursive: true });
+        writeFileSync(cachePath, JSON.stringify(cache, null, 2), 'utf-8');
+    }
+    catch (error) {
+        logger.debug('[model-limits] Cache write failed', { error: summarizeError(error) });
+    }
+}
+function isCacheStale(cache) {
+    return Date.now() - cache.fetchedAt > cache.ttlMs;
+}
+async function fetchOpenRouterModels() {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const response = await fetch(OPENROUTER_MODELS_URL, {
+            signal: controller.signal,
+            headers: { Accept: 'application/json' },
+        });
+        if (!response.ok) {
+            throw new Error(`OpenRouter API returned ${response.status}`);
+        }
+        const json = await response.json();
+        const map = new Map();
+        if (Array.isArray(json.data)) {
+            for (const model of json.data) {
+                if (typeof model.id === 'string') {
+                    map.set(model.id, model);
+                }
+            }
+        }
+        return map;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function getModelStem(modelId) {
+    return modelId
+        .replace(/-\d{8}$/, '')
+        .replace(/-(?:2[4-9]|3[0-9])\d{2}$/, '')
+        .replace(/-\d{6}$/, '');
+}
+function findOpenRouterMatch(modelId, provider, orModels) {
+    if (orModels.has(modelId))
+        return orModels.get(modelId) ?? null;
+    const prefixed = `${provider}/${modelId}`;
+    if (orModels.has(prefixed))
+        return orModels.get(prefixed) ?? null;
+    const stem = getModelStem(modelId);
+    if (stem !== modelId) {
+        if (orModels.has(stem))
+            return orModels.get(stem) ?? null;
+        const prefixedStem = `${provider}/${stem}`;
+        if (orModels.has(prefixedStem))
+            return orModels.get(prefixedStem) ?? null;
+    }
+    for (const [orId, orModel] of orModels) {
+        if (orId.endsWith(`/${stem}`) || orId.endsWith(`/${modelId}`)) {
+            return orModel;
+        }
+    }
+    return null;
+}
+function buildOrMap(cache) {
+    const map = new Map();
+    for (const [id, entry] of Object.entries(cache.models)) {
+        map.set(id, {
+            id,
+            context_length: entry.contextLength,
+            top_provider: { max_completion_tokens: entry.maxOutputTokens },
+            supported_parameters: entry.supportedParameters,
+            pricing: entry.pricing
+                ? { prompt: String(entry.pricing.prompt), completion: String(entry.pricing.completion) }
+                : undefined,
+        });
+    }
+    return map;
+}
+export class ModelLimitsService {
+    options;
+    cachedData = null;
+    cachedOrMap = null;
+    constructor(options) {
+        this.options = options;
+    }
+    ensureOpenRouterMap() {
+        if (!this.cachedData)
+            return null;
+        if (!this.cachedOrMap) {
+            this.cachedOrMap = buildOrMap(this.cachedData);
+        }
+        return this.cachedOrMap;
+    }
+    resolveTokenLimits(modelDef, providerLimits) {
+        const result = { ...DEFAULT_TOKEN_LIMITS };
+        const orMap = this.ensureOpenRouterMap();
+        if (orMap) {
+            const orMatch = findOpenRouterMatch(modelDef.id, modelDef.provider, orMap);
+            if (orMatch?.top_provider?.max_completion_tokens != null) {
+                result.maxOutputTokens = orMatch.top_provider.max_completion_tokens;
+            }
+        }
+        if (providerLimits) {
+            if (providerLimits.maxOutputTokens != null)
+                result.maxOutputTokens = providerLimits.maxOutputTokens;
+            if (providerLimits.maxToolResultTokens != null)
+                result.maxToolResultTokens = providerLimits.maxToolResultTokens;
+            if (providerLimits.maxToolCalls != null)
+                result.maxToolCalls = providerLimits.maxToolCalls;
+            if (providerLimits.maxReasoningTokens != null)
+                result.maxReasoningTokens = providerLimits.maxReasoningTokens;
+        }
+        const explicit = modelDef.tokenLimits;
+        if (explicit) {
+            if (explicit.maxOutputTokens != null)
+                result.maxOutputTokens = explicit.maxOutputTokens;
+            if (explicit.maxToolResultTokens != null)
+                result.maxToolResultTokens = explicit.maxToolResultTokens;
+            if (explicit.maxToolCalls != null)
+                result.maxToolCalls = explicit.maxToolCalls;
+            if (explicit.maxReasoningTokens != null)
+                result.maxReasoningTokens = explicit.maxReasoningTokens;
+        }
+        return result;
+    }
+    getPricingForModel(modelId, provider) {
+        const orMap = this.ensureOpenRouterMap();
+        if (!orMap)
+            return null;
+        const match = findOpenRouterMatch(modelId, provider, orMap);
+        if (!match?.pricing)
+            return null;
+        const prompt = parseFloat(match.pricing.prompt);
+        const completion = parseFloat(match.pricing.completion);
+        if (Number.isNaN(prompt) || Number.isNaN(completion))
+            return null;
+        return { prompt, completion };
+    }
+    getTokenLimitsForModel(modelDef) {
+        return this.resolveTokenLimits(modelDef);
+    }
+    getContextWindowForModel(modelDef) {
+        if (modelDef.contextWindowProvenance === 'provider_api' && modelDef.contextWindow > 0) {
+            return modelDef.contextWindow;
+        }
+        const orMap = this.ensureOpenRouterMap();
+        if (orMap) {
+            const orMatch = findOpenRouterMatch(modelDef.id, modelDef.provider, orMap);
+            if (orMatch?.context_length != null && orMatch.context_length > 0) {
+                return orMatch.context_length;
+            }
+        }
+        return modelDef.contextWindow;
+    }
+    getToolResultMaxCharsForModel(model) {
+        if (!model)
+            return DEFAULT_TOKEN_LIMITS.maxToolResultTokens;
+        return this.resolveTokenLimits(model).maxToolResultTokens;
+    }
+    async refresh() {
+        const orModels = await fetchOpenRouterModels();
+        const models = {};
+        for (const [id, model] of orModels) {
+            let pricing;
+            if (model.pricing?.prompt != null && model.pricing?.completion != null) {
+                const prompt = parseFloat(model.pricing.prompt);
+                const completion = parseFloat(model.pricing.completion);
+                if (!Number.isNaN(prompt) && !Number.isNaN(completion)) {
+                    pricing = { prompt, completion };
+                }
+            }
+            models[id] = {
+                contextLength: model.context_length ?? 0,
+                maxOutputTokens: model.top_provider?.max_completion_tokens ?? null,
+                supportedParameters: model.supported_parameters ?? [],
+                pricing,
+            };
+        }
+        const newCache = {
+            version: 1,
+            fetchedAt: Date.now(),
+            ttlMs: CACHE_TTL_MS,
+            models,
+        };
+        saveCachedLimits(newCache, this.options.cachePath);
+        this.cachedData = newCache;
+        this.cachedOrMap = buildOrMap(newCache);
+        return orModels.size;
+    }
+    init() {
+        this.cachedData = loadCachedLimits(this.options.cachePath);
+        this.cachedOrMap = this.cachedData ? buildOrMap(this.cachedData) : null;
+        if (!this.cachedData || isCacheStale(this.cachedData)) {
+            void this.refresh().catch((error) => {
+                logger.debug('[model-limits] Background refresh failed', { error: summarizeError(error) });
+            });
+        }
+    }
+}