@juspay/neurolink 10.11.3 → 10.12.1

package/dist/server/routes/claudeProxyRoutes.js

@@ -17,6 +17,7 @@ import { buildStableClaudeCodeBillingHeader, CLAUDE_CLI_USER_AGENT, CLAUDE_CODE_
 import { clearAccountCooldown, loadAccountCooldowns, saveAccountCooldown, } from "../../proxy/accountCooldown.js";
 import { anthropicAccountKeysEqual, ENV_ANTHROPIC_ACCOUNT_KEY, isAccountAllowed, LEGACY_ANTHROPIC_ACCOUNT_KEY, shouldLoadFallbackCredential, } from "../../proxy/accountSelection.js";
 import { getUnifiedRateLimitStatus, isQuotaOverageAvailable, loadAccountQuotas, parseQuotaHeaders, saveAccountQuota, } from "../../proxy/accountQuota.js";
+import { fetchAccountUsage, listAnthropicAccountsForUsage, usageToQuota, } from "../../proxy/accountUsage.js";
 import { buildProxyLimitHeaders, summarizePoolHeadroom, } from "../../proxy/quotaHeaders.js";
 import { buildClaudeError, ClaudeStreamSerializer, generateToolUseId, parseClaudeRequest, serializeClaudeResponse, } from "../../proxy/claudeFormat.js";
 import { buildAnthropicModelsListResponse, buildTranslationOptions, extractText, extractToolArgs, extractUsageFromStreamResult, handleTranslatedJsonRequest, handleTranslatedStreamRequest, hasTranslatedOutput, } from "../../proxy/proxyTranslationEngine.js";
@@ -639,6 +640,127 @@ async function seedRuntimeQuotasFromDisk(accounts) {
         // Non-fatal: seeding is best-effort; ordering falls back to probe-first.
     }
 }
+// ---------------------------------------------------------------------------
+// Manual limits refresh (GET /limits)
+// ---------------------------------------------------------------------------
+/** Minimum spacing between usage-endpoint fetches for one account. Bounds
+ *  abuse of the ungated endpoint; inside the window the last reading is
+ *  returned as "throttled" (still fresher than any passive snapshot). */
+const MIN_USAGE_REFETCH_INTERVAL_MS = 15_000;
+const lastUsageFetchAt = new Map();
+let limitsRefreshInFlight = null;
+const USAGE_REFRESH_CONCURRENCY = 4;
+/**
+ * Fetch fresh limits from Anthropic's usage endpoint for every eligible OAuth
+ * account and write them through the exact same chain the passive header
+ * capture uses (runtime state → cooldown reconciliation → debounced disk
+ * snapshot), so routing and `auth list` see the refreshed windows and the
+ * automatic path keeps working unchanged on top of them.
+ */
+async function refreshAccountLimits(options = {}) {
+    const fetchedAt = Date.now();
+    const allAccounts = await listAnthropicAccountsForUsage(options.accountAllowlist);
+    const accounts = options.accountFilter
+        ? allAccounts.filter((account) => account.label === options.accountFilter ||
+            account.key === options.accountFilter)
+        : allAccounts;
+    const persisted = await loadAccountQuotas().catch(() => ({}));
+    const buildResult = (account, status, quota, error) => {
+        const state = accountRuntimeState.get(account.key);
+        const result = {
+            account: account.label,
+            key: account.key,
+            type: account.type,
+            status,
+            quota: quota ?? state?.quota ?? persisted[account.label] ?? null,
+        };
+        if (error !== undefined) {
+            result.error = error;
+        }
+        if (state?.coolingUntil && state.coolingUntil > Date.now()) {
+            result.coolingUntil = state.coolingUntil;
+            if (state.coolingReason) {
+                result.coolingReason = state.coolingReason;
+            }
+        }
+        return result;
+    };
+    if (options.snapshotOnly) {
+        return {
+            fetchedAt,
+            snapshot: true,
+            results: accounts.map((account) => buildResult(account, "snapshot", null)),
+        };
+    }
+    const results = new Array(accounts.length);
+    let nextIndex = 0;
+    const worker = async () => {
+        for (;;) {
+            const index = nextIndex++;
+            if (index >= accounts.length) {
+                return;
+            }
+            const account = accounts[index];
+            if (account.type !== "oauth") {
+                results[index] = buildResult(account, "skipped_api_key", null);
+                continue;
+            }
+            const lastFetch = lastUsageFetchAt.get(account.key) ?? 0;
+            if (Date.now() - lastFetch < MIN_USAGE_REFETCH_INTERVAL_MS) {
+                results[index] = buildResult(account, "throttled", null);
+                continue;
+            }
+            lastUsageFetchAt.set(account.key, Date.now());
+            // Isolate failures per account: an unexpected rejection must not abort
+            // the Promise.all sweep and turn the whole /limits response into a 502.
+            try {
+                const fetchResult = await fetchAccountUsage(account);
+                // `=== false` (not `!ok`) — the react-hooks sub-build compiles this
+                // file without strictNullChecks, where negated boolean-discriminant
+                // narrowing does not apply.
+                if (fetchResult.ok === false) {
+                    results[index] = buildResult(account, "error", null, fetchResult.error);
+                    continue;
+                }
+                const state = getOrCreateRuntimeState(account.key);
+                const capturedAt = Date.now();
+                const quota = usageToQuota(fetchResult.usage, {
+                    now: capturedAt,
+                    prior: state.quota ?? persisted[account.label] ?? null,
+                });
+                if (!quota) {
+                    results[index] = buildResult(account, "error", null, "usage payload had no recognizable limit windows");
+                    continue;
+                }
+                // Guard against a passive header capture that landed mid-fetch: never
+                // replace a fresher runtime snapshot with an older reading.
+                if (quota.lastUpdated >= (state.quota?.lastUpdated ?? 0)) {
+                    state.quota = quota;
+                }
+                const cooldownUpdate = reconcileCooldownFromQuota(state, quota, capturedAt);
+                if (cooldownUpdate?.kind === "cooled") {
+                    await saveAccountCooldown(account.key, cooldownUpdate.coolingUntil, cooldownUpdate.coolingReason).catch(() => {
+                        // Non-fatal: cooldown is already active in memory.
+                    });
+                }
+                else if (cooldownUpdate?.kind === "cleared") {
+                    await clearAccountCooldown(account.key, cooldownUpdate.coolingUntil).catch(() => {
+                        // Non-fatal: the next successful response will reconcile again.
+                    });
+                }
+                await saveAccountQuota(account.label, quota).catch(() => {
+                    // Non-fatal: quota persistence is best-effort
+                });
+                results[index] = buildResult(account, "refreshed", quota);
+            }
+            catch (err) {
+                results[index] = buildResult(account, "error", null, err instanceof Error ? err.message : String(err));
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(USAGE_REFRESH_CONCURRENCY, accounts.length || 1) }, () => worker()));
+    return { fetchedAt, snapshot: false, results };
+}
 /** Quota-aware selection is on by default; disable with
  *  NEUROLINK_PROXY_QUOTA_ROUTING=off|false|0. Only affects the fill-first
  *  strategy (round-robin keeps strict rotation). */
