@juspay/neurolink 12.9.3 → 12.9.4

package/dist/providers/catalog/cloudflare.json

@@ -47,7 +47,7 @@
                 "contextWindow": 24000,
                 "vision": false,
                 "status": "production",
-                "description": "Llama 3.2 11B Vision Instruct — gated: Cloudflare returns 403 until the model's Community License is accepted once on the account, so it is unusable here and its vision flag is false despite being a vision model"
+                "description": "Llama 3.2 11B Vision Instruct — Meta Community License accepted on the account 2026-09-02, but Cloudflare's OpenAI-compatible endpoint accepts no image input for it: an image content part is rejected (400) and a top-level image is ignored ('There is no image'). The model reads images only through the native /ai/run prompt+image shape, which this OpenAI-compatible provider does not speak, so vision stays false here"
             },
             "@cf/mistral/mistral-7b-instruct-v0.2": {
                 "enumMember": "MISTRAL_7B_INSTRUCT_V0_2",
@@ -114,8 +114,8 @@
             "method": "real chat call per id against the live account"
         },
         "liveMatrix": {
-            "date": "2026-08-30",
-            "result": "Live tool round-trip verified on @cf/meta/llama-3.1-8b-instruct-fast, both non-streaming and streaming, once messageContentFormat normalization was applied; before it the follow-up turn was rejected with HTTP 400 (content sent as array/null). Of the three ids that failed, only two are actually gone: mistral-7b-instruct-v0.2 ('No such model') and qwen1.5-14b-chat-awq ('deprecated on 2025-10-01'). llama-3.2-11b-vision-instruct is alive but gated behind a one-time Community License acceptance on the account, so it answers 403 and is left production with vision false rather than retired."
+            "date": "2026-09-02",
+            "result": "Live tool round-trip verified on @cf/meta/llama-3.1-8b-instruct-fast, both non-streaming and streaming, once messageContentFormat normalization was applied; before it the follow-up turn was rejected with HTTP 400 (content sent as array/null). Of the three ids that failed, only two are actually gone: mistral-7b-instruct-v0.2 ('No such model') and qwen1.5-14b-chat-awq ('deprecated on 2025-10-01'). llama-3.2-11b-vision-instruct is alive but gated behind a one-time Community License acceptance on the account, so it answers 403 and is left production with vision false rather than retired. Update 2026-09-02: the Community License was accepted on the account; plain chat on llama-3.2-11b-vision-instruct now returns 200 on both endpoints, and the native /ai/run prompt+image call describes a 64x64 test image correctly. The OpenAI-compatible endpoint still cannot carry an image (content-part array → 400, top-level image ignored), so the vision flag remains false for this provider."
         },
         "addedInPR": "https://github.com/juspay/neurolink/pull/1587"
     },

package/dist/proxy/providerTransportCoordinator.d.ts

