@juspay/neurolink 12.51.0 → 12.51.1

package/dist/constants/timeouts.d.ts

@@ -8,6 +8,12 @@
  * @author NeuroLink Team
  * @version 1.0.0
  */
+/**
+ * Largest delay `setTimeout` honours (2^31 - 1 ms, about 24.8 days). A longer
+ * delay is not "later": Node warns and fires after 1 ms, so a caller-supplied
+ * deadline above this must be held at it rather than handed to the timer.
+ */
+export declare const MAX_TIMER_MS = 2147483647;
 /**
  * Tool execution timeout constants
  * These values balance reliability vs performance for AI tool operations

package/dist/constants/timeouts.js

@@ -8,6 +8,12 @@
  * @author NeuroLink Team
  * @version 1.0.0
  */
+/**
+ * Largest delay `setTimeout` honours (2^31 - 1 ms, about 24.8 days). A longer
+ * delay is not "later": Node warns and fires after 1 ms, so a caller-supplied
+ * deadline above this must be held at it rather than handed to the timer.
+ */
+export const MAX_TIMER_MS = 2_147_483_647;
 /**
  * Tool execution timeout constants
  * These values balance reliability vs performance for AI tool operations

package/dist/utils/errorHandling.d.ts

@@ -361,7 +361,17 @@ export declare class ErrorFactory {
     static csvProcessingFailed(filename: string, originalError: Error): NeuroLinkError;
 }
 /**
- * Timeout wrapper for async operations
+ * Timeout wrapper for async operations.
+ *
+ * Races an already-created promise against a deadline. It cannot cancel that
+ * promise: when the deadline wins the operation keeps running as an abandoned
+ * ghost. A caller that owns the abortable operation (an HTTP request, a
+ * provider call) must hand it an `AbortSignal` itself and abort it when this
+ * rejects.
+ *
+ * `timeoutMs` is held at `MAX_TIMER_MS`: a longer deadline would otherwise be
+ * handed to `setTimeout`, which fires after 1 ms and so rejected an operation
+ * that had asked for the longest wait available.
  */
 export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, timeoutError?: Error): Promise<T>;
 /**

package/dist/utils/errorHandling.js

@@ -3,6 +3,7 @@
  * Provides structured error management for tool execution and system operations
  */
 import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
+import { MAX_TIMER_MS } from "../constants/timeouts.js";
 import { logger } from "./logger.js";
 import { CircuitBreakerOpenError } from "../types/index.js";
 import { HITLTimeoutError } from "../hitl/hitlErrors.js";