@@ -5037,6 +5159,45 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                 description: "Count tokens for a messages request",
                 tags: ["claude-proxy", "tokens"],
             },
+            // =====================================================================
+            // GET /limits -- Fresh account limits from Anthropic's usage endpoint
+            // =====================================================================
+            {
+                method: "GET",
+                path: `${basePath}/limits`,
+                handler: async (ctx) => {
+                    const effectiveAllowlist = runtimeConfigProvider
+                        ? runtimeConfigProvider().accountAllowlist
+                        : accountAllowlist;
+                    const snapshotOnly = ctx.query?.snapshot === "true" || ctx.query?.snapshot === "1";
+                    const accountFilter = ctx.query?.account;
+                    return withSpan({
+                        name: "neurolink.http.claudeProxy.limits",
+                        tracer: tracers.http,
+                        attributes: { "http.route": `${basePath}/limits` },
+                    }, async () => {
+                        // Single-flight: concurrent full refreshes share one sweep.
+                        if (!snapshotOnly && !accountFilter) {
+                            if (!limitsRefreshInFlight) {
+                                limitsRefreshInFlight = refreshAccountLimits({
+                                    accountAllowlist: effectiveAllowlist,
+                                }).finally(() => {
+                                    limitsRefreshInFlight = null;
+                                });
+                            }
+                            return limitsRefreshInFlight;
+                        }
+                        return refreshAccountLimits({
+                            accountAllowlist: effectiveAllowlist,
+                            accountFilter,
+                            snapshotOnly,
+                        });
+                    });
+                },
+                description: "Fetch fresh per-account limits from Anthropic (usage API). " +
+                    "?account=<label> for one account, ?snapshot=true for stored state",
+                tags: ["claude-proxy", "limits"],
+            },
         ],
     };
 }
