@juspay/neurolink 1.6.0 → 1.9.0

package/dist/providers/mcp-provider.js

@@ -0,0 +1,183 @@
+/**
+ * NeuroLink MCP-Aware AI Provider
+ * Integrates MCP tools with AI providers following Lighthouse's pattern
+ */
+import { getMCPManager } from "../mcp/manager.js";
+import { initializeMCPTools } from "../mcp/initialize-tools.js";
+import { logger } from "../utils/logger.js";
+import { v4 as uuidv4 } from "uuid";
+/**
+ * MCP-Aware AI Provider
+ * Wraps any AI provider with MCP tool capabilities
+ */
+export class MCPAwareProvider {
+    baseProvider;
+    config;
+    sessionId;
+    mcpInitialized = false;
+    constructor(config) {
+        this.baseProvider = config.baseProvider;
+        this.config = config;
+        this.sessionId = config.sessionId || uuidv4();
+    }
+    /**
+     * Initialize MCP tools for this session
+     */
+    async initializeMCP() {
+        if (this.mcpInitialized || this.config.enableMCP === false) {
+            return;
+        }
+        try {
+            // Get or create MCP client for this session
+            const mcpClient = getMCPManager(this.sessionId, {
+                userId: this.config.userId,
+                aiProvider: this.config.providerName,
+                modelId: this.config.modelName,
+            });
+            // Create execution context
+            const context = {
+                sessionId: this.sessionId,
+                userId: this.config.userId,
+                organizationId: this.config.organizationId,
+                aiProvider: this.config.providerName,
+                modelId: this.config.modelName,
+                timestamp: Date.now(),
+            };
+            // Initialize all MCP tools
+            initializeMCPTools(this.sessionId, mcpClient, context);
+            this.mcpInitialized = true;
+            const tools = mcpClient.getTools();
+            const toolCount = Object.keys(tools).length;
+            logger.info(`[MCP Provider] Initialized ${toolCount} tools for session ${this.sessionId}`);
+        }
+        catch (error) {
+            logger.error(`[MCP Provider] Failed to initialize MCP for session ${this.sessionId}`, error);
+            // Continue without MCP tools if initialization fails
+        }
+    }
+    async generateText(optionsOrPrompt, analysisSchema) {
+        // Ensure MCP is initialized
+        await this.initializeMCP();
+        // Parse options
+        const options = typeof optionsOrPrompt === "string"
+            ? { prompt: optionsOrPrompt }
+            : optionsOrPrompt;
+        // Check if prompt requests tool usage
+        const needsTools = this.detectToolRequest(options.prompt);
+        if (needsTools && this.mcpInitialized) {
+            // Get MCP client
+            const mcpClient = getMCPManager(this.sessionId);
+            // Create enhanced prompt with available tools
+            const tools = mcpClient.getTools();
+            const toolList = Object.keys(tools)
+                .map((name) => {
+                const tool = tools[name];
+                return `- ${name}: ${tool.description || "No description"}`;
+            })
+                .join("\n");
+            const enhancedPrompt = `${options.prompt}
+
+Available tools:
+${toolList}
+
+To use a tool, respond with:
+TOOL: <tool_name>
+PARAMS: <json_params>
+
+Otherwise, provide a direct response.`;
+            // Generate response with enhanced prompt
+            const response = await this.baseProvider.generateText({
+                ...options,
+                prompt: enhancedPrompt,
+            }, analysisSchema);
+            if (!response) {
+                return null;
+            }
+            // Check if response includes tool invocation
+            const toolMatch = response.text.match(/TOOL:\s*(\S+)\s*\nPARAMS:\s*({.*})/s);
+            if (toolMatch) {
+                const toolName = toolMatch[1];
+                const toolParams = JSON.parse(toolMatch[2]);
+                // Execute tool
+                const toolResult = await mcpClient.executeTool(toolName, toolParams);
+                // Generate final response with tool result
+                const finalPrompt = `${options.prompt}
+
+Tool ${toolName} was executed with result:
+${JSON.stringify(toolResult, null, 2)}
+
+Please provide a response based on this information.`;
+                const finalResponse = await this.baseProvider.generateText({
+                    ...options,
+                    prompt: finalPrompt,
+                }, analysisSchema);
+                if (!finalResponse) {
+                    return null;
+                }
+                // Return response (tool usage is tracked internally)
+                return finalResponse;
+            }
+            return response;
+        }
+        // Regular generation without tools
+        return this.baseProvider.generateText(options);
+    }
+    async streamText(optionsOrPrompt, analysisSchema) {
+        // For now, streaming doesn't support tool usage
+        // This matches Lighthouse's approach where MCP is used for non-streaming requests
+        return this.baseProvider.streamText(optionsOrPrompt, analysisSchema);
+    }
+    /**
+     * Detect if the prompt is requesting tool usage
+     */
+    detectToolRequest(prompt) {
+        const toolKeywords = [
+            "use tool",
+            "call tool",
+            "execute tool",
+            "run tool",
+            "invoke tool",
+            "what tools",
+            "available tools",
+            "list tools",
+        ];
+        const lowerPrompt = prompt.toLowerCase();
+        return toolKeywords.some((keyword) => lowerPrompt.includes(keyword));
+    }
+    /**
+     * Get session statistics
+     */
+    getSessionStats() {
+        if (!this.mcpInitialized) {
+            return null;
+        }
+        const mcpClient = getMCPManager(this.sessionId);
+        return mcpClient.getStats();
+    }
+    /**
+     * Clean up session
+     */
+    async cleanup() {
+        if (this.mcpInitialized) {
+            const { removeMCPManager } = await import("../mcp/manager.js");
+            await removeMCPManager(this.sessionId);
+            this.mcpInitialized = false;
+        }
+    }
+}
+/**
+ * Create an MCP-aware provider
+ */
+export function createMCPAwareProvider(baseProvider, config) {
+    return new MCPAwareProvider({
+        baseProvider,
+        enableMCP: true,
+        ...config,
+    });
+}
+/**
+ * Check if a provider is MCP-aware
+ */
+export function isMCPAwareProvider(provider) {
+    return provider instanceof MCPAwareProvider;
+}

