@juspay/neurolink 5.0.0 → 5.2.0

package/dist/providers/huggingFace.d.ts

@@ -1,33 +1,39 @@
 import type { ZodType, ZodTypeDef } from "zod";
-import { type StreamTextResult, type ToolSet, type Schema, type GenerateTextResult } from "ai";
-import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
-export declare class HuggingFace implements AIProvider {
-    private modelName;
-    private client;
+import { type Schema, type LanguageModelV1 } from "ai";
+import type { AIProviderName } from "../core/types.js";
+import type { StreamOptions, StreamResult } from "../types/stream-types.js";
+import { BaseProvider } from "../core/base-provider.js";
+/**
+ * HuggingFace Provider - BaseProvider Implementation
+ * Using AI SDK with HuggingFace's OpenAI-compatible endpoint
+ */
+export declare class HuggingFaceProvider extends BaseProvider {
+    private model;
+    constructor(modelName?: string);
     /**
-     * Initializes a new instance of HuggingFace
-     * @param modelName - Optional model name to override the default from config
+     * HuggingFace models currently don't properly support tool/function calling
+     *
+     * **Tested Models & Issues:**
+     * - microsoft/DialoGPT-medium: Describes tools instead of executing them
+     * - Most HF models via router endpoint: Function schema passed but not executed
+     * - Issue: Models treat tool definitions as conversation context rather than executable functions
+     *
+     * **Known Limitations:**
+     * - Tools are visible to model but treated as descriptive text
+     * - No proper function call response format handling
+     * - HuggingFace router endpoint doesn't enforce OpenAI-compatible tool execution
+     *
+     * @returns false to disable tools by default until proper implementation
      */
-    constructor(modelName?: string | null);
+    supportsTools(): boolean;
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
     /**
-     * Gets the appropriate model instance
-     * @private
+     * Returns the Vercel AI SDK model instance for HuggingFace
      */
-    private getModel;
-    /**
-     * Processes text using streaming approach with enhanced error handling callbacks
-     * @param prompt - The input text prompt to analyze
-     * @param analysisSchema - Optional Zod schema or Schema object for output validation
-     * @returns Promise resolving to StreamTextResult or null if operation fails
-     */
-    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
-    /**
-     * Processes text using non-streaming approach with optional schema validation
-     * @param prompt - The input text prompt to analyze
-     * @param analysisSchema - Optional Zod schema or Schema object for output validation
-     * @returns Promise resolving to GenerateTextResult or null if operation fails
-     */
-    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
-    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
-    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
+    protected getAISDKModel(): LanguageModelV1;
+    protected handleProviderError(error: any): Error;
+    private validateStreamOptions;
 }
+export default HuggingFaceProvider;

package/dist/providers/huggingFace.js

@@ -1,433 +1,136 @@
-import { HfInference } from "@huggingface/inference";
-import { streamText, generateText, Output, } from "ai";
+import { createOpenAI } from "@ai-sdk/openai";
+import { streamText, Output } from "ai";
+import { BaseProvider } from "../core/base-provider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
-import { evaluateResponse } from "../core/evaluation.js";
-// Default system context
-const DEFAULT_SYSTEM_CONTEXT = {
-    systemPrompt: "You are a helpful AI assistant.",
-};
 // Configuration helpers
 const getHuggingFaceApiKey = () => {
     const apiKey = process.env.HUGGINGFACE_API_KEY || process.env.HF_TOKEN;
     if (!apiKey) {
-        throw new Error("HUGGINGFACE_API_KEY environment variable is not set");
+        throw new Error(`❌ HuggingFace Provider Configuration Error\n\nMissing required environment variables: HUGGINGFACE_API_KEY\n\n🔧 Step 1: Get Credentials\n1. Visit: https://huggingface.co/settings/tokens\n2. Create new API token\n3. Copy the token\n\n🔧 Step 2: Set Environment Variable\nAdd to your .env file:\nHUGGINGFACE_API_KEY=your_token_here\n\n🔧 Step 3: Restart Application\nRestart your application to load the new environment variables.`);
     }
     return apiKey;
 };
-const getHuggingFaceModelId = () => {
+const getDefaultHuggingFaceModel = () => {
     return process.env.HUGGINGFACE_MODEL || "microsoft/DialoGPT-medium";
 };
-const hasValidAuth = () => {
+const hasHuggingFaceCredentials = () => {
     return !!(process.env.HUGGINGFACE_API_KEY || process.env.HF_TOKEN);
 };
-// Lazy initialization cache
-let _hfClient = null;
-function getHuggingFaceClient() {
-    if (!_hfClient) {
+/**
+ * HuggingFace Provider - BaseProvider Implementation
+ * Using AI SDK with HuggingFace's OpenAI-compatible endpoint
+ */
+export class HuggingFaceProvider extends BaseProvider {
+    model;
+    constructor(modelName) {
+        super(modelName, "huggingface");
+        // Get API key and validate
         const apiKey = getHuggingFaceApiKey();
-        _hfClient = new HfInference(apiKey);
-    }
-    return _hfClient;
-}
-// Retry configuration for model loading
-const RETRY_CONFIG = {
-    maxRetries: 3,
-    baseDelay: 2000, // 2 seconds
-    maxDelay: 30000, // 30 seconds
-    backoffMultiplier: 2,
-};
-// Helper function for exponential backoff retry
-async function retryWithBackoff(operation, retryConfig = RETRY_CONFIG) {
-    let lastError;
-    for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
-        try {
-            return await operation();
-        }
-        catch (error) {
-            lastError = error;
-            // Check if it's a model loading error (503 status)
-            if (error instanceof Error && error.message.includes("503")) {
-                if (attempt < retryConfig.maxRetries) {
-                    const delay = Math.min(retryConfig.baseDelay *
-                        Math.pow(retryConfig.backoffMultiplier, attempt), retryConfig.maxDelay);
-                    logger.debug("HuggingFace model loading, retrying...", {
-                        attempt: attempt + 1,
-                        maxRetries: retryConfig.maxRetries,
-                        delayMs: delay,
-                        error: error.message,
-                    });
-                    await new Promise((resolve) => setTimeout(resolve, delay));
-                    continue;
-                }
-            }
-            // For non-503 errors or final attempt, throw immediately
-            throw error;
-        }
-    }
-    throw lastError;
-}
-// Custom LanguageModelV1 implementation for Hugging Face
-class HuggingFaceLanguageModel {
-    specificationVersion = "v1";
-    provider = "huggingface";
-    modelId;
-    maxTokens;
-    supportsStreaming = true;
-    defaultObjectGenerationMode = "json";
-    client;
-    constructor(modelId, client) {
-        this.modelId = modelId;
-        this.client = client;
-    }
-    estimateTokens(text) {
-        return Math.ceil(text.length / 4); // Rough estimation: 4 characters per token
-    }
-    convertMessagesToPrompt(messages) {
-        return messages
-            .map((msg) => {
-            if (typeof msg.content === "string") {
-                return `${msg.role}: ${msg.content}`;
-            }
-            else if (Array.isArray(msg.content)) {
-                // Handle multi-part content (text, images, etc.)
-                return `${msg.role}: ${msg.content
-                    .filter((part) => part.type === "text")
-                    .map((part) => part.text)
-                    .join(" ")}`;
-            }
-            return "";
-        })
-            .join("\n");
-    }
-    async doGenerate(options) {
-        const prompt = this.convertMessagesToPrompt(options.prompt);
-        const response = await retryWithBackoff(async () => {
-            return await this.client.textGeneration({
-                model: this.modelId,
-                inputs: prompt,
-                parameters: {
-                    temperature: options.temperature || 0.7,
-                    max_new_tokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
-                    return_full_text: false,
-                    do_sample: (options.temperature || 0.7) > 0,
-                },
-            });
+        // Create HuggingFace provider using unified router endpoint (2025)
+        const huggingface = createOpenAI({
+            apiKey: apiKey,
+            baseURL: "https://router.huggingface.co/v1",
         });
-        const generatedText = response.generated_text || "";
-        const promptTokens = this.estimateTokens(prompt);
-        const completionTokens = this.estimateTokens(generatedText);
-        return {
-            text: generatedText,
-            usage: {
-                promptTokens,
-                completionTokens,
-                totalTokens: promptTokens + completionTokens,
-            },
-            finishReason: "stop",
-            logprobs: undefined,
-            rawCall: { rawPrompt: prompt, rawSettings: options },
-            rawResponse: { headers: {} },
-        };
-    }
-    async doStream(options) {
-        const prompt = this.convertMessagesToPrompt(options.prompt);
-        // HuggingFace Inference API doesn't support true streaming
-        // We'll simulate streaming by generating the full text and chunking it
-        const response = await this.doGenerate(options);
-        // Create a ReadableStream that chunks the response
-        const stream = new ReadableStream({
-            start(controller) {
-                const text = response.text || "";
-                const chunkSize = Math.max(1, Math.floor(text.length / 10)); // 10 chunks
-                let index = 0;
-                const pushChunk = () => {
-                    if (index < text.length) {
-                        const chunk = text.slice(index, index + chunkSize);
-                        controller.enqueue({
-                            type: "text-delta",
-                            textDelta: chunk,
-                        });
-                        index += chunkSize;
-                        // Add delay to simulate streaming
-                        setTimeout(pushChunk, 50);
-                    }
-                    else {
-                        // Send finish event
-                        controller.enqueue({
-                            type: "finish",
-                            finishReason: response.finishReason,
-                            usage: response.usage,
-                            logprobs: response.logprobs,
-                        });
-                        controller.close();
-                    }
-                };
-                pushChunk();
-            },
+        // Initialize model
+        this.model = huggingface(this.modelName);
+        logger.debug("HuggingFaceProvider initialized", {
+            model: this.modelName,
+            provider: this.providerName,
         });
-        return {
-            stream,
-            rawCall: response.rawCall,
-            rawResponse: response.rawResponse,
-        };
     }
-}
-// Hugging Face class with enhanced error handling
-export class HuggingFace {
-    modelName;
-    client;
+    // ===================
+    // ABSTRACT METHOD IMPLEMENTATIONS
+    // ===================
     /**
-     * Initializes a new instance of HuggingFace
-     * @param modelName - Optional model name to override the default from config
+     * HuggingFace models currently don't properly support tool/function calling
+     *
+     * **Tested Models & Issues:**
+     * - microsoft/DialoGPT-medium: Describes tools instead of executing them
+     * - Most HF models via router endpoint: Function schema passed but not executed
+     * - Issue: Models treat tool definitions as conversation context rather than executable functions
+     *
+     * **Known Limitations:**
+     * - Tools are visible to model but treated as descriptive text
+     * - No proper function call response format handling
+     * - HuggingFace router endpoint doesn't enforce OpenAI-compatible tool execution
+     *
+     * @returns false to disable tools by default until proper implementation
      */
-    constructor(modelName) {
-        const functionTag = "HuggingFace.constructor";
-        this.modelName = modelName || getHuggingFaceModelId();
-        try {
-            this.client = getHuggingFaceClient();
-            logger.debug(`[${functionTag}] Initialization started`, {
-                modelName: this.modelName,
-                hasApiKey: hasValidAuth(),
-            });
-            logger.debug(`[${functionTag}] Initialization completed`, {
-                modelName: this.modelName,
-                success: true,
-            });
-        }
-        catch (err) {
-            logger.error(`[${functionTag}] Initialization failed`, {
-                message: "Error in initializing Hugging Face",
-                modelName: this.modelName,
-                error: err instanceof Error ? err.message : String(err),
-                stack: err instanceof Error ? err.stack : undefined,
-            });
-            throw err;
-        }
-    }
-    /**
-     * Gets the appropriate model instance
-     * @private
-     */
-    getModel() {
-        logger.debug("HuggingFace.getModel - Hugging Face model selected", {
-            modelName: this.modelName,
-        });
-        return new HuggingFaceLanguageModel(this.modelName, this.client);
+    supportsTools() {
+        // TODO: Implement proper HuggingFace tool calling support
+        // Requires: Custom tool schema formatting, response parsing, execution flow
+        // Track models that support function calling: CodeLlama, Llama variants
+        return false;
     }
-    /**
-     * Processes text using streaming approach with enhanced error handling callbacks
-     * @param prompt - The input text prompt to analyze
-     * @param analysisSchema - Optional Zod schema or Schema object for output validation
-     * @returns Promise resolving to StreamTextResult or null if operation fails
-     */
-    async streamText(optionsOrPrompt, analysisSchema) {
-        const functionTag = "HuggingFace.streamText";
-        const provider = "huggingface";
-        let chunkCount = 0;
+    // executeGenerate removed - BaseProvider handles all generation with tools
+    async executeStream(options, analysisSchema) {
+        this.validateStreamOptions(options);
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
-            // Parse parameters - support both string and options object
-            const options = typeof optionsOrPrompt === "string"
-                ? { prompt: optionsOrPrompt }
-                : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "stream"), } = options;
-            // Use schema from options or fallback parameter
-            const finalSchema = schema || analysisSchema;
-            logger.debug(`[${functionTag}] Stream request started`, {
-                provider,
-                modelName: this.modelName,
-                promptLength: prompt.length,
-                temperature,
-                maxTokens,
-                hasSchema: !!finalSchema,
-                timeout,
+            const result = await streamText({
+                model: this.model,
+                prompt: options.input.text,
+                system: options.systemPrompt,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                tools: options.tools,
+                toolChoice: "auto",
+                abortSignal: timeoutController?.controller.signal,
             });
-            const model = this.getModel();
-            // Create timeout controller if timeout is specified
-            const timeoutController = createTimeoutController(timeout, provider, "stream");
-            const streamOptions = {
-                model: model,
-                prompt: prompt,
-                system: systemPrompt,
-                temperature,
-                maxTokens,
-                // Add abort signal if available
-                ...(timeoutController && {
-                    abortSignal: timeoutController.controller.signal,
-                }),
-                onError: (event) => {
-                    const error = event.error;
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    const errorStack = error instanceof Error ? error.stack : undefined;
-                    logger.error(`[${functionTag}] Stream text error`, {
-                        provider,
-                        modelName: this.modelName,
-                        error: errorMessage,
-                        stack: errorStack,
-                        promptLength: prompt.length,
-                        chunkCount,
-                    });
-                },
-                onFinish: (event) => {
-                    logger.debug(`[${functionTag}] Stream text finished`, {
-                        provider,
-                        modelName: this.modelName,
-                        finishReason: event.finishReason,
-                        usage: event.usage,
-                        totalChunks: chunkCount,
-                        promptLength: prompt.length,
-                        responseLength: event.text?.length || 0,
-                    });
-                },
-                onChunk: (event) => {
-                    chunkCount++;
-                    logger.debug(`[${functionTag}] Stream text chunk`, {
-                        provider,
-                        modelName: this.modelName,
-                        chunkNumber: chunkCount,
-                        chunkLength: event.chunk.text?.length || 0,
-                        chunkType: event.chunk.type,
-                    });
-                },
+            timeoutController?.cleanup();
+            // Transform stream to match StreamResult interface
+            const transformedStream = async function* () {
+                for await (const chunk of result.textStream) {
+                    yield { content: chunk };
+                }
+            };
+            return {
+                stream: transformedStream(),
+                provider: this.providerName,
+                model: this.modelName,
             };
-            if (finalSchema) {
-                streamOptions.experimental_output = Output.object({
-                    schema: finalSchema,
-                });
-            }
-            const result = streamText(streamOptions);
-            // For streaming, we can't clean up immediately, but the timeout will auto-clean
-            // The user should handle the stream and any timeout errors
-            return result;
         }
-        catch (err) {
-            // Log timeout errors specifically
-            if (err instanceof TimeoutError) {
-                logger.error(`[${functionTag}] Timeout error`, {
-                    provider,
-                    modelName: this.modelName,
-                    timeout: err.timeout,
-                    message: err.message,
-                });
-            }
-            else {
-                logger.error(`[${functionTag}] Exception`, {
-                    provider,
-                    modelName: this.modelName,
-                    message: "Error in streaming text",
-                    err: String(err),
-                    promptLength: typeof optionsOrPrompt === "string"
-                        ? optionsOrPrompt.length
-                        : optionsOrPrompt.prompt.length,
-                });
-            }
-            throw err; // Re-throw error to trigger fallback
+        catch (error) {
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
         }
     }
+    getProviderName() {
+        return "huggingface";
+    }
+    getDefaultModel() {
+        return getDefaultHuggingFaceModel();
+    }
     /**
-     * Processes text using non-streaming approach with optional schema validation
-     * @param prompt - The input text prompt to analyze
-     * @param analysisSchema - Optional Zod schema or Schema object for output validation
-     * @returns Promise resolving to GenerateTextResult or null if operation fails
+     * Returns the Vercel AI SDK model instance for HuggingFace
      */
-    async generateText(optionsOrPrompt, analysisSchema) {
-        const functionTag = "HuggingFace.generateText";
-        const provider = "huggingface";
-        const startTime = Date.now();
-        try {
-            // Parse parameters - support both string and options object
-            const options = typeof optionsOrPrompt === "string"
-                ? { prompt: optionsOrPrompt }
-                : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "generate"), } = options;
-            // Use schema from options or fallback parameter
-            const finalSchema = schema || analysisSchema;
-            logger.debug(`[${functionTag}] Generate request started`, {
-                provider,
-                modelName: this.modelName,
-                promptLength: prompt.length,
-                temperature,
-                maxTokens,
-                timeout,
-            });
-            const model = this.getModel();
-            // Create timeout controller if timeout is specified
-            const timeoutController = createTimeoutController(timeout, provider, "generate");
-            const generateOptions = {
-                model: model,
-                prompt: prompt,
-                system: systemPrompt,
-                temperature,
-                maxTokens,
-                // Add abort signal if available
-                ...(timeoutController && {
-                    abortSignal: timeoutController.controller.signal,
-                }),
-            };
-            if (finalSchema) {
-                generateOptions.experimental_output = Output.object({
-                    schema: finalSchema,
-                });
-            }
-            try {
-                const result = await generateText(generateOptions);
-                // Clean up timeout if successful
-                timeoutController?.cleanup();
-                logger.debug(`[${functionTag}] Generate text completed`, {
-                    provider,
-                    modelName: this.modelName,
-                    usage: result.usage,
-                    finishReason: result.finishReason,
-                    responseLength: result.text?.length || 0,
-                    timeout,
-                });
-                // Add analytics if enabled
-                if (options.enableAnalytics) {
-                    result.analytics = {
-                        provider,
-                        model: this.modelName,
-                        tokens: result.usage,
-                        responseTime: Date.now() - startTime,
-                        context: options.context,
-                    };
-                }
-                // Add evaluation if enabled
-                if (options.enableEvaluation) {
-                    result.evaluation = await evaluateResponse(prompt, result.text, options.context);
-                }
-                return result;
-            }
-            finally {
-                // Always cleanup timeout
-                timeoutController?.cleanup();
-            }
+    getAISDKModel() {
+        return this.model;
+    }
+    handleProviderError(error) {
+        if (error instanceof TimeoutError) {
+            return new Error(`HuggingFace request timed out: ${error.message}`);
         }
-        catch (err) {
-            // Log timeout errors specifically
-            if (err instanceof TimeoutError) {
-                logger.error(`[${functionTag}] Timeout error`, {
-                    provider,
-                    modelName: this.modelName,
-                    timeout: err.timeout,
-                    message: err.message,
-                });
-            }
-            else {
-                logger.error(`[${functionTag}] Exception`, {
-                    provider,
-                    modelName: this.modelName,
-                    message: "Error in generating text",
-                    err: String(err),
-                });
-            }
-            throw err; // Re-throw error to trigger fallback
+        if (error?.message?.includes("API_TOKEN_INVALID") ||
+            error?.message?.includes("Invalid token")) {
+            return new Error("Invalid HuggingFace API token. Please check your HUGGING_FACE_API_KEY environment variable.");
         }
+        if (error?.message?.includes("rate limit")) {
+            return new Error("HuggingFace rate limit exceeded. Please try again later.");
+        }
+        return new Error(`HuggingFace error: ${error?.message || "Unknown error"}`);
     }
-    async generate(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
-    }
-    async gen(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
+    // ===================
+    // PRIVATE VALIDATION METHODS
+    // ===================
+    validateStreamOptions(options) {
+        if (!options.input?.text || options.input.text.trim().length === 0) {
+            throw new Error("Input text is required and cannot be empty");
+        }
     }
 }
+// Export for factory registration
+export default HuggingFaceProvider;

package/dist/providers/index.d.ts

@@ -2,15 +2,15 @@
  * Provider exports for Vercel AI SDK integration
  * This file centralizes all AI provider classes for easy import and usage
  */
-export { GoogleVertexAI } from "./googleVertexAI.js";
-export { AmazonBedrock } from "./amazonBedrock.js";
-export { OpenAI } from "./openAI.js";
-export { AnthropicProvider } from "./anthropic.js";
-export { AzureOpenAIProvider } from "./azureOpenAI.js";
-export { GoogleAIStudio } from "./googleAIStudio.js";
-export { HuggingFace } from "./huggingFace.js";
-export { Ollama } from "./ollama.js";
-export { MistralAI } from "./mistralAI.js";
+export { GoogleVertexProvider as GoogleVertexAI } from "./google-vertex.js";
+export { AmazonBedrockProvider as AmazonBedrock } from "./amazon-bedrock.js";
+export { OpenAIProvider as OpenAI } from "./openAI.js";
+export { AnthropicProvider as AnthropicProvider } from "./anthropic.js";
+export { AzureOpenAIProvider } from "./azure-openai.js";
+export { GoogleAIStudioProvider as GoogleAIStudio } from "./google-ai-studio.js";
+export { HuggingFaceProvider as HuggingFace } from "./huggingFace.js";
+export { OllamaProvider as Ollama } from "./ollama.js";
+export { MistralProvider as MistralAI } from "./mistral.js";
 export type { AIProvider } from "../core/types.js";
 /**
  * Provider registry for dynamic provider instantiation

package/dist/providers/index.js

@@ -2,15 +2,15 @@
  * Provider exports for Vercel AI SDK integration
  * This file centralizes all AI provider classes for easy import and usage
  */
-export { GoogleVertexAI } from "./googleVertexAI.js";
-export { AmazonBedrock } from "./amazonBedrock.js";
-export { OpenAI } from "./openAI.js";
-export { AnthropicProvider } from "./anthropic.js";
-export { AzureOpenAIProvider } from "./azureOpenAI.js";
-export { GoogleAIStudio } from "./googleAIStudio.js";
-export { HuggingFace } from "./huggingFace.js";
-export { Ollama } from "./ollama.js";
-export { MistralAI } from "./mistralAI.js";
+export { GoogleVertexProvider as GoogleVertexAI } from "./google-vertex.js";
+export { AmazonBedrockProvider as AmazonBedrock } from "./amazon-bedrock.js";
+export { OpenAIProvider as OpenAI } from "./openAI.js";
+export { AnthropicProvider as AnthropicProvider } from "./anthropic.js";
+export { AzureOpenAIProvider } from "./azure-openai.js";
+export { GoogleAIStudioProvider as GoogleAIStudio } from "./google-ai-studio.js";
+export { HuggingFaceProvider as HuggingFace } from "./huggingFace.js";
+export { OllamaProvider as Ollama } from "./ollama.js";
+export { MistralProvider as MistralAI } from "./mistral.js";
 /**
  * Provider registry for dynamic provider instantiation
  */