@juspay/neurolink 1.6.0 → 1.9.0

package/dist/providers/huggingFace.js

@@ -1,20 +1,20 @@
-import { HfInference } from '@huggingface/inference';
-import { streamText, generateText, Output } from 'ai';
-import { logger } from '../utils/logger.js';
+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.'
+    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');
+        throw new Error("HUGGINGFACE_API_KEY environment variable is not set");
     }
     return apiKey;
 };
 const getHuggingFaceModelId = () => {
-    return process.env.HUGGINGFACE_MODEL || 'microsoft/DialoGPT-medium';
+    return process.env.HUGGINGFACE_MODEL || "microsoft/DialoGPT-medium";
 };
 const hasValidAuth = () => {
     return !!(process.env.HUGGINGFACE_API_KEY || process.env.HF_TOKEN);
@@ -33,7 +33,7 @@ const RETRY_CONFIG = {
     maxRetries: 3,
     baseDelay: 2000, // 2 seconds
     maxDelay: 30000, // 30 seconds
-    backoffMultiplier: 2
+    backoffMultiplier: 2,
 };
 // Helper function for exponential backoff retry
 async function retryWithBackoff(operation, retryConfig = RETRY_CONFIG) {
@@ -45,16 +45,17 @@ async function retryWithBackoff(operation, retryConfig = RETRY_CONFIG) {
         catch (error) {
             lastError = error;
             // Check if it's a model loading error (503 status)
-            if (error instanceof Error && error.message.includes('503')) {
+            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...', {
+                    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
+                        error: error.message,
                     });
-                    await new Promise(resolve => setTimeout(resolve, delay));
+                    await new Promise((resolve) => setTimeout(resolve, delay));
                     continue;
                 }
             }
@@ -66,12 +67,12 @@ async function retryWithBackoff(operation, retryConfig = RETRY_CONFIG) {
 }
 // Custom LanguageModelV1 implementation for Hugging Face
 class HuggingFaceLanguageModel {
-    specificationVersion = 'v1';
-    provider = 'huggingface';
+    specificationVersion = "v1";
+    provider = "huggingface";
     modelId;
     maxTokens;
     supportsStreaming = true;
-    defaultObjectGenerationMode = 'json';
+    defaultObjectGenerationMode = "json";
     client;
     constructor(modelId, client) {
         this.modelId = modelId;
@@ -82,20 +83,20 @@ class HuggingFaceLanguageModel {
     }
     convertMessagesToPrompt(messages) {
         return messages
-            .map(msg => {
-            if (typeof msg.content === 'string') {
+            .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')
+                    .filter((part) => part.type === "text")
                     .map((part) => part.text)
-                    .join(' ')}`;
+                    .join(" ")}`;
             }
-            return '';
+            return "";
         })
-            .join('\n');
+            .join("\n");
     }
     async doGenerate(options) {
         const prompt = this.convertMessagesToPrompt(options.prompt);
@@ -107,11 +108,11 @@ class HuggingFaceLanguageModel {
                     temperature: options.temperature || 0.7,
                     max_new_tokens: options.maxTokens || 500,
                     return_full_text: false,
-                    do_sample: (options.temperature || 0.7) > 0
-                }
+                    do_sample: (options.temperature || 0.7) > 0,
+                },
             });
         });
-        const generatedText = response.generated_text || '';
+        const generatedText = response.generated_text || "";
         const promptTokens = this.estimateTokens(prompt);
         const completionTokens = this.estimateTokens(generatedText);
         return {
@@ -119,12 +120,12 @@ class HuggingFaceLanguageModel {
             usage: {
                 promptTokens,
                 completionTokens,
-                totalTokens: promptTokens + completionTokens
+                totalTokens: promptTokens + completionTokens,
             },
-            finishReason: 'stop',
+            finishReason: "stop",
             logprobs: undefined,
             rawCall: { rawPrompt: prompt, rawSettings: options },
-            rawResponse: { headers: {} }
+            rawResponse: { headers: {} },
         };
     }
     async doStream(options) {
@@ -135,15 +136,15 @@ class HuggingFaceLanguageModel {
         // Create a ReadableStream that chunks the response
         const stream = new ReadableStream({
             start(controller) {
-                const text = response.text || '';
+                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
+                            type: "text-delta",
+                            textDelta: chunk,
                         });
                         index += chunkSize;
                         // Add delay to simulate streaming
@@ -152,21 +153,21 @@ class HuggingFaceLanguageModel {
                     else {
                         // Send finish event
                         controller.enqueue({
-                            type: 'finish',
+                            type: "finish",
                             finishReason: response.finishReason,
                             usage: response.usage,
-                            logprobs: response.logprobs
+                            logprobs: response.logprobs,
                         });
                         controller.close();
                     }
                 };
                 pushChunk();
-            }
+            },
         });
         return {
             stream,
             rawCall: response.rawCall,
-            rawResponse: response.rawResponse
+            rawResponse: response.rawResponse,
         };
     }
 }
