@juspay/neurolink 1.6.0 → 1.9.0

package/dist/providers/openAI.js

@@ -1,57 +1,65 @@
-import { openai } from '@ai-sdk/openai';
-import { streamText, generateText, Output } from 'ai';
-import { logger } from '../utils/logger.js';
+import { openai } from "@ai-sdk/openai";
+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 getOpenAIApiKey = () => {
     const apiKey = process.env.OPENAI_API_KEY;
     if (!apiKey) {
-        throw new Error('OPENAI_API_KEY environment variable is not set');
+        throw new Error("OPENAI_API_KEY environment variable is not set");
     }
     return apiKey;
 };
 const getOpenAIModel = () => {
-    return process.env.OPENAI_MODEL || 'gpt-4o';
+    return process.env.OPENAI_MODEL || "gpt-4o";
 };
 // OpenAI class with enhanced error handling
 export class OpenAI {
     modelName;
     model;
     constructor(modelName) {
-        const functionTag = 'OpenAI.constructor';
+        const functionTag = "OpenAI.constructor";
         this.modelName = modelName || getOpenAIModel();
         try {
-            logger.debug(`[${functionTag}] Function called`, { modelName: this.modelName });
+            logger.debug(`[${functionTag}] Function called`, {
+                modelName: this.modelName,
+            });
             // Set OpenAI API key as environment variable
             process.env.OPENAI_API_KEY = getOpenAIApiKey();
             this.model = openai(this.modelName);
             logger.debug(`[${functionTag}] Function result`, {
                 modelName: this.modelName,
-                success: true
+                success: true,
             });
         }
         catch (err) {
             logger.debug(`[${functionTag}] Exception`, {
-                message: 'Error in initializing OpenAI',
+                message: "Error in initializing OpenAI",
                 modelName: this.modelName,
-                err: String(err)
+                err: String(err),
             });
             throw err;
         }
     }
+    /**
+     * Get the underlying model for function calling
+     */
+    getModel() {
+        return this.model;
+    }
     async streamText(optionsOrPrompt, analysisSchema) {
-        const functionTag = 'OpenAI.streamText';
-        const provider = 'openai';
+        const functionTag = "OpenAI.streamText";
+        const provider = "openai";
         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 text started`, {
@@ -59,7 +67,7 @@ export class OpenAI {
                 modelName: this.modelName,
                 promptLength: prompt.length,
                 temperature,
-                maxTokens
+                maxTokens,
             });
             const streamOptions = {
                 model: this.model,
@@ -77,7 +85,7 @@ export class OpenAI {
                         error: errorMessage,
                         stack: errorStack,
                         promptLength: prompt.length,
-                        chunkCount
+                        chunkCount,
                     });
                 },
                 onFinish: (event) => {
@@ -88,7 +96,7 @@ export class OpenAI {
                         usage: event.usage,
                         totalChunks: chunkCount,
                         promptLength: prompt.length,
-                        responseLength: event.text?.length || 0
+                        responseLength: event.text?.length || 0,
                     });
                 },
                 onChunk: (event) => {
@@ -98,12 +106,14 @@ export class OpenAI {
                         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;
@@ -112,21 +122,21 @@ export class OpenAI {
             logger.debug(`[${functionTag}] Exception`, {
                 provider,
                 modelName: this.modelName,
-                message: 'Error in streaming text',
-                err: String(err)
+                message: "Error in streaming text",
+                err: String(err),
             });
             throw err; // Re-throw error to trigger fallback
         }
     }
     async generateText(optionsOrPrompt, analysisSchema) {
-        const functionTag = 'OpenAI.generateText';
-        const provider = 'openai';
+        const functionTag = "OpenAI.generateText";
+        const provider = "openai";
         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 text started`, {
@@ -134,17 +144,19 @@ export class OpenAI {
                 modelName: this.modelName,
                 promptLength: prompt.length,
                 temperature,
-                maxTokens
+                maxTokens,
             });
             const generateOptions = {
                 model: this.model,
                 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`, {
@@ -152,7 +164,7 @@ export class OpenAI {
                 modelName: this.modelName,
                 usage: result.usage,
                 finishReason: result.finishReason,
-                responseLength: result.text?.length || 0
+                responseLength: result.text?.length || 0,
             });
             return result;
         }
@@ -160,8 +172,8 @@ export class OpenAI {
             logger.debug(`[${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/utils/logger.js

@@ -5,7 +5,7 @@
  */
 export const logger = {
     debug: (...args) => {
-        if (process.env.NEUROLINK_DEBUG === 'true') {
+        if (process.env.NEUROLINK_DEBUG === "true") {
             console.log(...args);
         }
     },
@@ -21,5 +21,5 @@ export const logger = {
     },
     always: (...args) => {
         console.log(...args);
-    }
+    },
 };

package/dist/utils/providerUtils.js

@@ -1,7 +1,7 @@
 /**
  * Utility functions for AI provider management
  */
-import { logger } from './logger.js';
+import { logger } from "./logger.js";
 /**
  * Get the best available provider based on preferences and availability
  * @param requestedProvider - Optional preferred provider name
@@ -12,9 +12,19 @@ export function getBestProvider(requestedProvider) {
     if (requestedProvider) {
         return requestedProvider;
     }
-    // Default fallback order based on environment variables - OpenAI first since it's most reliable
+    // Default fallback order - Google AI (Gemini) first as primary provider
     // Ollama last since it requires local setup
-    const providers = ['openai', 'anthropic', 'google-ai', 'mistral', 'vertex', 'azure', 'huggingface', 'bedrock', 'ollama'];
+    const providers = [
+        "google-ai",
+        "anthropic",
+        "openai",
+        "mistral",
+        "vertex",
+        "azure",
+        "huggingface",
+        "bedrock",
+        "ollama",
+    ];
     // Check which providers have their required environment variables
     for (const provider of providers) {
         if (isProviderConfigured(provider)) {
@@ -23,8 +33,8 @@ export function getBestProvider(requestedProvider) {
         }
     }
     // Default to bedrock if nothing is configured
-    logger.warn('[getBestProvider] No providers configured, defaulting to bedrock');
-    return 'bedrock';
+    logger.warn("[getBestProvider] No providers configured, defaulting to bedrock");
+    return "bedrock";
 }
 /**
  * Check if a provider has the minimum required configuration
@@ -33,39 +43,41 @@ export function getBestProvider(requestedProvider) {
  */
 function isProviderConfigured(provider) {
     switch (provider.toLowerCase()) {
-        case 'bedrock':
-        case 'amazon':
-        case 'aws':
+        case "bedrock":
+        case "amazon":
+        case "aws":
             return !!(process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY);
-        case 'vertex':
-        case 'google':
-        case 'gemini':
-            return !!(process.env.GOOGLE_VERTEX_PROJECT || process.env.GOOGLE_APPLICATION_CREDENTIALS);
-        case 'openai':
-        case 'gpt':
+        case "vertex":
+        case "google":
+        case "gemini":
+            return !!(process.env.GOOGLE_VERTEX_PROJECT ||
+                process.env.GOOGLE_APPLICATION_CREDENTIALS);
+        case "openai":
+        case "gpt":
             return !!process.env.OPENAI_API_KEY;
-        case 'anthropic':
-        case 'claude':
+        case "anthropic":
+        case "claude":
             return !!process.env.ANTHROPIC_API_KEY;
-        case 'azure':
-        case 'azure-openai':
+        case "azure":
+        case "azure-openai":
             return !!process.env.AZURE_OPENAI_API_KEY;
-        case 'google-ai':
-        case 'google-studio':
-            return !!(process.env.GOOGLE_AI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY);
-        case 'huggingface':
-        case 'hugging-face':
-        case 'hf':
+        case "google-ai":
+        case "google-studio":
+            return !!(process.env.GOOGLE_AI_API_KEY ||
+                process.env.GOOGLE_GENERATIVE_AI_API_KEY);
+        case "huggingface":
+        case "hugging-face":
+        case "hf":
             return !!(process.env.HUGGINGFACE_API_KEY || process.env.HF_TOKEN);
-        case 'ollama':
-        case 'local':
-        case 'local-ollama':
+        case "ollama":
+        case "local":
+        case "local-ollama":
             // For Ollama, we check if the service is potentially available
             // This is a basic check - actual connectivity will be verified during usage
             return true; // Ollama doesn't require environment variables, just local service
-        case 'mistral':
-        case 'mistral-ai':
-        case 'mistralai':
+        case "mistral":
+        case "mistral-ai":
+        case "mistralai":
             return !!process.env.MISTRAL_API_KEY;
         default:
             return false;
@@ -76,7 +88,17 @@ function isProviderConfigured(provider) {
  * @returns Array of available provider names
  */
 export function getAvailableProviders() {
-    return ['bedrock', 'vertex', 'openai', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama', 'mistral'];
+    return [
+        "bedrock",
+        "vertex",
+        "openai",
+        "anthropic",
+        "azure",
+        "google-ai",
+        "huggingface",
+        "ollama",
+        "mistral",
+    ];
 }
 /**
  * Validate provider name