@juspay/neurolink 10.11.2 → 10.12.0

package/dist/lib/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/lib/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/lib/types/file.d.ts

@@ -22,6 +22,36 @@ export type VisionImageConversion = {
     /** True when the bytes were re-encoded; false when they were left alone. */
     readonly converted: boolean;
 };
+/**
+ * Outcome of an audio-compatibility pass over one file.
+ *
+ * See `adapters/audioFormatSupport.ts`. As with images, `converted` is false
+ * both when the container was already acceptable and when nothing could
+ * re-encode it, so it is not a success flag — the caller decides what to do
+ * from the resulting `mimeType`.
+ */
+export type AudioConversionResult = {
+    readonly buffer: Buffer;
+    readonly mimeType: string;
+    /** True when the bytes were re-encoded; false when they were left alone. */
+    readonly converted: boolean;
+};
+/**
+ * One audio file destined for native delivery to a provider.
+ *
+ * Carries the bytes rather than a path because the decision to send audio is
+ * made per provider, after detection has already read the file — re-reading it
+ * from disk at dispatch time would be a second read of something already in
+ * memory.
+ */
+export type MultimodalAudioEntry = {
+    /** Raw audio bytes, as detected. */
+    buffer: Buffer;
+    /** Display name; may be a full path, so log only its basename. */
+    filename: string;
+    /** Detected MIME type of `buffer`. */
+    mimeType: string;
+};
 /**
  * Broad category a file format belongs to, as a human would name it.
  *
@@ -445,6 +475,17 @@ export type FileDetectorOptions = {
      * hint (the lazy FileReferenceRegistry path has its own hint-handling).
      */
     mimetypeHint?: string;
+    /**
+     * Caller-provided filename hint, the companion to {@link mimetypeHint}.
+     *
+     * The unified file path unwraps a `FileWithMetadata` to its `buffer` before
+     * detection runs, so the object's `filename` is gone by the time extension
+     * resolution looks for one — and TAR in particular cannot be identified any
+     * other way, because its "ustar" marker sits at byte 257 rather than at
+     * offset 0. Passing the name alongside the bytes keeps `.odp`, `.rtf` and
+     * `.tar` routed to the processors that can actually read them.
+     */
+    filenameHint?: string;
 };
 /**
  * Google AI Studio Files API types

package/dist/lib/types/generate.d.ts

@@ -17,7 +17,7 @@ import type { AvatarOptions, AvatarResult } from "./avatar.js";
 import type { MusicOptions, MusicResult } from "./music.js";
 import type { StandardRecord, ValidationSchema, ZodUnknownSchema } from "./aliases.js";
 import type { NeurolinkCredentials } from "./providers.js";
-import type { CSVProcessorOptions, FileWithMetadata } from "./file.js";
+import type { CSVProcessorOptions, FileWithMetadata, MultimodalAudioEntry } from "./file.js";
 import type { WorkflowConfig } from "./workflow.js";
 import type { Schema, Tool, ToolChoice } from "./tools.js";
 import type { StepResult, LanguageModel } from "./providers.js";
@@ -56,6 +56,17 @@ export type GenerateOptions = {
         csvFiles?: Array<Buffer | string>;
         pdfFiles?: Array<Buffer | string>;
         audioFiles?: Array<Buffer | string>;
+        /**
+         * Audio whose bytes should be delivered to the provider, populated during
+         * detection rather than by callers.
+         *
+         * Separate from `audioFiles` above, which is the caller-facing input that
+         * yields a metadata summary. This one carries the decoded bytes forward so
+         * a provider that can actually listen receives the audio instead of a
+         * description of it; providers that cannot fall back to the summary and
+         * this is ignored.
+         */
+        nativeAudioFiles?: MultimodalAudioEntry[];
         videoFiles?: Array<Buffer | string>;
         files?: Array<Buffer | string | FileWithMetadata>;
         content?: Content[];

package/dist/lib/types/processor.d.ts

