@juspay/neurolink 7.27.0 → 7.28.0

package/dist/lib/providers/litellm.d.ts

@@ -28,7 +28,7 @@ export declare class LiteLLMProvider extends BaseProvider {
      * Provider-specific streaming implementation
      * Note: This is only used when tools are disabled
      */
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected executeStream(options: StreamOptions, _analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
     /**
      * Get available models from LiteLLM proxy server
      * Dynamically fetches from /v1/models endpoint with caching and fallback

package/dist/lib/providers/litellm.js

@@ -2,11 +2,12 @@ import { createOpenAI } from "@ai-sdk/openai";
 import { streamText } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
-import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 import { getProviderModel } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { buildMessagesArray } from "../utils/messageBuilder.js";
+import { createProxyFetch } from "../proxy/proxyFetch.js";
 // Configuration helpers
 const getLiteLLMConfig = () => {
     return {
@@ -51,6 +52,7 @@ export class LiteLLMProvider extends BaseProvider {
         const customOpenAI = createOpenAI({
             baseURL: config.baseURL,
             apiKey: config.apiKey,
+            fetch: createProxyFetch(),
         });
         this.model = customOpenAI(this.modelName || getDefaultLiteLLMModel());
         logger.debug("LiteLLM Provider initialized", {
@@ -113,7 +115,7 @@ export class LiteLLMProvider extends BaseProvider {
      * Provider-specific streaming implementation
      * Note: This is only used when tools are disabled
      */
-    async executeStream(options, analysisSchema) {
+    async executeStream(options, _analysisSchema) {
         this.validateStreamOptions(options);
         const startTime = Date.now();
         const timeout = this.getTimeout(options);
@@ -121,7 +123,7 @@ export class LiteLLMProvider extends BaseProvider {
         try {
             // Build message array from options
             const messages = buildMessagesArray(options);
-            const result = await streamText({
+            const result = streamText({
                 model: this.model,
                 messages: messages,
                 temperature: options.temperature,
@@ -217,7 +219,8 @@ export class LiteLLMProvider extends BaseProvider {
         const timeoutId = setTimeout(() => controller.abort(), 5000); // 5 second timeout
         try {
             logger.debug(`[${functionTag}] Fetching models from ${modelsUrl}`);
-            const response = await fetch(modelsUrl, {
+            const proxyFetch = createProxyFetch();
+            const response = await proxyFetch(modelsUrl, {
                 method: "GET",
                 headers: {
                     Authorization: `Bearer ${config.apiKey}`,

package/dist/lib/providers/openaiCompatible.d.ts

@@ -29,7 +29,7 @@ export declare class OpenAICompatibleProvider extends BaseProvider {
      * Provider-specific streaming implementation
      * Note: This is only used when tools are disabled
      */
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
+    protected executeStream(options: StreamOptions, _analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
     /**
      * Get available models from OpenAI Compatible endpoint
      *

package/dist/lib/providers/openaiCompatible.js

@@ -2,9 +2,10 @@ import { createOpenAI } from "@ai-sdk/openai";
 import { streamText } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
-import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { createProxyFetch } from "../proxy/proxyFetch.js";
 // Constants
 const FALLBACK_OPENAI_COMPATIBLE_MODEL = "gpt-3.5-turbo";
 // Configuration helpers
@@ -51,6 +52,7 @@ export class OpenAICompatibleProvider extends BaseProvider {
         this.customOpenAI = createOpenAI({
             baseURL: this.config.baseURL,
             apiKey: this.config.apiKey,
+            fetch: createProxyFetch(),
         });
         logger.debug("OpenAI Compatible Provider initialized", {
             modelName: this.modelName,
@@ -149,14 +151,14 @@ export class OpenAICompatibleProvider extends BaseProvider {
      * Provider-specific streaming implementation
      * Note: This is only used when tools are disabled
      */
-    async executeStream(options, analysisSchema) {
+    async executeStream(options, _analysisSchema) {
         this.validateStreamOptions(options);
         const startTime = Date.now();
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
             const model = await this.getAISDKModel();
-            const result = await streamText({
+            const result = streamText({
                 model,
                 prompt: options.input.text,
                 system: options.systemPrompt,
@@ -204,7 +206,8 @@ export class OpenAICompatibleProvider extends BaseProvider {
         try {
             const modelsUrl = new URL("/v1/models", this.config.baseURL).toString();
             logger.debug(`Fetching available models from: ${modelsUrl}`);
-            const response = await fetch(modelsUrl, {
+            const proxyFetch = createProxyFetch();
+            const response = await proxyFetch(modelsUrl, {
                 headers: {
                     Authorization: `Bearer ${this.config.apiKey}`,
                     "Content-Type": "application/json",

package/dist/lib/proxy/proxyFetch.js

@@ -10,6 +10,28 @@ import { logger } from "../utils/logger.js";
 export function createProxyFetch() {
     const httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy;
     const httpProxy = process.env.HTTP_PROXY || process.env.http_proxy;
+    // EXHAUSTIVE LOGGING: Capture ALL proxy-related environment variables BEFORE configuration
+    logger.debug("[Proxy Fetch] 🔍 EXHAUSTIVE_PROXY_ENV_BEFORE", {
+        // Original proxy config function calls
+        proxyHostFunction: "getProxyHost equivalent",
+        proxyPortFunction: "getProxyPort equivalent",
+        // Raw environment variables BEFORE any changes
+        originalHttpProxy: process.env.HTTP_PROXY || "NOT_SET",
+        originalHttpsProxy: process.env.HTTPS_PROXY || "NOT_SET",
+        originalAllProxy: process.env.ALL_PROXY || "NOT_SET",
+        originalNoProxy: process.env.NO_PROXY || "NOT_SET",
+        // Node.js specific proxy variables
+        originalNodejsHttpProxy: process.env.nodejs_http_proxy || "NOT_SET",
+        originalNodejsHttpsProxy: process.env.nodejs_https_proxy || "NOT_SET",
+        // All potential proxy-related environment variables
+        allProxyRelatedEnvVars: Object.keys(process.env)
+            .filter((key) => key.toLowerCase().includes("proxy"))
+            .reduce((acc, key) => {
+            acc[key] = process.env[key] || "NOT_SET";
+            return acc;
+        }, {}),
+        message: "EXHAUSTIVE proxy environment capture BEFORE configuration",
+    });
     // If no proxy configured, return standard fetch
     if (!httpsProxy && !httpProxy) {
         logger.debug("[Proxy Fetch] No proxy environment variables found - using standard fetch");
@@ -20,34 +42,134 @@ export function createProxyFetch() {
     logger.debug(`[Proxy Fetch] HTTPS_PROXY: ${httpsProxy || "not set"}`);
     // Return proxy-aware fetch function
     return async (input, init) => {
+        const requestId = `req-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        logger.debug(`[Proxy Fetch] 🚀 EXHAUSTIVE REQUEST START`, {
+            requestId,
+            input: typeof input === "string"
+                ? input
+                : input instanceof URL
+                    ? input.href
+                    : input.url,
+            timestamp: new Date().toISOString(),
+            httpProxy: httpProxy || "NOT_SET",
+            httpsProxy: httpsProxy || "NOT_SET",
+            initHeaders: init?.headers || "NO_HEADERS",
+            initMethod: init?.method || "GET",
+        });
         try {
             // Dynamic import undici to avoid build issues
             const undici = await import("undici");
             const { ProxyAgent } = undici;
+            logger.debug(`[Proxy Fetch] 🔧 EXHAUSTIVE UNDICI IMPORT SUCCESS`, {
+                requestId,
+                hasUndici: !!undici,
+                hasProxyAgent: !!ProxyAgent,
+                undiciType: typeof undici,
+                proxyAgentType: typeof ProxyAgent,
+                timestamp: new Date().toISOString(),
+            });
             const url = typeof input === "string"
                 ? new URL(input)
                 : input instanceof URL
                     ? input
                     : new URL(input.url);
             const proxyUrl = url.protocol === "https:" ? httpsProxy : httpProxy;
+            logger.debug(`[Proxy Fetch] 🔗 EXHAUSTIVE URL ANALYSIS`, {
+                requestId,
+                urlString: url.href,
+                urlHostname: url.hostname,
+                urlProtocol: url.protocol,
+                urlPort: url.port,
+                urlPathname: url.pathname,
+                selectedProxyUrl: proxyUrl,
+                timestamp: new Date().toISOString(),
+            });
             if (proxyUrl) {
                 logger.debug(`[Proxy Fetch] Creating ProxyAgent for ${url.hostname} via ${proxyUrl}`);
+                logger.debug(`[Proxy Fetch] 🎯 EXHAUSTIVE PROXY AGENT CREATION`, {
+                    requestId,
+                    proxyUrl,
+                    targetHostname: url.hostname,
+                    targetProtocol: url.protocol,
+                    aboutToCreateProxyAgent: true,
+                    timestamp: new Date().toISOString(),
+                });
                 // Create ProxyAgent
                 const dispatcher = new ProxyAgent(proxyUrl);
+                logger.debug(`[Proxy Fetch] ✅ EXHAUSTIVE PROXY AGENT CREATED`, {
+                    requestId,
+                    hasDispatcher: !!dispatcher,
+                    dispatcherType: typeof dispatcher,
+                    dispatcherConstructor: dispatcher?.constructor?.name || "unknown",
+                    timestamp: new Date().toISOString(),
+                });
+                logger.debug(`[Proxy Fetch] 🌐 EXHAUSTIVE UNDICI FETCH CALL`, {
+                    requestId,
+                    aboutToCallUndici: true,
+                    inputType: typeof input,
+                    hasInit: !!init,
+                    hasDispatcher: !!dispatcher,
+                    timestamp: new Date().toISOString(),
+                });
                 // Use undici fetch with dispatcher
-                const response = await undici.fetch(input, {
-                    ...init,
+                // Handle Request objects by extracting URL and merging properties
+                let fetchInput;
+                let fetchInit = { ...init };
+                if (input instanceof Request) {
+                    fetchInput = input.url;
+                    // Merge Request properties into init
+                    fetchInit = {
+                        method: input.method,
+                        headers: input.headers,
+                        body: input.body,
+                        ...init, // Allow init to override Request properties
+                    };
+                }
+                else {
+                    fetchInput = input;
+                }
+                const response = await undici.fetch(fetchInput, {
+                    ...fetchInit,
                     dispatcher: dispatcher,
                 });
+                logger.debug(`[Proxy Fetch] 🎉 EXHAUSTIVE UNDICI FETCH SUCCESS`, {
+                    requestId,
+                    hasResponse: !!response,
+                    responseStatus: response?.status,
+                    responseStatusText: response?.statusText,
+                    responseHeaders: response?.headers
+                        ? Object.fromEntries(response.headers.entries())
+                        : "NO_HEADERS",
+                    responseOk: response?.ok,
+                    responseType: response?.type,
+                    responseUrl: response?.url,
+                    timestamp: new Date().toISOString(),
+                });
                 logger.debug(`[Proxy Fetch] ✅ Request proxied successfully to ${url.hostname}`);
                 return response; // undici.fetch returns compatible Response type
             }
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.debug(`[Proxy Fetch] 💥 EXHAUSTIVE ERROR ANALYSIS`, {
+                requestId,
+                error: errorMessage,
+                errorType: error instanceof Error ? error.constructor.name : typeof error,
+                errorStack: error instanceof Error ? error.stack : undefined,
+                errorCode: error?.code || "NO_CODE",
+                errorSyscall: error?.syscall || "NO_SYSCALL",
+                errorAddress: error?.address || "NO_ADDRESS",
+                errorPort: error?.port || "NO_PORT",
+                timestamp: new Date().toISOString(),
+            });
             logger.warn(`[Proxy Fetch] Proxy failed (${errorMessage}), falling back to direct connection`);
         }
         // Fallback to standard fetch
+        logger.debug(`[Proxy Fetch] 🔄 EXHAUSTIVE FALLBACK TO STANDARD FETCH`, {
+            requestId,
+            fallbackReason: "Either no proxy URL or error occurred",
+            timestamp: new Date().toISOString(),
+        });
         return fetch(input, init);
     };
 }

package/dist/lib/utils/providerHealth.d.ts

@@ -80,13 +80,69 @@ export declare class ProviderHealthChecker {
      * Get cached health status if still valid
      */
     private static getCachedHealth;
+    /**
+     * Check if Vertex AI supports Anthropic models (dual provider architecture)
+     */
+    static checkVertexAnthropicSupport(): Promise<{
+        isSupported: boolean;
+        hasCreateVertexAnthropic: boolean;
+        hasCorrectTypes: boolean;
+        hasValidProject: boolean;
+        hasRegionalSupport: boolean;
+        hasNetworkAccess: boolean;
+        hasAnthropicModels: boolean;
+        authentication: {
+            isValid: boolean;
+            method: string;
+            issues: string[];
+        };
+        projectConfiguration: {
+            isValid: boolean;
+            projectId: string | undefined;
+            region: string | undefined;
+            issues: string[];
+        };
+        modelSupport: {
+            availableModels: string[];
+            recommendedModels: string[];
+            deprecatedModels: string[];
+        };
+        recommendations: string[];
+        troubleshooting: string[];
+    }>;
+    /**
+     * Validate Vertex AI authentication configuration
+     */
+    private static validateVertexAuthentication;
+    /**
+     * Validate Vertex AI project configuration
+     */
+    private static validateVertexProjectConfiguration;
+    /**
+     * Check if the specified region supports Anthropic models
+     */
+    private static checkVertexRegionalSupport;
+    /**
+     * Check network connectivity to Vertex AI endpoints
+     */
+    private static checkVertexNetworkConnectivity;
+    /**
+     * Check if Anthropic model integration is enabled in the project
+     */
+    private static checkAnthropicModelIntegration;
+    /**
+     * Initialize health checks in the background (NON-BLOCKING)
+     * Starts background health monitoring without blocking initialization
+     */
+    static initializeBackgroundHealthChecks(): void;
     /**
      * Clear health cache for a provider or all providers
      */
     static clearHealthCache(providerName?: AIProviderName): void;
     /**
-     * Get the best healthy provider from a list of options
+     * Get the best healthy provider from a list of options (NON-BLOCKING)
      * Prioritizes healthy providers over configured but unhealthy ones
+     * Uses fast, cached health checks to avoid blocking initialization
      */
     static getBestHealthyProvider(preferredProviders?: string[]): Promise<string | null>;
     /**