@juspay/neurolink 9.91.1 → 9.92.1

package/dist/server/routes/claudeProxyRoutes.js

@@ -53,10 +53,9 @@ 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 (e.g. "anthropic:user@example.com") of the configured
- *  home/primary account. Set once at proxy boot from routing.primaryAccount.
- *  When undefined, home semantics fall back to enabledAccounts[0] (insertion
- *  order) — preserves pre-existing behavior. */
+/** 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;
@@ -130,8 +129,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) {
-    const primaryAccountKey = configuredPrimaryAccountKey;
+function resolveHomeIndex(enabledAccounts, primaryAccountKey = configuredPrimaryAccountKey) {
     if (!primaryAccountKey) {
         return 0;
     }
@@ -142,11 +140,11 @@ function resolveHomeIndex(enabledAccounts) {
  *  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) {
+function maybeResetPrimaryToHome(enabledAccounts, primaryAccountKey = configuredPrimaryAccountKey) {
     if (enabledAccounts.length <= 1) {
         return;
     }
-    const homeIndex = resolveHomeIndex(enabledAccounts);
+    const homeIndex = resolveHomeIndex(enabledAccounts, primaryAccountKey);
     if (primaryAccountIndex === homeIndex) {
         return;
     }
@@ -486,12 +484,7 @@ function accountSortMetrics(accountKey, now, sessionSoftLimit, sessionResetToler
  * Cooling/rejected accounts sort last, soonest-back-to-service first, as
  * last resort.
  */