@@ -741,7 +741,26 @@ export type ProcessedVideo = ProcessedFileBase & {
 /**
  * Supported archive format identifiers.
  */
-export type ArchiveFormat = "zip" | "tar" | "tar.gz" | "tar.bz2" | "gz" | "rar" | "7z";
+export type ArchiveFormat = "zip" | "tar" | "tar.gz" | "tar.bz2" | "gz" | "bz2" | "xz" | "zst" | "rar" | "7z";
+/**
+ * Outcome of decompressing a single-stream archive (.bz2, .xz, .zst).
+ *
+ * A plain `Buffer | null` collapsed two very different failures into one: a
+ * machine that has no `xz` installed and a `.xz` file that is corrupt both
+ * returned null, and the caller reported both as "the command is unavailable on
+ * this machine" — actively misleading for the second. The reason is carried so
+ * the message can match the fact.
+ */
+export type ArchiveDecompressionResult = {
+    readonly status: "ok";
+    readonly buffer: Buffer;
+} | {
+    readonly status: "tool-unavailable";
+} | {
+    readonly status: "too-large";
+} | {
+    readonly status: "failed";
+};
 /**
  * Metadata about an individual entry within an archive.
  */

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

@@ -6,6 +6,7 @@ import type { NeuroLink } from "../neurolink.js";
 import { AIProviderName, AnthropicModels, BedrockModels, DeepSeekModels, GoogleAIModels, LlamaCppModels, LMStudioModels, NvidiaNimModels, OpenAIModels, VertexModels } from "../constants/enums.js";
 import type { ValidationSchema } from "./aliases.js";
 import type { EnhancedGenerateResult, GenerateResult, TextGenerationOptions } from "./generate.js";
+import type { MultimodalAudioEntry } from "./file.js";
 import type { StreamOptions, StreamResult } from "./stream.js";
 import type { ExternalMCPToolInfo } from "./externalMcp.js";
 import type { ClaudeSubscriptionTier, AnthropicAuthMethod, AnthropicAuthConfig, SubscriptionInfo, OAuthToken } from "./subscription.js";
@@ -1821,6 +1822,12 @@ export type GeminiMultimodalInput = {
         data: Buffer | string;
         altText?: string;
     }>;
+    /**
+     * Audio collected during file detection, carried through to the native
+     * request as `inlineData`. Distinct from the user-facing `audioFiles`: these
+     * are already-materialised bytes with a resolved mime type.
+     */
+    nativeAudioFiles?: MultimodalAudioEntry[];
 };
 /**
  * Internal helpers used by the conversation-history builder in

package/dist/lib/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/dist/lib/utils/fileDetector.d.ts

@@ -17,6 +17,13 @@ import type { FileDetectorOptions, FileInput, FileProcessingResult } from "../ty
 export declare class FileDetector {
     static readonly DEFAULT_NETWORK_TIMEOUT = 30000;
     static readonly DEFAULT_HEAD_TIMEOUT = 5000;
+    /**
+     * Ceiling on an in-process document parse (unzip + XML walk). Generous
+     * relative to the work, because the cost of firing early on a large but
+     * legitimate file is a lost extraction, while the cost of never firing is a
+     * held request.
+     */
+    static readonly DEFAULT_DOCUMENT_TIMEOUT = 30000;
     /**
      * Auto-detect file type and process in one call
      *
@@ -80,6 +87,26 @@ export declare class FileDetector {
      * Stops at first strategy with confidence >= threshold (default: 80%)
      */
     private static detect;
+    /**
+     * Fill in `extension` from the input's name when detection did not set it.
+     *
+     * Content-based strategies identify a type from magic bytes and legitimately
+     * have no extension to report, so they return null. That is fine for the type
+     * itself but not for routing: several processors are chosen by extension
+     * *after* detection has settled the type, because one routing type covers
+     * several formats — `docx` covers .docx, .odt and .rtf.
+     *
+     * With a null extension those branches were unreachable. An .rtf scored high
+     * on its `{\\rtf1` signature, arrived as type "docx" with no extension, and
+     * fell through to the Word processor, which cannot read RTF — so a file whose
+     * dedicated processor extracts it perfectly reported "Could not extract
+     * content". The extension was known the whole time; it was simply dropped on
+     * the way through.
+     *
+     * Only fills a gap — a strategy that did determine an extension keeps it, so
+     * content still wins over a lying filename.
+     */
+    private static withResolvedExtension;
     /**
      * Load file content from various sources
      */