@juspay/neurolink 1.5.3 → 1.9.0

package/dist/providers/googleVertexAI.js

@@ -1,4 +1,4 @@
-import { createVertex } from '@ai-sdk/google-vertex';
+import { createVertex, } from "@ai-sdk/google-vertex";
 // Cache for anthropic module to avoid repeated imports
 let _createVertexAnthropic = null;
 let _anthropicImportAttempted = false;
@@ -10,33 +10,33 @@ async function getCreateVertexAnthropic() {
     _anthropicImportAttempted = true;
     try {
         // Try to import the anthropic module - available in @ai-sdk/google-vertex ^2.2.0+
-        const anthropicModule = await import('@ai-sdk/google-vertex/anthropic');
+        const anthropicModule = await import("@ai-sdk/google-vertex/anthropic");
         _createVertexAnthropic = anthropicModule.createVertexAnthropic;
-        logger.debug('[GoogleVertexAI] Anthropic module successfully loaded');
+        logger.debug("[GoogleVertexAI] Anthropic module successfully loaded");
         return _createVertexAnthropic;
     }
     catch (error) {
         // Anthropic module not available
-        logger.warn('[GoogleVertexAI] Anthropic module not available. Install @ai-sdk/google-vertex ^2.2.0 for Anthropic model support.');
+        logger.warn("[GoogleVertexAI] Anthropic module not available. Install @ai-sdk/google-vertex ^2.2.0 for Anthropic model support.");
         return null;
     }
 }
