@juspay/neurolink 10.7.1 → 10.8.0

package/dist/lib/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/lib/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/lib/utils/providerRetry.js

@@ -14,12 +14,19 @@
  * @module utils/providerRetry
  */
 import {} from "@opentelemetry/api";
+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.
  *
@@ -32,6 +39,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;
@@ -51,6 +61,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.
  *
@@ -59,12 +81,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`);
             }
@@ -76,9 +98,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,
@@ -88,10 +110,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 }),
@@ -104,7 +130,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/lib/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/lib/utils/retryAfter.js

@@ -0,0 +1,44 @@
+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;
+}
+//# sourceMappingURL=retryAfter.js.map

package/dist/mcp/httpRateLimiter.js

@@ -4,6 +4,7 @@
  * Provides fault tolerance and prevents server overload
  */
 import { mcpLogger } from "../utils/logger.js";
+import { parseRetryAfterMs } from "../utils/retryAfter.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
 import { getActiveTraceContext } from "../telemetry/traceContext.js";
 /**
@@ -176,48 +177,40 @@ export class HTTPRateLimiter {
      * @returns Wait time in milliseconds, or 0 if no rate limit headers found
      */
     handleRateLimitResponse(headers) {
-        // Check for Retry-After header (standard HTTP 429 response)
+        const parsedWaitTimeMs = parseRetryAfterMs(headers);
+        // Keep the existing source-specific logs while delegating delay parsing.
         const retryAfter = headers.get("Retry-After");
-        if (retryAfter) {
-            // Retry-After can be either a number of seconds or an HTTP-date
+        if (retryAfter && parsedWaitTimeMs !== undefined) {
             const seconds = parseInt(retryAfter, 10);
             if (!isNaN(seconds)) {
-                // It's a number of seconds
-                const waitTimeMs = seconds * 1000;
                 mcpLogger.info(`[HTTPRateLimiter] Server requested retry after ${seconds} seconds`);
-                return waitTimeMs;
+                return parsedWaitTimeMs;
             }
             else {
-                // Try to parse as HTTP-date
                 const retryDate = new Date(retryAfter);
                 if (!isNaN(retryDate.getTime())) {
-                    const waitTimeMs = Math.max(0, retryDate.getTime() - Date.now());
-                    mcpLogger.info(`[HTTPRateLimiter] Server requested retry at ${retryDate.toISOString()} (${waitTimeMs}ms)`);
-                    return waitTimeMs;
+                    mcpLogger.info(`[HTTPRateLimiter] Server requested retry at ${retryDate.toISOString()} (${parsedWaitTimeMs}ms)`);
+                    return parsedWaitTimeMs;
                 }
             }
         }
         // Check for X-RateLimit-Reset header (common non-standard header)
         const rateLimitReset = headers.get("X-RateLimit-Reset");
-        if (rateLimitReset) {
+        if (rateLimitReset && parsedWaitTimeMs !== undefined) {
             const resetTimestamp = parseInt(rateLimitReset, 10);
             if (!isNaN(resetTimestamp)) {
-                // Could be Unix timestamp (seconds) or milliseconds
                 const resetTime = resetTimestamp > 1e12 ? resetTimestamp : resetTimestamp * 1000;
-                const waitTimeMs = Math.max(0, resetTime - Date.now());
-                mcpLogger.info(`[HTTPRateLimiter] Rate limit resets at ${new Date(resetTime).toISOString()} (${waitTimeMs}ms)`);
-                return waitTimeMs;
+                mcpLogger.info(`[HTTPRateLimiter] Rate limit resets at ${new Date(resetTime).toISOString()} (${parsedWaitTimeMs}ms)`);
+                return parsedWaitTimeMs;
             }
         }
         // Check for X-RateLimit-Remaining header
         const remaining = headers.get("X-RateLimit-Remaining");
-        if (remaining === "0") {
-            // No remaining requests, use default backoff
-            const defaultBackoffMs = 1000;
-            mcpLogger.info(`[HTTPRateLimiter] Rate limit exhausted, using default backoff: ${defaultBackoffMs}ms`);
-            return defaultBackoffMs;
+        if (remaining === "0" && parsedWaitTimeMs !== undefined) {
+            mcpLogger.info(`[HTTPRateLimiter] Rate limit exhausted, using default backoff: ${parsedWaitTimeMs}ms`);
+            return parsedWaitTimeMs;
         }
-        return 0;
+        return parsedWaitTimeMs ?? 0;
     }
     /**
      * Get the number of remaining tokens

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/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.1",
+  "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": "",