@juspay/neurolink/dist/lib/providers/mistral.js

Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and

import { createMistral } from "@ai-sdk/mistral";
import { streamText } from "ai";
import { BaseProvider } from "../core/baseProvider.js";
import { logger } from "../utils/logger.js";
import { createAnalytics } from "../core/analytics.js";
import { validateApiKey, createMistralConfig, getProviderModel, } from "../utils/providerConfig.js";
import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
// Configuration helpers - now using consolidated utility
const getMistralApiKey = () => {
    return validateApiKey(createMistralConfig());
};
const getDefaultMistralModel = () => {
    return getProviderModel("MISTRAL_MODEL", "mistral-large-latest");
};
/**
 * 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 NeuroLinkSDK parameter validation
        const validatedSdk = sdk && typeof sdk === "object" && "getInMemoryServers" in sdk
            ? sdk
            : undefined;
        super(modelName, "mistral", validatedSdk);
        // Initialize Mistral model with API key validation
        const apiKey = getMistralApiKey();
        const mistral = createMistral({
            apiKey: apiKey,
        });
        this.model = mistral(this.modelName || getDefaultMistralModel());
        logger.debug("Mistral Provider v2 initialized", {
            modelName: this.modelName,
            providerName: this.providerName,
        });
    }
    /**
     * Generate text using Mistral API
     */
    async generate(options) {
        const startTime = Date.now();
        try {
            const result = await this.model.doGenerate({
                inputFormat: "prompt",
                mode: { type: "regular" },
                prompt: [
                    {
                        role: "user",
                        content: [{ type: "text", text: options.prompt || "" }],
                    },
                ],
                temperature: options.temperature,
                maxTokens: options.maxTokens,
            });
            const responseTime = Date.now() - startTime;
            // Extract token usage and text content
            const tokenUsage = result.usage;
            const textContent = result.text || "";
            // Create analytics data using helper
            const analytics = createAnalytics("mistral", this.modelName, { usage: tokenUsage, content: textContent }, responseTime, { requestId: `mistral-${Date.now()}` });
            return {
                content: textContent,
                usage: {
                    inputTokens: tokenUsage?.promptTokens || 0,
                    outputTokens: tokenUsage?.completionTokens || 0,
                    totalTokens: (tokenUsage?.promptTokens || 0) +
                        (tokenUsage?.completionTokens || 0),
                },
                provider: this.providerName,
                model: this.modelName,
                analytics,
            };
        }
        catch (error) {
            const responseTime = Date.now() - startTime;
            logger.error("Mistral generation failed", {
                error: error instanceof Error ? error.message : String(error),
                responseTime,
            });
            throw new Error(`Mistral generation failed: ${error instanceof Error ? error.message : String(error)}`);
        }
    }
    /**
     * Stream text generation using Mistral API
     */
    async executeStream(options) {
        const startTime = Date.now();
        try {
            const result = await streamText({
                model: this.model,
                prompt: options.input.text,
                temperature: options.temperature,
                maxTokens: options.maxTokens,
                tools: options.tools,
                toolChoice: "auto",
            });
            // Transform stream to match StreamResult interface
            const transformedStream = async function* () {
                for await (const chunk of result.textStream) {
                    yield { content: chunk };
                }
            };
            // Create analytics promise that resolves after stream completion
            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, 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) {
            logger.error("Mistral streaming failed", {
                error: error instanceof Error ? error.message : String(error),
            });
            throw new Error(`Mistral streaming failed: ${error instanceof Error ? error.message : String(error)}`);
        }
    }
    /**
     * Get default model name for this provider
     */
    getDefaultModel() {
        return getDefaultMistralModel();
    }
    /**
     * Get provider name
     */
    getProviderName() {
        return this.providerName;
    }
    /**
     * Get AI SDK model instance
     */
    getAISDKModel() {
        return this.model;
    }
    /**
     * Handle provider-specific errors
     */
    handleProviderError(error) {
        if (error instanceof Error) {
            return error;
        }
        return new Error(`Mistral provider error: ${String(error)}`);
    }
    /**
     * 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;