@@ -1081,14 +1082,28 @@ export class ErrorFactory {
     }
 }
 /**
- * Timeout wrapper for async operations
+ * Timeout wrapper for async operations.
+ *
+ * Races an already-created promise against a deadline. It cannot cancel that
+ * promise: when the deadline wins the operation keeps running as an abandoned
+ * ghost. A caller that owns the abortable operation (an HTTP request, a
+ * provider call) must hand it an `AbortSignal` itself and abort it when this
+ * rejects.
+ *
+ * `timeoutMs` is held at `MAX_TIMER_MS`: a longer deadline would otherwise be
+ * handed to `setTimeout`, which fires after 1 ms and so rejected an operation
+ * that had asked for the longest wait available.
  */
 export async function withTimeout(promise, timeoutMs, timeoutError) {
     let timer;
+    // An explicit upper-bound comparison, and `>` rather than `<=`: NaN fails
+    // `>`, so NaN, zero and negative deadlines reach `setTimeout` as they always
+    // did, and only a value above the limit is replaced by it.
+    const delayMs = timeoutMs > MAX_TIMER_MS ? MAX_TIMER_MS : timeoutMs;
     const timeoutPromise = new Promise((_, reject) => {
         timer = setTimeout(() => {
             reject(timeoutError || new Error(`Operation timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
+        }, delayMs);
     });
     try {
         return await Promise.race([promise, timeoutPromise]);

package/dist/workflow/core/ensembleExecutor.js

@@ -3,6 +3,7 @@
  * Parallel execution engine for ensemble workflows
  */
 import pLimit from "p-limit";
+import { MAX_TIMER_MS } from "../../constants/timeouts.js";
 import { AIProviderFactory } from "../../core/factory.js";
 import { logger } from "../../utils/logger.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../../observability/index.js";
@@ -130,12 +131,13 @@ async function executeModel(options, workflowDefaultSystemPrompt) {
         const MAX_ATTEMPTS = 2;
         while (true) {
             attempts++;
-            result = await executeWithTimeout(async () => {
+            result = await executeWithTimeout(async (abortSignal) => {
                 return await provider.generate({
                     prompt,
                     systemPrompt: resolvedSystemPrompt,
                     temperature: model.temperature,
                     maxTokens: model.maxTokens,
+                    abortSignal,
                 });
             }, timeout, `Model ${model.provider}/${model.model} timed out after ${timeout}ms`);
             const contentLen = result?.content?.length ?? 0;
@@ -199,14 +201,29 @@ async function createProvider(model) {
     return await AIProviderFactory.createProvider(model.provider, model.model);
 }
 /**
- * Execute function with timeout
- * @param fn - Async function to execute
+ * Run an abortable operation under a deadline.
+ *
+ * The operation receives the signal of an `AbortController` that this function
+ * aborts the moment the deadline lapses, so the owner of the work (the provider
+ * call and its HTTP request) is cancelled rather than abandoned. `Promise.race`
+ * alone only stops this caller waiting; it cannot stop a promise that already
+ * exists, so cancelling is the operation's job once it is handed the signal.
+ *
+ * `timeoutMs` is held at `MAX_TIMER_MS`: `setTimeout` fires after 1 ms for a
+ * longer delay, which turned the longest deadline a workflow could ask for into
+ * an immediate failure.
+ * @param run - Operation to execute; observes the signal to stop early
  * @param timeoutMs - Timeout in milliseconds
  * @param timeoutMessage - Error message for timeout
- * @returns Result of function execution
+ * @returns Result of the operation
  */
-async function executeWithTimeout(fn, timeoutMs, timeoutMessage) {
+async function executeWithTimeout(run, timeoutMs, timeoutMessage) {
+    const controller = new AbortController();
     let timeoutHandle;
+    // An explicit upper-bound comparison, and `>` rather than `<=`: NaN fails
+    // `>`, so NaN, zero and negative deadlines reach `setTimeout` as they always
+    // did, and only a value above the limit is replaced by it.
+    const delayMs = timeoutMs > MAX_TIMER_MS ? MAX_TIMER_MS : timeoutMs;
     const timeoutPromise = new Promise((_, reject) => {
         timeoutHandle = setTimeout(() => {
             const error = new WorkflowError(timeoutMessage, {
@@ -215,21 +232,17 @@ async function executeWithTimeout(fn, timeoutMs, timeoutMessage) {
                 phase: "ensemble",
                 retryable: true,
             });
+            // Reject before aborting: the abort can make the operation's own
+            // promise fail, and the race must already hold the deadline error.
             reject(error);
-        }, timeoutMs);
+            controller.abort(error);
+        }, delayMs);
     });
     try {
-        const result = await Promise.race([fn(), timeoutPromise]);
-        if (timeoutHandle) {
-            clearTimeout(timeoutHandle);
-        }
-        return result;
+        return await Promise.race([run(controller.signal), timeoutPromise]);
     }
-    catch (error) {
-        if (timeoutHandle) {
-            clearTimeout(timeoutHandle);
-        }
-        throw error;
+    finally {
+        clearTimeout(timeoutHandle);
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.51.0",
+  "version": "12.51.1",
   "packageManager": "pnpm@10.15.1",
   "description": "The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002/call) for routing, tool selection and context budgeting. MCP-native (4 transports), voice TTS/STT/realtime, RAG, agents, memory, compaction, 9 observability exporters. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · TypeSafe Jev and more.",
   "author": {
@@ -199,6 +199,7 @@
     "test:bugfixes": "pnpm exec tsx test/continuous-test-suite-bugfixes.ts",
     "test:json-e2e": "pnpm exec tsx test/continuous-test-suite-json-e2e.ts",
     "test:workflow": "pnpm exec tsx test/continuous-test-suite-workflow.ts",
+    "test:workflow-deadlines": "pnpm exec tsx test/continuous-test-suite-workflow-deadlines.ts",
     "test:hitl": "pnpm exec tsx test/continuous-test-suite-hitl.ts",
     "test:hitl:timeout-exclusions": "pnpm exec tsx test/continuous-test-suite-hitl-timeout-exclusions.ts",
     "test:tasks": "pnpm exec tsx test/continuous-test-suite-tasks.ts",