package/dist/providers/mistralAI.d.ts

@@ -1,6 +1,6 @@
-import type { ZodType, ZodTypeDef } from 'zod';
-import { type StreamTextResult, type ToolSet, type Schema, type GenerateTextResult } from 'ai';
-import type { AIProvider, TextGenerationOptions, StreamTextOptions } from '../core/types.js';
+import type { ZodType, ZodTypeDef } from "zod";
+import { type StreamTextResult, type ToolSet, type Schema, type GenerateTextResult } from "ai";
+import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
 export declare class MistralAI implements AIProvider {
     private modelName;
     private client;

package/dist/providers/mistralAI.js

@@ -1,20 +1,20 @@
-import { createMistral } from '@ai-sdk/mistral';
-import { streamText, generateText, Output } from 'ai';
-import { logger } from '../utils/logger.js';
+import { createMistral } from "@ai-sdk/mistral";
+import { streamText, generateText, Output, } from "ai";
+import { logger } from "../utils/logger.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
-    systemPrompt: 'You are a helpful AI assistant.'
+    systemPrompt: "You are a helpful AI assistant.",
 };
 // Configuration helpers
 const getMistralApiKey = () => {
     const apiKey = process.env.MISTRAL_API_KEY;
     if (!apiKey) {
-        throw new Error('MISTRAL_API_KEY environment variable is not set');
+        throw new Error("MISTRAL_API_KEY environment variable is not set");
     }
     return apiKey;
 };
 const getMistralModelId = () => {
-    return process.env.MISTRAL_MODEL || 'mistral-small';
+    return process.env.MISTRAL_MODEL || "mistral-small";
 };
 const hasValidAuth = () => {
     return !!process.env.MISTRAL_API_KEY;
@@ -26,7 +26,7 @@ function getMistralClient() {
         const apiKey = getMistralApiKey();
         _mistralClient = createMistral({
             apiKey,
-            baseURL: process.env.MISTRAL_ENDPOINT || 'https://api.mistral.ai/v1'
+            baseURL: process.env.MISTRAL_ENDPOINT || "https://api.mistral.ai/v1",
         });
     }
     return _mistralClient;
@@ -40,25 +40,25 @@ export class MistralAI {
      * @param modelName - Optional model name to override the default from config
      */
     constructor(modelName) {
-        const functionTag = 'MistralAI.constructor';
+        const functionTag = "MistralAI.constructor";
         this.modelName = modelName || getMistralModelId();
         try {
             this.client = getMistralClient();
             logger.debug(`[${functionTag}] Initialization started`, {
                 modelName: this.modelName,
-                hasApiKey: hasValidAuth()
+                hasApiKey: hasValidAuth(),
             });
             logger.debug(`[${functionTag}] Initialization completed`, {
                 modelName: this.modelName,
-                success: true
+                success: true,
             });
         }
         catch (err) {
             logger.error(`[${functionTag}] Initialization failed`, {
-                message: 'Error in initializing Mistral AI',
+                message: "Error in initializing Mistral AI",
                 modelName: this.modelName,
                 error: err instanceof Error ? err.message : String(err),
-                stack: err instanceof Error ? err.stack : undefined
+                stack: err instanceof Error ? err.stack : undefined,
             });
             throw err;
         }
@@ -68,8 +68,8 @@ export class MistralAI {
      * @private
      */
     getModel() {
-        logger.debug('MistralAI.getModel - Mistral AI model selected', {
-            modelName: this.modelName
+        logger.debug("MistralAI.getModel - Mistral AI model selected", {
+            modelName: this.modelName,
         });
         return this.client(this.modelName);
     }
@@ -80,15 +80,15 @@ export class MistralAI {
      * @returns Promise resolving to StreamTextResult or null if operation fails
      */
     async streamText(optionsOrPrompt, analysisSchema) {
-        const functionTag = 'MistralAI.streamText';
-        const provider = 'mistral';
+        const functionTag = "MistralAI.streamText";
+        const provider = "mistral";
         let chunkCount = 0;
         try {
             // Parse parameters - support both string and options object
-            const options = typeof optionsOrPrompt === 'string'
+            const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema } = options;
+            const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Stream request started`, {
@@ -97,7 +97,7 @@ export class MistralAI {
                 promptLength: prompt.length,
                 temperature,
                 maxTokens,
-                hasSchema: !!finalSchema
+                hasSchema: !!finalSchema,
             });
             const model = this.getModel();
             const streamOptions = {
@@ -116,7 +116,7 @@ export class MistralAI {
                         error: errorMessage,
                         stack: errorStack,
                         promptLength: prompt.length,
-                        chunkCount
+                        chunkCount,
                     });
                 },
                 onFinish: (event) => {
@@ -127,7 +127,7 @@ export class MistralAI {
                         usage: event.usage,
                         totalChunks: chunkCount,
                         promptLength: prompt.length,
-                        responseLength: event.text?.length || 0
+                        responseLength: event.text?.length || 0,
                     });
                 },
                 onChunk: (event) => {
@@ -137,12 +137,14 @@ export class MistralAI {
                         modelName: this.modelName,
                         chunkNumber: chunkCount,
                         chunkLength: event.chunk.text?.length || 0,
-                        chunkType: event.chunk.type
+                        chunkType: event.chunk.type,
                     });
-                }
+                },
             };
             if (finalSchema) {
-                streamOptions.experimental_output = Output.object({ schema: finalSchema });
+                streamOptions.experimental_output = Output.object({
+                    schema: finalSchema,
+                });
             }
             const result = streamText(streamOptions);
             return result;
@@ -151,9 +153,11 @@ export class MistralAI {
             logger.error(`[${functionTag}] Exception`, {
                 provider,
                 modelName: this.modelName,
-                message: 'Error in streaming text',
+                message: "Error in streaming text",
                 err: String(err),
-                promptLength: typeof optionsOrPrompt === 'string' ? optionsOrPrompt.length : optionsOrPrompt.prompt.length
+                promptLength: typeof optionsOrPrompt === "string"
+                    ? optionsOrPrompt.length
+                    : optionsOrPrompt.prompt.length,
             });
             throw err; // Re-throw error to trigger fallback
         }
@@ -165,14 +169,14 @@ export class MistralAI {
      * @returns Promise resolving to GenerateTextResult or null if operation fails
      */
     async generateText(optionsOrPrompt, analysisSchema) {
-        const functionTag = 'MistralAI.generateText';
-        const provider = 'mistral';
+        const functionTag = "MistralAI.generateText";
+        const provider = "mistral";
         try {
             // Parse parameters - support both string and options object
-            const options = typeof optionsOrPrompt === 'string'
+            const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema } = options;
+            const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Generate request started`, {
@@ -180,7 +184,7 @@ export class MistralAI {
                 modelName: this.modelName,
                 promptLength: prompt.length,
                 temperature,
-                maxTokens
+                maxTokens,
             });
             const model = this.getModel();
             const generateOptions = {
@@ -188,10 +192,12 @@ export class MistralAI {
                 prompt: prompt,
                 system: systemPrompt,
                 temperature,
-                maxTokens
+                maxTokens,
             };
             if (finalSchema) {
-                generateOptions.experimental_output = Output.object({ schema: finalSchema });
+                generateOptions.experimental_output = Output.object({
+                    schema: finalSchema,
+                });
             }
             const result = await generateText(generateOptions);
             logger.debug(`[${functionTag}] Generate text completed`, {
@@ -199,7 +205,7 @@ export class MistralAI {
                 modelName: this.modelName,
                 usage: result.usage,
                 finishReason: result.finishReason,
-                responseLength: result.text?.length || 0
+                responseLength: result.text?.length || 0,
             });
             return result;
         }
@@ -207,8 +213,8 @@ export class MistralAI {
             logger.error(`[${functionTag}] Exception`, {
                 provider,
                 modelName: this.modelName,
-                message: 'Error in generating text',
-                err: String(err)
+                message: "Error in generating text",
+                err: String(err),
             });
             throw err; // Re-throw error to trigger fallback
         }

package/dist/providers/ollama.d.ts

@@ -10,10 +10,10 @@
  * - Health checking and service validation
  * - Streaming and non-streaming text generation
  */
-import type { AIProvider, TextGenerationOptions, StreamTextOptions } from '../core/types.js';
-import type { GenerateTextResult, StreamTextResult, ToolSet } from 'ai';
-import type { ZodType, ZodTypeDef } from 'zod';
-import type { Schema } from 'ai';
+import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
+import type { GenerateTextResult, StreamTextResult, ToolSet } from "ai";
+import type { ZodType, ZodTypeDef } from "zod";
+import type { Schema } from "ai";
 export declare class Ollama implements AIProvider {
     private baseUrl;
     private modelName;