@juspay/neurolink 12.5.3 → 12.6.1

package/dist/types/proxyClient.d.ts

@@ -29,6 +29,17 @@ export type CliProxyClientConfigurator = {
      * alone and return false.
      */
     restore: (proxyBaseUrl: string) => Promise<boolean>;
+    /**
+     * Something the user must still do for apply() to take effect.
+     *
+     * Writing a file is not the same as being in effect. Copilot reads its
+     * provider settings from the environment only, so its configurator writes a
+     * script the user has to source; until they do, the proxy reports a green
+     * check for a file nothing reads. Returning a string here lets a client say
+     * "written, but not yet live, and here is the one line that fixes it".
+     * Return null when nothing is outstanding.
+     */
+    postApplyNote?: (proxyBaseUrl: string) => Promise<string | null>;
 };
 /** Outcome of applying one configurator, for per-client CLI reporting. */
 export type CliProxyClientApplyResult = {
@@ -36,6 +47,12 @@ export type CliProxyClientApplyResult = {
     displayName: string;
     /** True only when the configurator actually wrote configuration. */
     applied: boolean;
+    /**
+     * Set when the write landed but is not yet in effect — see
+     * CliProxyClientConfigurator.postApplyNote. Callers must render this; a
+     * silent note is the failure it exists to prevent.
+     */
+    note?: string;
     /** Present when the configurator threw; the caller decides how loud to be. */
     error?: Error;
 };

package/dist/utils/providerRetry.js

@@ -13,7 +13,7 @@
  *
  * @module utils/providerRetry
  */
-import { NeuroLinkError } from "./errorHandling.js";
+import { NeuroLinkError, isAbortError } from "./errorHandling.js";
 import { logger } from "./logger.js";
 import { APICallError } from "./generationErrors.js";
 import { parseRetryAfterMs } from "./retryAfter.js";
@@ -143,7 +143,50 @@ export function isOpenAIQuotaExhaustedError(error) {
     }
     return false;
 }
+/**
+ * True when `error` is an abort, or wraps one at any depth via `cause`.
+ *
+ * `isAbortError` alone is not enough here because it inspects one value, and
+ * by the time a provider failure reaches the retry wrapper it has usually been
+ * re-thrown inside a provider-specific error whose `name` no longer says
+ * "AbortError". The depth bound stops a self-referential or maliciously deep
+ * `cause` chain from hanging the classifier; nothing legitimate nests further.
+ */
+function isAbortLike(error, depth = 0) {
+    if (depth > 8 || error === null || typeof error !== "object") {
+        return isAbortError(error);
+    }
+    if (isAbortError(error)) {
+        return true;
+    }
+    const { cause } = error;
+    return cause === undefined || cause === error
+        ? false
+        : isAbortLike(cause, depth + 1);
+}
 export function isRetryableProviderError(error) {
+    // Ahead of everything, for the same reason as the quota branch below but a
+    // worse failure: the caller has already walked away. Retrying a cancelled
+    // turn cannot succeed — the signal stays aborted, so every further attempt
+    // rejects without reaching the network — and it costs the full ladder,
+    // 2 retries at the NO_HINT_FLOOR_MS floor, before the turn ends.
+    //
+    // Measured on SageMaker before this guard: abort at 400ms, provider failed
+    // at 232ms with "Request aborted", then two more attempts 10s apart each
+    // failing in 1ms without a request leaving the process, and the turn finally
+    // threw at 21,996ms — 55x the time the cancellation should have taken, with
+    // `name` by then reading "Error" rather than "AbortError".
+    //
+    // The cause chain matters and is not defensive padding. Providers wrap
+    // transport failures in their own error class on the way up: SageMaker's
+    // handleSageMakerError() stamps an unrecognised error `statusCode: 500`
+    // while keeping the original as `cause`. That fabricated 500 is what made an
+    // abort look retryable here — the duck-typed status branch below reads it
+    // and returns true, outranking the wrapper's own `retryable: false`. Reading
+    // through `cause` finds the abort whatever wrapped it.
+    if (isAbortLike(error)) {
+        return false;
+    }
     // Before every other branch, including the SDK's own flag: a 429 carrying
     // `insufficient_quota` is marked retryable by the AI SDK because it only
     // looks at the status code. Retrying it burns the full ladder — 3 attempts

package/package.json

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