npm-ai-hooks 1.0.2 → 2.0.0

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

@@ -0,0 +1,52 @@
+import { BaseProvider } from "./BaseProvider";
+import { providerConfigs } from "./ProviderConfigs";
+import { AIHookError } from "../../errors";
+// Claude provider with custom auth headers
+export class ClaudeProvider extends BaseProvider {
+    constructor() {
+        super(providerConfigs.claude);
+    }
+    buildAuthHeaders(apiKey) {
+        return {
+            "x-api-key": apiKey,
+            "anthropic-version": "2023-06-01"
+        };
+    }
+}
+// Gemini provider with custom URL and auth
+export class GeminiProvider extends BaseProvider {
+    constructor() {
+        super(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
+    }
+}
+// OpenRouter provider with custom error handling
+export class OpenRouterProvider extends BaseProvider {
+    constructor() {
+        super(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 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);
+    }
+}

package/dist/esm/providers/index.js

@@ -0,0 +1,75 @@
+import { AIHookError } from "../errors";
+import { providerRegistry } from "./base/ProviderRegistry";
+import { providerConfigs } from "./base/ProviderConfigs";
+import { BaseProvider } from "./base/BaseProvider";
+import { ClaudeProvider, GeminiProvider, OpenRouterProvider } from "./base/SpecializedProviders";
+// Import the new initialization system
+import { initAIHooks, addProvider, removeProvider, getAvailableProviders as getNewAvailableProviders, getProvider as getNewProvider, isInitialized, reset } from "./init";
+// 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[providerName];
+        if (config) {
+            const provider = new BaseProvider(config);
+            providerRegistry.register(providerName, provider);
+        }
+    });
+    // Specialized providers
+    providerRegistry.register("claude", new ClaudeProvider());
+    providerRegistry.register("gemini", new GeminiProvider());
+    providerRegistry.register("openrouter", new OpenRouterProvider());
+}
+// Initialize providers on module load (legacy)
+initializeProviders();
+// Legacy compatibility - create the old provider map
+const providers = {
+    openrouter: providerRegistry.get("openrouter"),
+    groq: providerRegistry.get("groq"),
+    openai: providerRegistry.get("openai"),
+    gemini: providerRegistry.get("gemini"),
+    claude: providerRegistry.get("claude"),
+    deepseek: providerRegistry.get("deepseek"),
+    xai: providerRegistry.get("xai"),
+    perplexity: providerRegistry.get("perplexity"),
+    mistral: providerRegistry.get("mistral"),
+    mock: async (prompt, model) => `[MOCK OUTPUT] ${prompt}`
+};
+// Returns an array of providers whose API keys exist in environment (legacy)
+export function getAvailableProviders() {
+    // If new system is initialized, use it
+    if (isInitialized()) {
+        return getNewAvailableProviders();
+    }
+    // Otherwise use legacy system
+    return providerRegistry.getAvailableProviders();
+}
+// Returns both the provider function and the actual provider name (legacy)
+export function getProvider(name) {
+    // If new system is initialized, use it
+    if (isInitialized()) {
+        const result = getNewProvider(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 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.");
+}
+// Export the new initialization system
+export { initAIHooks, addProvider, removeProvider, isInitialized, reset };
+// Export the registry for advanced usage (legacy)
+export { providerRegistry };

package/dist/esm/providers/init.js

@@ -0,0 +1,81 @@
+import { ProviderManager } from "./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
+ * });
+ * ```
+ */
+export function initAIHooks(options) {
+    providerManager = new ProviderManager(options);
+}
+/**
+ * Add a new provider after initialization
+ * @param config - Provider configuration
+ * @example
+ * ```typescript
+ * addProvider({ provider: 'mistral', key: '...', defaultModel: 'mistral-large' });
+ * ```
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export function isInitialized() {
+    return providerManager !== null;
+}
+/**
+ * Reset the provider manager (useful for testing)
+ */
+export function reset() {
+    providerManager = null;
+}

package/dist/esm/types/claude.js

@@ -0,0 +1,4 @@
+/**
+ * Default model choice - best balance of performance and cost
+ */
+export const ClaudeDefaultModel = "claude-sonnet-4-20250514";

package/dist/esm/types/core/providers.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/deepseek.js

@@ -0,0 +1,4 @@
+/**
+ * Default model choice
+ */
+export const DeepSeekDefaultModel = "deepseek-chat";

package/dist/esm/types/gemini.js

@@ -0,0 +1,4 @@
+/**
+ * Default model choice - best price-performance ratio
+ */
+export const GeminiDefaultModel = "gemini-2.5-flash";

package/dist/esm/types/groq.js

@@ -0,0 +1 @@
+export const GroqDefaultModel = "groq/compound";

package/dist/esm/types/index.js

@@ -0,0 +1,20 @@
+import { OpenAIDefaultModel } from "./openai";
+import { OpenRouterDefaultModel } from "./openrouter";
+import { GroqDefaultModel } from "./groq";
+import { GeminiDefaultModel } from "./gemini";
+import { ClaudeDefaultModel } from "./claude";
+import { DeepSeekDefaultModel } from "./deepseek";
+import { XAIDefaultModel } from "./xai";
+import { PerplexityDefaultModel } from "./perplexity";
+import { MistralDefaultModel } from "./mistral";
+export const DEFAULT_MODEL = {
+    openrouter: OpenRouterDefaultModel,
+    groq: GroqDefaultModel,
+    openai: OpenAIDefaultModel,
+    gemini: GeminiDefaultModel,
+    claude: ClaudeDefaultModel,
+    deepseek: DeepSeekDefaultModel,
+    xai: XAIDefaultModel,
+    perplexity: PerplexityDefaultModel,
+    mistral: MistralDefaultModel
+};

package/dist/esm/types/mistral.js

@@ -0,0 +1,4 @@
+/**
+ * Default model choice - best balance of performance and cost
+ */
+export const MistralDefaultModel = "mistral-small-latest";

package/dist/esm/types/openai.js

@@ -0,0 +1,4 @@
+/**
+ * Default model choice (you can adjust this).
+ */
+export const OpenAIDefaultModel = "gpt-4.1";

package/dist/esm/types/openrouter.js

@@ -0,0 +1 @@
+export const OpenRouterDefaultModel = "openai/gpt-oss-20b:free";

package/dist/esm/types/perplexity.js

@@ -0,0 +1,4 @@
+/**
+ * Default model choice - best balance of speed and accuracy
+ */
+export const PerplexityDefaultModel = "sonar";

package/dist/esm/types/xai.js

@@ -0,0 +1,4 @@
+/**
+ * Default model choice - best balance of performance and cost
+ */
+export const XAIDefaultModel = "grok-4-fast-non-reasoning";

package/dist/esm/wrap.js

@@ -0,0 +1,113 @@
+// dotenv removed - using explicit provider initialization instead
+import { getProvider } from "./providers";
+import { DEFAULT_MODEL } from "./types";
+import { AIHookError } from "./errors";
+function handleError(err) {
+    if (err && typeof err === "object" && "pretty" in err && typeof err.pretty === "function") {
+        // Print pretty message
+        console.error(err.pretty());
+        // 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);
+        // 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;
+    }
+}
+export 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 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);
+            // Step 1: get provider function and the actual provider name
+            const { fn: providerFn, provider: providerKey } = getProvider(options.provider);
+            // Step 2: pick model: passed model or provider-specific default
+            const model = options.model || (providerKey in DEFAULT_MODEL ? DEFAULT_MODEL[providerKey] : undefined);
+            if (!model) {
+                throw new 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);
+            const startTime = Date.now();
+            let output;
+            try {
+                output = await providerFn(prompt, model);
+            }
+            catch (err) {
+                if (err instanceof 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}`);
+                }
+                throw new Error(`[ai-hooks] Unknown non-error thrown by provider: ${String(err)}`);
+            }
+            const endTime = Date.now();
+            return {
+                output,
+                meta: {
+                    provider: providerKey,
+                    model,
+                    cached: false,
+                    estimatedCostUSD: 0.0,
+                    latencyMs: endTime - startTime
+                }
+            };
+        }
+        catch (err) {
+            if (err instanceof 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}`;
+        case "translate":
+            const language = targetLanguage || "English"; // default to English
+            return `Translate this text into ${language}:\n${text}`;
+        case "explain":
+            return `Explain this clearly:\n${text}`;
+        case "rewrite":
+            return `Rewrite this text with better clarity:\n${text}`;
+        case "sentiment":
+            return `Analyze the sentiment of this text:\n${text}`;
+        case "codeReview":
+            return `Review this code and suggest improvements:\n${text}`;
+        default:
+            return text;
+    }
+}

package/dist/index.d.ts

@@ -1 +1,2 @@
 export { wrap } from "./wrap";
+export { initAIHooks, addProvider, removeProvider, getAvailableProviders, getProvider, isInitialized, reset } from "./providers";

package/dist/providers/base/BaseProvider.d.ts

@@ -0,0 +1,33 @@
+import { AxiosRequestConfig, AxiosResponse } from "axios";
+import { AIHookError } from "../../errors";
+export interface ProviderConfig {
+    name: string;
+    baseUrl: string;
+    envKey: string;
+    headers: Record<string, string>;
+    requestBody: (prompt: string, model: string) => any;
+    responseParser: (response: AxiosResponse) => string;
+    errorMessages: {
+        missingKey: string;
+        emptyResponse: string;
+        badRequest: string;
+        invalidKey: string;
+        rateLimit: string;
+        networkError: string;
+        unknownError: string;
+    };
+}
+export declare class BaseProvider {
+    protected config: ProviderConfig;
+    constructor(config: ProviderConfig);
+    call(prompt: string, model: string): Promise<string>;
+    protected getApiKey(): string | undefined;
+    protected validateApiKey(apiKey: string | undefined): void;
+    protected buildRequestConfig(prompt: string, model: string, apiKey: string): AxiosRequestConfig;
+    protected buildAuthHeaders(apiKey: string): Record<string, string>;
+    protected makeRequest(config: AxiosRequestConfig): Promise<AxiosResponse>;
+    protected parseResponse(response: AxiosResponse): string;
+    protected handleError(error: any): AIHookError;
+    protected getCapitalizedProviderName(): string;
+    protected handleHttpError(error: any): AIHookError;
+}

package/dist/providers/base/ProviderConfig.d.ts

@@ -0,0 +1,28 @@
+import { Provider } from "../../types";
+export interface UserProviderConfig {
+    provider: Provider;
+    key: string;
+    defaultModel?: string;
+}
+export interface ProviderInitializationOptions {
+    providers: UserProviderConfig[];
+    defaultProvider?: Provider;
+}
+export declare class ProviderManager {
+    private providers;
+    private defaultProvider?;
+    private providerFunctions;
+    constructor(options: ProviderInitializationOptions);
+    private initializeProviders;
+    private createProviderFunctions;
+    private createProviderFunction;
+    private createProviderInstance;
+    private getDefaultModelForProvider;
+    getAvailableProviders(): Provider[];
+    getProvider(name?: Provider): {
+        fn: any;
+        provider: Provider;
+    };
+    addProvider(config: UserProviderConfig): void;
+    removeProvider(provider: Provider): void;
+}

package/dist/providers/base/ProviderConfigs.d.ts

@@ -0,0 +1,31 @@
+import { ProviderConfig } from "./BaseProvider";
+export declare const responseParsers: {
+    openaiStyle: (response: any) => any;
+    claudeStyle: (response: any) => any;
+    geminiStyle: (response: any) => any;
+};
+export declare const requestBodyBuilders: {
+    openaiStyle: (prompt: string, model: string) => {
+        model: string;
+        messages: {
+            role: string;
+            content: string;
+        }[];
+    };
+    claudeStyle: (prompt: string, model: string) => {
+        model: string;
+        max_tokens: number;
+        messages: {
+            role: string;
+            content: string;
+        }[];
+    };
+    geminiStyle: (prompt: string, model: string) => {
+        contents: {
+            parts: {
+                text: string;
+            }[];
+        }[];
+    };
+};
+export declare const providerConfigs: Record<string, ProviderConfig>;

package/dist/providers/base/ProviderRegistry.d.ts

@@ -0,0 +1,12 @@
+import { BaseProvider } from "./BaseProvider";
+import { Provider } from "../../types";
+import { ProviderFunction } from "../../types/core/providers";
+export declare class ProviderRegistry {
+    private providers;
+    private providerFunctions;
+    register<T extends Provider>(name: T, provider: BaseProvider): void;
+    get(name: Provider): ProviderFunction<any> | undefined;
+    getAvailableProviders(): Provider[];
+    private createProviderFunction;
+}
+export declare const providerRegistry: ProviderRegistry;

package/dist/providers/base/SpecializedProviders.d.ts

@@ -0,0 +1,68 @@
+import { BaseProvider } from "./BaseProvider";
+import { AIHookError } from "../../errors";
+export declare class ClaudeProvider extends BaseProvider {
+    constructor();
+    protected buildAuthHeaders(apiKey: string): Record<string, string>;
+}
+export declare class GeminiProvider extends BaseProvider {
+    constructor();
+    protected buildRequestConfig(prompt: string, model: string, apiKey: string): {
+        url: string;
+        headers: {};
+        method?: import("axios").Method | string;
+        baseURL?: string;
+        allowAbsoluteUrls?: boolean;
+        transformRequest?: import("axios").AxiosRequestTransformer | import("axios").AxiosRequestTransformer[];
+        transformResponse?: import("axios").AxiosResponseTransformer | import("axios").AxiosResponseTransformer[];
+        params?: any;
+        paramsSerializer?: import("axios").ParamsSerializerOptions | import("axios").CustomParamsSerializer;
+        data?: any;
+        timeout?: number;
+        timeoutErrorMessage?: string;
+        withCredentials?: boolean;
+        adapter?: (import("axios").AxiosAdapter | ("fetch" | "xhr" | "http" | (string & {}))) | (import("axios").AxiosAdapter | ("fetch" | "xhr" | "http" | (string & {})))[];
+        auth?: import("axios").AxiosBasicCredentials;
+        responseType?: import("axios").ResponseType;
+        responseEncoding?: import("axios").responseEncoding | string;
+        xsrfCookieName?: string;
+        xsrfHeaderName?: string;
+        onUploadProgress?: (progressEvent: import("axios").AxiosProgressEvent) => void;
+        onDownloadProgress?: (progressEvent: import("axios").AxiosProgressEvent) => void;
+        maxContentLength?: number;
+        validateStatus?: ((status: number) => boolean) | null;
+        maxBodyLength?: number;
+        maxRedirects?: number;
+        maxRate?: number | [number, number];
+        beforeRedirect?: (options: Record<string, any>, responseDetails: {
+            headers: Record<string, string>;
+            statusCode: import("axios").HttpStatusCode;
+        }) => void;
+        socketPath?: string | null;
+        transport?: any;
+        httpAgent?: any;
+        httpsAgent?: any;
+        proxy?: import("axios").AxiosProxyConfig | false;
+        cancelToken?: import("axios").CancelToken;
+        decompress?: boolean;
+        transitional?: import("axios").TransitionalOptions;
+        signal?: import("axios").GenericAbortSignal;
+        insecureHTTPParser?: boolean;
+        env?: {
+            FormData?: new (...args: any[]) => object;
+            fetch?: (input: URL | Request | string, init?: RequestInit) => Promise<Response>;
+            Request?: new (input: URL | Request | string, init?: RequestInit) => Request;
+            Response?: new (body?: ArrayBuffer | ArrayBufferView | Blob | FormData | URLSearchParams | string | null, init?: ResponseInit) => Response;
+        };
+        formSerializer?: import("axios").FormSerializerOptions;
+        family?: import("axios").AddressFamily;
+        lookup?: ((hostname: string, options: object, cb: (err: Error | null, address: import("axios").LookupAddress | import("axios").LookupAddress[], family?: import("axios").AddressFamily) => void) => void) | ((hostname: string, options: object) => Promise<[address: import("axios").LookupAddressEntry | import("axios").LookupAddressEntry[], family?: import("axios").AddressFamily] | import("axios").LookupAddress>);
+        withXSRFToken?: boolean | ((config: import("axios").InternalAxiosRequestConfig) => boolean | undefined);
+        parseReviver?: (this: any, key: string, value: any) => any;
+        fetchOptions?: Omit<RequestInit, "body" | "headers" | "method" | "signal"> | Record<string, any>;
+    };
+    protected buildAuthHeaders(): Record<string, string>;
+}
+export declare class OpenRouterProvider extends BaseProvider {
+    constructor();
+    protected handleHttpError(error: any): AIHookError;
+}

package/dist/providers/index.d.ts

@@ -1,7 +1,11 @@
 import { Provider } from "../types";
 import { ProviderFunction } from "../types/core/providers";
+import { providerRegistry } from "./base/ProviderRegistry";
+import { initAIHooks, addProvider, removeProvider, isInitialized, reset, UserProviderConfig, ProviderInitializationOptions } from "./init";
 export declare function getAvailableProviders(): Provider[];
 export declare function getProvider(name?: Provider): {
     fn: ProviderFunction<any>;
     provider: Provider | "mock";
 };
+export { initAIHooks, addProvider, removeProvider, isInitialized, reset, UserProviderConfig, ProviderInitializationOptions };
+export { providerRegistry };

package/dist/providers/init.d.ts

@@ -0,0 +1,58 @@
+import { UserProviderConfig, ProviderInitializationOptions } from "./base/ProviderConfig";
+import { Provider } from "../types";
+/**
+ * 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
+ * });
+ * ```
+ */
+export declare function initAIHooks(options: ProviderInitializationOptions): void;
+/**
+ * Add a new provider after initialization
+ * @param config - Provider configuration
+ * @example
+ * ```typescript
+ * addProvider({ provider: 'mistral', key: '...', defaultModel: 'mistral-large' });
+ * ```
+ */
+export declare function addProvider(config: UserProviderConfig): void;
+/**
+ * Remove a provider
+ * @param provider - Provider to remove
+ */
+export declare function removeProvider(provider: Provider): void;
+/**
+ * Get available providers
+ * @returns Array of available provider names
+ */
+export declare function getAvailableProviders(): Provider[];
+/**
+ * Get a provider function
+ * @param name - Optional provider name
+ * @returns Provider function and name
+ */
+export declare function getProvider(name?: Provider): {
+    fn: any;
+    provider: Provider;
+};
+/**
+ * Check if AI hooks is initialized
+ * @returns True if initialized
+ */
+export declare function isInitialized(): boolean;
+/**
+ * Reset the provider manager (useful for testing)
+ */
+export declare function reset(): void;
+export type { UserProviderConfig, ProviderInitializationOptions };