-import { streamText, generateText, Output } from 'ai';
-import { logger } from '../utils/logger.js';
+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 getGCPVertexBreezeProjectId = () => {
     const projectId = process.env.GOOGLE_VERTEX_PROJECT;
     if (!projectId) {
-        throw new Error('GOOGLE_VERTEX_PROJECT environment variable is not set');
+        throw new Error("GOOGLE_VERTEX_PROJECT environment variable is not set");
     }
     return projectId;
 };
 const getGCPVertexBreezeLocation = () => {
-    return process.env.GOOGLE_VERTEX_LOCATION || 'us-east5';
+    return process.env.GOOGLE_VERTEX_LOCATION || "us-east5";
 };
 const getGoogleApplicationCredentials = () => {
     return process.env.GOOGLE_APPLICATION_CREDENTIALS;
@@ -51,7 +51,7 @@ const getGooglePrivateKey = () => {
     return process.env.GOOGLE_AUTH_PRIVATE_KEY;
 };
 const getVertexModelId = () => {
-    return process.env.VERTEX_MODEL_ID || 'claude-sonnet-4@20250514';
+    return process.env.VERTEX_MODEL_ID || "claude-sonnet-4@20250514";
 };
 const hasPrincipalAccountAuth = () => {
     return !!getGoogleApplicationCredentials();
@@ -63,126 +63,132 @@ const hasServiceAccountEnvAuth = () => {
     return !!(getGoogleClientEmail() && getGooglePrivateKey());
 };
 const hasValidAuth = () => {
-    return hasPrincipalAccountAuth() || hasServiceAccountKeyAuth() || hasServiceAccountEnvAuth();
+    return (hasPrincipalAccountAuth() ||
+        hasServiceAccountKeyAuth() ||
+        hasServiceAccountEnvAuth());
 };
 // Setup environment for Google authentication
 const setupGoogleAuth = async () => {
-    const functionTag = 'setupGoogleAuth';
+    const functionTag = "setupGoogleAuth";
     // Method 2: Service Account Key (JSON string) - Create temporary file
     if (hasServiceAccountKeyAuth() && !hasPrincipalAccountAuth()) {
         const serviceAccountKey = getGoogleServiceAccountKey();
         logger.debug(`[${functionTag}] Service account key auth (JSON string)`, {
             hasServiceAccountKey: !!serviceAccountKey,
-            authMethod: 'service_account_key'
+            authMethod: "service_account_key",
         });
         try {
             // Parse to validate JSON
             JSON.parse(serviceAccountKey);
             // Write to temporary file and set environment variable using dynamic imports
-            const { writeFileSync } = await import('fs');
-            const { join } = await import('path');
-            const { tmpdir } = await import('os');
+            const { writeFileSync } = await import("fs");
+            const { join } = await import("path");
+            const { tmpdir } = await import("os");
             const tempFile = join(tmpdir(), `gcp-credentials-${Date.now()}.json`);
             writeFileSync(tempFile, serviceAccountKey);
             process.env.GOOGLE_APPLICATION_CREDENTIALS = tempFile;
             logger.debug(`[${functionTag}] Created temporary credentials file`, {
-                tempFile: '[CREATED]',
-                authMethod: 'service_account_key_temp_file'
+                tempFile: "[CREATED]",
+                authMethod: "service_account_key_temp_file",
             });
         }
         catch (error) {
             logger.error(`[${functionTag}] Failed to parse service account key`, {
-                error: error instanceof Error ? error.message : String(error)
+                error: error instanceof Error ? error.message : String(error),
             });
-            throw new Error('Invalid GOOGLE_SERVICE_ACCOUNT_KEY format. Must be valid JSON.');
+            throw new Error("Invalid GOOGLE_SERVICE_ACCOUNT_KEY format. Must be valid JSON.");
         }
     }
     // Method 3: Service Account Environment Variables - Set as individual env vars
-    if (hasServiceAccountEnvAuth() && !hasPrincipalAccountAuth() && !hasServiceAccountKeyAuth()) {
+    if (hasServiceAccountEnvAuth() &&
+        !hasPrincipalAccountAuth() &&
+        !hasServiceAccountKeyAuth()) {
         const clientEmail = getGoogleClientEmail();
         const privateKey = getGooglePrivateKey();
         logger.debug(`[${functionTag}] Service account env auth (separate variables)`, {
             hasClientEmail: !!clientEmail,
             hasPrivateKey: !!privateKey,
-            authMethod: 'service_account_env'
+            authMethod: "service_account_env",
         });
         // Create service account object and write to temporary file
         const serviceAccount = {
-            type: 'service_account',
+            type: "service_account",
             project_id: getGCPVertexBreezeProjectId(),
             client_email: clientEmail,
-            private_key: privateKey.replace(/\\n/g, '\n'),
-            auth_uri: 'https://accounts.google.com/o/oauth2/auth',
-            token_uri: 'https://oauth2.googleapis.com/token'
+            private_key: privateKey.replace(/\\n/g, "\n"),
+            auth_uri: "https://accounts.google.com/o/oauth2/auth",
+            token_uri: "https://oauth2.googleapis.com/token",
         };
         try {
             // Use dynamic imports for ESM compatibility
-            const { writeFileSync } = await import('fs');
-            const { join } = await import('path');
-            const { tmpdir } = await import('os');
+            const { writeFileSync } = await import("fs");
+            const { join } = await import("path");
+            const { tmpdir } = await import("os");
             const tempFile = join(tmpdir(), `gcp-credentials-env-${Date.now()}.json`);
             writeFileSync(tempFile, JSON.stringify(serviceAccount, null, 2));
             process.env.GOOGLE_APPLICATION_CREDENTIALS = tempFile;
             logger.debug(`[${functionTag}] Created temporary credentials file from env vars`, {
-                tempFile: '[CREATED]',
-                authMethod: 'service_account_env_temp_file'
+                tempFile: "[CREATED]",
+                authMethod: "service_account_env_temp_file",
             });
         }
         catch (error) {
             logger.error(`[${functionTag}] Failed to create service account file from env vars`, {
-                error: error instanceof Error ? error.message : String(error)
+                error: error instanceof Error ? error.message : String(error),
             });
-            throw new Error('Failed to create temporary service account file from environment variables.');
+            throw new Error("Failed to create temporary service account file from environment variables.");
         }
     }
 };
 // Vertex AI setup with multiple authentication support
 const createVertexSettings = async () => {
-    const functionTag = 'createVertexSettings';
+    const functionTag = "createVertexSettings";
     // Setup authentication first
     await setupGoogleAuth();
     const baseSettings = {
         project: getGCPVertexBreezeProjectId(),
-        location: getGCPVertexBreezeLocation()
+        location: getGCPVertexBreezeLocation(),
     };
     // Method 1: Principal Account Authentication (file path) - Recommended for production
     if (hasPrincipalAccountAuth()) {
         const credentialsPath = getGoogleApplicationCredentials();
         logger.debug(`[${functionTag}] Principal account auth (file path)`, {
-            credentialsPath: credentialsPath ? '[PROVIDED]' : '[NOT_PROVIDED]',
-            authMethod: 'principal_account_file'
+            credentialsPath: credentialsPath ? "[PROVIDED]" : "[NOT_PROVIDED]",
+            authMethod: "principal_account_file",
         });
         return baseSettings;
     }
     // Method 2 & 3: Other methods now set GOOGLE_APPLICATION_CREDENTIALS in setupGoogleAuth()
     if (hasServiceAccountKeyAuth() || hasServiceAccountEnvAuth()) {
         logger.debug(`[${functionTag}] Alternative auth method configured`, {
-            authMethod: hasServiceAccountKeyAuth() ? 'service_account_key' : 'service_account_env',
-            credentialsSet: !!process.env.GOOGLE_APPLICATION_CREDENTIALS
+            authMethod: hasServiceAccountKeyAuth()
+                ? "service_account_key"
+                : "service_account_env",
+            credentialsSet: !!process.env.GOOGLE_APPLICATION_CREDENTIALS,
         });
         return baseSettings;
     }
     // No valid authentication found
     logger.error(`[${functionTag}] No valid authentication method found`, {
-        authMethod: 'none',
+        authMethod: "none",
         hasPrincipalAccount: hasPrincipalAccountAuth(),
         hasServiceAccountKey: hasServiceAccountKeyAuth(),
         hasServiceAccountEnv: hasServiceAccountEnvAuth(),
         availableMethods: [
-            'GOOGLE_APPLICATION_CREDENTIALS (file path)',
-            'GOOGLE_SERVICE_ACCOUNT_KEY (JSON string)',
-            'GOOGLE_AUTH_CLIENT_EMAIL + GOOGLE_AUTH_PRIVATE_KEY (env vars)'
-        ]
+            "GOOGLE_APPLICATION_CREDENTIALS (file path)",
+            "GOOGLE_SERVICE_ACCOUNT_KEY (JSON string)",
+            "GOOGLE_AUTH_CLIENT_EMAIL + GOOGLE_AUTH_PRIVATE_KEY (env vars)",
+        ],
     });
-    throw new Error('No valid Google Vertex AI authentication found. Please provide one of:\n' +
-        '1. GOOGLE_APPLICATION_CREDENTIALS (path to service account file)\n' +
-        '2. GOOGLE_SERVICE_ACCOUNT_KEY (JSON string of service account)\n' +
-        '3. GOOGLE_AUTH_CLIENT_EMAIL + GOOGLE_AUTH_PRIVATE_KEY (environment variables)');
+    throw new Error("No valid Google Vertex AI authentication found. Please provide one of:\n" +
+        "1. GOOGLE_APPLICATION_CREDENTIALS (path to service account file)\n" +
+        "2. GOOGLE_SERVICE_ACCOUNT_KEY (JSON string of service account)\n" +
+        "3. GOOGLE_AUTH_CLIENT_EMAIL + GOOGLE_AUTH_PRIVATE_KEY (environment variables)");
 };
 // Helper function to determine if a model is an Anthropic model
 const isAnthropicModel = (modelName) => {
     // Anthropic models in Vertex AI contain "claude" anywhere in the model name
-    return modelName.toLowerCase().includes('claude');
+    return modelName.toLowerCase().includes("claude");
 };
 // Lazy initialization cache
 let _vertex = null;
@@ -201,45 +207,45 @@ export class GoogleVertexAI {
      * @param modelName - Optional model name to override the default from config
      */
     constructor(modelName) {
-        const functionTag = 'GoogleVertexAI.constructor';
+        const functionTag = "GoogleVertexAI.constructor";
         this.modelName = modelName || getVertexModelId();
         try {
             logger.debug(`[${functionTag}] Initialization started`, {
                 modelName: this.modelName,
-                isAnthropic: isAnthropicModel(this.modelName)
+                isAnthropic: isAnthropicModel(this.modelName),
             });
             const hasPrincipal = hasPrincipalAccountAuth();
             logger.debug(`[${functionTag}] Authentication validation`, {
                 hasPrincipalAccountAuth: hasPrincipal,
-                projectId: getGCPVertexBreezeProjectId() || 'MISSING',
-                location: getGCPVertexBreezeLocation() || 'MISSING'
+                projectId: getGCPVertexBreezeProjectId() || "MISSING",
+                location: getGCPVertexBreezeLocation() || "MISSING",
             });
             if (hasPrincipal) {
                 logger.debug(`[${functionTag}] Auth method selected`, {
-                    authMethod: 'principal_account',
-                    hasGoogleApplicationCredentials: !!getGoogleApplicationCredentials()
+                    authMethod: "principal_account",
+                    hasGoogleApplicationCredentials: !!getGoogleApplicationCredentials(),
                 });
             }
             else {
                 logger.warn(`[${functionTag}] Auth method missing`, {
-                    authMethod: 'none',
-                    hasPrincipalAccountAuth: hasPrincipal
+                    authMethod: "none",
+                    hasPrincipalAccountAuth: hasPrincipal,
                 });
             }
             logger.debug(`[${functionTag}] Initialization completed`, {
                 modelName: this.modelName,
                 isAnthropic: isAnthropicModel(this.modelName),
-                authMethod: hasPrincipalAccountAuth() ? 'principal_account' : 'none',
-                success: true
+                authMethod: hasPrincipalAccountAuth() ? "principal_account" : "none",
+                success: true,
             });
         }
         catch (err) {
             logger.error(`[${functionTag}] Initialization failed`, {
-                message: 'Error in initializing Google Vertex AI',
+                message: "Error in initializing Google Vertex AI",
                 modelName: this.modelName,
                 isAnthropic: isAnthropicModel(this.modelName),
                 error: err instanceof Error ? err.message : String(err),
-                stack: err instanceof Error ? err.stack : undefined
+                stack: err instanceof Error ? err.stack : undefined,
             });
         }
     }
@@ -249,13 +255,13 @@ export class GoogleVertexAI {
      */
     async getModel() {
         if (isAnthropicModel(this.modelName)) {
-            logger.debug('GoogleVertexAI.getModel - Anthropic model selected', {
-                modelName: this.modelName
+            logger.debug("GoogleVertexAI.getModel - Anthropic model selected", {
+                modelName: this.modelName,
             });
             const createVertexAnthropic = await getCreateVertexAnthropic();
             if (!createVertexAnthropic) {
                 throw new Error(`Anthropic model "${this.modelName}" requested but @ai-sdk/google-vertex/anthropic is not available. ` +
-                    'Please install @ai-sdk/google-vertex ^2.2.0 or use a Google model instead.');
+                    "Please install @ai-sdk/google-vertex ^2.2.0 or use a Google model instead.");
             }
             const settings = await createVertexSettings();
             const vertexAnthropic = createVertexAnthropic(settings);
@@ -271,15 +277,15 @@ export class GoogleVertexAI {
      * @returns Promise resolving to StreamTextResult or null if operation fails
      */
     async streamText(optionsOrPrompt, analysisSchema) {
-        const functionTag = 'GoogleVertexAI.streamText';
-        const provider = 'vertex';
+        const functionTag = "GoogleVertexAI.streamText";
+        const provider = "vertex";
         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`, {
@@ -289,7 +295,7 @@ export class GoogleVertexAI {
                 promptLength: prompt.length,
                 temperature,
                 maxTokens,
-                hasSchema: !!finalSchema
+                hasSchema: !!finalSchema,
             });
             const model = await this.getModel();
             const streamOptions = {
@@ -308,7 +314,7 @@ export class GoogleVertexAI {
                         error: errorMessage,
                         stack: errorStack,
                         promptLength: prompt.length,
-                        chunkCount
+                        chunkCount,
                     });
                 },
                 onFinish: (event) => {
@@ -319,7 +325,7 @@ export class GoogleVertexAI {
                         usage: event.usage,
                         totalChunks: chunkCount,
                         promptLength: prompt.length,
-                        responseLength: event.text?.length || 0
+                        responseLength: event.text?.length || 0,
                     });
                 },
                 onChunk: (event) => {
@@ -329,12 +335,14 @@ export class GoogleVertexAI {
                         modelName: this.modelName,
                         chunkNumber: chunkCount,
                         chunkLength: event.chunk.text?.length || 0,
-                        chunkType: event.chunk.type
+                        chunkType: event.chunk.type,
                     });
-                }
+                },
             };
             if (analysisSchema) {
-                streamOptions.experimental_output = Output.object({ schema: analysisSchema });
+                streamOptions.experimental_output = Output.object({
+                    schema: analysisSchema,
+                });
             }
             const result = streamText(streamOptions);
             return result;
@@ -343,9 +351,9 @@ export class GoogleVertexAI {
             logger.error(`[${functionTag}] Exception`, {
                 provider,
                 modelName: this.modelName,
-                message: 'Error in streaming text',
+                message: "Error in streaming text",
                 err: String(err),
-                promptLength: prompt.length
+                promptLength: prompt.length,
             });
             throw err; // Re-throw error to trigger fallback
         }
@@ -357,14 +365,14 @@ export class GoogleVertexAI {
      * @returns Promise resolving to GenerateTextResult or null if operation fails
      */
     async generateText(optionsOrPrompt, analysisSchema) {
-        const functionTag = 'GoogleVertexAI.generateText';
-        const provider = 'vertex';
+        const functionTag = "GoogleVertexAI.generateText";
+        const provider = "vertex";
         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`, {
@@ -373,7 +381,7 @@ export class GoogleVertexAI {
                 isAnthropic: isAnthropicModel(this.modelName),
                 promptLength: prompt.length,
                 temperature,
-                maxTokens
+                maxTokens,
             });
             const model = await this.getModel();
             const generateOptions = {
@@ -381,10 +389,12 @@ export class GoogleVertexAI {
                 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`, {
@@ -392,7 +402,7 @@ export class GoogleVertexAI {
                 modelName: this.modelName,
                 usage: result.usage,
                 finishReason: result.finishReason,
-                responseLength: result.text?.length || 0
+                responseLength: result.text?.length || 0,
             });
             return result;
         }
@@ -400,8 +410,8 @@ export class GoogleVertexAI {
             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/huggingFace.d.ts

@@ -0,0 +1,31 @@
+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 HuggingFace implements AIProvider {
+    private modelName;
+    private client;
+    /**
+     * Initializes a new instance of HuggingFace
+     * @param modelName - Optional model name to override the default from config
+     */
+    constructor(modelName?: string | null);
+    /**
+     * Gets the appropriate model instance
+     * @private
+     */
+    private getModel;
+    /**
+     * 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
+     */
+    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
+    /**
+     * 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
+     */
+    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+}