@@ -5340,6 +5501,11 @@ export const __testHooks = {
     maybeResetPrimaryToHome,
     planCooldownFor429,
     reconcileCooldownFromQuota,
+    refreshAccountLimits,
+    clearLimitsRefreshStateForTests: () => {
+        lastUsageFetchAt.clear();
+        limitsRefreshInFlight = null;
+    },
     isRetryableNetworkError,
     isPermanentRefreshFailure,
     getStreamFailureDetails,

package/dist/types/cli.d.ts

@@ -11,6 +11,7 @@ import type { PPTGenerationResult } from "./ppt.js";
 import type { AvatarResult } from "./avatar.js";
 import type { MusicResult } from "./music.js";
 import type { OAuthTokens } from "./auth.js";
+import type { AccountQuota } from "./proxy.js";
 import type { ClaudeSubscriptionTier } from "./subscription.js";
 import type { ServerFramework } from "./server.js";
 import type { AuthProviderType } from "./auth.js";
@@ -947,6 +948,8 @@ export type AuthCommandArgs = BaseCommandArgs & {
     label?: string;
     account?: string;
     force?: boolean;
+    /** `auth list --refresh`: fetch fresh limits from Anthropic before listing */
+    refresh?: boolean;
     /** Path to the proxy config YAML, used by set-/get-/clear-primary */
     config?: string;
     /** Email passed to `auth set-primary <email>` */
@@ -954,6 +957,15 @@ export type AuthCommandArgs = BaseCommandArgs & {
     /** Yargs positional arguments */
     _?: (string | number)[];
 };
+/** Outcome of the `auth list --refresh` fresh-limit fetch. */
+export type AuthListRefreshOutcome = {
+    /** How the fresh limits were obtained ("none" when every path failed). */
+    via: "proxy" | "direct" | "none";
+    /** Freshly fetched quotas keyed by account label; null when none fetched. */
+    quotas: Record<string, AccountQuota> | null;
+    /** Per-account and transport errors, already formatted for display. */
+    errors: string[];
+};
 /** Telemetry command arguments */
 export type TelemetryCommandArgs = {
     format?: "text" | "json" | "table";

package/dist/types/proxy.d.ts

@@ -943,6 +943,107 @@ export type AccountQuota = {
     overageStatus: string;
     /** Epoch ms when we last captured this data */
     lastUpdated: number;
+    /** Dynamic per-plan limit buckets from the usage API `limits[]` array
+     *  (session / weekly_all / model-scoped weeklies such as Fable / future
+     *  kinds). Absent on purely header-sourced snapshots. */
+    windows?: AccountQuotaWindow[];
+    /** Epoch ms when `windows` was last refreshed from the usage API. */
+    windowsUpdatedAt?: number;
+    /** Provenance of this snapshot's numbers. */
+    source?: AccountQuotaSource;
+};
+/** Where an AccountQuota snapshot came from.
+ *  - "headers"   : passive capture of anthropic-ratelimit-unified-* response
+ *                  headers on a routed request (the automatic path).
+ *  - "usage-api" : an explicit refresh against Anthropic's OAuth usage
+ *                  endpoint (manual refetch path). */
+export type AccountQuotaSource = "headers" | "usage-api";
+/** One dynamic limit bucket from the usage API. Provider vocabulary (`kind`,
+ *  `group`, `severity`) is preserved verbatim so buckets Anthropic adds later
+ *  survive storage and display without a code change. */
+export type AccountQuotaWindow = {
+    /** Provider kind, verbatim ("session", "weekly_all", "weekly_scoped", ...). */
+    kind: string;
+    /** Provider group, verbatim ("session" | "weekly" | future values). */
+    group?: string;
+    /** 0.0-1.0 utilization (provider percent / 100). */
+    used: number;
+    /** Provider severity, verbatim ("normal", ...). */
+    severity?: string;
+    /** Derived "allowed" | "rejected" (see usageToQuota status mapping). */
+    status: string;
+    /** Unix timestamp (seconds) when this window resets; 0 when unparseable. */
+    resetsAt: number;
+    isActive?: boolean;
+    /** Model display name for model-scoped windows (e.g. "Fable"). */
+    scopeModel?: string;
+    /** Surface scope when the provider reports one. */
+    scopeSurface?: string;
+};
+/** One utilization window from the OAuth usage endpoint (wire shape, loose). */
+export type AnthropicUsageWindow = {
+    /** 0-100 percent (note: NOT the 0-1 fraction used by headers). */
+    utilization?: number | null;
+    /** ISO-8601 timestamp. */
+    resets_at?: string | null;
+};
+/** One entry of the usage endpoint's generic `limits[]` array (wire shape). */
+export type AnthropicUsageLimit = {
+    kind?: string;
+    group?: string;
+    /** 0-100 percent. */
+    percent?: number | null;
+    severity?: string | null;
+    resets_at?: string | null;
+    scope?: {
+        model?: {
+            id?: string | null;
+            display_name?: string | null;
+        } | null;
+        surface?: string | null;
+    } | null;
+    is_active?: boolean | null;
+};
+/** Response body of GET https://api.anthropic.com/api/oauth/usage (loose —
+ *  unknown keys are ignored, known keys may be absent or null). */
+export type AnthropicUsageResponse = {
+    five_hour?: AnthropicUsageWindow | null;
+    seven_day?: AnthropicUsageWindow | null;
+    limits?: AnthropicUsageLimit[] | null;
+    extra_usage?: {
+        is_enabled?: boolean | null;
+    } | null;
+};
+/** Outcome of one account's usage-endpoint fetch. Return-not-throw. */
+export type AccountUsageFetchResult = {
+    ok: true;
+    usage: AnthropicUsageResponse;
+} | {
+    ok: false;
+    reason: "not_oauth" | "auth" | "http" | "network" | "parse";
+    error: string;
+    status?: number;
+};
+/** Per-account result inside a GET /limits response. */
+export type ProxyLimitsAccountResult = {
+    /** Account label (quota-store key). */
+    account: string;
+    /** Token-store key ("anthropic:<label>"). */
+    key: string;
+    type: ProxyAccountType;
+    status: "refreshed" | "throttled" | "skipped_api_key" | "snapshot" | "error";
+    /** Fresh quota on "refreshed"; last known snapshot otherwise (may be null). */
+    quota: AccountQuota | null;
+    error?: string;
+    coolingUntil?: number;
+    coolingReason?: AccountCoolingReason;
+};
+/** Response body of the proxy's GET /limits endpoint. */
+export type ProxyLimitsRefreshResponse = {
+    fetchedAt: number;
+    /** True when served from stored state without contacting Anthropic. */
+    snapshot: boolean;
+    results: ProxyLimitsAccountResult[];
 };
 /**
  * Provenance of the quota numbers attached to a single proxy response.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "10.11.3",
+  "version": "10.12.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": {
@@ -163,7 +163,7 @@
     "test:system-messages": "npx tsx test/continuous-test-suite-system-messages.ts",
     "test:test-stubs": "npx tsx test/continuous-test-suite-test-stubs.ts",
     "test:tool-routing-semantic": "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:file-detector-magic-bytes && 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:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:litellm-context && pnpm run test:dedup-execute-map && pnpm run test:step-budget-guard && pnpm run test:agent-plumbing && pnpm run test:tool-execution-recorder && pnpm run test:proxy-terminal-errors && pnpm run test:system-messages && pnpm run test:tool-routing-semantic && pnpm run test:anthropic-tools-policy && pnpm run test:anthropic-structured && pnpm run test:sagemaker-tools && pnpm run test:anthropic-multimodal && pnpm run test:excel-interop && pnpm run test:model-capabilities && pnpm run test:agent-runtime:vitest && pnpm run test:agent-delegation && pnpm run test:retry-after:vitest && pnpm run test:sampling-params && pnpm run test:structured-recovery && pnpm run test:prompt-redaction && pnpm run test:mcp-result-cache && pnpm run test:test-stubs && pnpm run test:model-not-found-retryable && pnpm run test:websearch-grounding",
+    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:file-detector-extension && pnpm run test:file-detector-magic-bytes && 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:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:litellm-context && pnpm run test:dedup-execute-map && pnpm run test:step-budget-guard && pnpm run test:agent-plumbing && pnpm run test:tool-execution-recorder && pnpm run test:proxy-terminal-errors && pnpm run test:proxy-usage-refresh && pnpm run test:system-messages && pnpm run test:tool-routing-semantic && pnpm run test:anthropic-tools-policy && pnpm run test:anthropic-structured && pnpm run test:sagemaker-tools && pnpm run test:anthropic-multimodal && pnpm run test:excel-interop && pnpm run test:model-capabilities && pnpm run test:agent-runtime:vitest && pnpm run test:agent-delegation && pnpm run test:retry-after:vitest && pnpm run test:sampling-params && pnpm run test:structured-recovery && pnpm run test:prompt-redaction && pnpm run test:mcp-result-cache && pnpm run test:test-stubs && pnpm run test:model-not-found-retryable && pnpm run test:websearch-grounding",
     "// 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": "",
@@ -233,6 +233,7 @@
     "test:tool-execution-recorder": "npx tsx test/continuous-test-suite-tool-execution-recorder.ts",
     "test:proxy-terminal-errors": "npx tsx test/continuous-test-suite-proxy-terminal-errors.ts",
     "test:proxy-limit-headers": "npx tsx test/continuous-test-suite-proxy-limit-headers.ts",
+    "test:proxy-usage-refresh": "npx tsx test/continuous-test-suite-proxy-usage-refresh.ts",
     "test:anthropic-limit-capture": "npx tsx test/continuous-test-suite-anthropic-limit-capture.ts",
     "test:audio": "npx tsx test/continuous-test-suite-audio.ts",
     "test:file-formats": "npx tsx test/continuous-test-suite-file-formats.ts",