@juspay/neurolink 10.7.1 → 10.8.1

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.1",
+  "version": "10.8.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": {
@@ -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": "",