@juspay/neurolink 11.26.1 → 11.26.2

package/dist/core/baseProvider.js

@@ -1733,6 +1733,22 @@ export class BaseProvider {
                 ? error
                 : new DOMException("The operation was aborted", "AbortError");
         }
+        // Already formatted by this method — hand it straight back. Formatting is
+        // NOT idempotent: formatProviderError prepends the provider tag every time,
+        // so a second pass produces
+        //   "[vertex] Google Vertex AI error: [vertex] Google Vertex AI error: ..."
+        // and, when a rule matched on statusCode the first time, can also DEGRADE
+        // the classification (a specific "quota exhausted" ProviderError re-matching
+        // the bare 429 rule as a generic RateLimitError) because the block below
+        // copies statusCode onto its own output.
+        //
+        // A single Vertex failure reaches here FIVE times for one logical error;
+        // this makes calls 2..5 cheap pass-throughs. `instanceof Error` rather than
+        // a cast: nothing but an Error is ever stamped, and an unstamped value
+        // simply falls through to formatting, which is the safe direction.
+        if (error instanceof Error && isProviderErrorClassified(error)) {
+            return error;
+        }
         const formatted = this.formatProviderError(error);
         // Preserve transport retry metadata across formatting. Provider
         // formatters return fresh Error instances (RateLimitError, NetworkError,

package/dist/providers/anthropic/client.js

@@ -15,6 +15,7 @@ import { getCapturedLimitSnapshot, getCapturedResponseHeaders, logClaudeLimitSna
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../../types/index.js";
 import { classifyProviderError } from "../../utils/errorClassifier.js";
 import { logger } from "../../utils/logger.js";
+import { drainDetachedPump } from "../../utils/drainDetachedPump.js";
 import { ANTHROPIC_ELISION_NOTE, planAnthropicLoopReclaim, previewAnthropicToolResultText, } from "../../context/anthropicLoopGuard.js";
 import { getAvailableInputTokens } from "../../constants/contextWindows.js";
 import { estimateTokens } from "../../utils/tokenEstimation.js";
@@ -1749,15 +1750,15 @@ export class AnthropicProvider extends BaseProvider {
             // formatted one the caller received, which is why the existing
             // `loopPromise.catch` guard below does not cover it.
             //
-            // Same shape googleAiStudio/client.ts and googleVertex/client.ts already
-            // use at every one of their pump sites; Anthropic was the only provider
-            // missing it.
+            // Every detached-drain site in the codebase now goes through
+            // drainDetachedPump(), which adopts the rejection and logs the reason at
+            // debug instead of discarding it silently.
             let result;
             try {
                 result = await resultPromise;
             }
             catch (error) {
-                await pump.catch(() => { });
+                await drainDetachedPump(pump, "Anthropic");
                 throw error;
             }
             await pump;

package/dist/providers/googleAiStudio/client.js

@@ -6,6 +6,7 @@ import { ATTR, tracers, withClientSpan, withClientStreamSpan, withSpan, } from "
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../../types/index.js";
 import { ERROR_CODES, NeuroLinkError } from "../../utils/errorHandling.js";
 import { logger } from "../../utils/logger.js";
+import { drainDetachedPump } from "../../utils/drainDetachedPump.js";
 import { createGeminiLoopAdapter } from "../../core/geminiLoopAdapter.js";
 import { runAgenticLoop } from "../../core/loopEngine.js";
 import { DEFAULT_TOOL_MAX_RETRIES } from "../../core/constants.js";
@@ -861,7 +862,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                             engineResult = await resultPromise;
                         }
                         catch (error) {
-                            await pump.catch(() => { });
+                            await drainDetachedPump(pump, "GoogleAIStudio");
                             logger.error("[GoogleAIStudio] Native SDK error", error);
                             throw this.handleProviderError(error);
                         }
@@ -1173,7 +1174,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                     engineResult = await resultPromise;
                 }
                 catch (error) {
-                    await drain.catch(() => { });
+                    await drainDetachedPump(drain, "GoogleAIStudio");
                     logger.error("[GoogleAIStudio] Native SDK generate error", error);
                     throw this.handleProviderError(error);
                 }

package/dist/providers/googleVertex/client.js

@@ -20,6 +20,7 @@ import { applyVertexAnthropicCacheBreakpoints } from "../../utils/anthropicCache
 import { FileDetector } from "../../utils/fileDetector.js";
 import { mergeMediaFileAliases, normalizeVisionImageFormats, processUnifiedFilesArray, } from "../../utils/messageBuilder.js";
 import { logger } from "../../utils/logger.js";
+import { drainDetachedPump } from "../../utils/drainDetachedPump.js";
 import { GEMINI_ELISION_NOTE, planGeminiLoopReclaim, previewGeminiToolResponseText, } from "../../context/geminiLoopGuard.js";
 import { ANTHROPIC_ELISION_NOTE, planAnthropicLoopReclaim, previewAnthropicToolResultText, } from "../../context/anthropicLoopGuard.js";
 import { hasRestrictedOutputLimit, RESTRICTED_OUTPUT_TOKEN_LIMIT, toVertexAnthropicModelId, } from "../../utils/modelDetection.js";
