npm-ai-hooks 1.0.2 → 2.0.0

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

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProvider = void 0;
+const axios_1 = __importDefault(require("axios"));
+const errors_1 = require("../../errors");
+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 errors_1.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 (0, axios_1.default)(config);
+    }
+    parseResponse(response) {
+        const output = this.config.responseParser(response);
+        if (!output) {
+            throw new errors_1.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 errors_1.AIHookError("NETWORK_ERROR", this.config.errorMessages.networkError, this.config.name, "Check your internet connection");
+        }
+        else {
+            return new errors_1.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 errors_1.AIHookError("BAD_REQUEST", `${this.getCapitalizedProviderName()} rejected the request: ${text}`, providerName, "Check your prompt and model");
+            case 401:
+                return new errors_1.AIHookError("INVALID_API_KEY", `Invalid ${this.getCapitalizedProviderName()} API key: ${text}`, providerName, `Verify your ${this.config.envKey} environment variable`);
+            case 403:
+                return new errors_1.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 errors_1.AIHookError("RATE_LIMIT", `Too many requests to ${this.getCapitalizedProviderName()}: ${text}`, providerName, "Throttle requests or upgrade your plan");
+            default:
+                return new errors_1.AIHookError("PROVIDER_ERROR", `${this.getCapitalizedProviderName()} API error: ${text}`, providerName);
+        }
+    }
+}
+exports.BaseProvider = BaseProvider;

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderManager = void 0;
+const types_1 = require("../../types");
+const BaseProvider_1 = require("./BaseProvider");
+const ProviderConfigs_1 = require("./ProviderConfigs");
+const SpecializedProviders_1 = require("./SpecializedProviders");
+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_1.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 SpecializedProviders_1.ClaudeProvider();
+            provider['getApiKey'] = () => apiKey;
+            return provider;
+        }
+        else if (providerName === 'gemini') {
+            const provider = new SpecializedProviders_1.GeminiProvider();
+            provider['getApiKey'] = () => apiKey;
+            return provider;
+        }
+        else if (providerName === 'openrouter') {
+            const provider = new SpecializedProviders_1.OpenRouterProvider();
+            provider['getApiKey'] = () => apiKey;
+            return provider;
+        }
+        else {
+            const provider = new BaseProvider_1.BaseProvider(providerConfig);
+            provider['getApiKey'] = () => apiKey;
+            return provider;
+        }
+    }
+    getDefaultModelForProvider(providerName) {
+        // Import default models
+        // Using imported DEFAULT_MODEL directly
+        return types_1.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);
+    }
+}
+exports.ProviderManager = ProviderManager;

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

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providerConfigs = exports.requestBodyBuilders = exports.responseParsers = void 0;
+// Common response parsers
+exports.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
+exports.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
+exports.providerConfigs = {
+    openai: {
+        name: "openai",
+        baseUrl: "https://api.openai.com/v1/chat/completions",
+        envKey: "AI_HOOK_OPENAI_KEY",
+        headers: { "Content-Type": "application/json" },
+        requestBody: exports.requestBodyBuilders.openaiStyle,
+        responseParser: exports.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: exports.requestBodyBuilders.openaiStyle,
+        responseParser: exports.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: exports.requestBodyBuilders.claudeStyle,
+        responseParser: exports.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: exports.requestBodyBuilders.geminiStyle,
+        responseParser: exports.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: exports.requestBodyBuilders.openaiStyle,
+        responseParser: exports.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: exports.requestBodyBuilders.openaiStyle,
+        responseParser: exports.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: exports.requestBodyBuilders.openaiStyle,
+        responseParser: exports.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: exports.requestBodyBuilders.openaiStyle,
+        responseParser: exports.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: exports.requestBodyBuilders.openaiStyle,
+        responseParser: exports.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/cjs/providers/base/ProviderRegistry.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providerRegistry = exports.ProviderRegistry = void 0;
+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);
+        };
+    }
+}
+exports.ProviderRegistry = ProviderRegistry;
+// Global registry instance
+exports.providerRegistry = new ProviderRegistry();

package/dist/cjs/providers/base/SpecializedProviders.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenRouterProvider = exports.GeminiProvider = exports.ClaudeProvider = void 0;
+const BaseProvider_1 = require("./BaseProvider");
+const ProviderConfigs_1 = require("./ProviderConfigs");
+const errors_1 = require("../../errors");
+// Claude provider with custom auth headers
+class ClaudeProvider extends BaseProvider_1.BaseProvider {
+    constructor() {
+        super(ProviderConfigs_1.providerConfigs.claude);
+    }
+    buildAuthHeaders(apiKey) {
+        return {
+            "x-api-key": apiKey,
+            "anthropic-version": "2023-06-01"
+        };
+    }
+}
+exports.ClaudeProvider = ClaudeProvider;
+// Gemini provider with custom URL and auth
+class GeminiProvider extends BaseProvider_1.BaseProvider {
+    constructor() {
+        super(ProviderConfigs_1.providerConfigs.gemini);
+    }
+    buildRequestConfig(prompt, model, apiKey) {
+        const baseConfig = super.buildRequestConfig(prompt, model, apiKey);
+        return {
+            ...baseConfig,
+            url: `${this.config.baseUrl}/${model}:generateContent?key=${apiKey}`,
+            headers: {
+                ...baseConfig.headers,
+                // Remove Authorization header for Gemini
+            }
+        };
+    }
+    buildAuthHeaders() {
+        return {}; // Gemini uses API key in URL
+    }
+}
+exports.GeminiProvider = GeminiProvider;
+// OpenRouter provider with custom error handling
+class OpenRouterProvider extends BaseProvider_1.BaseProvider {
+    constructor() {
+        super(ProviderConfigs_1.providerConfigs.openrouter);
+    }
+    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;
+        if (status === 403) {
+            return new errors_1.AIHookError("MODEL_NOT_ALLOWED", `Your API key cannot access this model: ${text}`, providerName, "Try a different model or check API key permissions");
+        }
+        return super.handleHttpError(error);
+    }
+}
+exports.OpenRouterProvider = OpenRouterProvider;

