npm-ai-hooks 1.0.2 → 2.0.0

package/dist/cjs/providers/init.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initAIHooks = initAIHooks;
+exports.addProvider = addProvider;
+exports.removeProvider = removeProvider;
+exports.getAvailableProviders = getAvailableProviders;
+exports.getProvider = getProvider;
+exports.isInitialized = isInitialized;
+exports.reset = reset;
+const ProviderConfig_1 = require("./base/ProviderConfig");
+// Global provider manager instance
+let providerManager = null;
+/**
+ * Initialize the AI hooks system with provider configurations
+ * @param options - Provider initialization options
+ * @example
+ * ```typescript
+ * import { initAIHooks } from 'npm-ai-hooks';
+ *
+ * initAIHooks({
+ *   providers: [
+ *     { provider: 'openai', key: 'sk-...', defaultModel: 'gpt-4' },
+ *     { provider: 'claude', key: 'sk-ant-...', defaultModel: 'claude-3-sonnet-20240229' },
+ *     { provider: 'groq', key: 'gsk_...', defaultModel: 'llama-3.1-70b-versatile' }
+ *   ],
+ *   defaultProvider: 'openai' // optional
+ * });
+ * ```
+ */
+function initAIHooks(options) {
+    providerManager = new ProviderConfig_1.ProviderManager(options);
+}
+/**
+ * Add a new provider after initialization
+ * @param config - Provider configuration
+ * @example
+ * ```typescript
+ * addProvider({ provider: 'mistral', key: '...', defaultModel: 'mistral-large' });
+ * ```
+ */
+function addProvider(config) {
+    if (!providerManager) {
+        throw new Error('AI hooks not initialized. Call initAIHooks() first.');
+    }
+    providerManager.addProvider(config);
+}
+/**
+ * Remove a provider
+ * @param provider - Provider to remove
+ */
+function removeProvider(provider) {
+    if (!providerManager) {
+        throw new Error('AI hooks not initialized. Call initAIHooks() first.');
+    }
+    providerManager.removeProvider(provider);
+}
+/**
+ * Get available providers
+ * @returns Array of available provider names
+ */
+function getAvailableProviders() {
+    if (!providerManager) {
+        throw new Error('AI hooks not initialized. Call initAIHooks() first.');
+    }
+    return providerManager.getAvailableProviders();
+}
+/**
+ * Get a provider function
+ * @param name - Optional provider name
+ * @returns Provider function and name
+ */
+function getProvider(name) {
+    if (!providerManager) {
+        throw new Error('AI hooks not initialized. Call initAIHooks() first.');
+    }
+    return providerManager.getProvider(name);
+}
+/**
+ * Check if AI hooks is initialized
+ * @returns True if initialized
+ */
+function isInitialized() {
+    return providerManager !== null;
+}
+/**
+ * Reset the provider manager (useful for testing)
+ */
+function reset() {
+    providerManager = null;
+}

package/dist/{wrap.js → cjs/wrap.js}

@@ -1,26 +1,37 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrap = wrap;
-const dotenv_1 = __importDefault(require("dotenv"));
-dotenv_1.default.config();
+// dotenv removed - using explicit provider initialization instead
 const providers_1 = require("./providers");
 const types_1 = require("./types");
