@juspay/neurolink 1.6.0 → 1.9.0

package/dist/providers/azureOpenAI.js

@@ -4,8 +4,8 @@
  * Enterprise-grade OpenAI integration through Microsoft Azure.
  * Supports all OpenAI models with enhanced security and compliance.
  */
-import { AIProviderName } from '../core/types.js';
-import { logger } from '../utils/logger.js';
+import { AIProviderName } from "../core/types.js";
+import { logger } from "../utils/logger.js";
 export class AzureOpenAIProvider {
     name = AIProviderName.AZURE;
     apiKey;
@@ -16,27 +16,28 @@ export class AzureOpenAIProvider {
         this.apiKey = this.getApiKey();
         this.endpoint = this.getEndpoint();
         this.deploymentId = this.getDeploymentId();
-        this.apiVersion = process.env.AZURE_OPENAI_API_VERSION || '2024-02-15-preview';
+        this.apiVersion =
+            process.env.AZURE_OPENAI_API_VERSION || "2024-02-15-preview";
         logger.debug(`[AzureOpenAIProvider] Initialized with endpoint: ${this.endpoint}, deployment: ${this.deploymentId}`);
     }
     getApiKey() {
         const apiKey = process.env.AZURE_OPENAI_API_KEY;
         if (!apiKey) {
-            throw new Error('AZURE_OPENAI_API_KEY environment variable is required');
+            throw new Error("AZURE_OPENAI_API_KEY environment variable is required");
         }
         return apiKey;
     }
     getEndpoint() {
         const endpoint = process.env.AZURE_OPENAI_ENDPOINT;
         if (!endpoint) {
-            throw new Error('AZURE_OPENAI_ENDPOINT environment variable is required');
+            throw new Error("AZURE_OPENAI_ENDPOINT environment variable is required");
         }
-        return endpoint.replace(/\/$/, ''); // Remove trailing slash
+        return endpoint.replace(/\/$/, ""); // Remove trailing slash
     }
     getDeploymentId() {
         const deploymentId = process.env.AZURE_OPENAI_DEPLOYMENT_ID;
         if (!deploymentId) {
-            throw new Error('AZURE_OPENAI_DEPLOYMENT_ID environment variable is required');
+            throw new Error("AZURE_OPENAI_DEPLOYMENT_ID environment variable is required");
         }
         return deploymentId;
     }
@@ -46,15 +47,15 @@ export class AzureOpenAIProvider {
     async makeRequest(body, stream = false) {
         const url = this.getApiUrl(stream);
         const headers = {
-            'Content-Type': 'application/json',
-            'api-key': this.apiKey
+            "Content-Type": "application/json",
+            "api-key": this.apiKey,
         };
-        logger.debug(`[AzureOpenAIProvider.makeRequest] ${stream ? 'Streaming' : 'Non-streaming'} request to deployment: ${this.deploymentId}`);
-        logger.debug(`[AzureOpenAIProvider.makeRequest] Max tokens: ${body.max_tokens || 'default'}, Temperature: ${body.temperature || 'default'}`);
+        logger.debug(`[AzureOpenAIProvider.makeRequest] ${stream ? "Streaming" : "Non-streaming"} request to deployment: ${this.deploymentId}`);
+        logger.debug(`[AzureOpenAIProvider.makeRequest] Max tokens: ${body.max_tokens || "default"}, Temperature: ${body.temperature || "default"}`);
         const response = await fetch(url, {
-            method: 'POST',
+            method: "POST",
             headers,
-            body: JSON.stringify(body)
+            body: JSON.stringify(body),
         });
         if (!response.ok) {
             const errorText = await response.text();
@@ -64,34 +65,34 @@ export class AzureOpenAIProvider {
         return response;
     }
     async generateText(optionsOrPrompt, schema) {
-        logger.debug('[AzureOpenAIProvider.generateText] Starting text generation');
+        logger.debug("[AzureOpenAIProvider.generateText] Starting text generation");
         // Parse parameters with backward compatibility
-        const options = typeof optionsOrPrompt === 'string'
+        const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = 'You are a helpful AI assistant.' } = options;
+        const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = "You are a helpful AI assistant.", } = options;
         logger.debug(`[AzureOpenAIProvider.generateText] Prompt: "${prompt.substring(0, 100)}...", Temperature: ${temperature}, Max tokens: ${maxTokens}`);
         const messages = [];
         if (systemPrompt) {
             messages.push({
-                role: 'system',
-                content: systemPrompt
+                role: "system",
+                content: systemPrompt,
             });
         }
         messages.push({
-            role: 'user',
-            content: prompt
+            role: "user",
+            content: prompt,
         });
         const requestBody = {
             messages,
             temperature,
-            max_tokens: maxTokens
+            max_tokens: maxTokens,
         };
         try {
             const response = await this.makeRequest(requestBody);
             const data = await response.json();
             logger.debug(`[AzureOpenAIProvider.generateText] Success. Generated ${data.usage.completion_tokens} tokens`);
-            const content = data.choices[0]?.message?.content || '';
+            const content = data.choices[0]?.message?.content || "";
             return {
                 content,
                 provider: this.name,
@@ -99,78 +100,81 @@ export class AzureOpenAIProvider {
                 usage: {
                     promptTokens: data.usage.prompt_tokens,
                     completionTokens: data.usage.completion_tokens,
-                    totalTokens: data.usage.total_tokens
+                    totalTokens: data.usage.total_tokens,
                 },
-                finishReason: data.choices[0]?.finish_reason || 'stop'
+                finishReason: data.choices[0]?.finish_reason || "stop",
             };
         }
         catch (error) {
-            logger.error('[AzureOpenAIProvider.generateText] Error:', error);
+            logger.error("[AzureOpenAIProvider.generateText] Error:", error);
             throw error;
         }
     }
     async streamText(optionsOrPrompt, schema) {
-        logger.debug('[AzureOpenAIProvider.streamText] Starting text streaming');
+        logger.debug("[AzureOpenAIProvider.streamText] Starting text streaming");
         // Parse parameters with backward compatibility
-        const options = typeof optionsOrPrompt === 'string'
+        const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = 'You are a helpful AI assistant.' } = options;
+        const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = "You are a helpful AI assistant.", } = options;
         logger.debug(`[AzureOpenAIProvider.streamText] Streaming prompt: "${prompt.substring(0, 100)}..."`);
         const messages = [];
         if (systemPrompt) {
             messages.push({
-                role: 'system',
-                content: systemPrompt
+                role: "system",
+                content: systemPrompt,
             });
         }
         messages.push({
-            role: 'user',
-            content: prompt
+            role: "user",
+            content: prompt,
         });
         const requestBody = {
             messages,
             temperature,
             max_tokens: maxTokens,
-            stream: true
+            stream: true,
         };
         try {
             const response = await this.makeRequest(requestBody, true);
             if (!response.body) {
-                throw new Error('No response body received');
+                throw new Error("No response body received");
             }
             // Return a StreamTextResult-like object
             return {
                 textStream: this.createAsyncIterable(response.body),
-                text: '',
+                text: "",
                 usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-                finishReason: 'stop'
+                finishReason: "stop",
             };
         }
         catch (error) {
-            logger.error('[AzureOpenAIProvider.streamText] Error:', error);
+            logger.error("[AzureOpenAIProvider.streamText] Error:", error);
             throw error;
         }
     }
     async *createAsyncIterable(body) {
         const reader = body.getReader();
         const decoder = new TextDecoder();
-        let buffer = '';
+        let buffer = "";
         try {
             while (true) {
                 const { done, value } = await reader.read();
-                if (done)
+                if (done) {
                     break;
+                }
                 buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split('\n');
-                buffer = lines.pop() || '';
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
                 for (const line of lines) {
-                    if (line.trim() === '')
+                    if (line.trim() === "") {
                         continue;
-                    if (line.startsWith('data: ')) {
+                    }
+                    if (line.startsWith("data: ")) {
                         const data = line.slice(6);
-                        if (data.trim() === '[DONE]')
+                        if (data.trim() === "[DONE]") {
                             continue;
+                        }
                         try {
                             const chunk = JSON.parse(data);
                             // Extract text content from chunk
@@ -179,7 +183,7 @@ export class AzureOpenAIProvider {
                             }
                         }
                         catch (parseError) {
-                            logger.warn('[AzureOpenAIProvider.createAsyncIterable] Failed to parse chunk:', parseError);
+                            logger.warn("[AzureOpenAIProvider.createAsyncIterable] Failed to parse chunk:", parseError);
                             continue;
                         }
                     }
@@ -191,53 +195,56 @@ export class AzureOpenAIProvider {
         }
     }
     async *generateTextStream(optionsOrPrompt) {
-        logger.debug('[AzureOpenAIProvider.generateTextStream] Starting text streaming');
+        logger.debug("[AzureOpenAIProvider.generateTextStream] Starting text streaming");
         // Parse parameters with backward compatibility
-        const options = typeof optionsOrPrompt === 'string'
+        const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = 'You are a helpful AI assistant.' } = options;
+        const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = "You are a helpful AI assistant.", } = options;
         logger.debug(`[AzureOpenAIProvider.generateTextStream] Streaming prompt: "${prompt.substring(0, 100)}..."`);
         const messages = [];
         if (systemPrompt) {
             messages.push({
-                role: 'system',
-                content: systemPrompt
+                role: "system",
+                content: systemPrompt,
             });
         }
         messages.push({
-            role: 'user',
-            content: prompt
+            role: "user",
+            content: prompt,
         });
         const requestBody = {
             messages,
             temperature,
             max_tokens: maxTokens,
-            stream: true
+            stream: true,
         };
         try {
             const response = await this.makeRequest(requestBody, true);
             if (!response.body) {
-                throw new Error('No response body received');
+                throw new Error("No response body received");
             }
             const reader = response.body.getReader();
             const decoder = new TextDecoder();
-            let buffer = '';
+            let buffer = "";
             try {
                 while (true) {
                     const { done, value } = await reader.read();
-                    if (done)
+                    if (done) {
                         break;
+                    }
                     buffer += decoder.decode(value, { stream: true });
-                    const lines = buffer.split('\n');
-                    buffer = lines.pop() || '';
+                    const lines = buffer.split("\n");
+                    buffer = lines.pop() || "";
                     for (const line of lines) {
-                        if (line.trim() === '')
+                        if (line.trim() === "") {
                             continue;
-                        if (line.startsWith('data: ')) {
+                        }
+                        if (line.startsWith("data: ")) {
                             const data = line.slice(6);
-                            if (data.trim() === '[DONE]')
+                            if (data.trim() === "[DONE]") {
                                 continue;
+                            }
                             try {
                                 const chunk = JSON.parse(data);
                                 // Extract text content from chunk
@@ -245,12 +252,12 @@ export class AzureOpenAIProvider {
                                     yield {
                                         content: chunk.choices[0].delta.content,
                                         provider: this.name,
-                                        model: chunk.model || this.deploymentId
+                                        model: chunk.model || this.deploymentId,
                                     };
                                 }
                             }
                             catch (parseError) {
-                                logger.warn('[AzureOpenAIProvider.generateTextStream] Failed to parse chunk:', parseError);
+                                logger.warn("[AzureOpenAIProvider.generateTextStream] Failed to parse chunk:", parseError);
                                 continue;
                             }
                         }
@@ -260,26 +267,26 @@ export class AzureOpenAIProvider {
             finally {
                 reader.releaseLock();
             }
-            logger.debug('[AzureOpenAIProvider.generateTextStream] Streaming completed');
+            logger.debug("[AzureOpenAIProvider.generateTextStream] Streaming completed");
         }
         catch (error) {
-            logger.error('[AzureOpenAIProvider.generateTextStream] Error:', error);
+            logger.error("[AzureOpenAIProvider.generateTextStream] Error:", error);
             throw error;
         }
     }
     async testConnection() {
-        logger.debug('[AzureOpenAIProvider.testConnection] Testing connection to Azure OpenAI');
+        logger.debug("[AzureOpenAIProvider.testConnection] Testing connection to Azure OpenAI");
         const startTime = Date.now();
         try {
             await this.generateText({
-                prompt: 'Hello',
-                maxTokens: 5
+                prompt: "Hello",
+                maxTokens: 5,
             });
             const responseTime = Date.now() - startTime;
             logger.debug(`[AzureOpenAIProvider.testConnection] Connection test successful (${responseTime}ms)`);
             return {
                 success: true,
-                responseTime
+                responseTime,
             };
         }
         catch (error) {
@@ -287,8 +294,8 @@ export class AzureOpenAIProvider {
             logger.error(`[AzureOpenAIProvider.testConnection] Connection test failed (${responseTime}ms):`, error);
             return {
                 success: false,
-                error: error instanceof Error ? error.message : 'Unknown error',
-                responseTime
+                error: error instanceof Error ? error.message : "Unknown error",
+                responseTime,
             };
         }
     }
@@ -304,18 +311,22 @@ export class AzureOpenAIProvider {
         }
     }
     getRequiredConfig() {
-        return ['AZURE_OPENAI_API_KEY', 'AZURE_OPENAI_ENDPOINT', 'AZURE_OPENAI_DEPLOYMENT_ID'];
+        return [
+            "AZURE_OPENAI_API_KEY",
+            "AZURE_OPENAI_ENDPOINT",
+            "AZURE_OPENAI_DEPLOYMENT_ID",
+        ];
     }
     getOptionalConfig() {
-        return ['AZURE_OPENAI_API_VERSION'];
+        return ["AZURE_OPENAI_API_VERSION"];
     }
     getModels() {
         return [
-            'gpt-4',
-            'gpt-4-turbo',
-            'gpt-4-32k',
-            'gpt-35-turbo',
-            'gpt-35-turbo-16k'
+            "gpt-4",
+            "gpt-4-turbo",
+            "gpt-4-32k",
+            "gpt-35-turbo",
+            "gpt-35-turbo-16k",
         ];
     }
     supportsStreaming() {
@@ -326,14 +337,14 @@ export class AzureOpenAIProvider {
     }
     getCapabilities() {
         return [
-            'text-generation',
-            'streaming',
-            'conversation',
-            'system-prompts',
-            'json-mode',
-            'function-calling',
-            'enterprise-security',
-            'content-filtering'
+            "text-generation",
+            "streaming",
+            "conversation",
+            "system-prompts",
+            "json-mode",
+            "function-calling",
+            "enterprise-security",
+            "content-filtering",
         ];
     }
 }

package/dist/providers/function-calling-provider.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Enhanced AI Provider with Real Function Calling Support
+ * Integrates MCP tools directly with AI SDK's function calling capabilities
+ * This is the missing piece that enables true AI function calling!
+ */
+import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
+import { type GenerateTextResult, type StreamTextResult, type ToolSet, type Schema } from "ai";
+import type { ZodType, ZodTypeDef } from "zod";
+/**
+ * Enhanced provider that enables real function calling with MCP tools
+ */
+export declare class FunctionCallingProvider implements AIProvider {
+    private baseProvider;
+    private enableFunctionCalling;
+    private sessionId;
+    private userId;
+    constructor(baseProvider: AIProvider, options?: {
+        enableFunctionCalling?: boolean;
+        sessionId?: string;
+        userId?: string;
+    });
+    /**
+     * Generate text with real function calling support
+     */
+    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+    /**
+     * Generate text using AI SDK's native function calling
+     */
+    private generateTextWithTools;
+    /**
+     * Get the model from the base provider
+     * This is a temporary solution - ideally we'd have a getModel() method on AIProvider
+     */
+    private getModelFromProvider;
+    /**
+     * Sanitize tool name to comply with AI provider requirements
+     */
+    private sanitizeToolName;
+    /**
+     * Convert our tools to AI SDK format with proper execution
+     */
+    private convertToAISDKTools;
+    /**
+     * Create function-aware system prompt
+     */
+    private createFunctionAwareSystemPrompt;
+    /**
+     * Stream text with function calling support
+     */
+    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
+}
+/**
+ * Create a function-calling enhanced version of any AI provider
+ */
+export declare function createFunctionCallingProvider(baseProvider: AIProvider, options?: {
+    enableFunctionCalling?: boolean;
+    sessionId?: string;
+    userId?: string;
+}): AIProvider;
+/**
+ * Enhanced MCP Provider Factory that creates function-calling enabled providers
+ */
+export declare function createMCPAwareProviderV3(baseProvider: AIProvider, options?: {
+    providerName?: string;
+    modelName?: string;
+    enableMCP?: boolean;
+    enableFunctionCalling?: boolean;
+    sessionId?: string;
+    userId?: string;
+}): AIProvider;