@juspay/neurolink 10.7.1 → 10.8.0

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [10.8.0](https://github.com/juspay/neurolink/compare/v10.7.1...v10.8.0) (2026-07-30)
+
+### Features
+
+- **(tts):** expose synthesis failure metadata and telemetry ([2ee39c2](https://github.com/juspay/neurolink/commit/2ee39c2b174356eef1c610578d9c511d3566d62c))
+
+### Bug Fixes
+
+- **(core):** honor Retry-After hints and add a no-hint retry floor ([f12984c](https://github.com/juspay/neurolink/commit/f12984c48f29da11bfb72b33ec99366ae45f43df))
+- **(sdk):** correct litellm PDF supportsNative config ([#1009](https://github.com/juspay/neurolink/issues/1009)) ([8ab56d4](https://github.com/juspay/neurolink/commit/8ab56d44684a69abc591f1c4ab3c9e0e03927a6b))
+
 ## [10.7.1](https://github.com/juspay/neurolink/compare/v10.7.0...v10.7.1) (2026-07-29)
 
 ### Bug Fixes

package/dist/adapters/replicate/predictionLifecycle.d.ts

@@ -18,7 +18,7 @@ import type { ReplicateAuth, ReplicateCreatePredictionInput, ReplicatePollOption
  * Submit a Replicate prediction. Uses `Prefer: wait=60` so quick
  * predictions complete in the initial POST and skip polling entirely.
  */
-export declare function createPrediction(auth: ReplicateAuth, input: ReplicateCreatePredictionInput): Promise<ReplicatePrediction>;
+export declare function createPrediction(auth: ReplicateAuth, input: ReplicateCreatePredictionInput, sleep?: (delayMs: number) => Promise<void>): Promise<ReplicatePrediction>;
 /**
  * Poll a Replicate prediction until it reaches a terminal status
  * (succeeded / failed / canceled) or the total timeout elapses.

package/dist/adapters/replicate/predictionLifecycle.js

@@ -17,6 +17,8 @@ import { ErrorCategory, ErrorSeverity } from "../../constants/enums.js";
 import { logger } from "../../utils/logger.js";
 import { NeuroLinkError, ERROR_CODES } from "../../utils/errorHandling.js";
 import { sanitizeForLog } from "../../utils/logSanitize.js";
+import { withProviderRetry } from "../../utils/providerRetry.js";
+import { parseRetryAfterMs } from "../../utils/retryAfter.js";
 import { safeDownload } from "../../utils/safeFetch.js";
 import { MAX_VIDEO_BYTES } from "../../utils/sizeGuard.js";
 // The submit path sends `Prefer: wait=60`, so Replicate can legitimately
@@ -31,7 +33,7 @@ const DEFAULT_TOTAL_TIMEOUT_MS = 5 * 60_000;
  * Submit a Replicate prediction. Uses `Prefer: wait=60` so quick
  * predictions complete in the initial POST and skip polling entirely.
  */
-export async function createPrediction(auth, input) {
+export async function createPrediction(auth, input, sleep) {
     const baseUrl = auth.baseUrl ?? "https://api.replicate.com";
     const [modelPath, version] = input.model.split(":", 2);
     const endpoint = version
@@ -46,51 +48,53 @@ export async function createPrediction(auth, input) {
     if (input.webhookEventsFilter && input.webhookEventsFilter.length > 0) {
         body.webhook_events_filter = input.webhookEventsFilter;
     }
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
-    let response;
-    try {
-        response = await fetch(endpoint, {
-            method: "POST",
-            headers: {
-                Authorization: `Token ${auth.apiToken}`,
-                "Content-Type": "application/json",
-                Prefer: "wait=60",
-            },
-            body: JSON.stringify(body),
-            signal: controller.signal,
-        });
-    }
-    catch (err) {
-        if (err instanceof NeuroLinkError) {
-            throw err;
-        }
-        if (err instanceof Error && err.name === "AbortError") {
-            throw new NeuroLinkError({
-                code: ERROR_CODES.OPERATION_ABORTED,
-                message: `Replicate predictions submit timed out after ${REQUEST_TIMEOUT_MS / 1000}s`,
-                category: ErrorCategory.TIMEOUT,
-                severity: ErrorSeverity.HIGH,
-                retriable: true,
-                originalError: err,
+    return withProviderRetry(async () => {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            const response = await fetch(endpoint, {
+                method: "POST",
+                headers: {
+                    Authorization: `Token ${auth.apiToken}`,
+                    "Content-Type": "application/json",
+                    Prefer: "wait=60",
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
             });
+            if (!response.ok) {
+                const raw = await response.text();
+                throw new NeuroLinkError({
+                    code: ERROR_CODES.PROVIDER_NOT_AVAILABLE,
+                    message: `Replicate predictions submit failed: ${response.status} — ${sanitizeForLog(raw, 500)}`,
+                    category: ErrorCategory.NETWORK,
+                    severity: ErrorSeverity.HIGH,
+                    retriable: response.status >= 500 || response.status === 429,
+                    retryAfterMs: parseRetryAfterMs(response.headers),
+                });
+            }
+            return (await response.json());
         }
-        throw err;
-    }
-    finally {
-        clearTimeout(timeoutId);
-    }
-    if (!response.ok) {
-        const raw = await response.text();
-        throw new NeuroLinkError({
-            code: ERROR_CODES.PROVIDER_NOT_AVAILABLE,
-            message: `Replicate predictions submit failed: ${response.status} — ${sanitizeForLog(raw, 500)}`,
-            category: ErrorCategory.NETWORK,
-            severity: ErrorSeverity.HIGH,
-            retriable: response.status >= 500,
-        });
-    }
-    return (await response.json());
+        catch (error) {
+            if (error instanceof NeuroLinkError) {
+                throw error;
+            }
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new NeuroLinkError({
+                    code: ERROR_CODES.OPERATION_ABORTED,
+                    message: `Replicate predictions submit timed out after ${REQUEST_TIMEOUT_MS / 1000}s`,
+                    category: ErrorCategory.TIMEOUT,
+                    severity: ErrorSeverity.HIGH,
+                    retriable: true,
+                    originalError: error,
+                });
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }, undefined, "Replicate prediction submission", sleep);
 }
 /**
  * Poll a Replicate prediction until it reaches a terminal status
@@ -164,7 +168,8 @@ export async function pollPrediction(auth, predictionId, options = {}) {
                 message: `Replicate poll failed: ${response.status} — ${sanitizeForLog(raw, 500)}`,
                 category: ErrorCategory.NETWORK,
                 severity: ErrorSeverity.HIGH,
-                retriable: response.status >= 500,
+                retriable: response.status >= 500 || response.status === 429,
+                retryAfterMs: parseRetryAfterMs(response.headers),
             });
         }
         const pred = (await response.json());

package/dist/agent/directTools.d.ts

@@ -104,7 +104,7 @@ export declare const directAgentTools: {
     writeFile: Tool<{
         path: string;
         content: string;
-        mode: "create" | "overwrite" | "append";
+        mode: "create" | "append" | "overwrite";
     }, {
         success: boolean;
         error: string;
@@ -115,7 +115,7 @@ export declare const directAgentTools: {
     } | {
         success: boolean;
         path: string;
-        mode: "create" | "overwrite" | "append";
+        mode: "create" | "append" | "overwrite";
         size: number;
         written: number;
         error?: undefined;