@juspay/neurolink 12.51.0 → 12.51.2

package/dist/cli/commands/setup-azure.js

@@ -290,6 +290,19 @@ function validateApiKey(input) {
     }
     return true;
 }
+const AZURE_OPENAI_HOST_SUFFIX = ".openai.azure.com";
+/**
+ * True only when the parsed hostname is a subdomain of openai.azure.com.
+ * A substring test also accepts `openai.azure.com.evil.example` and
+ * `evilopenai.azure.com`, so the leading dot of the suffix is what pins the
+ * label boundary. The URL class has already lower-cased the host; a single
+ * trailing dot (an absolute DNS name) is the same host and is ignored.
+ */
+function isAzureOpenAIHostname(hostname) {
+    const host = hostname.endsWith(".") ? hostname.slice(0, -1) : hostname;
+    return (host.length > AZURE_OPENAI_HOST_SUFFIX.length &&
+        host.endsWith(AZURE_OPENAI_HOST_SUFFIX));
+}
 /**
  * Validate Azure OpenAI endpoint URL
  */
@@ -300,7 +313,7 @@ function validateEndpoint(input) {
     const trimmed = input.trim();
     try {
         const url = new URL(trimmed);
-        if (!url.hostname.includes("openai.azure.com")) {
+        if (!isAzureOpenAIHostname(url.hostname)) {
             return "Endpoint should be an Azure OpenAI URL (*.openai.azure.com)";
         }
         return true;

package/dist/cli/commands/setup-gcp.js

@@ -469,6 +469,26 @@ function validateServiceAccountJSON(input) {
         return "Invalid JSON format";
     }
 }
+/**
+ * Quote a value for a double-quoted .env entry.
+ *
+ * Line breaks are folded first, whichever way they were typed (a real CR/LF,
+ * or the two characters `\n` a key copied out of a service-account JSON file
+ * carries), and written back as the `\n` escape the .env loaders expand. That
+ * has to come before the backslashes are escaped, or a pasted `\n` would be
+ * doubled into `\\n` and the key would stop being a key. Every other backslash
+ * is then escaped before the quote is: an unescaped one in front of a `"`
+ * cancels the quote's own escape, closes the value early and lets the rest of
+ * the input run as part of the .env line.
+ */
+function quoteEnvValue(value) {
+    const escaped = value
+        .replace(/\\r\\n|\\n|\\r|\r\n|\r/g, "\n")
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, "\\n");
+    return `"${escaped}"`;
+}
 /**
  * Update .env file with selected authentication method
  */
@@ -524,10 +544,7 @@ async function updateEnvFile(method, config) {
                     existingVars.set("GOOGLE_AUTH_CLIENT_EMAIL", config.clientEmail);
                 }
                 if (config.privateKey) {
-                    const escaped = config.privateKey
-                        .replace(/\r?\n/g, "\\n")
-                        .replace(/"/g, '\\"');
-                    existingVars.set("GOOGLE_AUTH_PRIVATE_KEY", `"${escaped}"`);
+                    existingVars.set("GOOGLE_AUTH_PRIVATE_KEY", quoteEnvValue(config.privateKey));
                 }
                 break;
         }

package/dist/cli/factories/sagemakerCommandFactory.js

@@ -1,3 +1,4 @@
+import { randomBytes } from "node:crypto";
 import chalk from "chalk";
 import ora from "ora";
 import inquirer from "inquirer";
@@ -134,7 +135,7 @@ export class SageMakerCommandFactory {
      * Create secure configuration without exposing credentials to process.env
      */
     static createSecureConfiguration(config) {
-        const sessionId = `sagemaker_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const sessionId = `sagemaker_${Date.now()}_${randomBytes(16).toString("hex")}`;
         const secureConfig = {
             ...config,
             sessionId,
@@ -143,9 +144,12 @@ export class SageMakerCommandFactory {
         // Store temporarily in secure memory store
         this.secureCredentialStore.set(sessionId, secureConfig);
         // Auto-cleanup after 5 minutes for security
-        setTimeout(() => {
+        const expiry = setTimeout(() => {
             this.secureCredentialStore.delete(sessionId);
         }, 5 * 60 * 1000);
+        // Setup also deletes the entry itself when it finishes; the timer is only
+        // the backstop and must not hold the CLI open for the rest of its window.
+        expiry.unref();
         return secureConfig;
     }
     /**
@@ -505,7 +509,7 @@ export class SageMakerCommandFactory {
                 "📖 Learn more: https://docs.aws.amazon.com/general/latest/gr/aws-access-keys-best-practices.html\n"));
             spinner.start("Setting up SageMaker configuration...");
             // Secure credential management without process.env exposure
-            const secureConfig = this.createSecureConfiguration({
+            const secureConfig = SageMakerCommandFactory.createSecureConfiguration({
                 accessKeyId: answers.accessKeyId,
                 secretAccessKey: answers.secretAccessKey,
                 region: answers.region,
@@ -516,7 +520,7 @@ export class SageMakerCommandFactory {
             // Clear cache and test configuration with secure config
             clearConfigurationCache();
             try {
-                await this.validateSecureConfiguration(secureConfig); // Validate configuration is loadable
+                await SageMakerCommandFactory.validateSecureConfiguration(secureConfig); // Validate configuration is loadable
                 spinner.succeed("✅ Configuration validated successfully");
                 logger.always(chalk.green("\n🎉 SageMaker setup complete!"));
                 logger.always(chalk.yellow("\n💡 Next steps:"));
@@ -544,13 +548,13 @@ export class SageMakerCommandFactory {
                     "  • Consider using AWS credential rotation policies\n" +
                     "  • Monitor AWS CloudTrail for unauthorized access attempts"));
                 // Clear secure credentials from memory after successful setup
-                this.clearSecureCredentials(secureConfig.sessionId);
+                SageMakerCommandFactory.clearSecureCredentials(secureConfig.sessionId);
             }
             catch (configError) {
                 spinner.fail("❌ Configuration validation failed");
                 logger.error(chalk.red(`Error: ${configError instanceof Error ? configError.message : String(configError)}`));
                 // Clear secure credentials from memory on error
-                this.clearSecureCredentials(secureConfig.sessionId);
+                SageMakerCommandFactory.clearSecureCredentials(secureConfig.sessionId);
                 process.exit(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.2",
   "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",