@juspay/neurolink 9.91.0 → 9.92.0

package/dist/lib/providers/sagemaker/client.js

@@ -4,38 +4,41 @@
  * This module provides a wrapper around the AWS SDK SageMaker Runtime client
  * with enhanced error handling, retry logic, and NeuroLink-specific features.
  */
-import { SageMakerRuntimeClient as AWSClient, InvokeEndpointCommand, InvokeEndpointWithResponseStreamCommand, } from "@aws-sdk/client-sagemaker-runtime";
 import { handleSageMakerError, SageMakerError, isRetryableError, getRetryDelay, } from "./errors.js";
 import { logger } from "../../utils/logger.js";
+/**
+ * Lazily load `@aws-sdk/client-sagemaker-runtime`.
+ *
+ * The package is an optional dependency: importing it only happens here, on
+ * first actual endpoint invocation, so constructing a SageMakerRuntimeClient
+ * (e.g. while the CLI builds its command tree at startup) never requires the
+ * SDK to be installed. If it's missing, surface a comprehensible, actionable
+ * error instead of a raw resolution failure.
+ */
+async function loadSageMakerRuntime() {
+    try {
+        return await import(/* @vite-ignore */ "@aws-sdk/client-sagemaker-runtime");
+    }
+    catch (err) {
+        const e = err instanceof Error ? err : null;
+        if (e?.code === "ERR_MODULE_NOT_FOUND" &&
+            e.message.includes("client-sagemaker-runtime")) {
+            throw new Error('SageMaker inference requires "@aws-sdk/client-sagemaker-runtime". Install it with:\n  pnpm add @aws-sdk/client-sagemaker-runtime', { cause: err });
+        }
+        throw err;
+    }
+}
 /**
  * Enhanced SageMaker Runtime client with retry logic and error handling
  */
 export class SageMakerRuntimeClient {
-    client;
+    client = null;
+    sdkModule = null;
     config;
     isDisposed = false;
     constructor(config) {
         this.config = config;
-        // Initialize AWS SDK client with configuration
-        this.client = new AWSClient({
-            region: config.region,
-            credentials: {
-                accessKeyId: config.accessKeyId,
-                secretAccessKey: config.secretAccessKey,
-                sessionToken: config.sessionToken,
-            },
-            maxAttempts: config.maxRetries || 3,
-            requestHandler: {
-                requestTimeout: config.timeout || 30000,
-                httpsAgent: {
-                    // Keep connections alive for better performance
-                    keepAlive: true,
-                    maxSockets: 50,
-                },
-            },
-            ...(config.endpoint && { endpoint: config.endpoint }),
-        });
-        logger.debug("SageMaker Runtime client initialized", {
+        logger.debug("SageMaker Runtime client configured", {
             region: config.region,
             timeout: config.timeout,
             maxRetries: config.maxRetries,
@@ -43,6 +46,51 @@ export class SageMakerRuntimeClient {
             customEndpoint: !!config.endpoint,
         });
     }
+    /**
+     * Lazily load (and cache) the `@aws-sdk/client-sagemaker-runtime` module.
+     */
+    async getSdk() {
+        if (!this.sdkModule) {
+            this.sdkModule = await loadSageMakerRuntime();
+        }
+        return this.sdkModule;
+    }
+    /**
+     * Lazily construct (and cache) the underlying AWS SDK client.
+     */
+    async getClient() {
+        if (this.isDisposed) {
+            throw new SageMakerError("Cannot perform operation on disposed SageMaker client", {
+                code: "VALIDATION_ERROR",
+                statusCode: 400,
+            });
+        }
+        if (!this.client) {
+            const { SageMakerRuntimeClient: AWSClientCtor } = await this.getSdk();
+            this.client = new AWSClientCtor({
+                region: this.config.region,
+                credentials: {
+                    accessKeyId: this.config.accessKeyId,
+                    secretAccessKey: this.config.secretAccessKey,
+                    sessionToken: this.config.sessionToken,
+                },
+                maxAttempts: this.config.maxRetries || 3,
+                requestHandler: {
+                    requestTimeout: this.config.timeout || 30000,
+                    httpsAgent: {
+                        // Keep connections alive for better performance
+                        keepAlive: true,
+                        maxSockets: 50,
+                    },
+                },
+                ...(this.config.endpoint && { endpoint: this.config.endpoint }),
+            });
+            logger.debug("SageMaker Runtime AWS SDK client initialized", {
+                region: this.config.region,
+            });
+        }
+        return this.client;
+    }
     /**
      * Invoke a SageMaker endpoint for synchronous inference
      *
@@ -61,6 +109,7 @@ export class SageMakerRuntimeClient {
                     ? params.Body.length
                     : params.Body?.length || 0,
             });
+            const { InvokeEndpointCommand } = await this.getSdk();
             // Prepare the command input
             const input = {
                 EndpointName: params.EndpointName,
@@ -73,10 +122,7 @@ export class SageMakerRuntimeClient {
                 InferenceId: params.InferenceId,
             };
             const command = new InvokeEndpointCommand(input);
-            const client = this.client;
-            if (!client) {
-                throw new Error("SageMaker client has been disposed");
-            }
+            const client = await this.getClient();
             const response = (await this.executeWithRetry(() => client.send(command), params.EndpointName));
             const duration = Date.now() - startTime;
             logger.debug("SageMaker endpoint invocation successful", {
@@ -120,6 +166,7 @@ export class SageMakerRuntimeClient {
                     ? params.Body.length
                     : params.Body?.length || 0,
             });
+            const { InvokeEndpointWithResponseStreamCommand } = await this.getSdk();
             // Prepare the command input for streaming
             const input = {
                 EndpointName: params.EndpointName,
@@ -130,10 +177,7 @@ export class SageMakerRuntimeClient {
                 // Note: TargetModel, TargetVariant, InferenceId not available in streaming interface
             };
             const command = new InvokeEndpointWithResponseStreamCommand(input);
-            const client = this.client;
-            if (!client) {
-                throw new Error("SageMaker client has been disposed");
-            }
+            const client = await this.getClient();
             const response = (await this.executeWithRetry(() => client.send(command), params.EndpointName));
             logger.debug("SageMaker streaming invocation started", {
                 endpointName: params.EndpointName,
@@ -415,6 +459,7 @@ export class SageMakerRuntimeClient {
         // Clear our client reference to enable garbage collection
         // Note: AWS SDK v3 handles all internal resource cleanup automatically
         this.client = null;
+        this.sdkModule = null;
         logger.debug("SageMaker Runtime client disposed", {
             note: "AWS SDK v3 handles internal resource cleanup automatically",
         });

package/dist/lib/proxy/proxyConfig.js

@@ -227,6 +227,33 @@ export function validateProxyConfig(config) {
                 });
             }
         }
+        const rawQuotaRouting = routing["quota-routing"] ?? routing.quotaRouting;
+        const normalizedQuotaRouting = typeof rawQuotaRouting === "string"
+            ? rawQuotaRouting.trim().toLowerCase()
+            : undefined;
+        if (rawQuotaRouting !== undefined &&
+            typeof rawQuotaRouting !== "boolean" &&
+            normalizedQuotaRouting !== "true" &&
+            normalizedQuotaRouting !== "false") {
+            errors.push("routing.quota-routing must be a boolean");
+        }
+        const rawSessionSoftLimit = routing["session-soft-limit"] ?? routing.sessionSoftLimit;
+        if (rawSessionSoftLimit !== undefined) {
+            const sessionSoftLimit = Number(rawSessionSoftLimit);
+            if (!Number.isFinite(sessionSoftLimit) ||
+                sessionSoftLimit <= 0 ||
+                sessionSoftLimit > 1) {
+                errors.push("routing.session-soft-limit must be a number in (0, 1]");
+            }
+        }
+        const rawSessionResetToleranceMs = routing["session-reset-tolerance-ms"] ?? routing.sessionResetToleranceMs;
+        if (rawSessionResetToleranceMs !== undefined) {
+            const sessionResetToleranceMs = Number(rawSessionResetToleranceMs);
+            if (!Number.isInteger(sessionResetToleranceMs) ||
+                sessionResetToleranceMs <= 0) {
+                errors.push("routing.session-reset-tolerance-ms must be a positive integer");
+            }
+        }
     }
     if (!hasAccounts && !hasRouting) {
         errors.push('Config must contain at least one of "accounts" or "routing"');
@@ -296,6 +323,9 @@ function warnPlaintextApiKeys(accounts) {
  * - `model-mappings` / `modelMappings` — array of {from, to, provider}
  * - `fallback-chain` / `fallbackChain` — array of {provider, model}
  * - `passthroughModels` / `passthrough-models` — array of model IDs
+ * - `quota-routing` / `quotaRouting` — quota-aware fill-first ordering
+ * - `session-soft-limit` / `sessionSoftLimit` — proactive handoff threshold
+ * - `session-reset-tolerance-ms` / `sessionResetToleranceMs` — reset bucket
  * - `account-allowlist` / `accountAllowlist` — allowed Anthropic account IDs
  *
  * Accepts both camelCase and kebab-case keys for YAML-friendliness.
@@ -353,6 +383,42 @@ function parseRoutingConfig(raw) {
     if (Array.isArray(rawPassthrough)) {
         result.passthroughModels = rawPassthrough.map(String);
     }
+    const rawQuotaRouting = raw["quota-routing"] ?? raw.quotaRouting;
+    if (rawQuotaRouting !== undefined) {
+        if (typeof rawQuotaRouting === "boolean") {
+            result.quotaRouting = rawQuotaRouting;
+        }
+        else if (typeof rawQuotaRouting === "string" &&
+            ["true", "false"].includes(rawQuotaRouting.trim().toLowerCase())) {
+            result.quotaRouting = rawQuotaRouting.trim().toLowerCase() === "true";
+        }
+        else {
+            logger.warn(`[proxy-config] Ignoring routing.quotaRouting: expected boolean, got ${typeof rawQuotaRouting}`);
+        }
+    }
+    const rawSessionSoftLimit = raw["session-soft-limit"] ?? raw.sessionSoftLimit;
+    if (rawSessionSoftLimit !== undefined) {
+        const sessionSoftLimit = Number(rawSessionSoftLimit);
+        if (Number.isFinite(sessionSoftLimit) &&
+            sessionSoftLimit > 0 &&
+            sessionSoftLimit <= 1) {
+            result.sessionSoftLimit = sessionSoftLimit;
+        }
+        else {
+            logger.warn(`[proxy-config] Ignoring routing.sessionSoftLimit: expected number in (0, 1], got ${String(rawSessionSoftLimit)}`);
+        }
+    }
+    const rawSessionResetToleranceMs = raw["session-reset-tolerance-ms"] ?? raw.sessionResetToleranceMs;
+    if (rawSessionResetToleranceMs !== undefined) {
+        const sessionResetToleranceMs = Number(rawSessionResetToleranceMs);
+        if (Number.isInteger(sessionResetToleranceMs) &&
+            sessionResetToleranceMs > 0) {
+            result.sessionResetToleranceMs = sessionResetToleranceMs;
+        }
+        else {
+            logger.warn(`[proxy-config] Ignoring routing.sessionResetToleranceMs: expected positive integer, got ${String(rawSessionResetToleranceMs)}`);
+        }
+    }
     // Primary account (accept kebab-case or camelCase). Email or label of the
     // Anthropic account that should be tried first ("home"). Resolved to a
     // stable key (anthropic:<email>) at proxy boot; absence preserves the

package/dist/lib/proxy/runtimeConfig.d.ts

@@ -0,0 +1,26 @@
+import type { ProxyRuntimeConfigListener, ProxyRuntimeConfigReloadListener, ProxyRuntimeConfigReloadResult, ProxyRuntimeConfigReloadSource, ProxyRuntimeConfigSnapshot, ProxyRuntimeConfigStatus, ProxyRuntimeConfigStoreOptions } from "../types/index.js";
+/** Atomic last-known-good runtime configuration with file-triggered reloads. */
+export declare class ProxyRuntimeConfigStore {
+    private readonly options;
+    private currentSnapshot;
+    private status;
+    private readonly listeners;
+    private readonly reloadListeners;
+    private reloadQueue;
+    private reloadTimer;
+    private configFileObserved;
+    private envFileObserved;
+    private readonly watchListener;
+    private constructor();
+    static create(options: ProxyRuntimeConfigStoreOptions): Promise<ProxyRuntimeConfigStore>;
+    getSnapshot(): ProxyRuntimeConfigSnapshot;
+    getStatus(): ProxyRuntimeConfigStatus;
+    subscribe(listener: ProxyRuntimeConfigListener): () => void;
+    subscribeReload(listener: ProxyRuntimeConfigReloadListener): () => void;
+    reload(source?: ProxyRuntimeConfigReloadSource): Promise<ProxyRuntimeConfigReloadResult>;
+    startWatching(): void;
+    stopWatching(): void;
+    private scheduleWatchReload;
+    private performReload;
+    private notifyReloadListeners;
+}