@juspay/neurolink 5.2.0 → 6.0.0

package/dist/providers/mistral.js

@@ -1,160 +1,168 @@
 import { createMistral } from "@ai-sdk/mistral";
-import { streamText, Output } from "ai";
+import { streamText } 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 { createAnalytics } from "./analytics-helper.js";
 // Configuration helpers
 const getMistralApiKey = () => {
     const apiKey = process.env.MISTRAL_API_KEY;
     if (!apiKey) {
-        throw new Error(`❌ Mistral AI Provider Configuration Error\n\nMissing required environment variable: MISTRAL_API_KEY\n\n🔧 Step 1: Get Mistral AI API Key\n1. Visit: https://console.mistral.ai/\n2. Sign in or create an account\n3. Go to API Keys section\n4. Create a new API key\n\n🔧 Step 2: Set Environment Variable\nAdd to your .env file:\nMISTRAL_API_KEY=your_api_key_here\n\n🔧 Step 3: Restart Application\nRestart your application to load the new environment variables.`);
+        throw new Error("Mistral API key not found. Please set MISTRAL_API_KEY environment variable.");
     }
     return apiKey;
 };
 const getDefaultMistralModel = () => {
-    return process.env.MISTRAL_MODEL || "mistral-small";
-};
-const hasMistralCredentials = () => {
-    return !!process.env.MISTRAL_API_KEY;
+    return process.env.MISTRAL_MODEL || "mistral-large-latest";
 };
 /**
  * Mistral AI Provider v2 - BaseProvider Implementation
- *
- * PHASE 3.6: Simple BaseProvider wrap around existing @ai-sdk/mistral implementation
- *
- * Features:
- * - Extends BaseProvider for shared functionality
- * - Uses pre-configured Mistral instance for efficiency
- * - Enhanced error handling with setup guidance
- * - Supports all Mistral models (mistral-small, mistral-medium, mistral-large)
+ * Supports official AI-SDK integration with all Mistral models
  */
 export class MistralProvider extends BaseProvider {
-    mistral;
     model;
     constructor(modelName, sdk) {
-        super(modelName, "mistral", sdk);
-        // Validate Mistral API credentials
-        if (!hasMistralCredentials()) {
-            throw new Error(`❌ Mistral AI Provider Configuration Error\n\nMissing Mistral AI API key.\n\n🔧 Required Environment Variable:\nMISTRAL_API_KEY=your_api_key_here\n\n🔧 Get API Key:\n1. Visit: https://console.mistral.ai/\n2. Sign in or create account\n3. Generate API key\n4. Add to .env file\n\n🔧 Restart Application\nRestart your application to load the new environment variables.`);
-        }
-        // Initialize Mistral provider
-        this.mistral = createMistral({
-            apiKey: getMistralApiKey(),
+        // 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,
         });
-        // Pre-initialize model for efficiency
-        this.model = this.mistral(this.modelName || getDefaultMistralModel());
-        logger.debug("Mistral AI BaseProvider v2 initialized", {
+        this.model = mistral(this.modelName || getDefaultMistralModel());
+        logger.debug("Mistral Provider v2 initialized", {
             modelName: this.modelName,
-            provider: this.providerName,
+            providerName: this.providerName,
         });
     }
-    getProviderName() {
-        return "mistral";
-    }
-    getDefaultModel() {
-        return getDefaultMistralModel();
-    }
     /**
-     * Returns the Vercel AI SDK model instance for Mistral
+     * Generate text using Mistral API
      */
-    getAISDKModel() {
-        return this.model;
+    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)}`);
+        }
     }
-    // executeGenerate removed - BaseProvider handles all generation with tools
-    async executeStream(options, analysisSchema) {
+    /**
+     * Stream text generation using Mistral API
+     */
+    async executeStream(options) {
+        const startTime = Date.now();
         try {
-            this.validateStreamOptions(options);
-            const result = await streamText({
+            const stream = await streamText({
                 model: this.model,
-                prompt: options.input.text,
-                system: options.systemPrompt,
-                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                prompt: options.prompt || "",
                 temperature: options.temperature,
+                maxTokens: options.maxTokens,
             });
             return {
                 stream: (async function* () {
-                    for await (const chunk of result.textStream) {
+                    for await (const chunk of stream.textStream) {
                         yield { content: chunk };
                     }
                 })(),
                 provider: this.providerName,
                 model: this.modelName,
+                metadata: {
+                    startTime,
+                },
             };
         }
         catch (error) {
-            throw this.handleProviderError(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)}`);
         }
     }