+const errors_1 = require("./errors");
 function handleError(err) {
     if (err && typeof err === "object" && "pretty" in err && typeof err.pretty === "function") {
-        // Print pretty message and exit
+        // Print pretty message
         console.error(err.pretty());
-        process.exit(1);
+        // Only exit in Node.js test environment, not in browser
+        if (typeof process !== "undefined" && process.env.NODE_ENV !== "test" && !process.env.JEST_WORKER_ID) {
+            process.exit(1);
+        }
+        // In browser or test mode, just throw the error instead of exiting
+        throw err;
     }
     else {
         console.error(err);
-        process.exit(1);
+        // Only exit in Node.js test environment, not in browser
+        if (typeof process !== "undefined" && process.env.NODE_ENV !== "test" && !process.env.JEST_WORKER_ID) {
+            process.exit(1);
+        }
+        // In browser or test mode, just throw the error instead of exiting
+        throw err;
     }
-    throw new Error("Process exited due to AIHookError"); // for TS never
 }
 function wrap(fn, options) {
+    // Validate task type immediately when wrap() is called
+    const validTasks = ["summarize", "translate", "explain", "rewrite", "sentiment", "codeReview"];
+    if (options.task && !validTasks.includes(options.task)) {
+        throw new errors_1.AIHookError("INVALID_TASK", `Invalid task type: ${options.task}. Valid tasks are: ${validTasks.join(", ")}`, options.provider, "Please use one of the supported task types.");
+    }
     return async (...args) => {
         try {
             const input = fn(...args);
@@ -29,7 +40,7 @@ function wrap(fn, options) {
             // Step 2: pick model: passed model or provider-specific default
             const model = options.model || (providerKey in types_1.DEFAULT_MODEL ? types_1.DEFAULT_MODEL[providerKey] : undefined);
             if (!model) {
-                throw new (require('./errors').AIHookError)("NO_MODEL_FOUND", "No model found: You must specify a provider or pass a valid model.\n\nAt least one provider API key is required in your .env file.\n\nPlease add one of the following to your .env (see .env.example for details):\n  - AI_HOOK_OPENAI_KEY\n  - AI_HOOK_OPENROUTER_KEY\n  - AI_HOOK_GROQ_KEY\n", options.provider, "Reference .env.example for setup instructions.");
+                throw new errors_1.AIHookError("NO_MODEL_FOUND", "No model found: You must specify a provider or pass a valid model.\n\nAt least one provider API key is required in your .env file.\n\nPlease add one of the following to your .env (see .env.example for details):\n  - AI_HOOK_OPENAI_KEY\n  - AI_HOOK_OPENROUTER_KEY\n  - AI_HOOK_GROQ_KEY\n", options.provider, "Reference .env.example for setup instructions.");
             }
             // Step 3: build prompt
             const prompt = buildPrompt(options.task, input, options.targetLanguage);
@@ -39,8 +50,9 @@ function wrap(fn, options) {
                 output = await providerFn(prompt, model);
             }
             catch (err) {
-                if (err instanceof require('./errors').AIHookError) {
-                    handleError(err);
+                if (err instanceof errors_1.AIHookError) {
+                    // For AIHookError, just re-throw it - it will be handled by the outer catch
+                    throw err;
                 }
                 if (err instanceof Error) {
                     throw new Error(`[ai-hooks] Unknown error calling provider: ${err.message}`);
@@ -60,11 +72,30 @@ function wrap(fn, options) {
             };
         }
         catch (err) {
+            if (err instanceof errors_1.AIHookError) {
+                // For AIHookError, just log the pretty message without the full error handling
+                console.error(err.pretty());
+                // Return a mock response to prevent the demo from crashing
+                return {
+                    output: "Error occurred",
+                    meta: {
+                        provider: "unknown",
+                        model: "unknown",
+                        cached: false,
+                        estimatedCostUSD: 0.0,
+                        latencyMs: 0,
+                        error: true
+                    }
+                };
+            }
             handleError(err);
         }
     };
 }
 function buildPrompt(task, text, targetLanguage) {
+    if (!task) {
+        return text; // If no task specified, just return the text as-is
+    }
     switch (task) {
         case "summarize":
             return `Summarize the following text:\n${text}`;

package/dist/esm/errors.js

@@ -0,0 +1,17 @@
+export class AIHookError extends Error {
+    constructor(code, message, provider, suggestion) {
+        super(message);
+        this.code = code;
+        this.provider = provider;
+        this.suggestion = suggestion;
+        // Do NOT print pretty message in constructor
+    }
+    pretty() {
+        return `\n❌ AI-HOOK ERROR: ${this.message}` +
+            (this.provider ? `\n   Provider: ${this.provider}` : "") +
+            (this.suggestion ? `\n   Suggestion: ${this.suggestion}\n` : "");
+    }
+    toString() {
+        return this.pretty();
+    }
+}

package/dist/esm/index.js

@@ -0,0 +1,3 @@
+// src/index.ts
+export { wrap } from "./wrap";
+export { initAIHooks, addProvider, removeProvider, getAvailableProviders, getProvider, isInitialized, reset } from "./providers";

package/dist/esm/providers/base/BaseProvider.js

@@ -0,0 +1,114 @@
+import axios from "axios";
+import { AIHookError } from "../../errors";
+export class BaseProvider {
+    constructor(config) {
+        this.config = config;
+    }
+    async call(prompt, model) {
+        const apiKey = this.getApiKey();
+        this.validateApiKey(apiKey);
+        // At this point, apiKey is guaranteed to be defined due to validateApiKey
+        const validatedApiKey = apiKey;
+        try {
+            const requestConfig = this.buildRequestConfig(prompt, model, validatedApiKey);
+            const response = await this.makeRequest(requestConfig);
+            return this.parseResponse(response);
+        }
+        catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    getApiKey() {
+        // This method should be overridden by the provider creation logic
+        // to return the explicitly provided API key instead of reading from process.env
+        if (typeof process !== "undefined" && process.env) {
+            return process.env[this.config.envKey];
+        }
+        return undefined;
+    }
+    validateApiKey(apiKey) {
+        if (!apiKey) {
+            throw new AIHookError("INVALID_API_KEY", this.config.errorMessages.missingKey, this.config.name, `Set ${this.config.envKey} in your environment variables.`);
+        }
+    }
+    buildRequestConfig(prompt, model, apiKey) {
+        return {
+            url: this.config.baseUrl,
+            method: "POST",
+            data: this.config.requestBody(prompt, model),
+            headers: {
+                ...this.config.headers,
+                ...this.buildAuthHeaders(apiKey)
+            }
+        };
+    }
+    buildAuthHeaders(apiKey) {
+        return {
+            "Authorization": `Bearer ${apiKey}`
+        };
+    }
+    async makeRequest(config) {
+        return axios(config);
+    }
+    parseResponse(response) {
+        const output = this.config.responseParser(response);
+        if (!output) {
+            throw new AIHookError("PROVIDER_ERROR", this.config.errorMessages.emptyResponse, this.config.name, "Check your model and API key");
+        }
+        return output;
+    }
+    handleError(error) {
+        if (error.response) {
+            return this.handleHttpError(error);
+        }
+        else if (error.request) {
+            return new AIHookError("NETWORK_ERROR", this.config.errorMessages.networkError, this.config.name, "Check your internet connection");
+        }
+        else {
+            return new AIHookError("UNKNOWN_ERROR", error.message || this.config.errorMessages.unknownError, this.config.name);
+        }
+    }
+    getCapitalizedProviderName() {
+        const name = this.config.name;
+        // Handle special cases
+        if (name === "openai")
+            return "OpenAI";
+        if (name === "openrouter")
+            return "OpenRouter";
+        if (name === "xai")
+            return "xAI";
+        if (name === "claude")
+            return "Claude";
+        if (name === "gemini")
+            return "Gemini";
+        if (name === "groq")
+            return "Groq";
+        if (name === "deepseek")
+            return "DeepSeek";
+        if (name === "mistral")
+            return "Mistral";
+        if (name === "perplexity")
+            return "Perplexity";
+        // Default: capitalize first letter
+        return name.charAt(0).toUpperCase() + name.slice(1);
+    }
+    handleHttpError(error) {
+        const status = error.response.status;
+        const text = error.response.data?.error
+            ? JSON.stringify(error.response.data.error)
+            : error.response.statusText || "Unknown error";
+        const providerName = this.config.name;
+        switch (status) {
+            case 400:
+                return new AIHookError("BAD_REQUEST", `${this.getCapitalizedProviderName()} rejected the request: ${text}`, providerName, "Check your prompt and model");
+            case 401:
+                return new AIHookError("INVALID_API_KEY", `Invalid ${this.getCapitalizedProviderName()} API key: ${text}`, providerName, `Verify your ${this.config.envKey} environment variable`);
+            case 403:
+                return new AIHookError("MODEL_NOT_ALLOWED", `Your API key cannot access this model: ${text}`, providerName, "Try a different model or check API key permissions");
+            case 429:
+                return new AIHookError("RATE_LIMIT", `Too many requests to ${this.getCapitalizedProviderName()}: ${text}`, providerName, "Throttle requests or upgrade your plan");
+            default:
+                return new AIHookError("PROVIDER_ERROR", `${this.getCapitalizedProviderName()} API error: ${text}`, providerName);
+        }
+    }
+}

package/dist/esm/providers/base/ProviderConfig.js

@@ -0,0 +1,114 @@
+import { DEFAULT_MODEL } from "../../types";
+import { BaseProvider } from "./BaseProvider";
+import { providerConfigs } from "./ProviderConfigs";
+import { ClaudeProvider, GeminiProvider, OpenRouterProvider } from "./SpecializedProviders";
+export class ProviderManager {
+    constructor(options) {
+        this.providers = new Map();
+        this.providerFunctions = new Map();
+        this.initializeProviders(options);
+    }
+    initializeProviders(options) {
+        // Store provider configs
+        for (const config of options.providers) {
+            this.providers.set(config.provider, {
+                key: config.key,
+                defaultModel: config.defaultModel
+            });
+        }
+        // Set default provider if specified
+        this.defaultProvider = options.defaultProvider;
+        // Create provider functions
+        this.createProviderFunctions();
+    }
+    createProviderFunctions() {
+        for (const [providerName, config] of this.providers) {
+            const providerFunction = this.createProviderFunction(providerName, config);
+            this.providerFunctions.set(providerName, providerFunction);
+        }
+    }
+    createProviderFunction(providerName, config) {
+        return async (prompt, model) => {
+            // Use provided model or default model for this provider
+            const modelToUse = model || config.defaultModel || this.getDefaultModelForProvider(providerName);
+            // Create a temporary provider instance for this call
+            const provider = this.createProviderInstance(providerName, config.key);
+            return provider.call(prompt, modelToUse);
+        };
+    }
+    createProviderInstance(providerName, apiKey) {
+        // Import the base provider and configs
+        // Using imported classes directly
+        const config = providerConfigs[providerName];
+        if (!config) {
+            throw new Error(`Unsupported provider: ${providerName}`);
+        }
+        // Create provider instance with the provided API key
+        const providerConfig = { ...config };
+        // Override the getApiKey method to return the provided key
+        if (providerName === 'claude') {
+            const provider = new ClaudeProvider();
+            provider['getApiKey'] = () => apiKey;
+            return provider;
+        }
+        else if (providerName === 'gemini') {
+            const provider = new GeminiProvider();
+            provider['getApiKey'] = () => apiKey;
+            return provider;
+        }
+        else if (providerName === 'openrouter') {
+            const provider = new OpenRouterProvider();
+            provider['getApiKey'] = () => apiKey;
+            return provider;
+        }
+        else {
+            const provider = new BaseProvider(providerConfig);
+            provider['getApiKey'] = () => apiKey;
+            return provider;
+        }
+    }
+    getDefaultModelForProvider(providerName) {
+        // Import default models
+        // Using imported DEFAULT_MODEL directly
+        return DEFAULT_MODEL[providerName];
+    }
+    getAvailableProviders() {
+        return Array.from(this.providers.keys());
+    }
+    getProvider(name) {
+        const available = this.getAvailableProviders();
+        if (available.length === 0) {
+            throw new Error('No providers initialized. Please initialize providers first.');
+        }
+        // 1. If user specified provider and it's available
+        if (name && this.providerFunctions.has(name)) {
+            return { fn: this.providerFunctions.get(name), provider: name };
+        }
+        // 2. If default provider is specified and available
+        if (this.defaultProvider && this.providerFunctions.has(this.defaultProvider)) {
+            return { fn: this.providerFunctions.get(this.defaultProvider), provider: this.defaultProvider };
+        }
+        // 3. Prefer OpenRouter if available
+        if (this.providerFunctions.has('openrouter')) {
+            return { fn: this.providerFunctions.get('openrouter'), provider: 'openrouter' };
+        }
+        // 4. Use first available provider
+        const firstProvider = available[0];
+        return { fn: this.providerFunctions.get(firstProvider), provider: firstProvider };
+    }
+    addProvider(config) {
+        this.providers.set(config.provider, {
+            key: config.key,
+            defaultModel: config.defaultModel
+        });
+        const providerFunction = this.createProviderFunction(config.provider, {
+            key: config.key,
+            defaultModel: config.defaultModel
+        });
+        this.providerFunctions.set(config.provider, providerFunction);
+    }
+    removeProvider(provider) {
+        this.providers.delete(provider);
+        this.providerFunctions.delete(provider);
+    }
+}

package/dist/esm/providers/base/ProviderConfigs.js

@@ -0,0 +1,182 @@
+// Common response parsers
+export const responseParsers = {
+    openaiStyle: (response) => response.data?.choices?.[0]?.message?.content,
+    claudeStyle: (response) => response.data?.content?.[0]?.text,
+    geminiStyle: (response) => response.data?.candidates?.[0]?.content?.parts?.[0]?.text,
+};
+// Common request body builders
+export const requestBodyBuilders = {
+    openaiStyle: (prompt, model) => ({
+        model,
+        messages: [{ role: "user", content: prompt }]
+    }),
+    claudeStyle: (prompt, model) => ({
+        model,
+        max_tokens: 4096,
+        messages: [{ role: "user", content: prompt }]
+    }),
+    geminiStyle: (prompt, model) => ({
+        contents: [{
+                parts: [{ text: prompt }]
+            }]
+    }),
+};
+// Provider configurations
+export const providerConfigs = {
+    openai: {
+        name: "openai",
+        baseUrl: "https://api.openai.com/v1/chat/completions",
+        envKey: "AI_HOOK_OPENAI_KEY",
+        headers: { "Content-Type": "application/json" },
+        requestBody: requestBodyBuilders.openaiStyle,
+        responseParser: responseParsers.openaiStyle,
+        errorMessages: {
+            missingKey: "Missing OpenAI API key.",
+            emptyResponse: "OpenAI returned empty response",
+            badRequest: "OpenAI rejected the request",
+            invalidKey: "Invalid OpenAI API key",
+            rateLimit: "Too many requests to OpenAI",
+            networkError: "Network error while contacting OpenAI",
+            unknownError: "Unknown error occurred"
+        }
+    },
+    groq: {
+        name: "groq",
+        baseUrl: "https://api.groq.com/openai/v1/chat/completions",
+        envKey: "AI_HOOK_GROQ_KEY",
+        headers: { "Content-Type": "application/json" },
+        requestBody: requestBodyBuilders.openaiStyle,
+        responseParser: responseParsers.openaiStyle,
+        errorMessages: {
+            missingKey: "Missing Groq API key.",
+            emptyResponse: "Groq returned empty response",
+            badRequest: "Groq rejected the request",
+            invalidKey: "Invalid Groq API key",
+            rateLimit: "Too many requests to Groq",
+            networkError: "Network error while contacting Groq",
+            unknownError: "Unknown error occurred"
+        }
+    },
+    claude: {
+        name: "claude",
+        baseUrl: "https://api.anthropic.com/v1/messages",
+        envKey: "AI_HOOK_CLAUDE_KEY",
+        headers: {
+            "Content-Type": "application/json",
+            "anthropic-version": "2023-06-01"
+        },
+        requestBody: requestBodyBuilders.claudeStyle,
+        responseParser: responseParsers.claudeStyle,
+        errorMessages: {
+            missingKey: "Missing Claude API key.",
+            emptyResponse: "Claude returned empty response",
+            badRequest: "Claude rejected the request",
+            invalidKey: "Invalid Claude API key",
+            rateLimit: "Too many requests to Claude",
+            networkError: "Network error while contacting Claude",
+            unknownError: "Unknown error occurred"
+        }
+    },
+    gemini: {
+        name: "gemini",
+        baseUrl: "https://generativelanguage.googleapis.com/v1beta/models",
+        envKey: "AI_HOOK_GEMINI_KEY",
+        headers: { "Content-Type": "application/json" },
+        requestBody: requestBodyBuilders.geminiStyle,
+        responseParser: responseParsers.geminiStyle,
+        errorMessages: {
+            missingKey: "Missing Gemini API key.",
+            emptyResponse: "Gemini returned empty response",
+            badRequest: "Gemini rejected the request",
+            invalidKey: "Invalid Gemini API key",
+            rateLimit: "Too many requests to Gemini",
+            networkError: "Network error while contacting Gemini",
+            unknownError: "Unknown error occurred"
+        }
+    },
+    deepseek: {
+        name: "deepseek",
+        baseUrl: "https://api.deepseek.com/v1/chat/completions",
+        envKey: "AI_HOOK_DEEPSEEK_KEY",
+        headers: { "Content-Type": "application/json" },
+        requestBody: requestBodyBuilders.openaiStyle,
+        responseParser: responseParsers.openaiStyle,
+        errorMessages: {
+            missingKey: "Missing DeepSeek API key.",
+            emptyResponse: "DeepSeek returned empty response",
+            badRequest: "DeepSeek rejected the request",
+            invalidKey: "Invalid DeepSeek API key",
+            rateLimit: "Too many requests to DeepSeek",
+            networkError: "Network error while contacting DeepSeek",
+            unknownError: "Unknown error occurred"
+        }
+    },
+    mistral: {
+        name: "mistral",
+        baseUrl: "https://api.mistral.ai/v1/chat/completions",
+        envKey: "AI_HOOK_MISTRAL_KEY",
+        headers: { "Content-Type": "application/json" },
+        requestBody: requestBodyBuilders.openaiStyle,
+        responseParser: responseParsers.openaiStyle,
+        errorMessages: {
+            missingKey: "Missing Mistral API key.",
+            emptyResponse: "Mistral returned empty response",
+            badRequest: "Mistral rejected the request",
+            invalidKey: "Invalid Mistral API key",
+            rateLimit: "Too many requests to Mistral",
+            networkError: "Network error while contacting Mistral",
+            unknownError: "Unknown error occurred"
+        }
+    },
+    xai: {
+        name: "xai",
+        baseUrl: "https://api.x.ai/v1/chat/completions",
+        envKey: "AI_HOOK_XAI_KEY",
+        headers: { "Content-Type": "application/json" },
+        requestBody: requestBodyBuilders.openaiStyle,
+        responseParser: responseParsers.openaiStyle,
+        errorMessages: {
+            missingKey: "Missing xAI API key.",
+            emptyResponse: "xAI returned empty response",
+            badRequest: "xAI rejected the request",
+            invalidKey: "Invalid xAI API key",
+            rateLimit: "Too many requests to xAI",
+            networkError: "Network error while contacting xAI",
+            unknownError: "Unknown error occurred"
+        }
+    },
+    perplexity: {
+        name: "perplexity",
+        baseUrl: "https://api.perplexity.ai/chat/completions",
+        envKey: "AI_HOOK_PERPLEXITY_KEY",
+        headers: { "Content-Type": "application/json" },
+        requestBody: requestBodyBuilders.openaiStyle,
+        responseParser: responseParsers.openaiStyle,
+        errorMessages: {
+            missingKey: "Missing Perplexity API key.",
+            emptyResponse: "Perplexity returned empty response",
+            badRequest: "Perplexity rejected the request",
+            invalidKey: "Invalid Perplexity API key",
+            rateLimit: "Too many requests to Perplexity",
+            networkError: "Network error while contacting Perplexity",
+            unknownError: "Unknown error occurred"
+        }
+    },
+    openrouter: {
+        name: "openrouter",
+        baseUrl: "https://openrouter.ai/api/v1/chat/completions",
+        envKey: "AI_HOOK_OPENROUTER_KEY",
+        headers: { "Content-Type": "application/json" },
+        requestBody: requestBodyBuilders.openaiStyle,
+        responseParser: responseParsers.openaiStyle,
+        errorMessages: {
+            missingKey: "Missing OpenRouter API key.",
+            emptyResponse: "OpenRouter returned empty response",
+            badRequest: "OpenRouter rejected the request",
+            invalidKey: "Invalid OpenRouter API key",
+            rateLimit: "Too many requests to OpenRouter",
+            networkError: "Network error while contacting OpenRouter",
+            unknownError: "Unknown error occurred"
+        }
+    }
+};

package/dist/esm/providers/base/ProviderRegistry.js

@@ -0,0 +1,43 @@
+export class ProviderRegistry {
+    constructor() {
+        this.providers = new Map();
+        this.providerFunctions = new Map();
+    }
+    register(name, provider) {
+        this.providers.set(name, provider);
+        this.providerFunctions.set(name, this.createProviderFunction(provider));
+    }
+    get(name) {
+        return this.providerFunctions.get(name);
+    }
+    getAvailableProviders() {
+        const available = [];
+        // Always prefer openrouter if present (matching original behavior)
+        if (this.providers.has("openrouter")) {
+            const openrouterProvider = this.providers.get("openrouter");
+            const apiKey = openrouterProvider['getApiKey']();
+            if (apiKey) {
+                available.push("openrouter");
+            }
+        }
+        // Add others in order of their presence (matching original behavior)
+        const otherProviders = ['groq', 'openai', 'gemini', 'claude', 'deepseek', 'xai', 'perplexity', 'mistral'];
+        for (const providerName of otherProviders) {
+            if (this.providers.has(providerName)) {
+                const provider = this.providers.get(providerName);
+                const apiKey = provider['getApiKey']();
+                if (apiKey && !available.includes(providerName)) {
+                    available.push(providerName);
+                }
+            }
+        }
+        return available;
+    }
+    createProviderFunction(provider) {
+        return async (prompt, model) => {
+            return provider.call(prompt, model);
+        };
+    }
+}
+// Global registry instance
+export const providerRegistry = new ProviderRegistry();