@juspay/neurolink 7.29.1 → 7.29.3

package/dist/utils/optionsUtils.js

@@ -42,7 +42,7 @@ export class OptionsEnhancer {
             try {
                 return new SharedArrayBuffer(4); // 4 bytes for Int32
             }
-            catch (e) {
+            catch {
                 // SharedArrayBuffer is defined but not usable (browser CORS headers not set)
                 if (typeof logger !== "undefined" && logger?.warn) {
                     logger.warn("[OptionsEnhancer] SharedArrayBuffer is defined but not usable. " +
@@ -304,6 +304,15 @@ export class OptionsEnhancer {
     }
     static applyLegacyMigration(options, enhancementOptions) {
         const legacyMigration = enhancementOptions.legacyMigration;
+        if (!legacyMigration) {
+            throw new Error("Legacy migration configuration is required");
+        }
+        if (!legacyMigration.legacyContext) {
+            throw new Error("Legacy context is required for migration");
+        }
+        if (!legacyMigration.domainType) {
+            throw new Error("Domain type is required for migration");
+        }
         // Convert legacy context to execution context
         const executionContext = ContextConverter.convertBusinessContext(legacyMigration.legacyContext, legacyMigration.domainType, {
             preserveLegacyFields: legacyMigration.preserveFields,

package/dist/utils/performance.d.ts

@@ -84,7 +84,7 @@ export declare class MemoryManager {
 /**
  * Decorator for tracking performance of async functions
  */
-export declare function trackPerformance(operationName: string): <T extends (...args: unknown[]) => Promise<unknown>>(target: unknown, propertyName: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
+export declare function trackPerformance(operationName: string): <T extends (...args: unknown[]) => Promise<unknown>>(_target: unknown, _propertyName: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
 /**
  * Performance monitoring for CLI operations
  */

package/dist/utils/performance.js

@@ -63,11 +63,20 @@ export class PerformanceTracker {
             return `${operationName}: No metrics available`;
         }
         const memoryMB = (bytes) => (bytes / 1024 / 1024).toFixed(1);
+        if (!metric.memoryDelta) {
+            return [
+                `${operationName}:`,
+                `  Duration: ${metric.duration}ms`,
+                `  Memory Delta: Not available`,
+            ].join("\n");
+        }
+        const signHeap = metric.memoryDelta.heapUsed >= 0 ? "+" : "-";
+        const signRss = metric.memoryDelta.rss >= 0 ? "+" : "-";
         return [
             `${operationName}:`,
             `  Duration: ${metric.duration}ms`,
-            `  Memory Delta: +${memoryMB(metric.memoryDelta.heapUsed)}MB heap`,
-            `  RSS Delta: +${memoryMB(metric.memoryDelta.rss)}MB`,
+            `  Memory Delta: ${signHeap}${memoryMB(Math.abs(metric.memoryDelta.heapUsed))}MB heap`,
+            `  RSS Delta: ${signRss}${memoryMB(Math.abs(metric.memoryDelta.rss))}MB`,
         ].join("\n");
     }
 }
@@ -142,8 +151,11 @@ export class MemoryManager {
  * Decorator for tracking performance of async functions
  */
 export function trackPerformance(operationName) {
-    return function (target, propertyName, descriptor) {
+    return function (_target, _propertyName, descriptor) {
         const method = descriptor.value;
+        if (!method) {
+            throw new Error(`Method descriptor value is required for performance tracking`);
+        }
         descriptor.value = async function (...args) {
             globalTracker.start(operationName);
             try {

package/dist/utils/providerConfig.d.ts

@@ -109,6 +109,7 @@ export declare function createGoogleAuthConfig(): ProviderConfigOptions;
 export declare function createAnthropicBaseConfig(): ProviderConfigOptions;
 /**
  * Gets AWS Region with default fallback
+ * Supports both AWS_REGION and AWS_DEFAULT_REGION for broader compatibility
  */
 export declare function getAWSRegion(): string;
 /**

package/dist/utils/providerConfig.js

@@ -359,9 +359,10 @@ export function createAnthropicBaseConfig() {
 // =============================================================================
 /**
  * Gets AWS Region with default fallback
+ * Supports both AWS_REGION and AWS_DEFAULT_REGION for broader compatibility
  */
 export function getAWSRegion() {
-    return process.env.AWS_REGION || "us-east-1";
+    return (process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || "us-east-1");
 }
 /**
  * Gets AWS Session Token if available

package/dist/utils/providerHealth.d.ts

@@ -72,6 +72,54 @@ export declare class ProviderHealthChecker {
      * Provider-specific configuration checks
      */
     private static checkProviderSpecificConfig;
+    /**
+     * Check Vertex AI configuration
+     */
+    private static checkVertexAIConfig;
+    /**
+     * Get Vertex AI project ID from environment variables
+     */
+    private static getVertexProjectId;
+    /**
+     * Check Vertex AI authentication
+     */
+    private static checkVertexAuthentication;
+    /**
+     * Check Google Application Credentials file
+     */
+    private static checkGoogleApplicationCredentials;
+    /**
+     * Check individual Google credentials
+     */
+    private static checkIndividualGoogleCredentials;
+    /**
+     * Check AWS Bedrock configuration
+     */
+    private static checkBedrockConfig;
+    /**
+     * Check AWS region configuration
+     */
+    private static checkAWSRegion;
+    /**
+     * Check AWS credentials
+     */
+    private static checkAWSCredentials;
+    /**
+     * Check Bedrock models
+     */
+    private static checkBedrockModels;
+    /**
+     * Check Bedrock endpoint
+     */
+    private static checkBedrockEndpoint;
+    /**
+     * Check Azure OpenAI configuration
+     */
+    private static checkAzureConfig;
+    /**
+     * Check Ollama configuration
+     */
+    private static checkOllamaConfig;
     /**
      * Get common models for a provider
      */

package/dist/utils/providerHealth.js

@@ -130,6 +130,14 @@ export class ProviderHealthChecker {
      */
     static async checkEnvironmentConfiguration(providerName, healthStatus) {
         const requiredEnvVars = this.getRequiredEnvironmentVariables(providerName);
+        logger.debug(`[ProviderHealthChecker] Checking environment configuration for ${providerName}`, {
+            requiredEnvVars,
+            presentEnvVars: requiredEnvVars.map((envVar) => ({
+                name: envVar,
+                present: !!process.env[envVar],
+                hasValue: !!(process.env[envVar] && process.env[envVar].trim() !== ""),
+            })),
+        });
         let allConfigured = true;
         const missingVars = [];
         for (const envVar of requiredEnvVars) {
@@ -140,6 +148,12 @@ export class ProviderHealthChecker {
             }
         }
         healthStatus.isConfigured = allConfigured;
+        logger.debug(`[ProviderHealthChecker] Environment configuration result for ${providerName}`, {
+            isConfigured: allConfigured,
+            missingVars,
+            totalRequired: requiredEnvVars.length,
+            totalMissing: missingVars.length,
+        });
         if (!allConfigured) {
             healthStatus.configurationIssues.push(`Missing required environment variables: ${missingVars.join(", ")}`);
             healthStatus.recommendations.push(`Set the following environment variables: ${missingVars.join(", ")}`);
@@ -211,6 +225,12 @@ export class ProviderHealthChecker {
             }
             return;
         }
+        // Providers that don't use API keys directly
+        if (providerName === AIProviderName.OLLAMA ||
+            providerName === AIProviderName.BEDROCK) {
+            healthStatus.hasApiKey = true;
+            return;
+        }
         // 🔧 STANDARD HANDLING FOR OTHER PROVIDERS
         const apiKeyVar = this.getApiKeyEnvironmentVariable(providerName);
         const apiKey = process.env[apiKeyVar];
@@ -342,7 +362,9 @@ export class ProviderHealthChecker {
             case AIProviderName.GOOGLE_AI:
                 return ["GOOGLE_AI_API_KEY"];
             case AIProviderName.BEDROCK:
-                return ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION"];
+                // Bedrock credentials are resolved via AWS SDK default provider chain.
+                // Region/auth validated in provider-specific checks.
+                return [];
             case AIProviderName.AZURE:
                 return ["AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT"];
             case AIProviderName.OLLAMA:
@@ -423,169 +445,210 @@ export class ProviderHealthChecker {
      */
     static async checkProviderSpecificConfig(providerName, healthStatus) {
         switch (providerName) {
-            case AIProviderName.VERTEX: {
-                logger.debug("Starting Vertex AI health check", {
-                    providerName,
-                });
-                // Check for Google Cloud project ID (with fallbacks)
-                const projectId = process.env.GOOGLE_PROJECT_ID ||
-                    process.env.GOOGLE_CLOUD_PROJECT_ID ||
-                    process.env.GOOGLE_VERTEX_PROJECT ||
-                    process.env.GOOGLE_CLOUD_PROJECT ||
-                    process.env.VERTEX_PROJECT_ID;
-                logger.debug("Project ID validation", {
-                    hasProjectId: !!projectId,
-                });
-                if (!projectId) {
-                    healthStatus.configurationIssues.push("Google Cloud project ID not set");
-                    healthStatus.recommendations.push("Set one of: GOOGLE_VERTEX_PROJECT, GOOGLE_CLOUD_PROJECT_ID, GOOGLE_PROJECT_ID, or GOOGLE_CLOUD_PROJECT");
-                }
-                // Check for authentication with proper file existence validation
-                // This aligns with the authentication logic fix in googleVertex.ts
-                let hasValidAuth = false;
-                logger.debug("Authentication validation starting", {
-                    hasGoogleApplicationCredentials: !!process.env.GOOGLE_APPLICATION_CREDENTIALS,
-                });
-                // Check for principal account authentication first (recommended for production)
-                // BUT CRITICALLY: Also verify the file actually exists
-                if (process.env.GOOGLE_APPLICATION_CREDENTIALS) {
-                    const credentialsPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
-                    logger.debug("Checking GOOGLE_APPLICATION_CREDENTIALS file");
-                    // Check if the credentials file actually exists
-                    let fileExists = false;
-                    try {
-                        const { promises: fs } = await import("fs");
-                        try {
-                            await fs.access(credentialsPath);
-                            fileExists = true;
-                        }
-                        catch {
-                            fileExists = false;
-                        }
-                        logger.debug("File existence check completed", {
-                            fileExists,
-                        });
-                    }
-                    catch (error) {
-                        logger.debug("File existence check failed", {
-                            error: String(error),
-                        });
-                        healthStatus.warning = `Failed to check credentials file existence: ${error}`;
-                        fileExists = false;
-                    }
-                    if (fileExists) {
-                        // Validate file format
-                        const fileName = basename(credentialsPath);
-                        const jsonFilePattern = /\.json(\.\w+)?$/;
-                        if (!jsonFilePattern.test(fileName)) {
-                            healthStatus.warning =
-                                "GOOGLE_APPLICATION_CREDENTIALS should point to a JSON file (e.g., 'credentials.json' or 'key.json.backup')";
-                        }
-                        hasValidAuth = true;
-                        healthStatus.hasApiKey = true;
-                        logger.debug("GOOGLE_APPLICATION_CREDENTIALS file validated", {
-                            fileName,
-                            hasValidAuth,
-                        });
-                    }
-                    else {
-                        healthStatus.warning = `GOOGLE_APPLICATION_CREDENTIALS file does not exist: ${credentialsPath}`;
-                        logger.debug("GOOGLE_APPLICATION_CREDENTIALS file missing, falling back to individual env vars");
-                        // Fall through to check individual environment variables
-                    }
-                }
-                else {
-                    logger.debug("GOOGLE_APPLICATION_CREDENTIALS not set, checking individual env vars");
-                }
-                // Fallback to individual credentials for development and production
-                // Enhanced to check ALL required fields from the .env file configuration
-                if (!hasValidAuth) {
-                    const hasServiceAccountKey = !!process.env.GOOGLE_SERVICE_ACCOUNT_KEY;
-                    const hasIndividualCredentials = !!(process.env.GOOGLE_AUTH_CLIENT_EMAIL &&
-                        process.env.GOOGLE_AUTH_PRIVATE_KEY);
-                    logger.debug("Individual credentials check", {
-                        hasServiceAccountKey,
-                        hasGoogleAuthClientEmail: !!process.env.GOOGLE_AUTH_CLIENT_EMAIL,
-                        hasGoogleAuthPrivateKey: !!process.env.GOOGLE_AUTH_PRIVATE_KEY,
-                        hasIndividualCredentials,
-                    });
-                    if (hasServiceAccountKey || hasIndividualCredentials) {
-                        hasValidAuth = true;
-                        healthStatus.hasApiKey = true;
-                        logger.debug("Individual credentials validated successfully", {
-                            hasServiceAccountKey,
-                            hasIndividualCredentials,
-                            hasValidAuth,
-                        });
-                    }
-                    else {
-                        logger.debug("Individual credentials validation failed", {
-                            hasServiceAccountKey,
-                            hasIndividualCredentials,
-                        });
-                    }
-                }
-                // Final validation
-                if (!hasValidAuth) {
-                    healthStatus.configurationIssues.push("Google Cloud authentication not configured or credentials file missing");
-                    healthStatus.recommendations.push("Set either GOOGLE_APPLICATION_CREDENTIALS (valid file path), GOOGLE_SERVICE_ACCOUNT_KEY (base64), or both GOOGLE_AUTH_CLIENT_EMAIL and GOOGLE_AUTH_PRIVATE_KEY");
-                    logger.debug("Final auth validation FAILED", {
-                        hasValidAuth,
-                    });
-                }
-                else {
-                    logger.debug("Final auth validation SUCCESS", {
-                        hasValidAuth,
-                    });
-                }
-                // Mark as configured if we have both project ID and auth
-                if (projectId && hasValidAuth) {
-                    healthStatus.isConfigured = true;
-                    logger.debug("Vertex AI health check PASSED", {
-                        hasProjectId: !!projectId,
-                        hasValidAuth,
-                        isConfigured: healthStatus.isConfigured,
-                    });
-                }
-                else {
-                    logger.debug("Vertex AI health check FAILED", {
-                        hasProjectId: !!projectId,
-                        hasValidAuth,
-                        isConfigured: healthStatus.isConfigured,
-                    });
-                }
+            case AIProviderName.VERTEX:
+                await this.checkVertexAIConfig(healthStatus);
                 break;
-            }
             case AIProviderName.BEDROCK:
-                // Check AWS region
-                if (!process.env.AWS_REGION) {
-                    healthStatus.configurationIssues.push("AWS_REGION not set");
-                    healthStatus.recommendations.push("Set AWS_REGION (e.g., us-east-1)");
-                }
+                await this.checkBedrockConfig(healthStatus);
                 break;
-            case AIProviderName.AZURE: {
-                // Check Azure OpenAI endpoint
-                const azureEndpoint = process.env.AZURE_OPENAI_ENDPOINT;
-                if (azureEndpoint && !azureEndpoint.startsWith("https://")) {
-                    healthStatus.configurationIssues.push("Invalid AZURE_OPENAI_ENDPOINT format");
-                    healthStatus.recommendations.push("Set AZURE_OPENAI_ENDPOINT to a valid URL (e.g., https://your-resource.openai.azure.com/)");
-                }
-                // Check for deployment name
-                if (!process.env.AZURE_OPENAI_DEPLOYMENT_NAME) {
-                    healthStatus.configurationIssues.push("AZURE_OPENAI_DEPLOYMENT_NAME not set");
-                    healthStatus.recommendations.push("Set AZURE_OPENAI_DEPLOYMENT_NAME to your deployment name");
-                }
+            case AIProviderName.AZURE:
+                await this.checkAzureConfig(healthStatus);
                 break;
-            }
-            case AIProviderName.OLLAMA: {
-                // Check if custom endpoint is set
-                const ollamaBase = process.env.OLLAMA_API_BASE || "http://localhost:11434";
-                if (!ollamaBase.startsWith("http")) {
-                    healthStatus.configurationIssues.push("Invalid OLLAMA_API_BASE format");
-                    healthStatus.recommendations.push("Set OLLAMA_API_BASE to a valid URL (e.g., http://localhost:11434)");
-                }
+            case AIProviderName.OLLAMA:
+                await this.checkOllamaConfig(healthStatus);
                 break;
+        }
+    }
+    /**
+     * Check Vertex AI configuration
+     */
+    static async checkVertexAIConfig(healthStatus) {
+        logger.debug("Starting Vertex AI health check");
+        const projectId = this.getVertexProjectId();
+        if (!projectId) {
+            healthStatus.configurationIssues.push("Google Cloud project ID not set");
+            healthStatus.recommendations.push("Set one of: GOOGLE_VERTEX_PROJECT, GOOGLE_CLOUD_PROJECT_ID, GOOGLE_PROJECT_ID, or GOOGLE_CLOUD_PROJECT");
+        }
+        const hasValidAuth = await this.checkVertexAuthentication(healthStatus);
+        if (projectId && hasValidAuth) {
+            healthStatus.isConfigured = true;
+            logger.debug("Vertex AI health check PASSED");
+        }
+        else {
+            logger.debug("Vertex AI health check FAILED");
+        }
+    }
+    /**
+     * Get Vertex AI project ID from environment variables
+     */
+    static getVertexProjectId() {
+        return (process.env.GOOGLE_PROJECT_ID ||
+            process.env.GOOGLE_CLOUD_PROJECT_ID ||
+            process.env.GOOGLE_VERTEX_PROJECT ||
+            process.env.GOOGLE_CLOUD_PROJECT ||
+            process.env.VERTEX_PROJECT_ID);
+    }
+    /**
+     * Check Vertex AI authentication
+     */
+    static async checkVertexAuthentication(healthStatus) {
+        let hasValidAuth = false;
+        if (process.env.GOOGLE_APPLICATION_CREDENTIALS) {
+            hasValidAuth = await this.checkGoogleApplicationCredentials(healthStatus);
+        }
+        if (!hasValidAuth) {
+            hasValidAuth = this.checkIndividualGoogleCredentials(healthStatus);
+        }
+        if (!hasValidAuth) {
+            healthStatus.configurationIssues.push("Google Cloud authentication not configured or credentials file missing");
+            healthStatus.recommendations.push("Set either GOOGLE_APPLICATION_CREDENTIALS (valid file path), GOOGLE_SERVICE_ACCOUNT_KEY (base64), or both GOOGLE_AUTH_CLIENT_EMAIL and GOOGLE_AUTH_PRIVATE_KEY");
+        }
+        return hasValidAuth;
+    }
+    /**
+     * Check Google Application Credentials file
+     */
+    static async checkGoogleApplicationCredentials(healthStatus) {
+        const credentialsPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
+        if (!credentialsPath) {
+            healthStatus.warning =
+                "GOOGLE_APPLICATION_CREDENTIALS environment variable not set";
+            return false;
+        }
+        try {
+            const { promises: fs } = await import("fs");
+            await fs.access(credentialsPath);
+            const fileName = basename(credentialsPath);
+            const jsonFilePattern = /\.json(\.\w+)?$/;
+            if (!jsonFilePattern.test(fileName)) {
+                healthStatus.warning =
+                    "GOOGLE_APPLICATION_CREDENTIALS should point to a JSON file";
             }
+            healthStatus.hasApiKey = true;
+            return true;
+        }
+        catch {
+            healthStatus.warning = `GOOGLE_APPLICATION_CREDENTIALS file does not exist: ${credentialsPath}`;
+            return false;
+        }
+    }
+    /**
+     * Check individual Google credentials
+     */
+    static checkIndividualGoogleCredentials(healthStatus) {
+        const hasServiceAccountKey = !!process.env.GOOGLE_SERVICE_ACCOUNT_KEY;
+        const hasIndividualCredentials = !!(process.env.GOOGLE_AUTH_CLIENT_EMAIL &&
+            process.env.GOOGLE_AUTH_PRIVATE_KEY);
+        if (hasServiceAccountKey || hasIndividualCredentials) {
+            healthStatus.hasApiKey = true;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check AWS Bedrock configuration
+     */
+    static async checkBedrockConfig(healthStatus) {
+        logger.debug("Starting AWS Bedrock comprehensive health check");
+        this.checkAWSRegion(healthStatus);
+        this.checkAWSCredentials(healthStatus);
+        this.checkBedrockModels(healthStatus);
+        this.checkBedrockEndpoint(healthStatus);
+        if (healthStatus.configurationIssues.length === 0) {
+            healthStatus.hasApiKey = true;
+            logger.debug("AWS Bedrock configuration appears valid");
+        }
+    }
+    /**
+     * Check AWS region configuration
+     */
+    static checkAWSRegion(healthStatus) {
+        const awsRegion = process.env.AWS_REGION;
+        const validBedrockRegions = [
+            "us-east-1",
+            "us-west-2",
+            "ap-southeast-1",
+            "ap-northeast-1",
+            "eu-central-1",
+            "eu-west-1",
+            "ap-south-1",
+        ];
+        if (!awsRegion) {
+            healthStatus.configurationIssues.push("AWS_REGION not set");
+            healthStatus.recommendations.push(`Set AWS_REGION to a Bedrock-supported region: ${validBedrockRegions.join(", ")}`);
+        }
+        else if (!validBedrockRegions.includes(awsRegion)) {
+            healthStatus.configurationIssues.push(`AWS_REGION '${awsRegion}' may not support all Bedrock models`);
+            healthStatus.recommendations.push(`Consider using a primary Bedrock region: ${validBedrockRegions.slice(0, 3).join(", ")}`);
+        }
+    }
+    /**
+     * Check AWS credentials
+     */
+    static checkAWSCredentials(healthStatus) {
+        const awsAccessKeyId = process.env.AWS_ACCESS_KEY_ID;
+        const awsSecretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+        const awsProfile = process.env.AWS_PROFILE;
+        if (!awsAccessKeyId && !awsProfile) {
+            healthStatus.configurationIssues.push("No AWS credentials found");
+            healthStatus.recommendations.push("Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY, or configure AWS_PROFILE");
+        }
+        else if (awsAccessKeyId && !awsSecretAccessKey) {
+            healthStatus.configurationIssues.push("AWS_ACCESS_KEY_ID set but AWS_SECRET_ACCESS_KEY missing");
+            healthStatus.recommendations.push("Set AWS_SECRET_ACCESS_KEY to match your AWS_ACCESS_KEY_ID");
+        }
+    }
+    /**
+     * Check Bedrock models
+     */
+    static checkBedrockModels(healthStatus) {
+        const bedrockModel = process.env.BEDROCK_MODEL || process.env.BEDROCK_MODEL_ID;
+        const supportedModels = [
+            "anthropic.claude-3-sonnet-20240229-v1:0",
+            "anthropic.claude-3-haiku-20240307-v1:0",
+            "anthropic.claude-3-opus-20240229-v1:0",
+            "anthropic.claude-v2:1",
+            "amazon.titan-text-express-v1",
+        ];
+        if (!bedrockModel) {
+            healthStatus.recommendations.push("Set BEDROCK_MODEL or BEDROCK_MODEL_ID for faster startup (e.g., anthropic.claude-3-sonnet-20240229-v1:0)");
+        }
+        else if (!supportedModels.includes(bedrockModel)) {
+            healthStatus.recommendations.push(`Consider using a popular Bedrock model: ${supportedModels.slice(0, 3).join(", ")}`);
+        }
+    }
+    /**
+     * Check Bedrock endpoint
+     */
+    static checkBedrockEndpoint(healthStatus) {
+        const bedrockEndpoint = process.env.BEDROCK_ENDPOINT_URL;
+        if (bedrockEndpoint && !bedrockEndpoint.startsWith("https://")) {
+            healthStatus.configurationIssues.push("BEDROCK_ENDPOINT_URL should use HTTPS");
+            healthStatus.recommendations.push("Update BEDROCK_ENDPOINT_URL to use HTTPS protocol");
+        }
+    }
+    /**
+     * Check Azure OpenAI configuration
+     */
+    static async checkAzureConfig(healthStatus) {
+        const azureEndpoint = process.env.AZURE_OPENAI_ENDPOINT;
+        if (azureEndpoint && !azureEndpoint.startsWith("https://")) {
+            healthStatus.configurationIssues.push("Invalid AZURE_OPENAI_ENDPOINT format");
+            healthStatus.recommendations.push("Set AZURE_OPENAI_ENDPOINT to a valid URL (e.g., https://your-resource.openai.azure.com/)");
+        }
+        if (!process.env.AZURE_OPENAI_DEPLOYMENT_NAME) {
+            healthStatus.configurationIssues.push("AZURE_OPENAI_DEPLOYMENT_NAME not set");
+            healthStatus.recommendations.push("Set AZURE_OPENAI_DEPLOYMENT_NAME to your deployment name");
+        }
+    }
+    /**
+     * Check Ollama configuration
+     */
+    static async checkOllamaConfig(healthStatus) {
+        const ollamaBase = process.env.OLLAMA_API_BASE || "http://localhost:11434";
+        if (!ollamaBase.startsWith("http")) {
+            healthStatus.configurationIssues.push("Invalid OLLAMA_API_BASE format");
+            healthStatus.recommendations.push("Set OLLAMA_API_BASE to a valid URL (e.g., http://localhost:11434)");
         }
     }
     /**

package/dist/utils/providerUtils.js

@@ -107,7 +107,7 @@ async function isProviderAvailable(providerName) {
             }
             return false;
         }
-        catch (error) {
+        catch {
             return false;
         }
     }
@@ -116,7 +116,7 @@ async function isProviderAvailable(providerName) {
         await provider.generate({ prompt: "test", maxTokens: 1 });
         return true;
     }
-    catch (error) {
+    catch {
         return false;
     }
 }

package/dist/utils/timeout.js

@@ -214,14 +214,17 @@ export class TimeoutManager {
     generateOperationId(operation) {
         return `${operation}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
     }
-    createTimeoutPromise(timeoutMs, operationId) {
+    createTimeoutPromise(timeoutMs, _operationId) {
         let timer;
         const promise = new Promise((_, reject) => {
             timer = setTimeout(() => {
                 reject(new TimeoutError(`Operation timeout after ${timeoutMs}ms`, timeoutMs));
             }, timeoutMs);
         });
-        return { promise, timer: timer };
+        if (!timer) {
+            throw new Error("Failed to create timeout timer");
+        }
+        return { promise, timer };
     }
     registerTimeout(operationId, timer, controller, cleanup) {
         this.activeTimeouts.set(operationId, { timer, controller, cleanup });
@@ -291,7 +294,9 @@ export async function* withStreamingTimeout(generator, timeout, provider) {
         }
     }
     finally {
-        clearTimeout(timeoutId);
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "7.29.1",
+  "version": "7.29.3",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 9 major providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",
@@ -145,8 +145,12 @@
     "@ai-sdk/openai": "^1.0.0",
     "@ai-sdk/provider": "^1.1.3",
     "@ai-sdk/provider-utils": "^2.2.8",
+    "@aws-sdk/client-bedrock": "^3.876.0",
+    "@aws-sdk/client-bedrock-runtime": "^3.876.0",
     "@aws-sdk/client-sagemaker": "^3.862.0",
     "@aws-sdk/client-sagemaker-runtime": "^3.862.0",
+    "@aws-sdk/credential-provider-node": "^3.876.0",
+    "@aws-sdk/credential-providers": "^3.876.0",
     "@aws-sdk/types": "^3.862.0",
     "@google-cloud/vertexai": "^1.10.0",
     "@google/generative-ai": "^0.24.1",