contaigents/dist/services/llm/LLMFactory.js

Modular AI Content Ecosystem with Audio Generation

import { AnthropicProvider } from "./AnthropicProvider.js";
import { DeepSeekProvider } from "./DeepSeekProvider.js";
import { GoogleProvider } from "./GoogleProvider.js";
import { HuggingFaceProvider } from "./HuggingFaceProvider.js";
import { OllamaProvider } from "./OllamaProvider.js";
import { OllamaApiProvider } from "./OllamaApiProvider.js";
import { OpenAIProvider } from "./OpenAIProvider.js";
import { ReplicateProvider } from "./ReplicateProvider.js";
import { OpenRouterProvider } from "./OpenRouterProvider.js";
import { FileService } from "../fileService.js";
export const providers = {
    OpenAI: OpenAIProvider.providerConfig,
    Anthropic: AnthropicProvider.providerConfig,
    Google: GoogleProvider.providerConfig,
    DeepSeek: DeepSeekProvider.providerConfig,
    HuggingFace: HuggingFaceProvider.providerConfig,
    Ollama: OllamaProvider.providerConfig,
    OllamaApi: OllamaApiProvider.providerConfig,
    Replicate: ReplicateProvider.providerConfig,
    OpenRouter: OpenRouterProvider.providerConfig,
};
export class LLMFactory {
    static getProvider(name) {
        const providerName = name.toLowerCase();
        if (!providerName) {
            throw new Error(`Unknown provider: ${name}`);
        }
        if (!this.instances.has(providerName)) {
            switch (providerName) {
                case "openai":
                    this.instances.set(providerName, new OpenAIProvider());
                    break;
                case "anthropic":
                    this.instances.set(providerName, new AnthropicProvider());
                    break;
                case "google":
                    this.instances.set(providerName, new GoogleProvider());
                    break;
                case "deepseek":
                    this.instances.set(providerName, new DeepSeekProvider());
                    break;
                case "huggingface":
                    this.instances.set(providerName, new HuggingFaceProvider());
                    break;
                case "openrouter":
                    this.instances.set(providerName, new OpenRouterProvider());
                    break;
                case "ollama":
                    this.instances.set(providerName, new OllamaProvider());
                    break;
                case "ollamaapi":
                    this.instances.set(providerName, new OllamaApiProvider());
                    break;
                case "replicate":
                    this.instances.set(providerName, new ReplicateProvider());
                    break;
                case "openrouter":
                    this.instances.set(providerName, new OpenRouterProvider());
                    break;
                default:
                    throw new Error(`Unknown provider: ${name}`);
            }
        }
        return this.instances.get(providerName);
    }
    static async getConfiguredProvider() {
        // First try to get the default provider from global config
        const defaultProvider = await this.getDefaultProvider();
        if (defaultProvider && await defaultProvider.isConfigured()) {
            return defaultProvider;
        }
        // Fall back to first configured provider
        for (const providerName of Object.keys(providers)) {
            const llm = this.getProvider(providerName);
            if (await llm.isConfigured()) {
                return llm;
            }
        }
        return null;
    }
    static async getDefaultProvider() {
        try {
            const fileService = new FileService();
            const configPath = './.config/global_config.json';
            const configData = await fileService.readFile(configPath);
            const globalConfig = JSON.parse(configData);
            if (globalConfig.defaultProvider) {
                const provider = this.getProvider(globalConfig.defaultProvider);
                if (await provider.isConfigured()) {
                    return provider;
                }
            }
        }
        catch (error) {
            // No global config or provider not configured
        }
        return null;
    }
    static getAvailableProviders() {
        return Object.keys(providers);
    }
    static clearCache() {
        this.instances.clear();
    }
}
LLMFactory.instances = new Map();