-function orderAccountsByQuota(accounts, now) {
-    const primaryKey = configuredPrimaryAccountKey;
-    // Read the env-tunable thresholds once per sort: cheaper than per-compare,
-    // and a mid-sort env change can never make the comparator intransitive.
-    const sessionSoftLimit = getSessionSoftLimit();
-    const sessionResetToleranceMs = getSessionResetToleranceMs();
+function orderAccountsByQuota(accounts, now, primaryKey = configuredPrimaryAccountKey, sessionSoftLimit = getSessionSoftLimit(), sessionResetToleranceMs = getSessionResetToleranceMs()) {
     const metrics = (key) => accountSortMetrics(key, now, sessionSoftLimit, sessionResetToleranceMs);
     return [...accounts].sort((a, b) => {
         const ma = metrics(a.key);
@@ -1545,7 +1538,7 @@ async function handleClaudePassthroughJsonResponse(args) {
     return responseJson;
 }
 async function loadClaudeProxyAccounts(args) {
-    const { ctx, body, tracer, requestStartTime, accountStrategy, buildLoggedClaudeError, } = args;
+    const { ctx, body, tracer, requestStartTime, accountStrategy, primaryAccountKey = configuredPrimaryAccountKey, accountAllowlist = configuredAccountAllowlist, quotaRoutingEnabled = isQuotaRoutingEnabled(), sessionSoftLimit = getSessionSoftLimit(), sessionResetToleranceMs = getSessionResetToleranceMs(), buildLoggedClaudeError, } = args;
     const fs = await import("fs");
     const os = await import("os");
     const accounts = [];
@@ -1558,7 +1551,7 @@ async function loadClaudeProxyAccounts(args) {
     }
     const compoundKeys = await tokenStore.listByPrefix("anthropic:");
     for (const key of compoundKeys) {
-        if (!isAccountAllowed(key, configuredAccountAllowlist)) {
+        if (!isAccountAllowed(key, accountAllowlist)) {
             logger.debug(`[proxy] skipping account=${key} (not in account allowlist)`);
             continue;
         }
@@ -1665,7 +1658,7 @@ async function loadClaudeProxyAccounts(args) {
         addAccount();
     }
     if (accounts.length === 0 &&
-        shouldLoadFallbackCredential(compoundKeys.length, LEGACY_ANTHROPIC_ACCOUNT_KEY, configuredAccountAllowlist)) {
+        shouldLoadFallbackCredential(compoundKeys.length, LEGACY_ANTHROPIC_ACCOUNT_KEY, accountAllowlist)) {
         try {
             const creds = JSON.parse(fs.readFileSync(legacyCredPath, "utf8"));
             const legacyAccount = await tryLoadLegacyAccount(creds, legacyCredPath);
@@ -1679,7 +1672,7 @@ async function loadClaudeProxyAccounts(args) {
     }
     if (process.env.ANTHROPIC_API_KEY &&
         accounts.length === 0 &&
-        shouldLoadFallbackCredential(compoundKeys.length, ENV_ANTHROPIC_ACCOUNT_KEY, configuredAccountAllowlist)) {
+        shouldLoadFallbackCredential(compoundKeys.length, ENV_ANTHROPIC_ACCOUNT_KEY, accountAllowlist)) {
         accounts.push({
             key: ENV_ANTHROPIC_ACCOUNT_KEY,
             label: "env",
@@ -1688,7 +1681,7 @@ async function loadClaudeProxyAccounts(args) {
         });
     }
     if (accounts.length === 0) {
-        const noCredentialsMessage = configuredAccountAllowlist
+        const noCredentialsMessage = accountAllowlist
             ? "No allowed Anthropic credentials are currently available"
             : compoundKeys.length > 0
                 ? "Configured Anthropic accounts are disabled or unavailable"
@@ -1728,12 +1721,12 @@ async function loadClaudeProxyAccounts(args) {
     let orderedAccounts = [...enabledAccounts];
     const quotaOrdered = accountStrategy === "fill-first" &&
         orderedAccounts.length > 1 &&
-        isQuotaRoutingEnabled();
+        quotaRoutingEnabled;
     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.
-        orderedAccounts = orderAccountsByQuota(enabledAccounts, Date.now());
+        orderedAccounts = orderAccountsByQuota(enabledAccounts, Date.now(), primaryAccountKey, sessionSoftLimit, sessionResetToleranceMs);
         if (logger.shouldLog("debug")) {
             logger.debug(`[proxy] quota-ordered fill sequence: ${orderedAccounts
                 .map((a) => a.label)
@@ -1743,7 +1736,7 @@ async function loadClaudeProxyAccounts(args) {
     else {
         if (accountStrategy === "round-robin" &&
             orderedAccounts.length !== lastKnownAccountCount) {
-            primaryAccountIndex = resolveHomeIndex(orderedAccounts);
+            primaryAccountIndex = resolveHomeIndex(orderedAccounts, primaryAccountKey);
             lastKnownAccountCount = orderedAccounts.length;
         }
         if (orderedAccounts.length > 1) {
@@ -3768,7 +3761,7 @@ function shouldAttemptClaudeFallback(loopState) {
     return loopState.invalidRequestFailure === null;
 }
 async function handleAnthropicRoutedClaudeRequest(args) {
-    const { ctx, body, modelRouter, tracer, requestStartTime, accountStrategy, buildLoggedClaudeError, logProxyBody, logFinalRequest, } = args;
+    const { ctx, body, modelRouter, tracer, requestStartTime, accountStrategy, primaryAccountKey, accountAllowlist, quotaRoutingEnabled = isQuotaRoutingEnabled(), sessionSoftLimit = getSessionSoftLimit(), sessionResetToleranceMs = getSessionResetToleranceMs(), buildLoggedClaudeError, logProxyBody, logFinalRequest, } = args;
     const parsedRequest = parseClaudeRequest(body);
     const loadedAccounts = await loadClaudeProxyAccounts({
         ctx,
@@ -3776,6 +3769,11 @@ async function handleAnthropicRoutedClaudeRequest(args) {
         tracer,
         requestStartTime,
         accountStrategy,
+        primaryAccountKey,
+        accountAllowlist,
+        quotaRoutingEnabled,
+        sessionSoftLimit,
+        sessionResetToleranceMs,
         buildLoggedClaudeError,
     });
     if ("response" in loadedAccounts) {
@@ -3798,9 +3796,9 @@ async function handleAnthropicRoutedClaudeRequest(args) {
     // from live quota (soonest-reset-first) rather than a static home index.
     const usingQuotaOrder = accountStrategy === "fill-first" &&
         enabledAccounts.length > 1 &&
-        isQuotaRoutingEnabled();
+        quotaRoutingEnabled;
     if (!usingQuotaOrder) {
-        maybeResetPrimaryToHome(enabledAccounts);
+        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
@@ -4154,6 +4152,11 @@ async function handleAnthropicRoutedClaudeRequest(args) {
 // ---------------------------------------------------------------------------
 // Route factory
 // ---------------------------------------------------------------------------
+function isClaudeProxyRouteRuntimeOptions(value) {
+    return (value !== undefined &&
+        "runtimeConfigProvider" in value &&
+        typeof value.runtimeConfigProvider === "function");
+}
 /**
  * Create Claude-compatible proxy routes.
  *
@@ -4164,7 +4167,13 @@ async function handleAnthropicRoutedClaudeRequest(args) {
  * @param basePath    - Base path prefix (default: "" since Claude API uses /v1/...).
  * @returns RouteGroup with Claude-compatible endpoints.
  */
-export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrategy = "fill-first", passthroughMode = false, primaryAccountKey, accountAllowlist) {
+export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrategy = "fill-first", passthroughMode = false, primaryAccountKey, accountAllowlistOrRuntimeOptions) {
+    const accountAllowlist = isClaudeProxyRouteRuntimeOptions(accountAllowlistOrRuntimeOptions)
+        ? accountAllowlistOrRuntimeOptions.accountAllowlist
+        : accountAllowlistOrRuntimeOptions;
+    const runtimeConfigProvider = isClaudeProxyRouteRuntimeOptions(accountAllowlistOrRuntimeOptions)
+        ? accountAllowlistOrRuntimeOptions.runtimeConfigProvider
+        : undefined;
     configuredPrimaryAccountKey = primaryAccountKey;
     configuredAccountAllowlist = accountAllowlist
         ? new Set(accountAllowlist)
@@ -4179,6 +4188,18 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                 method: "POST",
                 path: `${basePath}/v1/messages`,
                 handler: async (ctx) => {
+                    const requestRouting = runtimeConfigProvider?.() ?? {
+                        generation: 0,
+                        strategy: accountStrategy,
+                        modelRouter,
+                        passthrough: passthroughMode,
+                        primaryAccountKey,
+                        accountAllowlist,
+                        quotaRoutingEnabled: isQuotaRoutingEnabled(),
+                        sessionSoftLimit: getSessionSoftLimit(),
+                        sessionResetToleranceMs: getSessionResetToleranceMs(),
+                    };
+                    const requestModelRouter = requestRouting.modelRouter;
                     const body = ctx.body;
                     // 1. Validate
                     if (typeof body?.model !== "string" ||
@@ -4188,12 +4209,12 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                     // 2. Resolve model via router (or pass through to anthropic)
                     // Guard: without a model router, only Claude models are allowed.
                     const modelLower = body.model.toLowerCase();
-                    if (!modelRouter && !modelLower.startsWith("claude-")) {
+                    if (!requestModelRouter && !modelLower.startsWith("claude-")) {
                         return buildClaudeError(404, `Model '${body.model}' is not an Anthropic model. ` +
                             `The proxy only supports Claude models. ` +
                             `Use a model router to route non-Claude models to other providers.`);
                     }
-                    const route = modelRouter?.resolve(body.model) ?? {
+                    const route = requestModelRouter?.resolve(body.model) ?? {
                         provider: "anthropic",
                         model: body.model,
                     };
@@ -4213,7 +4234,7 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                         }
                         if (route.provider === "anthropic") {
                             tracer?.setMode("passthrough");
-                            if (passthroughMode) {
+                            if (requestRouting.passthrough) {
                                 return handleClaudePassthroughRequest({
                                     ctx,
                                     body,
@@ -4226,10 +4247,15 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                             return handleAnthropicRoutedClaudeRequest({
                                 ctx,
                                 body,
-                                modelRouter,
+                                modelRouter: requestModelRouter,
                                 tracer,
                                 requestStartTime,
-                                accountStrategy,
+                                accountStrategy: requestRouting.strategy,
+                                primaryAccountKey: requestRouting.primaryAccountKey,
+                                accountAllowlist: requestRouting.accountAllowlist,
+                                quotaRoutingEnabled: requestRouting.quotaRoutingEnabled,
+                                sessionSoftLimit: requestRouting.sessionSoftLimit,
+                                sessionResetToleranceMs: requestRouting.sessionResetToleranceMs,
                                 buildLoggedClaudeError,
                                 logProxyBody,
                                 logFinalRequest,
@@ -4243,7 +4269,7 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                                     provider: route.provider,
                                     model: route.model,
                                 },
-                                modelRouter,
+                                modelRouter: requestModelRouter,
                                 tracer,
                                 requestStartTime,
                                 logProxyBody,
@@ -4274,11 +4300,16 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
             {
                 method: "GET",
                 path: `${basePath}/v1/models`,
-                handler: async (_ctx) => withSpan({
-                    name: "neurolink.http.claudeProxy.listModels",
-                    tracer: tracers.http,
-                    attributes: { "http.route": `${basePath}/v1/models` },
-                }, async () => buildAnthropicModelsListResponse(modelRouter)),
+                handler: async (_ctx) => {
+                    const requestModelRouter = runtimeConfigProvider
+                        ? runtimeConfigProvider().modelRouter
+                        : modelRouter;
+                    return withSpan({
+                        name: "neurolink.http.claudeProxy.listModels",
+                        tracer: tracers.http,
+                        attributes: { "http.route": `${basePath}/v1/models` },
+                    }, async () => buildAnthropicModelsListResponse(requestModelRouter));
+                },
                 description: "List available models (Anthropic schema)",
                 tags: ["claude-proxy", "models"],
             },

package/dist/server/routes/openaiProxyRoutes.d.ts

@@ -11,8 +11,7 @@
  * An optional ModelRouter can remap incoming model names to different
  * provider/model pairs (e.g. "gpt-4o" -> vertex/gemini-2.5-pro).
  */
-import type { ModelRouter } from "../../proxy/modelRouter.js";
-import type { RouteGroup } from "../../types/index.js";
+import type { ModelRouterInterface, ProxyRuntimeConfigProvider, RouteGroup } from "../../types/index.js";
 /**
  * Create OpenAI-compatible proxy routes.
  *
@@ -27,4 +26,4 @@ import type { RouteGroup } from "../../types/index.js";
  *                        headers — to avoid SSRF.
  * @returns RouteGroup with OpenAI-compatible endpoints.
  */
-export declare function createOpenAIProxyRoutes(modelRouter?: ModelRouter, basePath?: string, loopbackPort?: number): RouteGroup;
+export declare function createOpenAIProxyRoutes(modelRouter?: ModelRouterInterface, basePath?: string, loopbackPort?: number, runtimeConfigProvider?: ProxyRuntimeConfigProvider): RouteGroup;

package/dist/server/routes/openaiProxyRoutes.js

@@ -227,7 +227,7 @@ async function handleOpenAIToAnthropicBridge(args) {
  *                        headers — to avoid SSRF.
  * @returns RouteGroup with OpenAI-compatible endpoints.
  */
-export function createOpenAIProxyRoutes(modelRouter, basePath = "", loopbackPort = DEFAULT_LOOPBACK_PORT) {
+export function createOpenAIProxyRoutes(modelRouter, basePath = "", loopbackPort = DEFAULT_LOOPBACK_PORT, runtimeConfigProvider) {
     return {
         prefix: `${basePath}/v1`,
         routes: [
@@ -239,6 +239,9 @@ export function createOpenAIProxyRoutes(modelRouter, basePath = "", loopbackPort
                 path: `${basePath}/v1/chat/completions`,
                 description: "OpenAI-compatible chat completions (translation mode)",
                 handler: async (ctx) => {
+                    const requestModelRouter = runtimeConfigProvider
+                        ? runtimeConfigProvider().modelRouter
+                        : modelRouter;
                     const requestStartTime = Date.now();
                     const body = ctx.body;
                     // --- Validation ---
@@ -246,8 +249,8 @@ export function createOpenAIProxyRoutes(modelRouter, basePath = "", loopbackPort
                         return buildOpenAIErrorResponse(400, "Request must include 'model' and 'messages' fields");
                     }
                     // --- Resolve target provider/model ---
-                    const route = modelRouter
-                        ? modelRouter.resolve(body.model)
+                    const route = requestModelRouter
+                        ? requestModelRouter.resolve(body.model)
                         : { provider: null, model: body.model };
                     const targetProvider = route.provider ?? undefined;
                     const targetModel = route.model ?? body.model;
@@ -302,7 +305,7 @@ export function createOpenAIProxyRoutes(modelRouter, basePath = "", loopbackPort
                     const plan = buildProxyTranslationPlan({
                         provider: targetProvider ?? "auto",
                         model: targetModel,
-                    }, modelRouter?.getFallbackChain() ?? [], body.model, 
+                    }, requestModelRouter?.getFallbackChain() ?? [], body.model, 
                     // The classifier only reads fields present on both types.
                     adapted);
                     const attempts = plan.attempts;
@@ -369,7 +372,10 @@ export function createOpenAIProxyRoutes(modelRouter, basePath = "", loopbackPort
                 path: `${basePath}/v1/models`,
                 description: "List available models in OpenAI format",
                 handler: async () => {
-                    return buildModelsListResponse(modelRouter);
+                    const requestModelRouter = runtimeConfigProvider
+                        ? runtimeConfigProvider().modelRouter
+                        : modelRouter;
+                    return buildModelsListResponse(requestModelRouter);
                 },
             },
         ],

package/dist/types/cli.d.ts

@@ -837,6 +837,14 @@ export type ProxyState = {
     managedBy?: "launchd" | "manual";
     /** Whether the proxy is running in transparent passthrough mode */
     passthrough?: boolean;
+    /** Active hot-reload configuration generation. */
+    configGeneration?: number;
+    /** Timestamp when the active configuration generation was loaded. */
+    configLoadedAt?: string;
+    /** Last rejected hot-reload error, when any. */
+    lastConfigReloadError?: string;
+    /** Absolute path watched for proxy routing configuration changes. */
+    configFile?: string;
 };
 /** Stored credentials for an authenticated provider. */
 export type StoredCredentials = {

package/dist/types/proxy.d.ts

@@ -18,7 +18,7 @@ import type { Hono } from "hono";
 import type { Ora } from "ora";
 import type { MCPToolRegistry } from "../mcp/toolRegistry.js";
 import type { ProxyTracer } from "../proxy/proxyTracer.js";
-import type { FallbackEntry, ProxyRoutingConfig, CloakingConfig } from "./subscription.js";
+import type { FallbackEntry, ModelMapping, ProxyRoutingConfig, CloakingConfig } from "./subscription.js";
 import type { RouteDeprecation } from "./server.js";
 /**
  * Type describing the ModelRouter contract.
@@ -28,6 +28,8 @@ export type ModelRouterInterface = {
     resolve(requestedModel: string): RouteResult;
     isClaudeTarget(requestedModel: string): boolean;
     getFallbackChain(): FallbackEntry[];
+    getModelMappings?: () => ModelMapping[];
+    getPassthroughModels?: () => string[];
 };
 /** A single text block in a Claude content array. */
 export type ClaudeTextBlock = {
@@ -1245,6 +1247,70 @@ export type LoadedProxyConfig = {
         strategy?: ProxyStartStrategy;
     };
 };
+/** Routing values captured once when a proxy request begins. */
+export type ProxyRequestRoutingSnapshot = {
+    generation: number;
+    strategy: ProxyStartStrategy;
+    modelRouter?: ModelRouterInterface;
+    passthrough: boolean;
+    primaryAccountKey?: string;
+    accountAllowlist?: ReadonlySet<string>;
+    quotaRoutingEnabled: boolean;
+    sessionSoftLimit: number;
+    sessionResetToleranceMs: number;
+};
+/** Immutable last-known-good proxy configuration published at runtime. */
+export type ProxyRuntimeConfigSnapshot = ProxyRequestRoutingSnapshot & {
+    loadedAt: string;
+    configHash: string;
+    proxyConfig: LoadedProxyConfig | null;
+};
+/** Source that requested a runtime configuration reload. */
+export type ProxyRuntimeConfigReloadSource = "startup" | "watch" | "sighup" | "manual";
+/** Result returned after a serialized runtime configuration reload attempt. */
+export type ProxyRuntimeConfigReloadResult = {
+    applied: boolean;
+    changed: boolean;
+    generation: number;
+    error?: string;
+};
+/** Safe runtime configuration diagnostics exposed through proxy status. */
+export type ProxyRuntimeConfigStatus = {
+    configPath: string;
+    envFilePath?: string;
+    generation: number;
+    loadedAt: string;
+    configHash: string;
+    watching: boolean;
+    lastReloadAttemptAt?: string;
+    lastReloadAt?: string;
+    lastReloadSource?: ProxyRuntimeConfigReloadSource;
+    lastReloadError?: string;
+    consecutiveFailures: number;
+};
+/** Constructor options for the proxy runtime configuration store. */
+export type ProxyRuntimeConfigStoreOptions = {
+    configPath: string;
+    configRequired: boolean;
+    envFilePath?: string;
+    envFileRequired?: boolean;
+    baseEnv: Record<string, string | undefined>;
+    strategyOverride?: ProxyStartStrategy;
+    passthrough: boolean;
+    watchIntervalMs?: number;
+    watchDebounceMs?: number;
+};
+/** Runtime configuration provider captured by route factories. */
+export type ProxyRuntimeConfigProvider = () => ProxyRequestRoutingSnapshot;
+/** Optional runtime configuration wiring for Claude proxy route factories. */
+export type ClaudeProxyRouteRuntimeOptions = {
+    accountAllowlist?: AccountAllowlist;
+    runtimeConfigProvider: ProxyRuntimeConfigProvider;
+};
+/** Listener invoked after a new configuration generation is published. */
+export type ProxyRuntimeConfigListener = (snapshot: ProxyRuntimeConfigSnapshot) => void;
+/** Listener invoked after every successful or rejected reload attempt. */
+export type ProxyRuntimeConfigReloadListener = (result: ProxyRuntimeConfigReloadResult, status: ProxyRuntimeConfigStatus) => void;
 /**
  * Handle for a NeuroLink runtime created by the proxy start command.
  * The `neurolink` field is typed structurally (only the method used by the

package/dist/types/subscription.d.ts

@@ -909,6 +909,12 @@ export type ProxyRoutingConfig = {
     modelMappings: ModelMapping[];
     fallbackChain: FallbackEntry[];
     passthroughModels?: string[];
+    /** Enable quota-aware fill-first account ordering. Defaults to true. */
+    quotaRouting?: boolean;
+    /** Session utilization threshold used to proactively demote an account. */
+    sessionSoftLimit?: number;
+    /** Reset-time bucket width used when ordering quota windows. */
+    sessionResetToleranceMs?: number;
     /** Email/label of the Anthropic account that should be tried first
      *  ("home"). When absent, falls back to insertion-order index 0.
      *  Resolved per-request to a stable key (anthropic:<email>); does not

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.91.1",
+  "version": "9.92.1",
   "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": {