@juspay/neurolink 9.92.1 → 9.92.3

package/dist/server/routes/claudeProxyRoutes.js

@@ -53,11 +53,6 @@ const BLOCKED_UPSTREAM_HEADERS = new Set([
 let primaryAccountIndex = 0;
 /** Track account count so we can reset primaryAccountIndex when it changes. */
 let lastKnownAccountCount = 0;
-/** Stable account key used by legacy fixed-config route factories. Runtime
- *  config providers pass the request generation's primary key explicitly.
- *  When undefined, home semantics retain insertion-order behavior. */
-let configuredPrimaryAccountKey;
-let configuredAccountAllowlist;
 const MAX_AUTH_RETRIES = 5;
 const MAX_TRANSIENT_SAME_ACCOUNT_RETRIES = 2;
 const TRANSIENT_SAME_ACCOUNT_RETRY_DELAYS_MS = [250, 1_000];
@@ -129,7 +124,7 @@ function advancePrimaryIfCurrent(accountKey, enabledCount, primaryAccountKey) {
  *  no key is configured or the key cannot be matched (account disabled/
  *  removed). The resolution is per-request because enabledAccounts membership
  *  can shift between requests. */
-function resolveHomeIndex(enabledAccounts, primaryAccountKey = configuredPrimaryAccountKey) {
+function resolveHomeIndex(enabledAccounts, primaryAccountKey) {
     if (!primaryAccountKey) {
         return 0;
     }
@@ -140,7 +135,7 @@ function resolveHomeIndex(enabledAccounts, primaryAccountKey = configuredPrimary
  *  primaryAccountIndex back to its index so traffic returns to the preferred
  *  account once its rate limit window expires. Called at the start of each
  *  request. Home is resolved fresh per call via resolveHomeIndex. */
-function maybeResetPrimaryToHome(enabledAccounts, primaryAccountKey = configuredPrimaryAccountKey) {
+function maybeResetPrimaryToHome(enabledAccounts, primaryAccountKey) {
     if (enabledAccounts.length <= 1) {
         return;
     }
@@ -463,28 +458,30 @@ function accountSortMetrics(accountKey, now, sessionSoftLimit, sessionResetToler
 }
 /**
  * Order accounts to MAXIMIZE quota utilization (fill-first, smart order):
- * spend the window that expires SOONEST first, so its about-to-reset
- * allowance isn't wasted, then move to accounts with longer-dated resets.
+ * spend the overall weekly allowance that expires SOONEST first, so quota
+ * cannot disappear while traffic is consuming a newer weekly window. The 5h
+ * window remains an availability boundary: a session at its soft limit is
+ * temporarily demoted until that session resets.
  *
  * Priority among usable accounts:
  *   1. no quota data yet — probe first: one request reveals its windows and
  *      self-corrects the ordering. (Ranking unknowns last would starve them
  *      forever: never picked → never observed → never comparable.)
  *   2. session headroom before session-saturated (>= soft limit or
- *      "throttled") — saturated accounts then follow the same bucketed
- *      session ordering below: soonest back in service first, weekly
- *      deciding same-bucket ties.
- *   3. soonest SESSION (5h) reset — the capacity expiring soonest; compared
- *      in tolerance buckets so near-simultaneous resets count as equal.
- *   4. soonest WEEKLY (7d) reset — decides between same-bucket sessions.
- *   5. highest weekly utilization — finish off the one closest to done
+ *      "throttled") — do not re-hammer an urgent weekly account while its 5h
+ *      capacity is temporarily unavailable.
+ *   3. soonest WEEKLY (7d) reset — consume the oldest overall allowance
+ *      before it expires.
+ *   4. soonest SESSION (5h) reset — decides equal-weekly or fresh-weekly ties,
+ *      using tolerance buckets for comparator stability.
+ *   5. highest weekly utilization — finish off the one closest to done.
  *   6. configured primary account, then insertion order
- * An account with NO ticking session window (fresh, not yet started) has
- * nothing expiring and sorts after ticking windows in step 3.
+ * Saturated pairs are ordered by soonest 5h recovery first, then weekly reset,
+ * because neither can consume more quota until session capacity returns.
  * Cooling/rejected accounts sort last, soonest-back-to-service first, as
  * last resort.
  */
-function orderAccountsByQuota(accounts, now, primaryKey = configuredPrimaryAccountKey, sessionSoftLimit = getSessionSoftLimit(), sessionResetToleranceMs = getSessionResetToleranceMs()) {
+function orderAccountsByQuota(accounts, now, primaryKey, sessionSoftLimit = getSessionSoftLimit(), sessionResetToleranceMs = getSessionResetToleranceMs()) {
     const metrics = (key) => accountSortMetrics(key, now, sessionSoftLimit, sessionResetToleranceMs);
     return [...accounts].sort((a, b) => {
         const ma = metrics(a.key);
@@ -503,14 +500,21 @@ function orderAccountsByQuota(accounts, now, primaryKey = configuredPrimaryAccou
         if (ma.saturated !== mb.saturated) {
             return ma.saturated ? 1 : -1;
         }
-        // Saturated pairs fall through to the same bucketed session ordering:
-        // soonest-back-in-service at bucket granularity, weekly deciding ties —
-        // honoring the configured tolerance instead of exact-epoch comparison.
-        if (ma.sessionResetBucket !== mb.sessionResetBucket) {
-            return ma.sessionResetBucket - mb.sessionResetBucket;
+        if (ma.saturated && mb.saturated) {
+            if (ma.sessionResetBucket !== mb.sessionResetBucket) {
+                return ma.sessionResetBucket - mb.sessionResetBucket;
+            }
+            if (ma.weeklyReset !== mb.weeklyReset) {
+                return ma.weeklyReset - mb.weeklyReset;
+            }
         }
-        if (ma.weeklyReset !== mb.weeklyReset) {
-            return ma.weeklyReset - mb.weeklyReset;
+        else {
+            if (ma.weeklyReset !== mb.weeklyReset) {
+                return ma.weeklyReset - mb.weeklyReset;
+            }
+            if (ma.sessionResetBucket !== mb.sessionResetBucket) {
+                return ma.sessionResetBucket - mb.sessionResetBucket;
+            }
         }
         if (ma.weeklyUsed !== mb.weeklyUsed) {
             return mb.weeklyUsed - ma.weeklyUsed;
@@ -1538,7 +1542,7 @@ async function handleClaudePassthroughJsonResponse(args) {
     return responseJson;
 }
 async function loadClaudeProxyAccounts(args) {
-    const { ctx, body, tracer, requestStartTime, accountStrategy, primaryAccountKey = configuredPrimaryAccountKey, accountAllowlist = configuredAccountAllowlist, quotaRoutingEnabled = isQuotaRoutingEnabled(), sessionSoftLimit = getSessionSoftLimit(), sessionResetToleranceMs = getSessionResetToleranceMs(), buildLoggedClaudeError, } = args;
+    const { ctx, body, tracer, requestStartTime, accountStrategy, primaryAccountKey, accountAllowlist, quotaRoutingEnabled = isQuotaRoutingEnabled(), sessionSoftLimit = getSessionSoftLimit(), sessionResetToleranceMs = getSessionResetToleranceMs(), buildLoggedClaudeError, } = args;
     const fs = await import("fs");
     const os = await import("os");
     const accounts = [];
@@ -1722,10 +1726,16 @@ async function loadClaudeProxyAccounts(args) {
     const quotaOrdered = accountStrategy === "fill-first" &&
         orderedAccounts.length > 1 &&
         quotaRoutingEnabled;
+    if (!quotaOrdered && accountStrategy === "fill-first") {
+        // Apply the request-scoped home before deriving this request's order. A
+        // hot-reloaded primary change must not lag by one request. Round-robin
+        // deliberately skips this reset so its rotating index remains strict.
+        maybeResetPrimaryToHome(enabledAccounts, primaryAccountKey);
+    }
     if (quotaOrdered) {
-        // Fill-first with a smart fill order: spend the account whose window resets
-        // soonest first (max utilization), proactively skipping any whose window is
-        // rejected until its reset. Supersedes the static home/primary index.
+        // Fill-first with a smart fill order: spend the account whose weekly window
+        // expires soonest while temporarily demoting sessions without headroom.
+        // Supersedes the static home/primary index.
         orderedAccounts = orderAccountsByQuota(enabledAccounts, Date.now(), primaryAccountKey, sessionSoftLimit, sessionResetToleranceMs);
         if (logger.shouldLog("debug")) {
             logger.debug(`[proxy] quota-ordered fill sequence: ${orderedAccounts
@@ -3791,15 +3801,6 @@ async function handleAnthropicRoutedClaudeRequest(args) {
         attemptNumber: 0,
     };
     const acctSelectionSpan = tracer?.startAccountSelection();
-    // Try to return to the home primary account if its cooling has expired.
-    // Skipped under quota routing, where the fill order is derived per-request
-    // from live quota (soonest-reset-first) rather than a static home index.
-    const usingQuotaOrder = accountStrategy === "fill-first" &&
-        enabledAccounts.length > 1 &&
-        quotaRoutingEnabled;
-    if (!usingQuotaOrder) {
-        maybeResetPrimaryToHome(enabledAccounts, primaryAccountKey);
-    }
     // Never re-hammer accounts with a known active cooldown. When every account
     // is cooling, report the earliest persisted retry time without an upstream
     // call; restarting the proxy must not erase or bypass this quarantine.
@@ -4174,10 +4175,6 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
     const runtimeConfigProvider = isClaudeProxyRouteRuntimeOptions(accountAllowlistOrRuntimeOptions)
         ? accountAllowlistOrRuntimeOptions.runtimeConfigProvider
         : undefined;
-    configuredPrimaryAccountKey = primaryAccountKey;
-    configuredAccountAllowlist = accountAllowlist
-        ? new Set(accountAllowlist)
-        : undefined;
     return {
         prefix: `${basePath}/v1`,
         routes: [
@@ -4608,14 +4605,6 @@ export const __testHooks = {
         const state = accountRuntimeState.get(key);
         return state ? { ...state } : undefined;
     },
-    setConfiguredPrimaryAccountKey: (key) => {
-        configuredPrimaryAccountKey = key;
-    },
-    getConfiguredPrimaryAccountKey: () => configuredPrimaryAccountKey,
-    setConfiguredAccountAllowlist: (allowlist) => {
-        configuredAccountAllowlist = allowlist ? new Set(allowlist) : undefined;
-    },
-    getConfiguredAccountAllowlist: () => configuredAccountAllowlist ? [...configuredAccountAllowlist] : undefined,
     setPrimaryAccountIndex: (index) => {
         primaryAccountIndex = index;
     },
@@ -4631,8 +4620,6 @@ export const __testHooks = {
         transientCooldownAdmissionSchedules.clear();
         primaryAccountIndex = 0;
         lastKnownAccountCount = 0;
-        configuredPrimaryAccountKey = undefined;
-        configuredAccountAllowlist = undefined;
     },
     polyfillOAuthBody: (bodyStr, isClaudeClientRequest) => polyfillOAuthBody(bodyStr, "test-account-token", null, isClaudeClientRequest),
     isAntiAbuseConstruction429,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.92.1",
+  "version": "9.92.3",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -128,6 +128,7 @@
     "test:autoresearch": "npx tsx test/continuous-test-suite-autoresearch.ts",
     "test:autoresearch:redis": "npx tsx test/continuous-test-suite-autoresearch-redis.ts",
     "test:anthropic-tools-policy": "npx tsx test/continuous-test-suite-anthropic-tools-policy.ts",
+    "test:sagemaker-tools": "npx tsx test/continuous-test-suite-sagemaker-tools.ts",
     "test:anthropic-multimodal": "npx tsx test/continuous-test-suite-anthropic-multimodal.ts",
     "test:excel-interop": "npx tsx test/continuous-test-suite-excel-interop.ts",
     "test:envguard": "npx tsx test/helpers/envGuard.test.ts",
@@ -145,7 +146,7 @@
     "test:system-messages:vitest": "pnpm exec vitest run test/systemMessages.test.ts",
     "test:tool-routing-semantic:vitest": "pnpm exec vitest run test/toolRoutingSemantic.test.ts",
     "test:tool-routing-semantic": "pnpm run test:tool-routing-semantic:vitest && npx tsx test/continuous-test-suite-tool-routing-semantic.ts",
-    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:file-detector-extension && pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:autoresearch:redis && pnpm run test:unit:vitest && pnpm run test:tool-routing-cli:vitest && pnpm run test:tool-dedup:vitest && pnpm run test:model-pool:vitest && pnpm run test:system-messages:vitest && pnpm run test:tool-routing-semantic:vitest && pnpm run test:anthropic-tools-policy && pnpm run test:anthropic-multimodal && pnpm run test:excel-interop",
+    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:file-detector-extension && pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:autoresearch:redis && pnpm run test:unit:vitest && pnpm run test:tool-routing-cli:vitest && pnpm run test:tool-dedup:vitest && pnpm run test:model-pool:vitest && pnpm run test:system-messages:vitest && pnpm run test:tool-routing-semantic:vitest && pnpm run test:anthropic-tools-policy && pnpm run test:sagemaker-tools && pnpm run test:anthropic-multimodal && pnpm run test:excel-interop",
     "// CI tier — live providers, runs only when API keys are present (test:credentials and test:dynamic make real provider calls when keys are set, so they live here, not in test:unit)": "",
     "test:live": "pnpm run test:providers && pnpm run test:mcp:http && pnpm run test:mcp:sdk && pnpm run test:mcp:cli && pnpm run test:observability && pnpm run test:context && pnpm run test:memory && pnpm run test:tool-reliability && pnpm run test:evaluation && pnpm run test:autoresearch && pnpm run test:credentials && pnpm run test:dynamic",
     "// CI tier — product output (image/video/TTS/PPT) — costs $$ per run": "",