@juspay/neurolink 12.7.5 → 12.7.7

package/dist/core/baseProvider.js

@@ -1260,7 +1260,18 @@ export class BaseProvider {
         // never enforced on this path, and enforcing them now would break
         // long-running generations that have always been allowed.
         const descriptorGenerateMs = PROVIDER_DESCRIPTORS_BY_NAME.get(this.providerName)?.timeouts?.generateMs;
-        const effectiveTimeout = options.timeout ?? Math.max(descriptorGenerateMs ?? 0, 180_000);
+        // An explicit, valid turnTimeoutMs is the caller's whole-turn contract
+        // and owns this hard abort; `timeout` then keeps its per-model-call
+        // meaning (it reaches the model layer via providerOptions.neurolink).
+        // Before this, `timeout` alone bounded the ENTIRE multi-step loop, so a
+        // caller asking for a 40-minute turn of 5-minute calls was killed at 5
+        // minutes flat — mid-loop, dressed as "Request was aborted.".
+        const hasValidTurnTimeout = typeof options.turnTimeoutMs === "number" &&
+            Number.isFinite(options.turnTimeoutMs) &&
+            options.turnTimeoutMs > 0;
+        const effectiveTimeout = hasValidTurnTimeout
+            ? options.turnTimeoutMs
+            : (options.timeout ?? Math.max(descriptorGenerateMs ?? 0, 180_000));
         const timeoutController = createTimeoutController(effectiveTimeout, this.providerName, "generate");
         const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
         const composedOptions = composedSignal
@@ -1270,6 +1281,24 @@ export class BaseProvider {
         try {
             generateResult = await this.executeGeneration(model, messages, tools, composedOptions);
         }
+        catch (error) {
+            // When OUR timer fired, provider SDKs typically normalize the abort
+            // into their own generic cancel shape (e.g. Anthropic's
+            // APIUserAbortError, "Request was aborted.") and discard the signal's
+            // reason. The TimeoutError on the signal is the honest identity —
+            // rethrow it so logs and abort classification see a timeout, not a
+            // caller cancel. A genuine caller abort (their signal fired) keeps its
+            // original shape even if our timer also expired in the race window.
+            const reason = timeoutController?.controller.signal.aborted
+                ? timeoutController.controller.signal.reason
+                : undefined;
+            if (reason instanceof TimeoutError &&
+                isAbortError(error) &&
+                options.abortSignal?.aborted !== true) {
+                throw reason;
+            }
+            throw error;
+        }
         finally {
             timeoutController?.cleanup();
         }

package/dist/providers/anthropic/client.js

@@ -26,7 +26,7 @@ import { stringifyAnthropicToolOutput } from "./toolOutput.js";
 import { createAnthropicLoopAdapter } from "./loopAdapter.js";
 import { runAgenticLoop } from "../../core/loopEngine.js";
 import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
-import { composeAbortSignals, createTimeoutController, mergeAbortSignals, } from "../../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, mergeAbortSignals, TimeoutError, } from "../../utils/timeout.js";
 import { resolveToolChoice } from "../../utils/toolChoice.js";
 import { emitToolEndFromStepFinish } from "../../utils/toolEndEmitter.js";
 import { NoOutputGeneratedError } from "../../utils/generationErrors.js";
@@ -1126,28 +1126,47 @@ export class AnthropicProvider extends BaseProvider {
                     ...(toolChoice ? { tool_choice: toolChoice } : {}),
                     ...(thinking ? { thinking } : {}),
                 };
-                // The 60s anthropic generate default was tuned for the old ~4096
-                // max_tokens. Now that the default ceiling is the model's real max,
-                // a large structured response needs more wall-clock to be produced —
-                // otherwise the inner controller aborts mid-generation (the AI-SDK
-                // doGenerate layer doesn't see the caller's `timeout`). Raise the
-                // floor to 5 min when a large output budget is in play — but only
-                // when the caller did NOT set an explicit timeout: an explicit value
-                // is a contract and must never be silently extended. The abort
-                // signal stays the real bound.
-                const callerTimeout = options
-                    .timeout;
-                const callerSpecifiedTimeout = callerTimeout !== undefined && callerTimeout !== null;
-                const generateTimeoutMs = params.max_tokens > 8192 && !callerSpecifiedTimeout
-                    ? Math.max(getTimeoutForOptions(options), 300_000)
-                    : getTimeoutForOptions(options);
+                // The caller's resolved `timeout` reaches this layer only through
+                // providerOptions.neurolink.timeoutMs (AI-SDK call options carry no
+                // `timeout`; the old `options.timeout` read here never fired on V3).
+                // An explicit value is a per-call contract: never floored, never
+                // extended. Without one, the 60s anthropic default was tuned for the
+                // old ~4096 max_tokens — now that the default ceiling is the model's
+                // real max, raise the floor to 5 min when a large output budget is
+                // in play. The abort signal stays the real bound.
+                const neurolinkNs = options.providerOptions?.neurolink;
+                const forwardedTimeoutMs = typeof neurolinkNs?.timeoutMs === "number" &&
+                    Number.isFinite(neurolinkNs.timeoutMs) &&
+                    neurolinkNs.timeoutMs > 0
+                    ? neurolinkNs.timeoutMs
+                    : undefined;
+                const generateTimeoutMs = forwardedTimeoutMs !== undefined
+                    ? forwardedTimeoutMs
+                    : params.max_tokens > 8192
+                        ? Math.max(getTimeoutForOptions(options), 300_000)
+                        : getTimeoutForOptions(options);
                 const timeoutController = createTimeoutController(generateTimeoutMs, providerName, "generate");
+                const requestSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
                 let response;
                 try {
                     response = await client.messages.create(params, {
-                        signal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                        signal: requestSignal,
                     });
                 }
+                catch (error) {
+                    // The Anthropic SDK collapses ANY fired signal into its generic
+                    // APIUserAbortError ("Request was aborted."), discarding the
+                    // signal's reason. When the abort came from one of NeuroLink's own
+                    // timers (this per-call timer, or the turn-level one upstream),
+                    // the TimeoutError reason is the honest identity — surface it.
+                    const reason = requestSignal?.aborted
+                        ? requestSignal.reason
+                        : undefined;
+                    if (reason instanceof TimeoutError) {
+                        throw reason;
+                    }
+                    throw error;
+                }
                 finally {
                     timeoutController?.cleanup();
                 }

package/dist/proxy/claudeFormat.js

@@ -71,6 +71,28 @@ export function parseClaudeRequest(body) {
     for (let msgIdx = 0; msgIdx < body.messages.length; msgIdx++) {
         const msg = body.messages[msgIdx];
         const isLatestUserMsg = msgIdx === lastUserMsgIdx;
+        // The Messages API restricts `messages[].role` to "user"/"assistant" —
+        // system prompts are a separate top-level field — but nothing at the
+        // wire boundary enforces that. A client that inlines a "system" message
+        // here would otherwise flow straight into conversationMessages and land
+        // at a non-leading index once translated to an OpenAI-shaped request for
+        // a fallback provider (e.g. LiteLLM/vLLM), whose chat templates reject
+        // any system message not at index 0. Fold it into systemPrompt instead,
+        // mirroring parseOpenAIRequest's handling of inline system messages.
+        if (msg.role === "system") {
+            const text = typeof msg.content === "string"
+                ? msg.content
+                : Array.isArray(msg.content)
+                    ? msg.content
+                        .map((b) => (b.type === "text" ? b.text : ""))
+                        .filter((t) => t.length > 0)
+                        .join("\n")
+                    : "";
+            if (text) {
+                systemPrompt = systemPrompt ? `${systemPrompt}\n\n${text}` : text;
+            }
+            continue;
+        }
         if (typeof msg.content === "string") {
             conversationMessages.push({ role: msg.role, content: msg.content });
             if (msg.role === "user") {

package/dist/types/conversation.d.ts

@@ -60,6 +60,13 @@ export type ConversationMemoryConfig = {
     summarizationProvider?: string;
     /** Model to use for summarization */
     summarizationModel?: string;
+    /**
+     * Wall-clock cap for one summarization generate call, in milliseconds
+     * (default: 60000). A summary that overruns is dropped, not fatal — the
+     * turn continues without it — so size this for the slowest summary a real
+     * conversation produces rather than losing compaction summaries silently.
+     */
+    summarizationTimeoutMs?: number;
     /** Memory SDK config (condensed key-value memory per user). Set enabled: true to activate. */
     memory?: HippocampusMemory;
     /** Redis configuration (optional) - overrides environment variables */

package/dist/types/generate.d.ts

@@ -348,7 +348,14 @@ export type GenerateOptions = {
      * multi-step tool loop (Vertex Gemini / Vertex Claude), this bounds EACH
      * model call in the loop, not the whole turn — a tool-heavy turn may run
      * far longer than this value in total. Size it for the slowest single
-     * step (default 300s), and use `abortSignal` for a total-turn deadline.
+     * step (default 300s), and use `turnTimeoutMs` (or `abortSignal`) for a
+     * total-turn deadline.
+     *
+     * On the AI-SDK loop path (direct Anthropic, litellm, OpenAI-compatible)
+     * the same split holds only when `turnTimeoutMs` is ALSO set: then this
+     * value bounds each model call and `turnTimeoutMs` bounds the turn. With
+     * `turnTimeoutMs` unset, this value bounds the WHOLE turn there (the
+     * pre-existing defensive behavior, kept for backward compatibility).
      *
      * When set explicitly, a step timeout is surfaced immediately instead of
      * burning internal retries/fallbacks that would re-run the same
@@ -363,9 +370,11 @@ export type GenerateOptions = {
      * imposes no product policy).
      *
      * Enforced by the native Vertex loops (Gemini + Claude) AND the AI-SDK
-     * loop path (litellm and other OpenAI-compatible providers). On the AI-SDK
-     * path, an explicit `timeout` also engages the same wrap-up when
-     * `turnTimeoutMs` is unset. Once the wrap-up window begins (see
+     * loop path (direct Anthropic, litellm and other OpenAI-compatible
+     * providers). On the AI-SDK path this value also owns the whole-turn hard
+     * abort: when set, `timeout` keeps its per-model-call meaning instead of
+     * bounding the entire loop. An explicit `timeout` also engages the same
+     * wrap-up when `turnTimeoutMs` is unset. Once the wrap-up window begins (see
      * `wrapupTimeLeadMs`), the loop forcibly sets `toolChoice: "none"` for the
      * remaining steps — overriding any caller-supplied `toolChoice` or
      * `prepareStep` tool selection — and appends an honest time message that a

package/dist/utils/conversationMemory.js

@@ -593,7 +593,15 @@ export function getEffectiveTokenThreshold(provider, model, envOverride, session
 export async function generateSummary(messages, config, logPrefix = "[ConversationMemory]", previousSummary, requestId) {
     const summarizationPrompt = createSummarizationPrompt(messages, previousSummary);
     const SUMMARIZER_INIT_TIMEOUT = 15_000;
-    const SUMMARIZER_GENERATE_TIMEOUT = 60_000;
+    // Config-driven: a compaction summary of a large conversation routinely
+    // needs more than the old hard-coded 60s, and each overrun silently loses
+    // one summary (non-fatal — the turn continues) with no knob to raise it.
+    const configuredTimeoutMs = config.summarizationTimeoutMs;
+    const SUMMARIZER_GENERATE_TIMEOUT = typeof configuredTimeoutMs === "number" &&
+        Number.isFinite(configuredTimeoutMs) &&
+        configuredTimeoutMs > 0
+        ? configuredTimeoutMs
+        : 60_000;
     try {
         if (!cachedSummarizer) {
             cachedSummarizer = await withTimeout((async () => {

package/dist/utils/errorHandling.js

@@ -1189,7 +1189,11 @@ export function isAbortError(error) {
     if (error instanceof Error &&
         (error.message?.includes("This operation was aborted") ||
             error.message?.includes("The operation was aborted") ||
-            error.message?.includes("The user aborted a request"))) {
+            error.message?.includes("The user aborted a request") ||
+            // Anthropic SDK's APIUserAbortError — name is plain "Error", so only
+            // the message identifies it. Missing this classified real aborts as
+            // provider failures (ERROR log + fallback consulted on a user cancel).
+            error.message?.includes("Request was aborted"))) {
         return true;
     }
     return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.7.5",
+  "version": "12.7.7",
   "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": {