@juspay/neurolink 10.7.1 → 10.8.1

package/dist/lib/proxy/proxyAnalysis.js

@@ -212,6 +212,19 @@ function parseSince(value, nowMs) {
     }
     return parsed;
 }
+function parseUntil(value, nowMs) {
+    let parsed;
+    try {
+        parsed = parseSince(value, nowMs);
+    }
+    catch {
+        throw new Error(`Invalid --until value "${value}". Use an ISO timestamp or a duration such as 6h, 1d, or 1w.`);
+    }
+    if (parsed > nowMs) {
+        throw new Error(`Invalid --until value "${value}". It must not be later than the analysis start time.`);
+    }
+    return parsed;
+}
 async function readJsonLines(filePath, onRecord, onMalformed) {
     let linesRead = 0;
     const lines = createInterface({
@@ -412,6 +425,10 @@ async function discoverLogFiles(logsDir) {
 export async function analyzeProxyLogs(options) {
     const nowMs = options?.nowMs ?? Date.now();
     const sinceMs = parseSince(options?.since ?? "24h", nowMs);
+    const untilMs = options?.until ? parseUntil(options.until, nowMs) : nowMs;
+    if (untilMs < sinceMs) {
+        throw new Error(`Invalid analysis window: --until must not be earlier than --since.`);
+    }
     const logsDir = resolve(options?.logsDir ?? join(homedir(), ".neurolink", "logs"));
     const { lifecycleFiles, requestFiles, attemptFiles, debugFiles } = await discoverLogFiles(logsDir);
     const observedRanges = {
@@ -448,7 +465,7 @@ export async function analyzeProxyLogs(options) {
     for (const filePath of lifecycleFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
             const timestamp = observeTimestamp("lifecycle", record);
-            if (timestamp === null || timestamp < sinceMs) {
+            if (timestamp === null || timestamp < sinceMs || timestamp > untilMs) {
                 return;
             }
             const event = stringValue(record.event);
@@ -530,7 +547,7 @@ export async function analyzeProxyLogs(options) {
     for (const filePath of attemptFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
             const timestamp = observeTimestamp("attempts", record);
-            if (timestamp === null || timestamp < sinceMs) {
+            if (timestamp === null || timestamp < sinceMs || timestamp > untilMs) {
                 return;
             }
             const requestId = stringValue(record.requestId);
@@ -595,7 +612,7 @@ export async function analyzeProxyLogs(options) {
     for (const filePath of requestFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
             const timestamp = observeTimestamp("requests", record);
-            if (timestamp === null || timestamp < sinceMs) {
+            if (timestamp === null || timestamp < sinceMs || timestamp > untilMs) {
                 return;
             }
             const requestId = stringValue(record.requestId);
@@ -649,7 +666,7 @@ export async function analyzeProxyLogs(options) {
     for (const filePath of debugFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
             const timestamp = observeTimestamp("debug", record);
-            if (timestamp === null || timestamp < sinceMs) {
+            if (timestamp === null || timestamp < sinceMs || timestamp > untilMs) {
                 return;
             }
             if (record.type !== "body_capture") {
@@ -709,6 +726,7 @@ export async function analyzeProxyLogs(options) {
     return {
         generatedAt: new Date(nowMs).toISOString(),
         since: new Date(sinceMs).toISOString(),
+        until: new Date(untilMs).toISOString(),
         logsDir,
         files: {
             lifecycle: lifecycleFiles.length,

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

@@ -795,6 +795,7 @@ export type ProxyStatusArgs = {
 export type ProxyAnalyzeArgs = {
     logsDir?: string;
     since?: string;
+    until?: string;
     format?: "text" | "json";
     quiet?: boolean;
 };

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

@@ -1247,6 +1247,7 @@ export type ProxyAnalysisStreamName = "lifecycle" | "requests" | "attempts" | "d
 export type ProxyAnalysisReport = {
     generatedAt: string;
     since: string;
+    until: string;
     logsDir: string;
     files: {
         lifecycle: number;
@@ -1352,6 +1353,7 @@ export type ProxyAnalysisReport = {
 export type ProxyAnalysisOptions = {
     logsDir?: string;
     since?: string;
+    until?: string;
     nowMs?: number;
 };
 /** Attempt timing retained while joining offline proxy log records. */

package/dist/lib/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/lib/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/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/proxy/proxyAnalysis.js

@@ -212,6 +212,19 @@ function parseSince(value, nowMs) {
     }
     return parsed;
 }
+function parseUntil(value, nowMs) {
+    let parsed;
+    try {
+        parsed = parseSince(value, nowMs);
+    }
+    catch {
+        throw new Error(`Invalid --until value "${value}". Use an ISO timestamp or a duration such as 6h, 1d, or 1w.`);
+    }
+    if (parsed > nowMs) {
+        throw new Error(`Invalid --until value "${value}". It must not be later than the analysis start time.`);
+    }
+    return parsed;
+}
 async function readJsonLines(filePath, onRecord, onMalformed) {
     let linesRead = 0;
     const lines = createInterface({
@@ -412,6 +425,10 @@ async function discoverLogFiles(logsDir) {
 export async function analyzeProxyLogs(options) {
     const nowMs = options?.nowMs ?? Date.now();
     const sinceMs = parseSince(options?.since ?? "24h", nowMs);
+    const untilMs = options?.until ? parseUntil(options.until, nowMs) : nowMs;
+    if (untilMs < sinceMs) {
+        throw new Error(`Invalid analysis window: --until must not be earlier than --since.`);
+    }
     const logsDir = resolve(options?.logsDir ?? join(homedir(), ".neurolink", "logs"));
     const { lifecycleFiles, requestFiles, attemptFiles, debugFiles } = await discoverLogFiles(logsDir);
     const observedRanges = {
@@ -448,7 +465,7 @@ export async function analyzeProxyLogs(options) {
     for (const filePath of lifecycleFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
             const timestamp = observeTimestamp("lifecycle", record);
-            if (timestamp === null || timestamp < sinceMs) {
+            if (timestamp === null || timestamp < sinceMs || timestamp > untilMs) {
                 return;
             }
             const event = stringValue(record.event);
@@ -530,7 +547,7 @@ export async function analyzeProxyLogs(options) {
     for (const filePath of attemptFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
             const timestamp = observeTimestamp("attempts", record);
-            if (timestamp === null || timestamp < sinceMs) {
+            if (timestamp === null || timestamp < sinceMs || timestamp > untilMs) {
                 return;
             }
             const requestId = stringValue(record.requestId);
@@ -595,7 +612,7 @@ export async function analyzeProxyLogs(options) {
     for (const filePath of requestFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
             const timestamp = observeTimestamp("requests", record);
-            if (timestamp === null || timestamp < sinceMs) {
+            if (timestamp === null || timestamp < sinceMs || timestamp > untilMs) {
                 return;
             }
             const requestId = stringValue(record.requestId);
@@ -649,7 +666,7 @@ export async function analyzeProxyLogs(options) {
     for (const filePath of debugFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
             const timestamp = observeTimestamp("debug", record);
-            if (timestamp === null || timestamp < sinceMs) {
+            if (timestamp === null || timestamp < sinceMs || timestamp > untilMs) {
                 return;
             }
             if (record.type !== "body_capture") {
@@ -709,6 +726,7 @@ export async function analyzeProxyLogs(options) {
     return {
         generatedAt: new Date(nowMs).toISOString(),
         since: new Date(sinceMs).toISOString(),
+        until: new Date(untilMs).toISOString(),
         logsDir,
         files: {
             lifecycle: lifecycleFiles.length,

package/dist/types/cli.d.ts

@@ -795,6 +795,7 @@ export type ProxyStatusArgs = {
 export type ProxyAnalyzeArgs = {
     logsDir?: string;
     since?: string;
+    until?: string;
     format?: "text" | "json";
     quiet?: boolean;
 };

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

@@ -1247,6 +1247,7 @@ export type ProxyAnalysisStreamName = "lifecycle" | "requests" | "attempts" | "d
 export type ProxyAnalysisReport = {
     generatedAt: string;
     since: string;
+    until: string;
     logsDir: string;
     files: {
         lifecycle: number;
@@ -1352,6 +1353,7 @@ export type ProxyAnalysisReport = {
 export type ProxyAnalysisOptions = {
     logsDir?: string;
     since?: string;
+    until?: string;
     nowMs?: number;
 };
 /** Attempt timing retained while joining offline proxy log records. */

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>;