@juspay/neurolink 9.32.0 → 9.32.1

package/dist/client/providers/litellm.js

@@ -1,488 +0,0 @@
-import { createOpenAI } from "@ai-sdk/openai";
-import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
-import { NoOutputGeneratedError, Output, streamText, } from "ai";
-import { BaseProvider } from "../core/baseProvider.js";
-import { DEFAULT_MAX_STEPS } from "../core/constants.js";
-import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
-import { createProxyFetch } from "../proxy/proxyFetch.js";
-import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
-import { isAbortError } from "../utils/errorHandling.js";
-import { logger } from "../utils/logger.js";
-import { calculateCost } from "../utils/pricing.js";
-import { getProviderModel } from "../utils/providerConfig.js";
-import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
-import { getModelId } from "./providerTypeUtils.js";
-const streamTracer = trace.getTracer("neurolink.provider.litellm");
-// Configuration helpers
-const getLiteLLMConfig = () => {
-    return {
-        baseURL: process.env.LITELLM_BASE_URL || "http://localhost:4000",
-        apiKey: process.env.LITELLM_API_KEY || "sk-anything",
-    };
-};
-/**
- * Returns the default model name for LiteLLM.
- *
- * LiteLLM uses a 'provider/model' format for model names.
- * For example:
- *   - 'openai/gpt-4o-mini'
- *   - 'openai/gpt-3.5-turbo'
- *   - 'anthropic/claude-3-sonnet-20240229'
- *   - 'google/gemini-pro'
- *
- * You can override the default by setting the LITELLM_MODEL environment variable.
- */
-const getDefaultLiteLLMModel = () => {
-    return getProviderModel("LITELLM_MODEL", "openai/gpt-4o-mini");
-};
-/**
- * LiteLLM Provider - BaseProvider Implementation
- * Provides access to 100+ models via LiteLLM proxy server
- */
-export class LiteLLMProvider extends BaseProvider {
-    model;
-    // Cache for available models to avoid repeated API calls
-    static modelsCache = [];
-    static modelsCacheTime = 0;
-    static MODELS_CACHE_DURATION = 10 * 60 * 1000; // 10 minutes
-    constructor(modelName, sdk) {
-        super(modelName, "litellm", sdk);
-        // Initialize LiteLLM using OpenAI SDK with explicit configuration
-        const config = getLiteLLMConfig();
-        // Create OpenAI SDK instance configured for LiteLLM proxy
-        // LiteLLM acts as a proxy server that implements the OpenAI-compatible API.
-        // To communicate with LiteLLM instead of the default OpenAI endpoint, we use createOpenAI
-        // with a custom baseURL and apiKey. This ensures all requests are routed through the LiteLLM
-        // proxy, allowing access to multiple models and custom authentication.
-        const customOpenAI = createOpenAI({
-            baseURL: config.baseURL,
-            apiKey: config.apiKey,
-            fetch: createProxyFetch(),
-        });
-        this.model = customOpenAI(this.modelName || getDefaultLiteLLMModel());
-        logger.debug("LiteLLM Provider initialized", {
-            modelName: this.modelName,
-            provider: this.providerName,
-            baseURL: config.baseURL,
-        });
-    }
-    getProviderName() {
-        return "litellm";
-    }
-    getDefaultModel() {
-        return getDefaultLiteLLMModel();
-    }
-    /**
-     * Returns the Vercel AI SDK model instance for LiteLLM
-     */
-    getAISDKModel() {
-        return this.model;
-    }
-    formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new NetworkError(`Request timed out: ${error.message}`, this.providerName);
-        }
-        // Check for timeout by error name and message as fallback
-        const errorRecord = error;
-        if (errorRecord?.name === "TimeoutError" ||
-            (typeof errorRecord?.message === "string" &&
-                errorRecord.message.toLowerCase().includes("timeout"))) {
-            return new NetworkError(`Request timed out: ${errorRecord?.message || "Unknown timeout"}`, this.providerName);
-        }
-        if (typeof errorRecord?.message === "string") {
-            if (errorRecord.message.includes("ECONNREFUSED") ||
-                errorRecord.message.includes("Failed to fetch")) {
-                return new NetworkError("LiteLLM proxy server not available. Please start the LiteLLM proxy server at " +
-                    `${process.env.LITELLM_BASE_URL || "http://localhost:4000"}`, this.providerName);
-            }
-            if (errorRecord.message.includes("API_KEY_INVALID") ||
-                errorRecord.message.includes("Invalid API key")) {
-                return new AuthenticationError("Invalid LiteLLM configuration. Please check your LITELLM_API_KEY environment variable.", this.providerName);
-            }
-            if (errorRecord.message.toLowerCase().includes("rate limit")) {
-                return new RateLimitError("LiteLLM rate limit exceeded. Please try again later.", this.providerName);
-            }
-            if (errorRecord.message.toLowerCase().includes("model") &&
-                errorRecord.message.toLowerCase().includes("not found")) {
-                return new InvalidModelError(`Model '${this.modelName}' not available in LiteLLM proxy. ` +
-                    "Please check your LiteLLM configuration and ensure the model is configured.", this.providerName);
-            }
-        }
-        return new ProviderError(`LiteLLM error: ${errorRecord?.message || "Unknown error"}`, this.providerName);
-    }
-    /**
-     * LiteLLM supports tools for compatible models
-     */
-    supportsTools() {
-        return true;
-    }
-    /**
-     * Provider-specific streaming implementation
-     * Note: This is only used when tools are disabled
-     */
-    async executeStream(options, analysisSchema) {
-        this.validateStreamOptions(options);
-        const startTime = Date.now();
-        let chunkCount = 0; // Track chunk count for debugging
-        const timeout = this.getTimeout(options);
-        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
-        try {
-            // Build message array from options with multimodal support
-            // Using protected helper from BaseProvider to eliminate code duplication
-            const messages = await this.buildMessagesForStream(options);
-            const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
-            // Get tools - options.tools is pre-merged by BaseProvider.stream()
-            const shouldUseTools = !options.disableTools && this.supportsTools();
-            const tools = shouldUseTools
-                ? options.tools || (await this.getAllTools())
-                : {};
-            logger.debug(`LiteLLM: Tools for streaming`, {
-                shouldUseTools,
-                toolCount: Object.keys(tools).length,
-                toolNames: Object.keys(tools),
-            });
-            // Model-specific maxTokens handling - Gemini 2.5 models have issues with maxTokens
-            const modelName = this.modelName || getDefaultLiteLLMModel();
-            const isGemini25Model = modelName.includes("gemini-2.5") || modelName.includes("gemini/2.5");
-            const maxTokens = isGemini25Model ? undefined : options.maxTokens;
-            if (isGemini25Model && options.maxTokens) {
-                logger.debug(`LiteLLM: Skipping maxTokens for Gemini 2.5 model (known compatibility issue)`, {
-                    modelName,
-                    requestedMaxTokens: options.maxTokens,
-                });
-            }
-            // Build complete stream options with proper typing - matching Vertex pattern
-            let streamOptions = {
-                model: model,
-                messages: messages,
-                temperature: options.temperature,
-                ...(maxTokens && { maxTokens }), // Conditionally include maxTokens
-                ...(shouldUseTools &&
-                    Object.keys(tools).length > 0 && {
-                    tools,
-                    toolChoice: "auto",
-                    maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
-                }),
-                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
-                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
-                onError: (event) => {
-                    const error = event.error;
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    logger.error(`LiteLLM: Stream error`, {
-                        provider: this.providerName,
-                        modelName: this.modelName,
-                        error: errorMessage,
-                        chunkCount,
-                    });
-                },
-                onFinish: (event) => {
-                    logger.debug(`LiteLLM: Stream finished`, {
-                        finishReason: event.finishReason,
-                        totalChunks: chunkCount,
-                    });
-                },
-                onChunk: () => {
-                    chunkCount++;
-                },
-                onStepFinish: ({ toolCalls, toolResults }) => {
-                    logger.info("Tool execution completed", { toolResults, toolCalls });
-                    this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
-                        logger.warn("[LiteLLMProvider] Failed to store tool executions", {
-                            provider: this.providerName,
-                            error: error instanceof Error ? error.message : String(error),
-                        });
-                    });
-                },
-            };
-            // Add analysisSchema support if provided
-            if (analysisSchema) {
-                try {
-                    streamOptions = {
-                        ...streamOptions,
-                        experimental_output: Output.object({
-                            schema: analysisSchema,
-                        }),
-                    };
-                }
-                catch (error) {
-                    logger.warn("Schema application failed, continuing without schema", {
-                        error: String(error),
-                    });
-                }
-            }
-            // Wrap streamText in an OTel span to capture provider-level latency, token usage, and cost
-            const streamSpan = streamTracer.startSpan("neurolink.provider.streamText", {
-                kind: SpanKind.CLIENT,
-                attributes: {
-                    "gen_ai.system": "litellm",
-                    "gen_ai.request.model": getModelId(model, this.modelName || "unknown"),
-                },
-            });
-            let result;
-            try {
-                result = streamText(streamOptions);
-            }
-            catch (streamError) {
-                streamSpan.setStatus({
-                    code: SpanStatusCode.ERROR,
-                    message: streamError instanceof Error
-                        ? streamError.message
-                        : String(streamError),
-                });
-                streamSpan.end();
-                throw streamError;
-            }
-            // Collect token usage, cost, and finish reason asynchronously when the stream completes,
-            // then end the span. This avoids blocking the stream consumer.
-            Promise.resolve(result.usage)
-                .then((usage) => {
-                streamSpan.setAttribute("gen_ai.usage.input_tokens", usage.inputTokens || 0);
-                streamSpan.setAttribute("gen_ai.usage.output_tokens", usage.outputTokens || 0);
-                const cost = calculateCost(this.providerName, this.modelName, {
-                    input: usage.inputTokens || 0,
-                    output: usage.outputTokens || 0,
-                    total: (usage.inputTokens || 0) + (usage.outputTokens || 0),
-                });
-                if (cost && cost > 0) {
-                    streamSpan.setAttribute("neurolink.cost", cost);
-                }
-            })
-                .catch(() => {
-                // Usage may not be available if the stream is aborted
-            });
-            Promise.resolve(result.finishReason)
-                .then((reason) => {
-                streamSpan.setAttribute("gen_ai.response.finish_reason", reason || "unknown");
-            })
-                .catch(() => {
-                // Finish reason may not be available if the stream is aborted
-            });
-            Promise.resolve(result.text)
-                .then(() => {
-                streamSpan.end();
-            })
-                .catch((err) => {
-                streamSpan.setStatus({
-                    code: SpanStatusCode.ERROR,
-                    message: err instanceof Error ? err.message : String(err),
-                });
-                streamSpan.end();
-            });
-            timeoutController?.cleanup();
-            // Transform stream to content object stream using fullStream (handles both text and tool calls)
-            // Note: fullStream includes tool results, textStream only has text
-            const transformedStream = (async function* () {
-                try {
-                    // Try fullStream first (handles both text and tool calls), fallback to textStream
-                    const streamToUse = result.fullStream || result.textStream;
-                    for await (const chunk of streamToUse) {
-                        // Handle different chunk types from fullStream
-                        if (chunk && typeof chunk === "object") {
-                            // Check for error chunks first (critical error handling)
-                            if ("type" in chunk && chunk.type === "error") {
-                                const errorChunk = chunk;
-                                logger.error(`LiteLLM: Error chunk received:`, {
-                                    errorType: errorChunk.type,
-                                    errorDetails: errorChunk.error,
-                                });
-                                throw new Error(`LiteLLM streaming error: ${errorChunk.error?.message || "Unknown error"}`);
-                            }
-                            if ("textDelta" in chunk) {
-                                // Text delta from fullStream
-                                const textDelta = chunk.textDelta;
-                                if (textDelta) {
-                                    yield { content: textDelta };
-                                }
-                            }
-                            else if ("type" in chunk &&
-                                chunk.type === "tool-call" &&
-                                "toolCallId" in chunk) {
-                                // Tool call event - log for debugging
-                                const toolCallId = String(chunk.toolCallId);
-                                const toolName = "toolName" in chunk ? String(chunk.toolName) : "unknown";
-                                logger.debug("LiteLLM: Tool call", {
-                                    toolCallId,
-                                    toolName,
-                                });
-                            }
-                        }
-                        else if (typeof chunk === "string") {
-                            // Direct string chunk from textStream fallback
-                            yield { content: chunk };
-                        }
-                    }
-                }
-                catch (streamError) {
-                    // AI SDK v6 throws NoOutputGeneratedError when the stream produced no output.
-                    if (NoOutputGeneratedError.isInstance(streamError)) {
-                        logger.warn("LiteLLM: Stream produced no output (NoOutputGeneratedError)");
-                        return;
-                    }
-                    throw streamError;
-                }
-            })();
-            // Create analytics promise that resolves after stream completion
-            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
-                requestId: options.requestId ??
-                    `litellm-stream-${Date.now()}`,
-                streamingMode: true,
-            });
-            return {
-                stream: transformedStream,
-                provider: this.providerName,
-                model: this.modelName,
-                analytics: analyticsPromise,
-                metadata: {
-                    startTime,
-                    streamId: `litellm-${Date.now()}`,
-                },
-            };
-        }
-        catch (error) {
-            timeoutController?.cleanup();
-            throw this.handleProviderError(error);
-        }
-    }
-    /**
-     * Generate an embedding for a single text input
-     * Uses the LiteLLM proxy with OpenAI-compatible embedding API
-     */
-    async embed(text, modelName) {
-        const { embed: aiEmbed } = await import("ai");
-        const { createOpenAI } = await import("@ai-sdk/openai");
-        const config = getLiteLLMConfig();
-        const embeddingModelName = modelName ||
-            process.env.LITELLM_EMBEDDING_MODEL ||
-            "gemini-embedding-001";
-        const customOpenAI = createOpenAI({
-            baseURL: config.baseURL,
-            apiKey: config.apiKey,
-            fetch: createProxyFetch(),
-        });
-        const embeddingModel = customOpenAI.textEmbeddingModel(embeddingModelName);
-        const result = await aiEmbed({ model: embeddingModel, value: text });
-        return result.embedding;
-    }
-    /**
-     * Generate embeddings for multiple text inputs
-     * Uses the LiteLLM proxy with OpenAI-compatible embedding API
-     */
-    async embedMany(texts, modelName) {
-        const { embedMany: aiEmbedMany } = await import("ai");
-        const { createOpenAI } = await import("@ai-sdk/openai");
-        const config = getLiteLLMConfig();
-        const embeddingModelName = modelName ||
-            process.env.LITELLM_EMBEDDING_MODEL ||
-            "gemini-embedding-001";
-        const customOpenAI = createOpenAI({
-            baseURL: config.baseURL,
-            apiKey: config.apiKey,
-            fetch: createProxyFetch(),
-        });
-        const embeddingModel = customOpenAI.textEmbeddingModel(embeddingModelName);
-        const result = await aiEmbedMany({ model: embeddingModel, values: texts });
-        return result.embeddings;
-    }
-    /**
-     * Get available models from LiteLLM proxy server
-     * Dynamically fetches from /v1/models endpoint with caching and fallback
-     */
-    async getAvailableModels() {
-        const functionTag = "LiteLLMProvider.getAvailableModels";
-        const now = Date.now();
-        // Check if cached models are still valid
-        if (LiteLLMProvider.modelsCache.length > 0 &&
-            now - LiteLLMProvider.modelsCacheTime <
-                LiteLLMProvider.MODELS_CACHE_DURATION) {
-            logger.debug(`[${functionTag}] Using cached models`, {
-                cacheAge: Math.round((now - LiteLLMProvider.modelsCacheTime) / 1000),
-                modelCount: LiteLLMProvider.modelsCache.length,
-            });
-            return LiteLLMProvider.modelsCache;
-        }
-        // Try to fetch models dynamically
-        try {
-            const dynamicModels = await this.fetchModelsFromAPI();
-            if (dynamicModels.length > 0) {
-                // Cache successful result
-                LiteLLMProvider.modelsCache = dynamicModels;
-                LiteLLMProvider.modelsCacheTime = now;
-                logger.debug(`[${functionTag}] Successfully fetched models from API`, {
-                    modelCount: dynamicModels.length,
-                });
-                return dynamicModels;
-            }
-        }
-        catch (error) {
-            logger.warn(`[${functionTag}] Failed to fetch models from API, using fallback`, {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-        // Fallback to hardcoded list if API fetch fails
-        const fallbackModels = process.env.LITELLM_FALLBACK_MODELS?.split(",").map((m) => m.trim()) || [
-            "openai/gpt-4o", // minimal safe baseline
-            "anthropic/claude-3-haiku",
-            "meta-llama/llama-3.1-8b-instruct",
-            "google/gemini-2.5-flash",
-        ];
-        logger.debug(`[${functionTag}] Using fallback model list`, {
-            modelCount: fallbackModels.length,
-        });
-        return fallbackModels;
-    }
-    /**
-     * Fetch available models from LiteLLM proxy /v1/models endpoint
-     * @private
-     */
-    async fetchModelsFromAPI() {
-        const functionTag = "LiteLLMProvider.fetchModelsFromAPI";
-        const config = getLiteLLMConfig();
-        const modelsUrl = `${config.baseURL}/v1/models`;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), 5000); // 5 second timeout
-        try {
-            logger.debug(`[${functionTag}] Fetching models from ${modelsUrl}`);
-            const proxyFetch = createProxyFetch();
-            const response = await proxyFetch(modelsUrl, {
-                method: "GET",
-                headers: {
-                    Authorization: `Bearer ${config.apiKey}`,
-                    "Content-Type": "application/json",
-                },
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-            }
-            const data = await response.json();
-            // Parse OpenAI-compatible models response
-            if (data && Array.isArray(data.data)) {
-                const models = data.data
-                    .map((model) => typeof model === "object" &&
-                    model !== null &&
-                    "id" in model &&
-                    typeof model.id === "string"
-                    ? model.id
-                    : undefined)
-                    .filter((id) => typeof id === "string" && id.length > 0)
-                    .sort();
-                logger.debug(`[${functionTag}] Successfully parsed models`, {
-                    totalModels: models.length,
-                    sampleModels: models.slice(0, 5),
-                });
-                return models;
-            }
-            else {
-                throw new Error("Invalid response format: expected data.data array");
-            }
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            if (isAbortError(error)) {
-                throw new NetworkError("Request timed out after 5 seconds", this.providerName);
-            }
-            throw error;
-        }
-    }
-}

package/dist/client/providers/mistral.js

@@ -1,157 +0,0 @@
-import { createMistral } from "@ai-sdk/mistral";
-import { stepCountIs, streamText } from "ai";
-import { BaseProvider } from "../core/baseProvider.js";
-import { DEFAULT_MAX_STEPS } from "../core/constants.js";
-import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
-import { createProxyFetch } from "../proxy/proxyFetch.js";
-import { logger } from "../utils/logger.js";
-import { createMistralConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
-import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
-import { toAnalyticsStreamResult } from "./providerTypeUtils.js";
-// Configuration helpers - now using consolidated utility
-const getMistralApiKey = () => {
-    return validateApiKey(createMistralConfig());
-};
-const getDefaultMistralModel = () => {
-    // Default to vision-capable Mistral Small 2506 (June 2025) with multimodal support
-    return getProviderModel("MISTRAL_MODEL", "mistral-small-2506");
-};
-/**
- * Mistral AI Provider v2 - BaseProvider Implementation
- * Supports official AI-SDK integration with all Mistral models
- */
-export class MistralProvider extends BaseProvider {
-    model;
-    constructor(modelName, sdk) {
-        // Type guard for NeuroLink parameter validation
-        const validatedNeurolink = sdk && typeof sdk === "object" && "getInMemoryServers" in sdk
-            ? sdk
-            : undefined;
-        super(modelName, "mistral", validatedNeurolink);
-        // Initialize Mistral model with API key validation and proxy support
-        const apiKey = getMistralApiKey();
-        const mistral = createMistral({
-            apiKey: apiKey,
-            fetch: createProxyFetch(),
-        });
-        this.model = mistral(this.modelName);
-        logger.debug("Mistral Provider v2 initialized", {
-            modelName: this.modelName,
-            providerName: this.providerName,
-        });
-    }
-    // generate() method is inherited from BaseProvider; this provider uses the base implementation for generation with tools
-    async executeStream(options, _analysisSchema) {
-        this.validateStreamOptions(options);
-        const startTime = Date.now();
-        const timeout = this.getTimeout(options);
-        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
-        try {
-            // Get tools - options.tools is pre-merged by BaseProvider.stream()
-            const shouldUseTools = !options.disableTools && this.supportsTools();
-            const tools = shouldUseTools
-                ? options.tools || (await this.getAllTools())
-                : {};
-            // Build message array from options with multimodal support
-            // Using protected helper from BaseProvider to eliminate code duplication
-            const messages = await this.buildMessagesForStream(options);
-            const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
-            const result = await streamText({
-                model,
-                messages: messages,
-                temperature: options.temperature,
-                maxOutputTokens: options.maxTokens, // No default limit - unlimited unless specified
-                tools,
-                stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
-                toolChoice: shouldUseTools ? "auto" : "none",
-                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
-                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
-                onStepFinish: ({ toolCalls, toolResults }) => {
-                    this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
-                        logger.warn("[MistralProvider] Failed to store tool executions", {
-                            provider: this.providerName,
-                            error: error instanceof Error ? error.message : String(error),
-                        });
-                    });
-                },
-            });
-            timeoutController?.cleanup();
-            // Transform string stream to content object stream using BaseProvider method
-            const transformedStream = this.createTextStream(result);
-            // Create analytics promise that resolves after stream completion
-            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, toAnalyticsStreamResult(result), Date.now() - startTime, {
-                requestId: `mistral-stream-${Date.now()}`,
-                streamingMode: true,
-            });
-            return {
-                stream: transformedStream,
-                provider: this.providerName,
-                model: this.modelName,
-                analytics: analyticsPromise,
-                metadata: {
-                    startTime,
-                    streamId: `mistral-${Date.now()}`,
-                },
-            };
-        }
-        catch (error) {
-            timeoutController?.cleanup();
-            throw this.handleProviderError(error);
-        }
-    }
-    // ===================
-    // ABSTRACT METHOD IMPLEMENTATIONS
-    // ===================
-    getProviderName() {
-        return this.providerName;
-    }
-    getDefaultModel() {
-        return getDefaultMistralModel();
-    }
-    /**
-     * Returns the Vercel AI SDK model instance for Mistral
-     */
-    getAISDKModel() {
-        return this.model;
-    }
-    formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new Error(`Mistral request timed out: ${error.message}`);
-        }
-        const errorRecord = error;
-        const message = typeof errorRecord?.message === "string"
-            ? errorRecord.message
-            : "Unknown error";
-        if (message.includes("API_KEY_INVALID") ||
-            message.includes("Invalid API key")) {
-            return new Error("Invalid Mistral API key. Please check your MISTRAL_API_KEY environment variable.");
-        }
-        if (message.includes("Rate limit exceeded")) {
-            return new Error("Mistral rate limit exceeded");
-        }
-        return new Error(`Mistral error: ${message}`);
-    }
-    /**
-     * Validate provider configuration
-     */
-    async validateConfiguration() {
-        try {
-            getMistralApiKey();
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Get provider-specific configuration
-     */
-    getConfiguration() {
-        return {
-            provider: this.providerName,
-            model: this.modelName,
-            defaultModel: getDefaultMistralModel(),
-        };
-    }
-}
-export default MistralProvider;