pit-manager/dist/providers/registry.js

Centralized prompt management system for Human Behavior AI agents

"use strict";
/**
 * Provider registry for managing LLM providers in TypeScript.
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.registry = exports.ProviderRegistry = void 0;
const dotenv = require("dotenv");
const exceptions_1 = require("../core/exceptions");
const openai_1 = require("./openai");
const anthropic_1 = require("./anthropic");
const google_1 = require("./google");
// Load environment variables
dotenv.config();
class ProviderRegistry {
    constructor() {
        this.providers = new Map();
        this.modelToProvider = new Map();
        this.initializeProviders();
    }
    initializeProviders() {
        const providerConfigs = [
            {
                ProviderClass: openai_1.OpenAIProvider,
                envVars: ['OPENAI_API_KEY']
            },
            {
                ProviderClass: anthropic_1.AnthropicProvider,
                envVars: ['ANTHROPIC_API_KEY']
            },
            {
                ProviderClass: google_1.GoogleProvider,
                envVars: ['GOOGLE_API_KEY', 'GEMINI_API_KEY'] // Support both env var names
            }
        ];
        for (const config of providerConfigs) {
            // Try to get API key from environment variables
            let apiKey;
            for (const envVar of config.envVars) {
                apiKey = process.env[envVar];
                if (apiKey)
                    break;
            }
            if (apiKey) {
                try {
                    const provider = new config.ProviderClass(apiKey);
                    this.registerProvider(provider);
                }
                catch (error) {
                    // Skip providers with invalid keys
                    if (!(error instanceof exceptions_1.APIKeyError)) {
                        console.warn(`Failed to initialize provider: ${error}`);
                    }
                }
            }
        }
    }
    registerProvider(provider) {
        if (!provider.validateConfig()) {
            throw new exceptions_1.ProviderError(`Invalid configuration for provider ${provider.name}`);
        }
        this.providers.set(provider.name, provider);
        // Map models to this provider
        for (const model of provider.supportedModels) {
            this.modelToProvider.set(model, provider.name);
        }
    }
    getProvider(providerName) {
        const provider = this.providers.get(providerName);
        if (!provider) {
            const available = Array.from(this.providers.keys()).join(', ');
            throw new exceptions_1.ProviderError(`Provider ${providerName} not found. Available: ${available}`);
        }
        return provider;
    }
    getProviderForModel(model) {
        const providerName = this.modelToProvider.get(model);
        if (!providerName) {
            const availableModels = Array.from(this.modelToProvider.keys()).join(', ');
            throw new exceptions_1.UnsupportedModelError(`Model ${model} not supported. Available: ${availableModels}`);
        }
        return this.getProvider(providerName);
    }
    listProviders() {
        return Array.from(this.providers.keys());
    }
    listModels(providerName) {
        if (providerName) {
            const provider = this.providers.get(providerName);
            return provider ? provider.supportedModels : [];
        }
        return Array.from(this.modelToProvider.keys());
    }
    getModelInfo() {
        const info = {};
        for (const [model, providerName] of this.modelToProvider.entries()) {
            const provider = this.providers.get(providerName);
            if (provider) {
                info[model] = {
                    provider: providerName,
                    // Add provider-specific info if available
                    pricing: provider.PRICING?.[model],
                    supportsStreaming: false, // Can be extended later
                    supportsFunctions: false // Can be extended later
                };
            }
        }
        return info;
    }
    async chatCompletion(model, messages, options) {
        const provider = this.getProviderForModel(model);
        return provider.chatCompletion(model, messages, options);
    }
    calculateCost(model, tokens) {
        const provider = this.getProviderForModel(model);
        return provider.calculateCost(model, tokens);
    }
}
exports.ProviderRegistry = ProviderRegistry;
// Global registry instance
exports.registry = new ProviderRegistry();