@juspay/neurolink 10.3.0 → 10.4.0

package/dist/utils/timeout.d.ts

@@ -128,8 +128,30 @@ export declare function createTimeoutController(timeout: number | string | undef
  * @returns Combined AbortSignal, or undefined if neither is present
  */
 export declare function composeAbortSignals(externalSignal?: AbortSignal, timeoutSignal?: AbortSignal): AbortSignal | undefined;
+/**
+ * Scoped variant of {@link composeAbortSignals} for per-step / per-request
+ * composition against a LONG-LIVED external signal (e.g. the generate-call
+ * signal inside a multi-step agent loop). `AbortSignal.any` keeps its source
+ * registration alive until the derived signal is GC'd, so composing per step
+ * accumulates listeners on the outer signal for the whole turn
+ * (MaxListenersExceededWarning at 10+ steps). This helper registers plain
+ * listeners instead and returns a `dispose()` that removes them the moment
+ * the step settles.
+ */
+export declare function composeAbortSignalsScoped(externalSignal?: AbortSignal, timeoutSignal?: AbortSignal): {
+    signal: AbortSignal | undefined;
+    dispose: () => void;
+};
 /**
  * Merge abort signals (for combining user abort with timeout)
+ *
+ * Implemented via `AbortSignal.any` with a single once-listener forward, so
+ * no per-source listeners are left behind on long-lived input signals once
+ * the merged controller becomes unreachable (registrations are released with
+ * the derived signal). The previous implementation attached one permanent
+ * listener per source per call — repeated stream calls sharing one caller
+ * signal accumulated listeners for the life of that signal.
+ *
  * @param signals - Array of abort signals to merge
  * @returns Combined abort controller
  */

package/dist/utils/timeout.js

@@ -342,25 +342,85 @@ export function composeAbortSignals(externalSignal, timeoutSignal) {
     }
     return externalSignal ?? timeoutSignal;
 }