@@ -179,25 +180,25 @@ export class HuggingFace {
      * @param modelName - Optional model name to override the default from config
      */
     constructor(modelName) {
-        const functionTag = 'HuggingFace.constructor';
+        const functionTag = "HuggingFace.constructor";
         this.modelName = modelName || getHuggingFaceModelId();
         try {
             this.client = getHuggingFaceClient();
             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 Hugging Face',
+                message: "Error in initializing Hugging Face",
                 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;
         }
@@ -207,8 +208,8 @@ export class HuggingFace {
      * @private
      */
     getModel() {
-        logger.debug('HuggingFace.getModel - Hugging Face model selected', {
-            modelName: this.modelName
+        logger.debug("HuggingFace.getModel - Hugging Face model selected", {
+            modelName: this.modelName,
         });
         return new HuggingFaceLanguageModel(this.modelName, this.client);
     }
@@ -219,15 +220,15 @@ export class HuggingFace {
      * @returns Promise resolving to StreamTextResult or null if operation fails
      */
     async streamText(optionsOrPrompt, analysisSchema) {
-        const functionTag = 'HuggingFace.streamText';
-        const provider = 'huggingface';
+        const functionTag = "HuggingFace.streamText";
+        const provider = "huggingface";
         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`, {
@@ -236,7 +237,7 @@ export class HuggingFace {
                 promptLength: prompt.length,
                 temperature,
                 maxTokens,
-                hasSchema: !!finalSchema
+                hasSchema: !!finalSchema,
             });
             const model = this.getModel();
             const streamOptions = {
@@ -255,7 +256,7 @@ export class HuggingFace {
                         error: errorMessage,
                         stack: errorStack,
                         promptLength: prompt.length,
-                        chunkCount
+                        chunkCount,
                     });
                 },
                 onFinish: (event) => {
@@ -266,7 +267,7 @@ export class HuggingFace {
                         usage: event.usage,
                         totalChunks: chunkCount,
                         promptLength: prompt.length,
-                        responseLength: event.text?.length || 0
+                        responseLength: event.text?.length || 0,
                     });
                 },
                 onChunk: (event) => {
@@ -276,12 +277,14 @@ export class HuggingFace {
                         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;
@@ -290,9 +293,11 @@ export class HuggingFace {
             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
         }
@@ -304,14 +309,14 @@ export class HuggingFace {
      * @returns Promise resolving to GenerateTextResult or null if operation fails
      */
     async generateText(optionsOrPrompt, analysisSchema) {
-        const functionTag = 'HuggingFace.generateText';
-        const provider = 'huggingface';
+        const functionTag = "HuggingFace.generateText";
+        const provider = "huggingface";
         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`, {
@@ -319,7 +324,7 @@ export class HuggingFace {
                 modelName: this.modelName,
                 promptLength: prompt.length,
                 temperature,
-                maxTokens
+                maxTokens,
             });
             const model = this.getModel();
             const generateOptions = {
@@ -327,10 +332,12 @@ export class HuggingFace {
                 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`, {
@@ -338,7 +345,7 @@ export class HuggingFace {
                 modelName: this.modelName,
                 usage: result.usage,
                 finishReason: result.finishReason,
-                responseLength: result.text?.length || 0
+                responseLength: result.text?.length || 0,
             });
             return result;
         }
@@ -346,8 +353,8 @@ export class HuggingFace {
             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/index.d.ts

@@ -2,16 +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 { HuggingFace } from './huggingFace.js';
-export { Ollama } from './ollama.js';
-export { MistralAI } from './mistralAI.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
  */
@@ -21,7 +21,7 @@ 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";

package/dist/providers/index.js

@@ -2,28 +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 { HuggingFace } from './huggingFace.js';
-export { Ollama } from './ollama.js';
-export { MistralAI } from './mistralAI.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',
-    huggingface: 'HuggingFace',
-    ollama: 'Ollama',
-    mistral: 'MistralAI'
+    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/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;