@@ -1814,7 +1815,7 @@ export class GoogleVertexProvider extends BaseProvider {
             // rethrow the very error the branch below has already decided to absorb —
             // which is what turned both turn-clock cases into failures instead of
             // clean deadline exits.
-            await pump.catch(() => { });
+            await drainDetachedPump(pump, "GoogleVertex");
             if (turnFailure !== undefined) {
                 // A mid-drain abort surfaces as an AbortError. End gracefully into the
                 // terminal block instead of re-throwing — a re-throw would route the
@@ -2598,7 +2599,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 engineResult = await resultPromise;
             }
             catch (error) {
-                await pump.catch(() => { });
+                await drainDetachedPump(pump, "GoogleVertex");
                 // A mid-drain abort surfaces as an AbortError. End gracefully into the
                 // terminal block instead of re-throwing — a re-throw would route the
                 // caller's abort into a second unbounded fallback stream().
@@ -3687,7 +3688,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 // Drained tolerantly and exactly once: when a turn ends by abort the
                 // channel rejects too, and re-awaiting a settled rejection would rethrow
                 // the error the branch below has already decided to absorb.
-                await pump.catch(() => { });
+                await drainDetachedPump(pump, "GoogleVertex");
                 if (turnFailure !== undefined) {
                     if (internalAbort.signal.aborted || isAbortError(turnFailure)) {
                         wasAborted = true;
@@ -4686,7 +4687,7 @@ export class GoogleVertexProvider extends BaseProvider {
         catch (error) {
             turnFailure = error;
         }
-        await pump.catch(() => { });
+        await drainDetachedPump(pump, "GoogleVertex");
         if (turnFailure !== undefined) {
             if (internalAbort.signal.aborted || isAbortError(turnFailure)) {
                 wasAborted = true;

package/dist/utils/drainDetachedPump.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Await a detached stream pump, swallowing its rejection but not its evidence.
+ *
+ * Several providers drain their engine's channel with a pump started outside
+ * the promise chain the caller awaits:
+ *
+ *   const pump = (async () => { for await (const chunk of stream) { ... } })();
+ *   const result = await resultPromise;   // can throw
+ *   await pump;                           // never reached if it does
+ *
+ * When the turn fails, `resultPromise` and the pump reject together — the
+ * engine calls `channel.error(err)` before closing — so the pump must be
+ * adopted on the error path too. Nothing adopting it is not a cosmetic leak:
+ * an unhandled rejection TERMINATES the process, so a caller who correctly
+ * try/catches the streaming error still dies. That was a real bug in the
+ * Anthropic path.
+ *
+ * The established remedy is `await pump.catch(() => {})`, which every site
+ * already uses. The gap this closes is the second half: `() => {}` throws the
+ * reason away, so the raw upstream error — the one carrying the provider's
+ * actual wire response — was invisible in traces at every one of the seven
+ * sites (six named `pump`, plus one named `drain` in googleAiStudio's
+ * non-streaming path, which a search for `pump` does not find). It is logged at DEBUG rather than WARN deliberately: on a failing turn
+ * this reason is almost always a duplicate of the error the caller is already
+ * being handed, and on an aborted turn it is the expected AbortError. It is
+ * diagnostic detail, not a new event worth alerting on.
+ *
+ * Behaviour is otherwise identical to `await pump.catch(() => {})`: it awaits,
+ * it never rethrows.
+ */
+export declare function drainDetachedPump(pump: Promise<unknown>, providerLabel: string): Promise<void>;

package/dist/utils/drainDetachedPump.js

@@ -0,0 +1,39 @@
+import { logger } from "./logger.js";
+/**
+ * Await a detached stream pump, swallowing its rejection but not its evidence.
+ *
+ * Several providers drain their engine's channel with a pump started outside
+ * the promise chain the caller awaits:
+ *
+ *   const pump = (async () => { for await (const chunk of stream) { ... } })();
+ *   const result = await resultPromise;   // can throw
+ *   await pump;                           // never reached if it does
+ *
+ * When the turn fails, `resultPromise` and the pump reject together — the
+ * engine calls `channel.error(err)` before closing — so the pump must be
+ * adopted on the error path too. Nothing adopting it is not a cosmetic leak:
+ * an unhandled rejection TERMINATES the process, so a caller who correctly
+ * try/catches the streaming error still dies. That was a real bug in the
+ * Anthropic path.
+ *
+ * The established remedy is `await pump.catch(() => {})`, which every site
+ * already uses. The gap this closes is the second half: `() => {}` throws the
+ * reason away, so the raw upstream error — the one carrying the provider's
+ * actual wire response — was invisible in traces at every one of the seven
+ * sites (six named `pump`, plus one named `drain` in googleAiStudio's
+ * non-streaming path, which a search for `pump` does not find). It is logged at DEBUG rather than WARN deliberately: on a failing turn
+ * this reason is almost always a duplicate of the error the caller is already
+ * being handed, and on an aborted turn it is the expected AbortError. It is
+ * diagnostic detail, not a new event worth alerting on.
+ *
+ * Behaviour is otherwise identical to `await pump.catch(() => {})`: it awaits,
+ * it never rethrows.
+ */
+export async function drainDetachedPump(pump, providerLabel) {
+    try {
+        await pump;
+    }
+    catch (error) {
+        logger.debug(`[${providerLabel}] detached stream pump rejected; reason absorbed because the turn's own error is authoritative`, error);
+    }
+}

package/package.json

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