@juspay/neurolink 7.29.1 → 7.29.3

package/dist/providers/sagemaker/parsers.js

@@ -262,7 +262,11 @@ export class HuggingFaceStreamParser extends BaseStreamingParser {
         // Error format
         if (data.error) {
             const errorMessage = extractApiErrorMessage(data.error);
-            throw new SageMakerError(`HuggingFace streaming error: ${errorMessage}`, "MODEL_ERROR", 500);
+            throw new SageMakerError(`HuggingFace streaming error: ${errorMessage}`, {
+                code: "MODEL_ERROR",
+                statusCode: 500,
+                retryable: false,
+            });
         }
         return null;
     }
@@ -274,7 +278,7 @@ export class HuggingFaceStreamParser extends BaseStreamingParser {
         return {
             promptTokens: Number(tokens.input) || 0,
             completionTokens: Number(tokens.generated) || 0,
-            totalTokens: Number(tokens.total) || 0,
+            total: Number(tokens.total) || 0,
         };
     }
     mapFinishReason(reason) {
@@ -379,7 +383,11 @@ export class LlamaStreamParser extends BaseStreamingParser {
         if (data.error) {
             const errorData = data.error;
             const errorMessage = extractApiErrorMessage(errorData);
-            throw new SageMakerError(`LLaMA streaming error: ${errorMessage}`, "MODEL_ERROR", 500);
+            throw new SageMakerError(`LLaMA streaming error: ${errorMessage}`, {
+                code: "MODEL_ERROR",
+                statusCode: 500,
+                retryable: false,
+            });
         }
         return null;
     }
@@ -441,7 +449,7 @@ export class LlamaStreamParser extends BaseStreamingParser {
         return {
             promptTokens: Number(usage.prompt_tokens) || 0,
             completionTokens: Number(usage.completion_tokens) || 0,
-            totalTokens: Number(usage.total_tokens) || 0,
+            total: Number(usage.total_tokens) || 0,
         };
     }
     mapFinishReason(reason) {
@@ -563,7 +571,7 @@ export class CustomStreamParser extends BaseStreamingParser {
         return {
             promptTokens: Number(usage.prompt_tokens || usage.input_tokens) || 0,
             completionTokens: Number(usage.completion_tokens || usage.output_tokens) || 0,
-            totalTokens: Number(usage.total_tokens) || 0,
+            total: Number(usage.total_tokens) || 0,
         };
     }
 }
@@ -621,6 +629,6 @@ export function estimateTokenUsage(prompt, completion) {
     return {
         promptTokens,
         completionTokens,
-        totalTokens: promptTokens + completionTokens,
+        total: promptTokens + completionTokens,
     };
 }

package/dist/providers/sagemaker/streaming.js

@@ -69,7 +69,18 @@ async function createProtocolSpecificStream(responseStream, parser, capability,
                 while (true) {
                     // Check for abort signal
                     if (options.abortSignal?.aborted) {
-                        throw new SageMakerError("Stream aborted by user", "NETWORK_ERROR", 499);
+                        // Clean up upstream iterator before throwing
+                        try {
+                            await reader.return?.();
+                        }
+                        catch {
+                            // Ignore cleanup errors, still propagate original abort
+                        }
+                        throw new SageMakerError("Stream aborted by user", {
+                            code: "NETWORK_ERROR",
+                            statusCode: 499,
+                            retryable: false,
+                        });
                     }
                     const { done, value } = await reader.next();
                     if (done) {
@@ -86,7 +97,7 @@ async function createProtocolSpecificStream(responseStream, parser, capability,
                         options.onComplete?.(finalUsage || {
                             promptTokens: 0,
                             completionTokens: 0,
-                            totalTokens: 0,
+                            total: 0,
                         });
                         controller.close();
                         break;
@@ -315,6 +326,6 @@ export function estimateTokenUsage(prompt, completion) {
     return {
         promptTokens,
         completionTokens,
-        totalTokens: promptTokens + completionTokens,
+        total: promptTokens + completionTokens,
     };
 }

package/dist/providers/sagemaker/types.d.ts

@@ -96,7 +96,7 @@ export interface SageMakerUsage {
     /** Number of completion tokens */
     completionTokens: number;
     /** Total tokens used */
-    totalTokens: number;
+    total: number;
     /** Request processing time in milliseconds */
     requestTime?: number;
     /** Model inference time in milliseconds */

package/dist/proxy/awsProxyIntegration.d.ts

@@ -0,0 +1,23 @@
+/**
+ * AWS SDK Global Agent Configuration for Proxy Support
+ * Configures Node.js global HTTP/HTTPS agents to work with AWS SDK
+ * Ensures BedrockRuntimeClient and other AWS services respect proxy settings
+ */
+/**
+ * Configure global Node.js agents for AWS SDK proxy support
+ * This ensures BedrockRuntimeClient and other AWS SDK clients respect proxy settings
+ */
+export declare function configureAWSProxySupport(): Promise<void>;
+/**
+ * Create a proxy-aware HTTP handler for AWS SDK clients
+ * This is the proper way to inject proxy support into AWS SDK v3 clients
+ */
+export declare function createAWSProxyHandler(targetUrl?: string): Promise<unknown | null>;
+/**
+ * Clean up global agents (for testing or shutdown)
+ */
+export declare function cleanupAWSProxySupport(): Promise<void>;
+/**
+ * Test AWS endpoint connectivity through proxy
+ */
+export declare function testAWSProxyConnectivity(): Promise<boolean>;

package/dist/proxy/awsProxyIntegration.js

@@ -0,0 +1,285 @@
+/**
+ * AWS SDK Global Agent Configuration for Proxy Support
+ * Configures Node.js global HTTP/HTTPS agents to work with AWS SDK
+ * Ensures BedrockRuntimeClient and other AWS services respect proxy settings
+ */
+import { logger } from "../utils/logger.js";
+/**
+ * Configure global Node.js agents for AWS SDK proxy support
+ * This ensures BedrockRuntimeClient and other AWS SDK clients respect proxy settings
+ */
+export async function configureAWSProxySupport() {
+    try {
+        // Check if proxy is needed for AWS endpoints
+        const testUrl = "https://bedrock-runtime.us-east-1.amazonaws.com";
+        const proxyUrl = await getProxyUrlForTarget(testUrl);
+        if (!proxyUrl) {
+            logger.debug("[AWS Proxy] No proxy configuration needed for AWS SDK");
+            return;
+        }
+        logger.debug("[AWS Proxy] Configuring global agents for AWS SDK", {
+            proxyUrl: proxyUrl.replace(/\/\/[^:]+:[^@]+@/, "//*****:*****@"),
+            targetEndpoint: testUrl,
+        });
+        // Configure global agents
+        await configureGlobalAgents(proxyUrl);
+        logger.info("[AWS Proxy] AWS SDK proxy support configured successfully");
+    }
+    catch (error) {
+        logger.error("[AWS Proxy] Failed to configure AWS SDK proxy support", {
+            error,
+        });
+        // Don't throw - allow AWS SDK to work without proxy
+    }
+}
+/**
+ * Configure Node.js global HTTP/HTTPS agents
+ */
+async function configureGlobalAgents(proxyUrl) {
+    try {
+        const parsed = new URL(proxyUrl);
+        logger.debug("[AWS Proxy] Configuring global agents", {
+            protocol: parsed.protocol,
+            hostname: parsed.hostname,
+            port: parsed.port || getDefaultPort(parsed.protocol),
+        });
+        // For HTTP/HTTPS proxies, we need to set global agents
+        if (parsed.protocol === "http:" || parsed.protocol === "https:") {
+            await configureHttpAgents(proxyUrl);
+        }
+        else if (parsed.protocol === "socks4:" || parsed.protocol === "socks5:") {
+            await configureSocksAgents(proxyUrl);
+        }
+        else {
+            throw new Error(`Unsupported proxy protocol for AWS SDK: ${parsed.protocol}`);
+        }
+    }
+    catch (error) {
+        logger.error("[AWS Proxy] Failed to configure global agents", {
+            proxyUrl,
+            error,
+        });
+        throw error;
+    }
+}
+/**
+ * Configure HTTP/HTTPS proxy agents using existing proxy infrastructure
+ */
+async function configureHttpAgents(proxyUrl) {
+    // No-op here. Prefer explicit handler injection at client construction time.
+    logger.debug("[AWS Proxy] Skipping global env/agent mutation; use injected HttpHandler instead", {
+        proxyUrl: proxyUrl.replace(/\/\/[^:]+:[^@]+@/, "//*****:*****@"),
+    });
+}
+/**
+ * Configure SOCKS proxy agents - simplified approach
+ */
+async function configureSocksAgents(proxyUrl) {
+    // SOCKS via HTTP(S)_PROXY won't work; avoid setting to socks://
+    // Setting HTTP_PROXY/HTTPS_PROXY to a socks:// URL is not respected by Node's https module nor by AWS SDK handlers
+    logger.warn("[AWS Proxy] SOCKS proxy configuration not supported for AWS SDK", {
+        proxyUrl: proxyUrl.replace(/\/\/[^:]+:[^@]+@/, "//*****:*****@"),
+        reason: "AWS SDK v3 does not support SOCKS proxies via environment variables",
+    });
+    throw new Error(`SOCKS proxy configuration not supported for AWS SDK. Consider using HTTP/HTTPS proxy instead. ` +
+        `For SOCKS support, use a proxy-aware agent injected into AWS clients.`);
+}
+/**
+ * Minimal HTTP agent configuration (fallback)
+ */
+async function _configureMinimalHttpAgents(_proxyUrl) {
+    // Remove broken fallback. Use explicit proxy-aware HttpHandler instead.
+    logger.warn("[AWS Proxy] Minimal agent fallback removed; a proper proxy agent is required.");
+}
+/**
+ * Create a proxy-aware HTTP handler for AWS SDK clients
+ * This is the proper way to inject proxy support into AWS SDK v3 clients
+ */
+export async function createAWSProxyHandler(targetUrl) {
+    try {
+        const testUrl = targetUrl || "https://bedrock-runtime.us-east-1.amazonaws.com";
+        const proxyUrl = await getProxyUrlForTarget(testUrl);
+        if (!proxyUrl) {
+            logger.debug("[AWS Proxy] No proxy configured, using default HTTP handler");
+            return null;
+        }
+        logger.debug("[AWS Proxy] Creating proxy-aware HTTP handler for AWS SDK", {
+            proxyUrl: proxyUrl.replace(/\/\/[^:]+:[^@]+@/, "//*****:*****@"),
+        });
+        // Dynamically import proxy agent modules
+        const parsed = new URL(proxyUrl);
+        if (parsed.protocol === "http:" || parsed.protocol === "https:") {
+            try {
+                // Use undici ProxyAgent for HTTP/HTTPS proxies
+                const { ProxyAgent } = await import("undici");
+                const proxyAgent = new ProxyAgent(proxyUrl);
+                // Create a custom dispatcher wrapper for AWS SDK
+                return {
+                    async handle(request) {
+                        const { fetch } = await import("undici");
+                        const req = request;
+                        return fetch(req.url, {
+                            method: req.method,
+                            headers: req.headers,
+                            body: req.body,
+                            dispatcher: proxyAgent,
+                        });
+                    },
+                };
+            }
+            catch (undiciError) {
+                logger.warn("[AWS Proxy] No suitable proxy agent available", {
+                    undiciError: undiciError instanceof Error
+                        ? undiciError.message
+                        : String(undiciError),
+                });
+                return null;
+            }
+        }
+        else {
+            logger.warn("[AWS Proxy] Unsupported proxy protocol for AWS SDK", {
+                protocol: parsed.protocol,
+            });
+            return null;
+        }
+    }
+    catch (error) {
+        logger.error("[AWS Proxy] Failed to create proxy-aware HTTP handler", {
+            error,
+        });
+        return null;
+    }
+}
+/**
+ * Get default port for protocol
+ */
+function getDefaultPort(protocol) {
+    switch (protocol) {
+        case "http:":
+            return 8080;
+        case "https:":
+            return 8080;
+        case "socks4:":
+            return 1080;
+        case "socks5:":
+            return 1080;
+        default:
+            return 8080;
+    }
+}
+// Import shared NO_PROXY utility
+import { shouldBypassProxySimple } from "./utils/noProxyUtils.js";
+/**
+ * Get proxy URL for specific target (reuse existing logic)
+ */
+async function getProxyUrlForTarget(targetUrl) {
+    try {
+        // Simple fallback proxy detection using environment variables
+        // This is more reliable than trying to import internal functions
+        const httpProxy = process.env.HTTP_PROXY || process.env.http_proxy;
+        const httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy;
+        const allProxy = process.env.ALL_PROXY || process.env.all_proxy;
+        const noProxy = process.env.NO_PROXY || process.env.no_proxy;
+        // Check if target should bypass proxy using shared utility
+        if (noProxy && shouldBypassProxySimple(targetUrl, noProxy)) {
+            return null;
+        }
+        // Use HTTPS proxy for HTTPS URLs, HTTP proxy for HTTP URLs
+        const url = new URL(targetUrl);
+        if (url.protocol === "https:" && (httpsProxy || allProxy)) {
+            return httpsProxy || allProxy || null;
+        }
+        else if (url.protocol === "http:" && httpProxy) {
+            return httpProxy;
+        }
+        else if (httpProxy) {
+            // Fallback to HTTP proxy for any protocol
+            return httpProxy;
+        }
+        else if (allProxy) {
+            return allProxy;
+        }
+        return null;
+    }
+    catch (error) {
+        // Fallback to simple environment variable check
+        // (Ensure any logged URLs here are masked before emitting.)
+        logger.warn("[AWS Proxy] Error in proxy detection, using simple fallback", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        // Check NO_PROXY bypass first in fallback path too
+        const noProxy = process.env.NO_PROXY || process.env.no_proxy;
+        if (noProxy && shouldBypassProxySimple(targetUrl, noProxy)) {
+            return null;
+        }
+        const url = new URL(targetUrl);
+        const httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy;
+        const httpProxy = process.env.HTTP_PROXY || process.env.http_proxy;
+        const allProxy = process.env.ALL_PROXY || process.env.all_proxy;
+        if (url.protocol === "https:" && httpsProxy) {
+            return httpsProxy;
+        }
+        if (url.protocol === "http:" && httpProxy) {
+            return httpProxy;
+        }
+        if (allProxy) {
+            return allProxy;
+        }
+        return null;
+    }
+}
+/**
+ * Clean up global agents (for testing or shutdown)
+ */
+export async function cleanupAWSProxySupport() {
+    try {
+        const http = await import("http");
+        const https = await import("https");
+        // Reset to default agents
+        https.globalAgent = new https.Agent();
+        http.globalAgent = new http.Agent();
+        logger.debug("[AWS Proxy] Global agents reset to defaults");
+    }
+    catch (error) {
+        logger.warn("[AWS Proxy] Failed to cleanup global agents", { error });
+    }
+}
+/**
+ * Test AWS endpoint connectivity through proxy
+ */
+export async function testAWSProxyConnectivity() {
+    try {
+        const testUrl = "https://bedrock-runtime.us-east-1.amazonaws.com";
+        const proxyUrl = await getProxyUrlForTarget(testUrl);
+        if (!proxyUrl) {
+            logger.debug("[AWS Proxy] No proxy configured, direct connection test");
+            return true; // No proxy needed
+        }
+        logger.debug("[AWS Proxy] Testing proxy connectivity to AWS", {
+            testUrl,
+            proxyUrl: proxyUrl.replace(/\/\/[^:]+:[^@]+@/, "//*****:*****@"),
+        });
+        // Simple connectivity test using fetch with AbortController for timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 5000); // 5 second timeout
+        // Use proxy-aware fetch instead of raw fetch
+        const { createProxyFetch } = await import("./proxyFetch.js");
+        const proxyAwareFetch = createProxyFetch();
+        const response = await proxyAwareFetch(testUrl, {
+            method: "HEAD",
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        const success = response.status < 500; // Accept any non-5xx response
+        logger.debug("[AWS Proxy] AWS proxy connectivity test", {
+            success,
+            status: response.status,
+            statusText: response.statusText,
+        });
+        return success;
+    }
+    catch (error) {
+        logger.warn("[AWS Proxy] AWS proxy connectivity test failed", { error });
+        return false;
+    }
+}

package/dist/proxy/proxyFetch.d.ts

@@ -1,19 +1,23 @@
 /**
- * Proxy-aware fetch implementation for AI SDK providers
- * Implements the proven Vercel AI SDK proxy pattern using undici
+ * Enhanced proxy-aware fetch implementation for AI SDK providers
+ * Supports HTTP/HTTPS, SOCKS4/5, authentication, and NO_PROXY bypass
+ * Lightweight implementation extracted from research of major proxy packages
  */
 /**
- * Create a proxy-aware fetch function
- * This implements the community-validated approach for Vercel AI SDK
+ * Create a proxy-aware fetch function with enhanced capabilities
+ * Supports HTTP/HTTPS, SOCKS4/5, authentication, and NO_PROXY bypass
  */
 export declare function createProxyFetch(): typeof fetch;
 /**
- * Get proxy status information
+ * Get enhanced proxy status information
  */
 export declare function getProxyStatus(): {
     enabled: boolean;
     httpProxy: string | null;
     httpsProxy: string | null;
+    allProxy: string | null;
+    socksProxy: string | null;
     noProxy: string | null;
     method: string;
+    capabilities: string[];
 };