@@ -5,10 +5,13 @@ export declare class ProviderTransportCoordinator {
     private backoffUntil;
     private lastErrorCode;
     private lastTransportScope;
+    /** Whether the failure that degraded the transport happened before any
+     *  request byte was sent. Waiters use it to pick their retry budget. */
+    private lastFailureConnectPhase;
     private probe;
     acquire(signal?: AbortSignal): Promise<ProxyProviderTransportPermit>;
     reportSuccess(permit: ProxyProviderTransportPermit): void;
-    reportTransportFailure(errorCode: string | undefined, transportScope: "shared_provider_transport" | "connection_transport", permit: ProxyProviderTransportPermit): void;
+    reportTransportFailure(errorCode: string | undefined, transportScope: "shared_provider_transport" | "connection_transport", permit: ProxyProviderTransportPermit, connectPhase?: boolean): void;
     reportProbeAbandoned(permit: ProxyProviderTransportPermit): void;
     clear(): void;
     private wait;

package/dist/proxy/providerTransportCoordinator.js

@@ -7,6 +7,9 @@ export class ProviderTransportCoordinator {
     backoffUntil = 0;
     lastErrorCode = null;
     lastTransportScope = "shared_provider_transport";
+    /** Whether the failure that degraded the transport happened before any
+     *  request byte was sent. Waiters use it to pick their retry budget. */
+    lastFailureConnectPhase = false;
     probe;
     async acquire(signal) {
         if (!this.degraded) {
@@ -31,6 +34,7 @@ export class ProviderTransportCoordinator {
                 allowed: false,
                 errorCode: this.lastErrorCode,
                 transportScope: this.lastTransportScope,
+                connectPhase: this.lastFailureConnectPhase,
             };
         }
         let resolveProbe;
@@ -55,12 +59,13 @@ export class ProviderTransportCoordinator {
         this.backoffUntil = 0;
         this.lastErrorCode = null;
         this.lastTransportScope = "shared_provider_transport";
+        this.lastFailureConnectPhase = false;
         if (permit.probe && this.probe?.generation === permit.generation) {
             this.probe.resolve("recovered");
             this.probe = undefined;
         }
     }
-    reportTransportFailure(errorCode, transportScope, permit) {
+    reportTransportFailure(errorCode, transportScope, permit, connectPhase = false) {
         if (!permit.allowed || permit.generation !== this.generation) {
             return;
         }
@@ -71,6 +76,7 @@ export class ProviderTransportCoordinator {
         this.backoffUntil = Date.now() + SHARED_TRANSPORT_BACKOFF_MS;
         this.lastErrorCode = errorCode ?? null;
         this.lastTransportScope = transportScope;
+        this.lastFailureConnectPhase = connectPhase;
         if (permit.probe && this.probe?.generation === permit.generation) {
             this.probe.resolve("failed");
             this.probe = undefined;
@@ -96,6 +102,7 @@ export class ProviderTransportCoordinator {
         this.backoffUntil = 0;
         this.lastErrorCode = null;
         this.lastTransportScope = "shared_provider_transport";
+        this.lastFailureConnectPhase = false;
     }
     async wait(ms, signal) {
         if (signal?.aborted) {

package/dist/server/routes/claudeProxyRoutes.d.ts

@@ -389,6 +389,20 @@ declare function reconcileEligibleAccountRuntimeState(account: ProxyPassthroughA
 export declare function getTransientSameAccountRetryDelayMs(retryNumber: number): number;
 export declare function getOverloadRotationDelayMs(attemptNumber: number): number;
 declare function describeTransportError(error: unknown): string;
+/**
+ * Whether a transport failure provably happened while connecting, before any
+ * byte of the request left the process.
+ *
+ * Node tags its connect errors with `syscall: "connect"`; with happy-eyeballs
+ * enabled (the default) the error is an AggregateError whose every entry is
+ * one such attempt, and undici wraps either as `fetch failed` with the
+ * original as `cause`. The code alone cannot make this call: an `ETIMEDOUT`
+ * from the connect timer and an `ETIMEDOUT` from a socket that went quiet
+ * after dispatch look identical by code, and only the first is safe to
+ * retry. Both proxies behind one lossy Wi-Fi uplink returned 116 terminal
+ * 502s in a day on exactly that ambiguity.
+ */
+declare function isConnectPhaseNetworkError(error: unknown): boolean;
 /**
  * Determine whether a POST can be retried without risking duplicate provider
  * work. Only failures that prove connection establishment did not complete are
@@ -470,6 +484,9 @@ export declare const __testHooks: {
     clearLimitsRefreshStateForTests: () => void;
     setAccountDirectoryForTests: (override: ProxyAccountDirectoryOverride | null) => void;
     isRetryableNetworkError: typeof isRetryableNetworkError;
+    isConnectPhaseNetworkError: typeof isConnectPhaseNetworkError;
+    MAX_CONNECT_PHASE_SAME_ACCOUNT_RETRIES: number;
+    clearProviderTransportCoordinatorForTests: () => void;
     isPermanentRefreshFailure: typeof isPermanentRefreshFailure;
     getStreamFailureDetails: typeof getStreamFailureDetails;
     trackUpstreamReadableStream: typeof trackUpstreamReadableStream;

package/dist/server/routes/claudeProxyRoutes.js

@@ -109,6 +109,15 @@ let lastKnownAccountCount = 0;
 const MAX_AUTH_RETRIES = 5;
 const MAX_TRANSIENT_SAME_ACCOUNT_RETRIES = 2;
 const TRANSIENT_SAME_ACCOUNT_RETRY_DELAYS_MS = [250, 1_000];
+/**
+ * Retry budget for failures that happened before any request byte was sent
+ * (a SYN lost on a lossy uplink). Nothing was dispatched, so each retry is
+ * free of duplicate-work risk; on a link losing one connect in five, four
+ * retries take the per-request failure rate from about 20% to under 1%.
+ * Delays follow TRANSIENT_SAME_ACCOUNT_RETRY_DELAYS_MS, clamped to its last
+ * entry.
+ */
+const MAX_CONNECT_PHASE_SAME_ACCOUNT_RETRIES = 4;
 const OVERLOAD_ACCOUNT_ROTATION_DELAYS_MS = [250, 500, 1_000, 2_000];
 const MAX_FALLBACK_NETWORK_RETRIES = 1;
 const FALLBACK_STREAM_IDLE_TIMEOUT_MS = 2 * 60 * 1000;
@@ -5841,6 +5850,9 @@ function createAnthropicAttemptLogger(args) {
                 ? { cacheReadTokens: extra.cacheReadTokens }
                 : {}),
             ...(extra?.retryable !== undefined ? { retryable: extra.retryable } : {}),
+            ...(extra?.connectPhase !== undefined
+                ? { connectPhase: extra.connectPhase }
+                : {}),
             ...(extra?.rateLimitKind ? { rateLimitKind: extra.rateLimitKind } : {}),
             ...(extra?.cooldownReason
                 ? { cooldownReason: extra.cooldownReason }
@@ -6044,6 +6056,7 @@ async function fetchAnthropicAccountResponse(args) {
     }
     catch (fetchErr) {
         const retryable = isRetryableNetworkError(fetchErr);
+        const connectPhase = isConnectPhaseNetworkError(fetchErr);
         const transportScope = classifyNetworkTransportScope(fetchErr);
         // Every dispatched upstream request is an attempt, including terminal
         // transport failures. Record it once before preserving the throw behavior.
@@ -6055,6 +6068,7 @@ async function fetchAnthropicAccountResponse(args) {
         logger.always(`[proxy] fetch error account=${account.label} code=${errorCode} (${retryable ? "retryable" : "terminal"}): ${errorMessage}`);
         logAttempt(502, "network_error", errorMessage, {
             retryable,
+            connectPhase,
             errorCode,
             transportScope,
         });
@@ -6071,6 +6085,7 @@ async function fetchAnthropicAccountResponse(args) {
             retrySameAccount: true,
             transportScope,
             errorCode,
+            connectPhase,
             lastError,
             sawRateLimit,
             sawNetworkError,
@@ -6340,6 +6355,20 @@ async function handleAnthropicRoutedClaudeRequest(args) {
                     transportPermit.errorCode ?? undefined;
                 loopState.lastTransportScope = transportPermit.transportScope;
                 loopState.lastError = `Anthropic transport recovery probe failed (${transportPermit.errorCode ?? "unknown"})`;
+                // The probe that failed was another request's attempt; this one has
+                // sent nothing. Give it the same bounded same-account budget a direct
+                // transport failure gets, instead of failing every queued request the
+                // moment one probe times out.
+                const probeRetryBudget = transportPermit.connectPhase
+                    ? MAX_CONNECT_PHASE_SAME_ACCOUNT_RETRIES
+                    : MAX_TRANSIENT_SAME_ACCOUNT_RETRIES;
+                if (transientSameAccountRetries < probeRetryBudget) {
+                    transientSameAccountRetries += 1;
+                    const delayMs = getTransientSameAccountRetryDelayMs(transientSameAccountRetries);
+                    logger.always(`[proxy] retrying same account=${account.label} after failed transport recovery probe (${transientSameAccountRetries}/${probeRetryBudget}) in ${delayMs}ms`);
+                    await sleep(delayMs);
+                    continue;
+                }
                 break accountLoop;
             }
             loopState.attemptNumber += 1;
@@ -6441,7 +6470,7 @@ async function handleAnthropicRoutedClaudeRequest(args) {
                     throw error;
                 }
                 if (fetchResult.transportScope) {
-                    providerTransportCoordinator.reportTransportFailure(fetchResult.errorCode, fetchResult.transportScope, transportPermit);
+                    providerTransportCoordinator.reportTransportFailure(fetchResult.errorCode, fetchResult.transportScope, transportPermit, fetchResult.connectPhase === true);
                 }
                 else {
                     providerTransportCoordinator.reportSuccess(transportPermit);
@@ -6518,12 +6547,16 @@ async function handleAnthropicRoutedClaudeRequest(args) {
                         }
                         continue accountLoop;
                     }
-                    // Transient error retry (network errors, 529 overloaded)
+                    // Transient error retry (network errors, 529 overloaded). A failure
+                    // from the connect phase sent nothing, so it earns the larger budget.
+                    const sameAccountRetryBudget = fetchResult.connectPhase
+                        ? MAX_CONNECT_PHASE_SAME_ACCOUNT_RETRIES
+                        : MAX_TRANSIENT_SAME_ACCOUNT_RETRIES;
                     if (fetchResult.retrySameAccount &&
-                        transientSameAccountRetries < MAX_TRANSIENT_SAME_ACCOUNT_RETRIES) {
+                        transientSameAccountRetries < sameAccountRetryBudget) {
                         transientSameAccountRetries += 1;
                         const delayMs = getTransientSameAccountRetryDelayMs(transientSameAccountRetries);
-                        logger.always(`[proxy] retrying same account=${account.label} after transient network error (${transientSameAccountRetries}/${MAX_TRANSIENT_SAME_ACCOUNT_RETRIES}) in ${delayMs}ms`);
+                        logger.always(`[proxy] retrying same account=${account.label} after transient network error (${transientSameAccountRetries}/${sameAccountRetryBudget}) in ${delayMs}ms`);
                         await sleep(delayMs);
                         continue;
                     }
@@ -7883,12 +7916,46 @@ function describeTransportError(error) {
         .join(": ");
     return detail ? `${message} (${detail})` : message;
 }
+/**
+ * Whether a transport failure provably happened while connecting, before any
+ * byte of the request left the process.
+ *
+ * Node tags its connect errors with `syscall: "connect"`; with happy-eyeballs
+ * enabled (the default) the error is an AggregateError whose every entry is
+ * one such attempt, and undici wraps either as `fetch failed` with the
+ * original as `cause`. The code alone cannot make this call: an `ETIMEDOUT`
+ * from the connect timer and an `ETIMEDOUT` from a socket that went quiet
+ * after dispatch look identical by code, and only the first is safe to
+ * retry. Both proxies behind one lossy Wi-Fi uplink returned 116 terminal
+ * 502s in a day on exactly that ambiguity.
+ */
+function isConnectPhaseNetworkError(error) {
+    const seen = new Set();
+    let current = error;
+    while (current && typeof current === "object" && !seen.has(current)) {
+        seen.add(current);
+        const candidate = current;
+        if (candidate.syscall === "connect") {
+            return true;
+        }
+        if (Array.isArray(candidate.errors) && candidate.errors.length > 0) {
+            return candidate.errors.every((entry) => entry !== null &&
+                typeof entry === "object" &&
+                entry.syscall === "connect");
+        }
+        current = candidate.cause;
+    }
+    return false;
+}
 /**
  * Determine whether a POST can be retried without risking duplicate provider
  * work. Only failures that prove connection establishment did not complete are
  * safe; a reset, socket error, or response timeout can happen after dispatch.
  */
 function isRetryableNetworkError(error) {
+    if (isConnectPhaseNetworkError(error)) {
+        return true;
+    }
     const code = getErrorCode(error);
     return (code !== undefined &&
         [
@@ -8112,6 +8179,11 @@ export const __testHooks = {
         accountDirectoryOverride = override;
     },
     isRetryableNetworkError,
+    isConnectPhaseNetworkError,
+    MAX_CONNECT_PHASE_SAME_ACCOUNT_RETRIES,
+    clearProviderTransportCoordinatorForTests: () => {
+        providerTransportCoordinator.clear();
+    },
     isPermanentRefreshFailure,
     getStreamFailureDetails,
     trackUpstreamReadableStream,

package/dist/types/proxy.d.ts

@@ -445,6 +445,8 @@ export type ProxyProviderTransportPermit = {
     allowed: false;
     errorCode: string | null;
     transportScope: ProxyNetworkTransportScope;
+    /** The degrading failure happened before any request byte was sent. */
+    connectPhase: boolean;
 };
 export type ProxyAccountRoutingCandidate = {
     account: string;
@@ -626,6 +628,8 @@ export type RequestAttemptLogEntry = {
     transportScope?: ProxyTransportScope;
     /** Whether this failed attempt may be retried without changing the request. */
     retryable?: boolean;
+    /** The transport failure happened before any request byte was sent. */
+    connectPhase?: boolean;
     /** Distinguishes short-lived admission throttles from exhausted quota windows. */
     rateLimitKind?: "transient" | "quota";
     /** Reset-aware cooldown reason selected for a rate-limited attempt. */
@@ -701,6 +705,8 @@ export type AnthropicAttemptLogger = (status: number, errorType?: string, errorM
     cacheCreationTokens?: number;
     cacheReadTokens?: number;
     retryable?: boolean;
+    /** The transport failure happened before any request byte was sent. */
+    connectPhase?: boolean;
     /** Low-level transport code such as ETIMEDOUT or EADDRNOTAVAIL. */
     errorCode?: string;
     transportScope?: ProxyTransportScope;
@@ -874,6 +880,9 @@ export type AnthropicUpstreamFetchResult = {
     retrySameAccount?: boolean;
     transportScope?: ProxyNetworkTransportScope;
     errorCode?: string;
+    /** The transport failure happened while connecting, before any request
+     *  byte was sent, so retrying it cannot duplicate provider work. */
+    connectPhase?: boolean;
     /** When set, the caller should wait this many ms before retrying (from upstream retry-after). */
     retryAfterMs?: number;
     /** Set on a genuine 429: how long / why to cool this account before rotating. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.9.3",
+  "version": "12.9.4",
   "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": {
@@ -138,6 +138,7 @@
     "test:local-usage": "pnpm exec tsx test/continuous-test-suite-local-usage.ts",
     "test:dynamic": "pnpm exec tsx test/continuous-test-suite-dynamic.ts",
     "test:proxy": "pnpm exec tsx test/continuous-test-suite-proxy.ts",
+    "test:proxy-connect-retry": "pnpm exec tsx test/continuous-test-suite-proxy-connect-retry.ts",
     "test:codex": "pnpm exec tsx test/continuous-test-suite-codex.ts",
     "test:bugfixes": "pnpm exec tsx test/continuous-test-suite-bugfixes.ts",
     "test:json-e2e": "pnpm exec tsx test/continuous-test-suite-json-e2e.ts",