+/**
+ * Scoped variant of {@link composeAbortSignals} for per-step / per-request
+ * composition against a LONG-LIVED external signal (e.g. the generate-call
+ * signal inside a multi-step agent loop). `AbortSignal.any` keeps its source
+ * registration alive until the derived signal is GC'd, so composing per step
+ * accumulates listeners on the outer signal for the whole turn
+ * (MaxListenersExceededWarning at 10+ steps). This helper registers plain
+ * listeners instead and returns a `dispose()` that removes them the moment
+ * the step settles.
+ */
+export function composeAbortSignalsScoped(externalSignal, timeoutSignal) {
+    if (!externalSignal || !timeoutSignal) {
+        return { signal: externalSignal ?? timeoutSignal, dispose: () => { } };
+    }
+    const controller = new AbortController();
+    const sources = [externalSignal, timeoutSignal];
+    const listeners = [];
+    const dispose = () => {
+        for (const { source, listener } of listeners) {
+            source.removeEventListener("abort", listener);
+        }
+        listeners.length = 0;
+    };
+    const onAbort = (source) => {
+        if (!controller.signal.aborted) {
+            controller.abort(source.reason);
+        }
+        // Self-clean on abort: once the composed signal fired, no source
+        // listener has any work left — detach from the OTHER source too (the
+        // firing one auto-removed via `once`), so callers that only observe
+        // `signal.aborted` and never reach their dispose() leave nothing behind.
+        dispose();
+    };
+    for (const source of sources) {
+        const listener = () => onAbort(source);
+        source.addEventListener("abort", listener, { once: true });
+        listeners.push({ source, listener });
+    }
+    for (const source of sources) {
+        if (source.aborted) {
+            onAbort(source);
+            break;
+        }
+    }
+    return { signal: controller.signal, dispose };
+}
 /**
  * Merge abort signals (for combining user abort with timeout)
+ *
+ * Implemented via `AbortSignal.any` with a single once-listener forward, so
+ * no per-source listeners are left behind on long-lived input signals once
+ * the merged controller becomes unreachable (registrations are released with
+ * the derived signal). The previous implementation attached one permanent
+ * listener per source per call — repeated stream calls sharing one caller
+ * signal accumulated listeners for the life of that signal.
+ *
  * @param signals - Array of abort signals to merge
  * @returns Combined abort controller
  */
 export function mergeAbortSignals(signals) {
     const controller = new AbortController();
-    for (const signal of signals) {
-        if (signal && !signal.aborted) {
-            signal.addEventListener("abort", () => {
-                if (!controller.signal.aborted) {
-                    controller.abort(signal.reason);
-                }
-            });
-        }
-        if (signal?.aborted) {
-            controller.abort(signal.reason);
-            break;
-        }
+    const active = signals.filter((s) => s !== undefined);
+    const aborted = active.find((s) => s.aborted);
+    if (aborted) {
+        controller.abort(aborted.reason);
+        return controller;
     }
+    if (active.length === 0) {
+        return controller;
+    }
+    const merged = AbortSignal.any(active);
+    merged.addEventListener("abort", () => {
+        if (!controller.signal.aborted) {
+            controller.abort(merged.reason);
+        }
+    }, { once: true });
+    // Pin the derived signal to the returned controller: sources hold only
+    // weak refs to `any()` dependents, so without this strong ref the derived
+    // signal (and the forward listener with it) could be GC'd before firing.
+    controller.__nlMergedSignal = merged;
     return controller;
 }

package/dist/utils/tokenLimits.js

@@ -2,6 +2,7 @@
  * Provider-specific token limit utilities
  * Provides safe maxTokens values based on provider and model capabilities
  */
+import { getRuntimeOutputCeiling } from "../constants/contextWindows.js";
 import { PROVIDER_MAX_TOKENS } from "../core/constants.js";
 import { logger } from "./logger.js";
 import { hasRestrictedOutputLimit, RESTRICTED_OUTPUT_TOKEN_LIMIT, } from "./modelDetection.js";
@@ -34,6 +35,27 @@ export function getSafeMaxTokens(provider, model, requestedMaxTokens) {
         // Otherwise, use the requested value (it's within limits, including 0)
         return requestedMaxTokens;
     }
+    // Runtime-discovered output ceiling (e.g. LiteLLM /model/info
+    // max_output_tokens): the serving infrastructure's own number for the
+    // deployed model, authoritative over the static per-provider table. This
+    // both clamps over-large requests to the real cap AND replaces the static
+    // provider default for callers that pass no maxTokens — the litellm
+    // blanket default (128000) is a context-window-sized value that slashed
+    // usable input on total-context backends. Checked AFTER the
+    // restricted-model branch so hard caps proven at the origin API (Gemini 3
+    // / image models) still win over a proxy that over-advertises them.
+    const runtimeCeiling = getRuntimeOutputCeiling(provider, model);
+    if (runtimeCeiling !== undefined) {
+        if (requestedMaxTokens === undefined || requestedMaxTokens === null) {
+            return runtimeCeiling;
+        }
+        if (requestedMaxTokens > runtimeCeiling) {
+            logger.warn(`Requested maxTokens ${requestedMaxTokens} exceeds the advertised ` +
+                `${provider}/${model} output ceiling of ${runtimeCeiling}. Using ${runtimeCeiling} instead.`);
+            return runtimeCeiling;
+        }
+        return requestedMaxTokens;
+    }
     // Get provider-specific limits
     const providerLimits = PROVIDER_MAX_TOKENS[provider];
     if (!providerLimits) {

package/dist/utils/toolCallRepair.d.ts

@@ -4,3 +4,11 @@ import type { ToolCallRepairFunction, ToolSet } from "../types/index.js";
  * Fully dynamic — reads the tool schema at repair time, no configuration needed.
  */
 export declare function createToolCallRepair(): ToolCallRepairFunction<ToolSet>;
+/**
+ * Coerce a value to match the expected schema type.
+ * Handles: string→number, JSON string→object, JSON string→array, value→[value].
+ * Exported for reuse by the MCP-layer parameter validator
+ * (toolDiscoveryService), which coerces before rejecting so a recoverable
+ * mismatch doesn't cost the agent loop a full model round-trip.
+ */
+export declare function coerceType(value: unknown, propSchema: Record<string, unknown>): unknown;

package/dist/utils/toolCallRepair.js

@@ -173,8 +173,11 @@ function findMatchingKey(inputKey, schemaKeys) {
 /**
  * Coerce a value to match the expected schema type.
  * Handles: string→number, JSON string→object, JSON string→array, value→[value].
+ * Exported for reuse by the MCP-layer parameter validator
+ * (toolDiscoveryService), which coerces before rejecting so a recoverable
+ * mismatch doesn't cost the agent loop a full model round-trip.
  */
-function coerceType(value, propSchema) {
+export function coerceType(value, propSchema) {
     const expectedType = propSchema.type;
     if (!expectedType || value === null || value === undefined) {
         return value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "10.3.0",
+  "version": "10.4.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": {
@@ -80,6 +80,7 @@
     "test:mcp:cli": "npx tsx test/continuous-test-suite-mcp-cli.ts",
     "test:mcp:full": "pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:mcp:sdk && pnpm run test:mcp:cli && pnpm run test:mcp:http",
     "test:media": "npx tsx test/continuous-test-suite-media-gen.ts",
+    "test:litellm-parity": "npx tsx test/continuous-test-suite-litellm-parity.ts",
     "test:memory": "npx tsx test/continuous-test-suite-memory.ts",
     "test:middleware": "npx tsx test/continuous-test-suite-middleware.ts",
     "test:observability": "npx tsx test/continuous-test-suite-observability.ts",
@@ -346,6 +347,7 @@
     "@anthropic-ai/sdk": "^0.102.0",
     "@anthropic-ai/vertex-sdk": "^0.16.0",
     "@aws-sdk/types": "^3.862.0",
+    "@cfworker/json-schema": "^4.1.1",
     "@google/genai": "^1.43.0",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@opentelemetry/api-logs": "^0.214.0",
@@ -382,6 +384,7 @@
     "p-limit": "^7.3.0",
     "redis": "^5.11.0",
     "tar-stream": "^3.1.8",
+    "type-decoder": "^2.3.1",
     "undici": ">=7.24.0 <8.0.0",
     "ws": "^8.20.1",
     "yargs": "^18.0.0",