@juspay/neurolink 1.5.3 → 1.9.0

package/dist/lib/providers/huggingFace.js

@@ -0,0 +1,362 @@
+import { HfInference } from "@huggingface/inference";
+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.",
+};
+// 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");
+    }
+    return apiKey;
+};
+const getHuggingFaceModelId = () => {
+    return process.env.HUGGINGFACE_MODEL || "microsoft/DialoGPT-medium";
+};
+const hasValidAuth = () => {
+    return !!(process.env.HUGGINGFACE_API_KEY || process.env.HF_TOKEN);
+};
+// Lazy initialization cache
+let _hfClient = null;
+function getHuggingFaceClient() {
+    if (!_hfClient) {
+        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 || 500,
+                    return_full_text: false,
+                    do_sample: (options.temperature || 0.7) > 0,
+                },
+            });
+        });
+        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();
+            },
+        });
+        return {
+            stream,
+            rawCall: response.rawCall,
+            rawResponse: response.rawResponse,
+        };
+    }
+}
+// Hugging Face class with enhanced error handling
+export class HuggingFace {
+    modelName;
+    client;
+    /**
+     * Initializes a new instance of HuggingFace
+     * @param modelName - Optional model name to override the default from config
+     */
+    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);
+    }
+    /**
+     * 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;
+        try {
+            // Parse parameters - support both string and options object
+            const options = typeof optionsOrPrompt === "string"
+                ? { prompt: optionsOrPrompt }
+                : optionsOrPrompt;
+            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`, {
+                provider,
+                modelName: this.modelName,
+                promptLength: prompt.length,
+                temperature,
+                maxTokens,
+                hasSchema: !!finalSchema,
+            });
+            const model = this.getModel();
+            const streamOptions = {
+                model: model,
+                prompt: prompt,
+                system: systemPrompt,
+                temperature,
+                maxTokens,
+                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,
+                    });
+                },
+            };
+            if (finalSchema) {
+                streamOptions.experimental_output = Output.object({
+                    schema: finalSchema,
+                });
+            }
+            const result = streamText(streamOptions);
+            return result;
+        }
+        catch (err) {
+            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
+        }
+    }
+    /**
+     * 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
+     */
+    async generateText(optionsOrPrompt, analysisSchema) {
+        const functionTag = "HuggingFace.generateText";
+        const provider = "huggingface";
+        try {
+            // Parse parameters - support both string and options object
+            const options = typeof optionsOrPrompt === "string"
+                ? { prompt: optionsOrPrompt }
+                : optionsOrPrompt;
+            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`, {
+                provider,
+                modelName: this.modelName,
+                promptLength: prompt.length,
+                temperature,
+                maxTokens,
+            });
+            const model = this.getModel();
+            const generateOptions = {
+                model: model,
+                prompt: prompt,
+                system: systemPrompt,
+                temperature,
+                maxTokens,
+            };
+            if (finalSchema) {
+                generateOptions.experimental_output = Output.object({
+                    schema: finalSchema,
+                });
+            }
+            const result = await generateText(generateOptions);
+            logger.debug(`[${functionTag}] Generate text completed`, {
+                provider,
+                modelName: this.modelName,
+                usage: result.usage,
+                finishReason: result.finishReason,
+                responseLength: result.text?.length || 0,
+            });
+            return result;
+        }
+        catch (err) {
+            logger.error(`[${functionTag}] Exception`, {
+                provider,
+                modelName: this.modelName,
+                message: "Error in generating text",
+                err: String(err),
+            });
+            throw err; // Re-throw error to trigger fallback
+        }
+    }
+}

package/dist/lib/providers/index.d.ts

@@ -2,13 +2,16 @@
  * 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 type { AIProvider } from '../core/types.js';
+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 type { AIProvider } from "../core/types.js";
 /**
  * Provider registry for dynamic provider instantiation
  */
@@ -18,7 +21,10 @@ export declare const PROVIDERS: {
     readonly openai: "OpenAI";
     readonly anthropic: "AnthropicProvider";
     readonly azure: "AzureOpenAIProvider";
-    readonly 'google-ai': "GoogleAIStudio";
+    readonly "google-ai": "GoogleAIStudio";
+    readonly huggingface: "HuggingFace";
+    readonly ollama: "Ollama";
+    readonly mistral: "MistralAI";
 };
 /**
  * Type for valid provider names

package/dist/lib/providers/index.js

@@ -2,22 +2,28 @@
  * 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 { 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";
 /**
  * Provider registry for dynamic provider instantiation
  */
 export const PROVIDERS = {
-    vertex: 'GoogleVertexAI',
-    bedrock: 'AmazonBedrock',
-    openai: 'OpenAI',
-    anthropic: 'AnthropicProvider',
-    azure: 'AzureOpenAIProvider',
-    'google-ai': 'GoogleAIStudio'
+    vertex: "GoogleVertexAI",
+    bedrock: "AmazonBedrock",
+    openai: "OpenAI",
+    anthropic: "AnthropicProvider",
+    azure: "AzureOpenAIProvider",
+    "google-ai": "GoogleAIStudio",
+    huggingface: "HuggingFace",
+    ollama: "Ollama",
+    mistral: "MistralAI",
 };
 /**
  * List of all available provider names

package/dist/lib/providers/mcp-provider.d.ts

@@ -0,0 +1,62 @@
+/**
+ * NeuroLink MCP-Aware AI Provider
+ * Integrates MCP tools with AI providers following Lighthouse's pattern
+ */
+import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
+import type { StreamTextResult, ToolSet, Schema, GenerateTextResult } from "ai";
+import type { ZodType, ZodTypeDef } from "zod";
+/**
+ * MCP-Aware Provider Configuration
+ */
+export interface MCPProviderConfig {
+    baseProvider: AIProvider;
+    providerName?: string;
+    modelName?: string;
+    enableMCP?: boolean;
+    sessionId?: string;
+    userId?: string;
+    organizationId?: string;
+}
+/**
+ * MCP-Aware AI Provider
+ * Wraps any AI provider with MCP tool capabilities
+ */
+export declare class MCPAwareProvider implements AIProvider {
+    private baseProvider;
+    private config;
+    private sessionId;
+    private mcpInitialized;
+    constructor(config: MCPProviderConfig);
+    /**
+     * Initialize MCP tools for this session
+     */
+    private initializeMCP;
+    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
+    /**
+     * Detect if the prompt is requesting tool usage
+     */
+    private detectToolRequest;
+    /**
+     * Get session statistics
+     */
+    getSessionStats(): {
+        sessionId: string;
+        toolCount: number;
+        executionCount: number;
+        isConnected: boolean;
+        uptime: number;
+    } | null;
+    /**
+     * Clean up session
+     */
+    cleanup(): Promise<void>;
+}
+/**
+ * Create an MCP-aware provider
+ */
+export declare function createMCPAwareProvider(baseProvider: AIProvider, config?: Partial<MCPProviderConfig>): MCPAwareProvider;
+/**
+ * Check if a provider is MCP-aware
+ */
+export declare function isMCPAwareProvider(provider: AIProvider): provider is MCPAwareProvider;

package/dist/lib/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;
+}