@juspay/neurolink 10.7.0 → 10.8.0

package/dist/server/routes/claudeProxyRoutes.js

@@ -562,16 +562,18 @@ function buildRoutingDecision(args) {
     const { accounts, orderedAccounts, metricsByKey, evaluatedAt, strategy, primaryKey, quotaRoutingEnabled, quotaOrdered, sessionSoftLimit, sessionResetToleranceMs, rotationOffset, } = args;
     const sourceIndexes = new Map(accounts.map((account, index) => [account.key, index]));
     const configuredPrimaryMatched = !!primaryKey && accounts.some((account) => account.key === primaryKey);
-    const candidates = orderedAccounts.map((account, rank) => {
+    const candidates = [];
+    for (const account of orderedAccounts) {
         const metrics = metricsByKey.get(account.key);
         if (!metrics) {
-            throw new Error(`Missing precomputed routing metrics for account ${account.label}`);
+            logger.warn(`[proxy] routing evidence omitted because metrics are missing for account=${account.label}`);
+            return undefined;
         }
-        return {
+        candidates.push({
             account: account.label,
             accountType: account.type,
-            sourceIndex: sourceIndexes.get(account.key) ?? rank,
-            rank,
+            sourceIndex: sourceIndexes.get(account.key) ?? candidates.length,
+            rank: candidates.length,
             configuredPrimary: !!primaryKey && account.key === primaryKey,
             usable: metrics.usable,
             saturated: metrics.saturated,
@@ -598,8 +600,8 @@ function buildRoutingDecision(args) {
             weeklyResetAt: Number.isFinite(metrics.weeklyReset)
                 ? metrics.weeklyReset
                 : null,
-        };
-    });
+        });
+    }
     const initialAccount = orderedAccounts[0];
     let mode;
     let selectionReason;
@@ -684,7 +686,7 @@ function selectClaudeProxyAccountOrder(args) {
             accountSortMetrics(account.key, evaluatedAt, sessionSoftLimit, sessionResetToleranceMs),
         ]));
     }
-    setRoutingDecision(buildRoutingDecision({
+    const routingDecision = buildRoutingDecision({
         accounts: enabledAccounts,
         orderedAccounts,
         metricsByKey,
@@ -696,7 +698,10 @@ function selectClaudeProxyAccountOrder(args) {
         sessionSoftLimit,
         sessionResetToleranceMs,
         rotationOffset,
-    }));
+    });
+    if (routingDecision) {
+        setRoutingDecision(routingDecision);
+    }
     return orderedAccounts;
 }
 // ---------------------------------------------------------------------------
@@ -4896,6 +4901,7 @@ export const __testHooks = {
             rotationOffset: 0,
         });
     },
+    buildRoutingDecision,
     resetEpochToMs,
     seedRuntimeQuotasFromDisk,
     reconcileEligibleAccountRuntimeState,

package/dist/types/generate.d.ts

@@ -1418,9 +1418,25 @@ export type TextGenerationResult = {
 /**
  * Enhanced result type with optional analytics/evaluation
  */
+export type TTSMetadata = {
+    /** Whether TTS synthesis was invoked. False indicates TTS was skipped. */
+    attempted: boolean;
+    /** Whether TTS synthesis completed successfully. */
+    success: boolean;
+    /** Structured synthesis error details, present only when synthesis failed. */
+    error?: {
+        code: string;
+        message: string;
+        retriable?: boolean;
+    };
+    /** TTS synthesis time in milliseconds. */
+    latency?: number;
+};
 export type EnhancedGenerateResult = GenerateResult & {
     analytics?: AnalyticsData;
     evaluation?: EvaluationData;
+    /** Outcome metadata when TTS was enabled for this generation. */
+    ttsMetadata?: TTSMetadata;
 };
 /**
  * NL-004: Model alias/deprecation configuration.

package/dist/types/proxy.d.ts

@@ -1341,6 +1341,9 @@ export type ProxyAnalysisReport = {
         initialAccounts: Record<string, number>;
         finalAccountChanges: number;
         finalOutsideCandidateSet: number;
+        /** Number of routing decisions aggregated before sampling records. */
+        totalRecords: number;
+        /** Most recent bounded sample retained for offline inspection. */
         records: ProxyAnalysisRoutingRecord[];
     };
     accounts: ProxyAnalysisAccount[];