package/dist/cjs/providers/index.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providerRegistry = exports.reset = exports.isInitialized = exports.removeProvider = exports.addProvider = exports.initAIHooks = void 0;
+exports.getAvailableProviders = getAvailableProviders;
+exports.getProvider = getProvider;
+const errors_1 = require("../errors");
+const ProviderRegistry_1 = require("./base/ProviderRegistry");
+Object.defineProperty(exports, "providerRegistry", { enumerable: true, get: function () { return ProviderRegistry_1.providerRegistry; } });
+const ProviderConfigs_1 = require("./base/ProviderConfigs");
+const BaseProvider_1 = require("./base/BaseProvider");
+const SpecializedProviders_1 = require("./base/SpecializedProviders");
+// Import the new initialization system
+const init_1 = require("./init");
+Object.defineProperty(exports, "initAIHooks", { enumerable: true, get: function () { return init_1.initAIHooks; } });
+Object.defineProperty(exports, "addProvider", { enumerable: true, get: function () { return init_1.addProvider; } });
+Object.defineProperty(exports, "removeProvider", { enumerable: true, get: function () { return init_1.removeProvider; } });
+Object.defineProperty(exports, "isInitialized", { enumerable: true, get: function () { return init_1.isInitialized; } });
+Object.defineProperty(exports, "reset", { enumerable: true, get: function () { return init_1.reset; } });
+// Initialize all providers (legacy environment-based system)
+function initializeProviders() {
+    // Standard providers using BaseProvider
+    const standardProviders = ['openai', 'groq', 'deepseek', 'mistral', 'xai', 'perplexity'];
+    standardProviders.forEach(providerName => {
+        const config = ProviderConfigs_1.providerConfigs[providerName];
+        if (config) {
+            const provider = new BaseProvider_1.BaseProvider(config);
+            ProviderRegistry_1.providerRegistry.register(providerName, provider);
+        }
+    });
+    // Specialized providers
+    ProviderRegistry_1.providerRegistry.register("claude", new SpecializedProviders_1.ClaudeProvider());
+    ProviderRegistry_1.providerRegistry.register("gemini", new SpecializedProviders_1.GeminiProvider());
+    ProviderRegistry_1.providerRegistry.register("openrouter", new SpecializedProviders_1.OpenRouterProvider());
+}
+// Initialize providers on module load (legacy)
+initializeProviders();
+// Legacy compatibility - create the old provider map
+const providers = {
+    openrouter: ProviderRegistry_1.providerRegistry.get("openrouter"),
+    groq: ProviderRegistry_1.providerRegistry.get("groq"),
+    openai: ProviderRegistry_1.providerRegistry.get("openai"),
+    gemini: ProviderRegistry_1.providerRegistry.get("gemini"),
+    claude: ProviderRegistry_1.providerRegistry.get("claude"),
+    deepseek: ProviderRegistry_1.providerRegistry.get("deepseek"),
+    xai: ProviderRegistry_1.providerRegistry.get("xai"),
+    perplexity: ProviderRegistry_1.providerRegistry.get("perplexity"),
+    mistral: ProviderRegistry_1.providerRegistry.get("mistral"),
+    mock: async (prompt, model) => `[MOCK OUTPUT] ${prompt}`
+};
+// Returns an array of providers whose API keys exist in environment (legacy)
+function getAvailableProviders() {
+    // If new system is initialized, use it
+    if ((0, init_1.isInitialized)()) {
+        return (0, init_1.getAvailableProviders)();
+    }
+    // Otherwise use legacy system
+    return ProviderRegistry_1.providerRegistry.getAvailableProviders();
+}
+// Returns both the provider function and the actual provider name (legacy)
+function getProvider(name) {
+    // If new system is initialized, use it
+    if ((0, init_1.isInitialized)()) {
+        const result = (0, init_1.getProvider)(name);
+        return { fn: result.fn, provider: result.provider };
+    }
+    // Otherwise use legacy system
+    const available = getAvailableProviders();
+    // 1. If user specified provider and it's available
+    if (name && providers[name]) {
+        return { fn: providers[name], provider: name };
+    }
+    // 2. If at least one provider is available, pick the first one (openrouter always preferred if present)
+    if (available.length > 0) {
+        // Only log in non-test environments to avoid Jest warnings
+        if (process.env.NODE_ENV !== "test" && !process.env.JEST_WORKER_ID) {
+            console.log(`[ai-hooks] ✅ Auto-selected provider: ${available[0]}`);
+        }
+        return { fn: providers[available[0]], provider: available[0] };
+    }
+    // 3. No valid keys found → throw error (single instruction, no fallback)
+    throw new errors_1.AIHookError("NO_PROVIDER_FOUND", "No valid AI provider API key was found.\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", undefined, "Reference .env.example for setup instructions.");
+}