-    handleProviderError(error) {
-        if (error.name === "TimeoutError") {
-            return new TimeoutError(`Mistral AI request timed out. Consider increasing timeout or using a lighter model.`, this.defaultTimeout);
-        }
-        if (error.message?.includes("401") ||
-            error.message?.includes("Unauthorized")) {
-            return new Error(`❌ Mistral AI Authentication Error\n\nYour API key is invalid or expired.\n\n🔧 Steps to Fix:\n1. Check your MISTRAL_API_KEY in .env file\n2. Verify the API key is correct and active\n3. Generate a new API key if needed at https://console.mistral.ai/\n4. Restart your application after updating`);
-        }
-        if (error.message?.includes("403") ||
-            error.message?.includes("Forbidden")) {
-            return new Error(`❌ Mistral AI Access Denied\n\nYour account doesn't have permission to access this model.\n\n🔧 Possible Solutions:\n1. Check if your account has access to the model: ${this.modelName}\n2. Try a different model (e.g., 'mistral-small')\n3. Verify your subscription status\n4. Contact Mistral AI support if needed`);
-        }
-        if (error.message?.includes("429") ||
-            error.message?.includes("rate limit")) {
-            return new Error(`❌ Mistral AI Rate Limit Exceeded\n\n${error.message}\n\n🔧 Solutions:\n1. Wait a moment before retrying\n2. Reduce request frequency\n3. Check your usage quotas\n4. Consider upgrading your plan`);
-        }
-        if (error.message?.includes("400") ||
-            error.message?.includes("Bad Request")) {
-            return new Error(`❌ Mistral AI Invalid Request\n\n${error.message}\n\n🔧 Check:\n1. Input text is properly formatted\n2. Model name is correct: ${this.modelName}\n3. Parameters are within limits\n4. Request format matches API requirements`);
-        }
-        if (error.message?.includes("404") ||
-            error.message?.includes("Not Found")) {
-            return new Error(`❌ Mistral AI Model Not Found\n\nModel '${this.modelName}' is not available.\n\n🔧 Available Models:\n- mistral-small (fastest, cost-effective)\n- mistral-medium (balanced performance)\n- mistral-large (highest quality)\n\n🔧 Fix: Update MISTRAL_MODEL environment variable`);
-        }
-        return new Error(`❌ Mistral AI Provider Error\n\n${error.message || "Unknown error occurred"}\n\n🔧 Troubleshooting:\n1. Check API key and network connectivity\n2. Verify model availability\n3. Review request parameters\n4. Check Mistral AI status page`);
+    /**
+     * Get default model name for this provider
+     */
+    getDefaultModel() {
+        return getDefaultMistralModel();
     }
-    validateStreamOptions(options) {
-        if (!options.input?.text?.trim()) {
-            throw new Error("Prompt is required for streaming");
-        }
-        if (options.maxTokens &&
-            (options.maxTokens < 1 || options.maxTokens > 32768)) {
-            throw new Error("maxTokens must be between 1 and 32768 for Mistral AI");
-        }
-        if (options.temperature &&
-            (options.temperature < 0 || options.temperature > 1)) {
-            throw new Error("temperature must be between 0 and 1");
-        }
+    /**
+     * Get provider name
+     */
+    getProviderName() {
+        return this.providerName;
     }
     /**
-     * Check available Mistral models
-     * @returns Array of available model names
+     * Get AI SDK model instance
      */
-    getAvailableModels() {
-        return [
-            "mistral-small",
-            "mistral-medium",
-            "mistral-large",
-            "mistral-7b-instruct",
-            "mistral-8x7b-instruct",
-            "mistral-8x22b-instruct",
-        ];
+    getAISDKModel() {
+        return this.model;
     }
     /**
-     * Get recommended model based on use case
-     * @param useCase - The intended use case
-     * @returns Recommended model name
+     * Handle provider-specific errors
      */
-    getRecommendedModel(useCase) {
-        switch (useCase) {
-            case "speed":
-                return "mistral-small";
-            case "balanced":
-                return "mistral-medium";
-            case "quality":
-                return "mistral-large";
-            default:
-                return "mistral-small";
+    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;

package/dist/providers/ollama.d.ts

@@ -24,6 +24,7 @@ export declare class OllamaProvider extends BaseProvider {
     protected getDefaultModel(): string;
     /**
      * Returns the Vercel AI SDK model instance for Ollama
+     * The OllamaLanguageModel implements LanguageModelV1 interface properly
      */
     protected getAISDKModel(): LanguageModelV1;
     /**
@@ -52,7 +53,7 @@ export declare class OllamaProvider extends BaseProvider {
     supportsTools(): boolean;
     protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
     private createOllamaStream;
-    protected handleProviderError(error: any): Error;
+    protected handleProviderError(error: unknown): Error;
     private validateStreamOptions;
     /**
      * Check if Ollama service is healthy and accessible

package/dist/providers/ollama.js

@@ -55,7 +55,8 @@ class OllamaLanguageModel {
             .join("\n");
     }
     async doGenerate(options) {
-        const messages = options.messages || [];
+        const messages = options
+            .messages || [];
         const prompt = this.convertMessagesToPrompt(messages);
         const response = await fetch(`${this.baseUrl}/api/generate`, {
             method: "POST",
@@ -81,11 +82,25 @@ class OllamaLanguageModel {
             usage: {
                 promptTokens: this.estimateTokens(prompt),
                 completionTokens: this.estimateTokens(data.response),
+                totalTokens: this.estimateTokens(prompt) + this.estimateTokens(data.response),
+            },
+            finishReason: "stop",
+            rawCall: {
+                rawPrompt: prompt,
+                rawSettings: {
+                    model: this.modelId,
+                    temperature: options.temperature,
+                    num_predict: options.maxTokens,
+                },
+            },
+            rawResponse: {
+                headers: {},
             },
         };
     }
     async doStream(options) {
-        const messages = options.messages || [];
+        const messages = options
+            .messages || [];
         const prompt = this.convertMessagesToPrompt(messages);
         const response = await fetch(`${this.baseUrl}/api/generate`, {
             method: "POST",
@@ -105,8 +120,32 @@ class OllamaLanguageModel {
         if (!response.ok) {
             throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
         }
+        const self = this;
         return {
-            stream: this.parseStreamResponse(response),
+            stream: new ReadableStream({
+                async start(controller) {
+                    try {
+                        for await (const chunk of self.parseStreamResponse(response)) {
+                            controller.enqueue(chunk);
+                        }
+                        controller.close();
+                    }
+                    catch (error) {
+                        controller.error(error);
+                    }
+                },
+            }),
+            rawCall: {
+                rawPrompt: prompt,
+                rawSettings: {
+                    model: this.modelId,
+                    temperature: options.temperature,
+                    num_predict: options.maxTokens,
+                },
+            },
+            rawResponse: {
+                headers: {},
+            },
         };
     }
     async *parseStreamResponse(response) {
@@ -195,6 +234,7 @@ export class OllamaProvider extends BaseProvider {
     }
     /**
      * Returns the Vercel AI SDK model instance for Ollama
+     * The OllamaLanguageModel implements LanguageModelV1 interface properly
      */
     getAISDKModel() {
         return this.ollamaModel;

package/dist/providers/openAI.d.ts

@@ -16,7 +16,7 @@ export declare class OpenAIProvider extends BaseProvider {
      * Returns the Vercel AI SDK model instance for OpenAI
      */
     protected getAISDKModel(): LanguageModelV1;
-    protected handleProviderError(error: any): Error;
+    protected handleProviderError(error: unknown): Error;
     /**
      * executeGenerate method removed - generation is now handled by BaseProvider.
      * For details on the changes and migration steps, refer to the BaseProvider documentation

package/dist/providers/openAI.js

@@ -52,14 +52,18 @@ export class OpenAIProvider extends BaseProvider {
         if (error instanceof TimeoutError) {
             return new Error(`OpenAI request timed out: ${error.message}`);
         }
-        if (error?.message?.includes("API_KEY_INVALID") ||
-            error?.message?.includes("Invalid API key")) {
+        const errorObj = error;
+        const message = errorObj?.message && typeof errorObj.message === "string"
+            ? errorObj.message
+            : "Unknown error";
+        if (message.includes("API_KEY_INVALID") ||
+            message.includes("Invalid API key")) {
             return new Error("Invalid OpenAI API key. Please check your OPENAI_API_KEY environment variable.");
         }
-        if (error?.message?.includes("rate limit")) {
+        if (message.includes("rate limit")) {
             return new Error("OpenAI rate limit exceeded. Please try again later.");
         }
-        return new Error(`OpenAI error: ${error?.message || "Unknown error"}`);
+        return new Error(`OpenAI error: ${message}`);
     }
     /**
      * executeGenerate method removed - generation is now handled by BaseProvider.

package/dist/proxy/proxy-fetch.js

@@ -40,11 +40,12 @@ export function createProxyFetch() {
                     dispatcher: dispatcher,
                 });
                 logger.debug(`[Proxy Fetch] ✅ Request proxied successfully to ${url.hostname}`);
-                return response; // Type assertion to avoid complex type issues
+                return response; // undici.fetch returns compatible Response type
             }
         }
         catch (error) {
-            logger.warn(`[Proxy Fetch] Proxy failed (${error.message}), falling back to direct connection`);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.warn(`[Proxy Fetch] Proxy failed (${errorMessage}), falling back to direct connection`);
         }
         // Fallback to standard fetch
         return fetch(input, init);

package/dist/sdk/tool-extension.d.ts

@@ -16,11 +16,11 @@ export interface CustomTool {
     /**
      * Parameters schema using Zod or JSON Schema
      */
-    parameters?: z.ZodSchema | Record<string, any>;
+    parameters?: z.ZodSchema | Record<string, unknown>;
     /**
      * Tool execution function
      */
-    execute: (args: any, context?: ToolContext) => Promise<any> | any;
+    execute: (args: unknown, context?: ToolContext) => Promise<unknown> | unknown;
     /**
      * Optional metadata
      */
@@ -46,7 +46,7 @@ export interface ToolContext {
     /**
      * Call another tool
      */
-    callTool: (name: string, args: any) => Promise<any>;
+    callTool: (name: string, args: unknown) => Promise<unknown>;
     /**
      * Current session information
      */
@@ -64,7 +64,7 @@ export interface ToolContext {
 /**
  * Tool middleware function
  */
-export type ToolMiddleware = (toolName: string, args: any, next: () => Promise<any>, context: ToolContext) => Promise<any>;
+export type ToolMiddleware = (toolName: string, args: unknown, next: () => Promise<unknown>, context: ToolContext) => Promise<unknown>;
 /**
  * Tool permission configuration
  */
@@ -72,7 +72,7 @@ export interface ToolPermissions {
     allowlist?: string[];
     denylist?: string[];
     requireApproval?: string[];
-    customValidator?: (toolName: string, args: any) => boolean | Promise<boolean>;
+    customValidator?: (toolName: string, args: unknown) => boolean | Promise<boolean>;
 }
 /**
  * Converts a custom tool to Vercel AI SDK format
@@ -129,7 +129,7 @@ export declare class ToolRegistry {
     /**
      * Execute a tool with middleware
      */
-    execute(name: string, args: any, context: ToolContext): Promise<any>;
+    execute(name: string, args: unknown, context: ToolContext): Promise<unknown>;
 }
 /**
  * Create a simple tool helper
@@ -139,7 +139,7 @@ export declare function createTool(config: CustomTool): CustomTool;
  * Create an async tool helper
  */
 export declare function createAsyncTool(config: Omit<CustomTool, "execute"> & {
-    execute: (args: any, context?: ToolContext) => Promise<any>;
+    execute: (args: unknown, context?: ToolContext) => Promise<unknown>;
 }): CustomTool;
 /**
  * Create a batch tool that processes multiple items
@@ -163,16 +163,16 @@ export declare const TestUtils: {
      * Test a tool with mock data
      */
     testTool(tool: CustomTool, testCases: Array<{
-        input: any;
-        expected?: any;
+        input: unknown;
+        expected?: unknown;
     }>): Promise<({
-        input: any;
-        output: any;
+        input: unknown;
+        output: unknown;
         success: boolean;
         matches: boolean | undefined;
         error?: undefined;
     } | {
-        input: any;
+        input: unknown;
         error: string;
         success: boolean;
         output?: undefined;

package/dist/sdk/tool-extension.js

@@ -217,7 +217,8 @@ export function createAsyncTool(config) {
 export function createBatchTool(config) {
     return {
         ...config,
-        execute: async ({ items }, context) => {
+        execute: async (args, context) => {
+            const { items } = args;
             const batchSize = config.batchSize || 10;
             const results = [];
             for (let i = 0; i < items.length; i += batchSize) {

package/dist/sdk/tool-registration.d.ts

@@ -6,18 +6,17 @@ import { z } from "zod";
 import type { Tool } from "ai";
 import { logger } from "../utils/logger.js";
 import type { InMemoryMCPServerConfig, InMemoryToolInfo } from "../types/mcp-types.js";
+import type { ToolArgs, ToolContext as CoreToolContext, ToolResult, SimpleTool as CoreSimpleTool } from "../types/tools.js";
+import type { JsonValue } from "../types/common.js";
 /**
  * Context provided to tools during execution
+ * Extends the core ToolContext with SDK-specific features
  */
-export interface ToolContext {
+export interface ToolContext extends CoreToolContext {
     /**
      * Current session ID
      */
     sessionId: string;
-    /**
-     * User ID if available
-     */
-    userId?: string;
     /**
      * AI provider being used
      */
@@ -29,7 +28,7 @@ export interface ToolContext {
     /**
      * Call another tool
      */
-    callTool?: (name: string, args: any) => Promise<any>;
+    callTool?: (name: string, args: ToolArgs) => Promise<ToolResult>;
     /**
      * Logger instance
      */
@@ -37,8 +36,9 @@ export interface ToolContext {
 }
 /**
  * Simple tool interface for SDK users
+ * Extends the core SimpleTool with specific types
  */
-export interface SimpleTool {
+export interface SimpleTool<TArgs = ToolArgs, TResult = JsonValue> extends Omit<CoreSimpleTool<TArgs, TResult>, "execute"> {
     /**
      * Tool description that helps AI understand when to use it
      */
@@ -50,7 +50,7 @@ export interface SimpleTool {
     /**
      * Tool execution function
      */
-    execute: (args: any, context?: ToolContext) => Promise<any> | any;
+    execute: (args: TArgs, context?: ToolContext) => Promise<TResult> | TResult;
     /**
      * Optional metadata
      */
@@ -58,7 +58,9 @@ export interface SimpleTool {
         category?: string;
         version?: string;
         author?: string;
-        [key: string]: any;
+        tags?: string[];
+        documentation?: string;
+        [key: string]: JsonValue | undefined;
     };
 }
 /**
@@ -76,18 +78,20 @@ export declare function createMCPServerFromTools(serverId: string, tools: Record
     title?: string;
     description?: string;
     category?: string;
-    [key: string]: any;
+    version?: string;
+    author?: string;
+    [key: string]: JsonValue | undefined;
 }): InMemoryMCPServerConfig;
 /**
  * Helper to create a tool with type safety
  */
-export declare function createTool<TParams = any>(config: SimpleTool): SimpleTool;
+export declare function createTool<TParams = ToolArgs>(config: SimpleTool): SimpleTool;
 /**
  * Helper to create a tool with typed parameters
  */
 export declare function createTypedTool<TParams extends z.ZodSchema>(config: Omit<SimpleTool, "execute"> & {
     parameters: TParams;
-    execute: (args: z.infer<TParams>, context?: ToolContext) => Promise<any> | any;
+    execute: (args: z.infer<TParams>, context?: ToolContext) => Promise<JsonValue> | JsonValue;
 }): SimpleTool;
 /**
  * Validate tool configuration with detailed error messages

package/dist/sdk/tool-registration.js

@@ -42,8 +42,9 @@ export function convertToMCPTool(simpleTool) {
     return {
         description: simpleTool.description,
         execute: async (params) => {
+            const typedParams = params;
             try {
-                const result = await simpleTool.execute(params);
+                const result = await simpleTool.execute(typedParams);
                 return {
                     success: true,
                     data: result,
@@ -135,7 +136,7 @@ export function validateTool(name, tool) {
     // Validate execute function with signature guidance
     if (typeof tool.execute !== "function") {
         throw new Error(`Tool '${name}' must have an execute function. ` +
-            `Expected signature: async (params?: any) => Promise<any>. ` +
+            `Expected signature: async (params?: ToolArgs) => Promise<unknown>. ` +
             `Received: ${typeof tool.execute}. ` +
             `Example: { execute: async (params) => { return { success: true, data: result }; } }`);
     }