game-analysis-types/dist/ai/modelRegistry.js

Common TypeScript types and utilities for game analysis tools.

import { ClaudeModelStrategy } from './claude.js';
import { GeminiModelStrategy } from './gemini.js';
// Helper to fetch env vars in Node (process.env) or Vite/browser (import.meta.env)
function getEnvVar(key, viteKey) {
    if (typeof process !== 'undefined' && process.env && process.env[key] !== undefined) {
        return process.env[key];
    }
    // Vite/browser
    if (typeof import.meta !== 'undefined' && import.meta.env && import.meta.env[viteKey || key] !== undefined) {
        return import.meta.env[viteKey || key];
    }
    return '';
}
export class AIModelRegistry {
    models = new Map();
    constructor( /* Removed environmentService dependency for now */) {
        this.registerDefaultModels();
    }
    registerDefaultModels() {
        // Claude Model
        try {
            const modelId = getEnvVar('CLAUDE_MODEL', 'VITE_CLAUDE_MODEL') || 'claude-3-opus-20240229';
            this.register('claude', new ClaudeModelStrategy({
                id: modelId,
                name: 'Claude',
                provider: 'Anthropic',
                model: modelId,
                apiKey: getEnvVar('CLAUDE_API_KEY', 'VITE_CLAUDE_API_KEY'),
                apiEndpoint: getEnvVar('CLAUDE_API_ENDPOINT', 'VITE_CLAUDE_API_URL'),
                maxTokens: 100000,
                temperature: 0.7,
                costPerRequest: 0.0035,
                creditCost: 0,
                requiresSubscription: false,
                minSubscriptionTier: 'free',
                inputCostPer1K: 0.015,
                outputCostPer1K: 0.075,
                capabilities: ['text', 'reasoning', 'coaching', 'analysis']
            }));
        }
        catch (error) {
            console.warn('Failed to register Claude model:', error);
        }
        // Gemini Model
        try {
            const modelId = getEnvVar('GEMINI_MODEL', 'VITE_GEMINI_MODEL') || 'gemini-pro';
            this.register('gemini', new GeminiModelStrategy({
                id: modelId,
                name: 'Gemini',
                provider: 'Google',
                model: modelId,
                apiKey: getEnvVar('GEMINI_API_KEY', 'VITE_GEMINI_API_KEY'),
                apiEndpoint: getEnvVar('GEMINI_API_ENDPOINT', 'VITE_GEMINI_API_ENDPOINT'),
                maxTokens: 8192,
                temperature: 0.7,
                costPerRequest: 0.00025,
                creditCost: 0,
                requiresSubscription: false,
                minSubscriptionTier: 'free',
                inputCostPer1K: 0.0005,
                outputCostPer1K: 0.0015,
                capabilities: ['text', 'reasoning', 'analysis']
            }));
        }
        catch (error) {
            console.warn('Failed to register Gemini model:', error);
        }
        // Add more models here as needed
    }
    register(key, model) {
        if (!model || typeof model.getConfig !== 'function') {
            console.error(`Attempted to register invalid model for key: ${key}. Model:`, model);
            throw new Error(`Invalid model strategy provided for key ${key}`);
        }
        console.log(`Registering AI model: ${key} (${model.getConfig().provider} - ${model.getConfig().name})`);
        this.models.set(key, model);
    }
    getModel(key) {
        const model = this.models.get(key);
        if (!model) {
            console.error(`AI model not found for key: ${key}. Available models: ${Array.from(this.models.keys()).join(', ')}`);
            throw new Error(`AI model not found: ${key}`);
        }
        return model;
    }
    has(key) {
        return this.models.has(key);
    }
    listModelKeys() {
        return Array.from(this.models.keys());
    }
    async checkAvailability(key) {
        try {
            const model = this.getModel(key);
            return await model.isAvailable();
        }
        catch (error) {
            // If getModel throws (model not registered), it's not available
            return false;
        }
    }
    async getAvailableModels() {
        const availableModels = [];
        for (const key of this.models.keys()) {
            try {
                const model = this.getModel(key);
                if (await model.isAvailable()) {
                    availableModels.push(model.getConfig());
                }
            }
            catch (error) {
                console.warn(`Error checking availability or getting config for model ${key}:`, error);
            }
        }
        return availableModels;
    }
    // Add a static getInstance method for singleton pattern
    static instance;
    static getInstance() {
        if (!AIModelRegistry.instance) {
            AIModelRegistry.instance = new AIModelRegistry();
        }
        return AIModelRegistry.instance;
    }
}
//# sourceMappingURL=modelRegistry.js.map