package/dist/utils/errorHandling.d.ts

@@ -70,6 +70,7 @@ export declare class NeuroLinkError extends Error {
     readonly category: ErrorCategory;
     readonly severity: ErrorSeverity;
     readonly retriable: boolean;
+    readonly retryAfterMs?: number;
     readonly context: Record<string, unknown>;
     readonly timestamp: Date;
     readonly toolName?: string;
@@ -80,6 +81,7 @@ export declare class NeuroLinkError extends Error {
         category: ErrorCategory;
         severity: ErrorSeverity;
         retriable: boolean;
+        retryAfterMs?: number;
         context?: Record<string, unknown>;
         originalError?: Error;
         toolName?: string;

package/dist/utils/errorHandling.js

@@ -87,6 +87,7 @@ export class NeuroLinkError extends Error {
     category;
     severity;
     retriable;
+    retryAfterMs;
     context;
     timestamp;
     toolName;
@@ -98,6 +99,7 @@ export class NeuroLinkError extends Error {
         this.category = options.category;
         this.severity = options.severity;
         this.retriable = options.retriable;
+        this.retryAfterMs = options.retryAfterMs;
         this.context = options.context || {};
         this.timestamp = new Date();
         this.toolName = options.toolName;

package/dist/utils/pdfProcessor.js

@@ -91,14 +91,14 @@ const PDF_PROVIDER_CONFIGS = {
     litellm: {
         maxSizeMB: 10,
         maxPages: 100,
-        supportsNative: true,
+        supportsNative: false, // LiteLLM is a proxy — underlying model may not support native PDF; default to safe text extraction
         requiresCitations: false,
         apiType: "files-api",
     },
     "openai-compatible": {
         maxSizeMB: 10,
         maxPages: 100,
-        supportsNative: false, // LiteLLM is a proxy — underlying model may not support native PDF; default to safe text extraction
+        supportsNative: false,
         requiresCitations: false,
         apiType: "files-api",
     },

package/dist/utils/providerRetry.d.ts

@@ -18,6 +18,10 @@ import { type Span } from "@opentelemetry/api";
 export declare const MAX_PROVIDER_RETRIES = 2;
 /** Base delay in ms for exponential backoff between retries. */
 export declare const BASE_RETRY_DELAY_MS = 1000;
+/** Minimum delay in ms when a retryable response provides no retry timing. */
+export declare const NO_HINT_FLOOR_MS = 10000;
+/** Maximum server-requested retry delay honored by provider retries. */
+export declare const MAX_RETRY_AFTER_MS = 120000;
 /**
  * Check whether an error thrown by the AI SDK is retryable.
  *
@@ -38,4 +42,4 @@ export declare function getErrorStatusCode(error: unknown): number | undefined;
  * @param label      - A human-readable label for log messages (e.g. "generateText", "streamText")
  * @returns The result of the operation
  */
-export declare function withProviderRetry<T>(operation: () => Promise<T>, span: Span, label: string): Promise<T>;
+export declare function withProviderRetry<T>(operation: () => Promise<T>, span: Span | undefined, label: string, sleep?: (delayMs: number) => Promise<void>): Promise<T>;

package/dist/utils/providerRetry.js

@@ -13,12 +13,19 @@
  *
  * @module utils/providerRetry
  */
+import { NeuroLinkError } from "./errorHandling.js";
 import { logger } from "./logger.js";
 import { APICallError } from "./generationErrors.js";
+import { parseRetryAfterMs } from "./retryAfter.js";
 /** Maximum number of retry attempts after the initial call (total = 1 + MAX_PROVIDER_RETRIES). */
 export const MAX_PROVIDER_RETRIES = 2;
 /** Base delay in ms for exponential backoff between retries. */
 export const BASE_RETRY_DELAY_MS = 1000;
+/** Minimum delay in ms when a retryable response provides no retry timing. */
+export const NO_HINT_FLOOR_MS = 10_000;
+/** Maximum server-requested retry delay honored by provider retries. */
+export const MAX_RETRY_AFTER_MS = 120_000;
+const sleepWithTimeout = (delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs));
 /**
  * Check whether an error thrown by the AI SDK is retryable.
  *
@@ -31,6 +38,9 @@ export function isRetryableProviderError(error) {
     if (APICallError.isInstance(error)) {
         return error.isRetryable;
     }
+    if (error instanceof NeuroLinkError) {
+        return error.retriable;
+    }
     // Fallback: duck-type for status codes on errors that aren't APICallError
     if (error && typeof error === "object" && "statusCode" in error) {
         const statusCode = error.statusCode;
@@ -50,6 +60,18 @@ export function getErrorStatusCode(error) {
     }
     return undefined;
 }
+function getRetryAfterMs(error) {
+    if (APICallError.isInstance(error) && error.responseHeaders) {
+        const parsedDelay = parseRetryAfterMs(error.responseHeaders);
+        if (parsedDelay !== undefined) {
+            return parsedDelay;
+        }
+    }
+    if (error instanceof NeuroLinkError && error.retryAfterMs !== undefined) {
+        return error.retryAfterMs;
+    }
+    return undefined;
+}
 /**
  * Execute a provider call with instrumented retry logic.
  *
@@ -58,12 +80,12 @@ export function getErrorStatusCode(error) {
  * @param label      - A human-readable label for log messages (e.g. "generateText", "streamText")
  * @returns The result of the operation
  */
-export async function withProviderRetry(operation, span, label) {
+export async function withProviderRetry(operation, span, label, sleep = sleepWithTimeout) {
     for (let attempt = 0; attempt <= MAX_PROVIDER_RETRIES; attempt++) {
         try {
             const result = await operation();
             // Record how many attempts it took on the span
-            span.setAttribute("gen_ai.provider.total_attempts", attempt + 1);
+            span?.setAttribute("gen_ai.provider.total_attempts", attempt + 1);
             if (attempt > 0) {
                 logger.info(`[providerRetry] ${label} succeeded after ${attempt + 1} attempts`);
             }
@@ -75,9 +97,9 @@ export async function withProviderRetry(operation, span, label) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             if (!retryable || attempt === MAX_PROVIDER_RETRIES) {
                 // Record failure details before re-throwing
-                span.setAttribute("gen_ai.provider.total_attempts", attempt + 1);
+                span?.setAttribute("gen_ai.provider.total_attempts", attempt + 1);
                 if (attempt > 0) {
-                    span.setAttribute("gen_ai.provider.retries_exhausted", true);
+                    span?.setAttribute("gen_ai.provider.retries_exhausted", true);
                 }
                 logger.warn(`[providerRetry] ${label} failed (non-retryable or retries exhausted)`, {
                     attempt: attempt + 1,
@@ -87,10 +109,14 @@ export async function withProviderRetry(operation, span, label) {
                 });
                 throw error;
             }
-            // Calculate exponential backoff delay
-            const delay = BASE_RETRY_DELAY_MS * Math.pow(2, attempt);
+            const retryAfterMs = getRetryAfterMs(error);
+            const boundedRetryAfterMs = retryAfterMs === undefined
+                ? undefined
+                : Math.min(MAX_RETRY_AFTER_MS, Math.max(0, retryAfterMs));
+            const delay = boundedRetryAfterMs ??
+                Math.max(BASE_RETRY_DELAY_MS * Math.pow(2, attempt), NO_HINT_FLOOR_MS);
             // Record retry event on the OTel span
-            span.addEvent("gen_ai.provider.retry", {
+            span?.addEvent("gen_ai.provider.retry", {
                 "retry.attempt": attempt + 1,
                 "retry.delay_ms": delay,
                 ...(statusCode !== undefined && { "retry.status_code": statusCode }),
@@ -103,7 +129,7 @@ export async function withProviderRetry(operation, span, label) {
                 statusCode,
                 error: errorMessage,
             });
-            await new Promise((r) => setTimeout(r, delay));
+            await sleep(delay);
         }
     }
     // This should never be reached due to the throw inside the loop,

package/dist/utils/retryAfter.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Parse standard and commonly used rate-limit response headers.
+ *
+ * @returns The requested delay in milliseconds, or undefined when the
+ * response does not provide a usable rate-limit delay.
+ */
+export declare function parseRetryAfterMs(headers: Pick<Headers, "get"> | Readonly<Record<string, string>>): number | undefined;

package/dist/utils/retryAfter.js

@@ -0,0 +1,43 @@
+function getHeader(headers, headerName) {
+    if ("get" in headers && typeof headers.get === "function") {
+        return headers.get(headerName);
+    }
+    const normalizedHeaderName = headerName.toLowerCase();
+    for (const [name, value] of Object.entries(headers)) {
+        if (name.toLowerCase() === normalizedHeaderName) {
+            return value;
+        }
+    }
+    return null;
+}
+/**
+ * Parse standard and commonly used rate-limit response headers.
+ *
+ * @returns The requested delay in milliseconds, or undefined when the
+ * response does not provide a usable rate-limit delay.
+ */
+export function parseRetryAfterMs(headers) {
+    const retryAfter = getHeader(headers, "Retry-After");
+    if (retryAfter) {
+        const seconds = parseInt(retryAfter, 10);
+        if (!Number.isNaN(seconds)) {
+            return Math.max(0, seconds * 1000);
+        }
+        const retryDate = new Date(retryAfter);
+        if (!Number.isNaN(retryDate.getTime())) {
+            return Math.max(0, retryDate.getTime() - Date.now());
+        }
+    }
+    const rateLimitReset = getHeader(headers, "X-RateLimit-Reset");
+    if (rateLimitReset) {
+        const resetTimestamp = parseInt(rateLimitReset, 10);
+        if (!Number.isNaN(resetTimestamp)) {
+            const resetTime = resetTimestamp > 1e12 ? resetTimestamp : resetTimestamp * 1000;
+            return Math.max(0, resetTime - Date.now());
+        }
+    }
+    if (getHeader(headers, "X-RateLimit-Remaining") === "0") {
+        return 1000;
+    }
+    return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "10.7.0",
+  "version": "10.8.0",
   "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": {
@@ -144,6 +144,7 @@
     "test:model-pool": "pnpm run test:model-pool:vitest && npx tsx test/continuous-test-suite-model-pool.ts",
     "test:model-capabilities:vitest": "pnpm exec vitest run test/modelCapabilities.test.ts",
     "test:agent-runtime:vitest": "pnpm exec vitest run test/agentRuntime.test.ts test/agentDelegation.test.ts test/agentPlumbing.test.ts test/toolExecutionRecorder.test.ts test/samplingParams.test.ts test/structuredRecovery.test.ts",
+    "test:retry-after:vitest": "pnpm exec vitest run test/retryAfter.test.ts",
     "test:ci": "pnpm run test && pnpm run test:client && pnpm run test:hitl",
     "// CI tier — fast, no live AI calls, safe for every commit": "",
     "test:unit:vitest": "pnpm exec vitest run test/toolRouting.test.ts",
@@ -152,7 +153,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: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:unit:vitest && pnpm run test:tool-routing-cli:vitest && pnpm run test:tool-dedup:vitest && pnpm run test:model-pool:vitest && pnpm run test:litellm-context:vitest && pnpm run test:step-budget-guard: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 && pnpm run test:model-capabilities:vitest && pnpm run test:agent-runtime:vitest",
+    "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:unit:vitest && pnpm run test:tool-routing-cli:vitest && pnpm run test:tool-dedup:vitest && pnpm run test:model-pool:vitest && pnpm run test:litellm-context:vitest && pnpm run test:step-budget-guard: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 && pnpm run test:model-capabilities:vitest && pnpm run test:agent-runtime:vitest && pnpm run test:retry-after:vitest",
     "// 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": "",