@juspay/neurolink 11.26.0 → 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/factories/providerDescriptors.js

@@ -11,6 +11,8 @@ import { API_KEY_FORMATS } from "../utils/providerConfig.js";
 export const PROVIDER_DESCRIPTORS = [
     {
         name: AIProviderName.BEDROCK,
+        defaultHealthSweepPriority: 5,
+        autoSelectPreference: 7,
         aliases: ["aws"],
         credentialsKey: "bedrock",
         envVars: {
@@ -32,6 +34,8 @@ export const PROVIDER_DESCRIPTORS = [
     },
     {
         name: AIProviderName.OPENAI,
+        defaultHealthSweepPriority: 4,
+        autoSelectPreference: 3,
         aliases: ["gpt", "chatgpt"],
         credentialsKey: "openai",
         envVars: { apiKey: "OPENAI_API_KEY", baseURL: "OPENAI_BASE_URL" },
@@ -75,6 +79,8 @@ export const PROVIDER_DESCRIPTORS = [
     },
     {
         name: AIProviderName.VERTEX,
+        defaultHealthSweepPriority: 1,
+        autoSelectPreference: 5,
         aliases: ["googleVertex"],
         credentialsKey: "vertex",
         envVars: {
@@ -115,6 +121,8 @@ export const PROVIDER_DESCRIPTORS = [
     },
     {
         name: AIProviderName.ANTHROPIC,
+        defaultHealthSweepPriority: 3,
+        autoSelectPreference: 4,
         aliases: ["claude"],
         credentialsKey: "anthropic",
         envVars: {
@@ -137,6 +145,8 @@ export const PROVIDER_DESCRIPTORS = [
     },
     {
         name: AIProviderName.AZURE,
+        defaultHealthSweepPriority: 6,
+        autoSelectPreference: 8,
         aliases: ["azureOpenai"],
         credentialsKey: "azure",
         envVars: {
@@ -160,6 +170,8 @@ export const PROVIDER_DESCRIPTORS = [
     },
     {
         name: AIProviderName.GOOGLE_AI,
+        defaultHealthSweepPriority: 2,
+        autoSelectPreference: 6,
         aliases: ["googleAiStudio", "google", "gemini", "google-ai-studio"],
         credentialsKey: "googleAiStudio",
         envVars: {
@@ -202,6 +214,8 @@ export const PROVIDER_DESCRIPTORS = [
     },
     {
         name: AIProviderName.OLLAMA,
+        defaultHealthSweepPriority: 8,
+        autoSelectPreference: 2,
         aliases: ["local"],
         credentialsKey: "ollama",
         envVars: {
@@ -234,6 +248,8 @@ export const PROVIDER_DESCRIPTORS = [
     },
     {
         name: AIProviderName.LITELLM,
+        defaultHealthSweepPriority: 7,
+        autoSelectPreference: 1,
         aliases: [],
         credentialsKey: "litellm",
         envVars: {

package/dist/models/modelResolver.js

@@ -5,6 +5,22 @@
  */
 import { MODEL_REGISTRY, MODEL_ALIASES, USE_CASE_RECOMMENDATIONS, getAllModels, getModelById, getModelsByProvider, getAvailableProviders, calculateCost, formatModelForDisplay, } from "./modelRegistry.js";
 import { isNonNullObject } from "../utils/typeUtils.js";
+const MIN_FUZZY_QUERY_LENGTH = 4;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * True when `needle` appears in `haystack` at a real token boundary (hyphen,
+ * underscore, dot, slash, whitespace, or string start/end) — not merely as
+ * an arbitrary substring. Model ids use hyphens/dots ("gpt-4.1-mini");
+ * MODEL_REGISTRY .name fields use spaces ("GPT-4 Omni"), hence including
+ * \s in the boundary class.
+ */
+function includesAtWordBoundary(haystack, needle) {
+    const boundary = "(?:^|[-_./\\s])";
+    const pattern = new RegExp(`${boundary}${escapeRegExp(needle)}${boundary.replace("^|", "$|")}`);
+    return pattern.test(haystack);
+}
 /**
  * Model resolver class with advanced search and recommendation functionality
  */
@@ -23,25 +39,31 @@ export class ModelResolver {
             const resolvedId = MODEL_ALIASES[normalizedQuery];
             return MODEL_REGISTRY[resolvedId] || null;
         }
+        // Underspecified queries produce ambiguous, iteration-order-dependent
+        // matches (see Task 13 of the model metadata consolidation plan) — skip
+        // fuzzy matching entirely below this length.
+        if (normalizedQuery.length < MIN_FUZZY_QUERY_LENGTH) {
+            return null;
+        }
         // Fuzzy matching
         const allModels = getAllModels();
         // Try partial matching on ID
-        const idMatch = allModels.find((model) => model.id.toLowerCase().includes(normalizedQuery) ||
-            normalizedQuery.includes(model.id.toLowerCase()));
+        const idMatch = allModels.find((model) => includesAtWordBoundary(model.id.toLowerCase(), normalizedQuery) ||
+            includesAtWordBoundary(normalizedQuery, model.id.toLowerCase()));
         if (idMatch) {
             return idMatch;
         }
         // Try partial matching on name
-        const nameMatch = allModels.find((model) => model.name.toLowerCase().includes(normalizedQuery) ||
-            normalizedQuery.includes(model.name.toLowerCase()));
+        const nameMatch = allModels.find((model) => includesAtWordBoundary(model.name.toLowerCase(), normalizedQuery) ||
+            includesAtWordBoundary(normalizedQuery, model.name.toLowerCase()));
         if (nameMatch) {
             return nameMatch;
         }
         // Try provider-specific matching
         const providerMatch = allModels.find((model) => {
             const providerQuery = `${model.provider}-${normalizedQuery}`;
-            return (model.id.toLowerCase().includes(providerQuery) ||
-                model.name.toLowerCase().includes(normalizedQuery));
+            return (includesAtWordBoundary(model.id.toLowerCase(), providerQuery) ||
+                includesAtWordBoundary(model.name.toLowerCase(), normalizedQuery));
         });
         if (providerMatch) {
             return providerMatch;

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/routing/classifierRouter.js

@@ -160,7 +160,13 @@ export class ClassifierRouter {
         const mode = DIFFICULTY_RANK_MODE[difficulty];
         const originalIndex = new Map(members.map((m, i) => [m, i]));
         const num = (v) => (typeof v === "number" ? v : NEUTRAL);
-        return [...members].sort((a, b) => {
+        const isFullyUnmeasured = (m) => {
+            const meta = this.metaFor(m);
+            return meta.cost === undefined && meta.quality === undefined;
+        };
+        const measured = members.filter((m) => !isFullyUnmeasured(m));
+        const unmeasured = members.filter(isFullyUnmeasured);
+        const sortMeasured = (pool) => [...pool].sort((a, b) => {
             const ma = this.metaFor(a);
             const mb = this.metaFor(b);
             let delta;
@@ -185,6 +191,11 @@ export class ClassifierRouter {
             // Stable: preserve declared pool order on a tie.
             return (originalIndex.get(a) ?? 0) - (originalIndex.get(b) ?? 0);
         });
+        // The unmeasured bucket ranks after every measured member, but WITHIN the
+        // bucket the same comparator still applies: with cost/quality both
+        // NEUTRAL it falls through to the weight tie-break, preserving the
+        // documented weight contract that a plain append would silently drop.
+        return [...sortMeasured(measured), ...sortMeasured(unmeasured)];
     }
     /** Tool narrowing: per-difficulty directive, then classifier hints. */
     selectTools(decision) {
@@ -223,7 +234,10 @@ export class ClassifierRouter {
         if (needsEnrichment && member.model) {
             try {
                 const info = ModelResolver.resolveModel(member.model);
-                if (info) {
+                if (!info) {
+                    this.deps.logger?.debug?.(`[ClassifierRouter] metaFor: no registry match for ${member.provider}/${member.model}`);
+                }
+                else {
                     if (cost === undefined) {
                         cost = info.pricing.inputCostPer1K + info.pricing.outputCostPer1K;
                     }
@@ -251,8 +265,8 @@ export class ClassifierRouter {
                     }
                 }
             }
-            catch {
-                // Enrichment is best-effort; ignore registry lookup failures.
+            catch (err) {
+                this.deps.logger?.warn?.(`[ClassifierRouter] metaFor: registry lookup threw for ${member.provider}/${member.model}`, { error: err instanceof Error ? err.message : String(err) });
             }
         }
         const meta = { cost, quality, capabilities };

package/dist/types/providers.d.ts

@@ -1885,6 +1885,24 @@ export type ProviderDescriptor = {
     localRuntime: boolean;
     /** How ProviderHealthChecker should verify this provider is reachable. */
     healthCheck: "env-only" | "models-probe" | "live-generate";
+    /**
+     * Membership + order in the default health sweep
+     * (`ProviderHealthChecker.checkAllProvidersHealth` with no explicit
+     * list). Lower number = checked and reported first; the sweep's array
+     * order is behaviour for its first-healthy fallback consumers. Absent =
+     * not part of the default sweep. Replaces the hand-maintained 8-provider
+     * array that lived in providerHealth.ts.
+     */
+    defaultHealthSweepPriority?: number;
+    /**
+     * Preference rank for `getBestHealthyProvider`'s default auto-selection
+     * (lower = tried first). Deliberately a SEPARATE ordering from the sweep:
+     * auto-select prefers local/cheap runtimes (litellm, ollama) before cloud
+     * providers, while the sweep reports the majors first. Absent = not in
+     * the default preference list. Replaces the second hand-maintained array
+     * that lived inline as getBestHealthyProvider's default parameter.
+     */
+    autoSelectPreference?: number;
     setupUrl?: string;
     timeouts?: {
         generateMs?: number;

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/dist/utils/providerHealth.js

@@ -9,6 +9,7 @@ import { basename } from "path";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { DEFAULT_OLLAMA_MODEL } from "../providers/ollama/constants.js";
 import { ProviderFactory } from "../factories/providerFactory.js";
+import { PROVIDER_DESCRIPTORS } from "../factories/providerDescriptors.js";
 export class ProviderHealthChecker {
     static healthCache = new Map();
     static DEFAULT_TIMEOUT = 5000; // 5 seconds
@@ -1382,16 +1383,13 @@ export class ProviderHealthChecker {
      * Prioritizes healthy providers over configured but unhealthy ones
      * Uses fast, cached health checks to avoid blocking initialization
      */
-    static async getBestHealthyProvider(preferredProviders = [
-        "litellm",
-        "ollama",
-        "openai",
-        "anthropic",
-        "vertex",
-        "google-ai",
-        "bedrock",
-        "azure",
-    ]) {
+    static async getBestHealthyProvider(
+    // Auto-select preference comes from the descriptors too — a SEPARATE
+    // ordering from the sweep (local/cheap runtimes first), carried by
+    // autoSelectPreference rather than defaultHealthSweepPriority.
+    preferredProviders = PROVIDER_DESCRIPTORS.filter((d) => d.autoSelectPreference !== undefined)
+        .sort((a, b) => (a.autoSelectPreference ?? 0) - (b.autoSelectPreference ?? 0))
+        .map((d) => d.name)) {
         const healthStatuses = await this.checkAllProvidersHealth({
             includeConnectivityTest: false, // Quick config check only
             cacheResults: true,
@@ -1424,16 +1422,13 @@ export class ProviderHealthChecker {
      * Get health status for all registered providers
      */
     static async checkAllProvidersHealth(options = {}) {
-        const providers = [
-            AIProviderName.VERTEX,
-            AIProviderName.GOOGLE_AI,
-            AIProviderName.ANTHROPIC,
-            AIProviderName.OPENAI,
-            AIProviderName.BEDROCK,
-            AIProviderName.AZURE,
-            AIProviderName.LITELLM,
-            AIProviderName.OLLAMA,
-        ];
+        // Sweep membership and ORDER come from the descriptors. Order is
+        // behaviour: auto-select takes the first healthy provider, so the
+        // priority field, not the descriptor array's layout, decides preference.
+        const providers = PROVIDER_DESCRIPTORS.filter((d) => d.defaultHealthSweepPriority !== undefined)
+            .sort((a, b) => (a.defaultHealthSweepPriority ?? 0) -
+            (b.defaultHealthSweepPriority ?? 0))
+            .map((d) => d.name);
         const healthChecks = providers.map((provider) => this.checkProviderHealth(provider, options));
         const results = await Promise.allSettled(healthChecks);
         return results.map((result, index) => {

package/dist/utils/retryHandler.d.ts

@@ -13,17 +13,6 @@ import type { RetryOptions } from "../types/index.js";
  * @returns Calculated delay in milliseconds
  */
 export declare function calculateBackoffDelay(attempt: number, initialDelay?: number, multiplier?: number, maxDelay?: number, addJitter?: boolean): number;
-/**
- * Error types that are typically retryable
- */
-export declare class NetworkError extends Error {
-    readonly cause?: Error | undefined;
-    constructor(message: string, cause?: Error | undefined);
-}
-export declare class TemporaryError extends Error {
-    readonly cause?: Error | undefined;
-    constructor(message: string, cause?: Error | undefined);
-}
 /**
  * Default retry configuration
  */

package/dist/utils/retryHandler.js

@@ -4,6 +4,7 @@
  */
 import { logger } from "./logger.js";
 import { SYSTEM_LIMITS } from "../core/constants.js";
+import { NetworkError } from "../types/index.js";
 /**
  * Calculate exponential backoff delay with jitter
  * @param attempt - Current attempt number (1-based)
@@ -24,25 +25,6 @@ export function calculateBackoffDelay(attempt, initialDelay = SYSTEM_LIMITS.DEFA
         : 0;
     return cappedDelay + jitter;
 }
-/**
- * Error types that are typically retryable
- */
-export class NetworkError extends Error {
-    cause;
-    constructor(message, cause) {
-        super(message);
-        this.cause = cause;
-        this.name = "NetworkError";
-    }
-}
-export class TemporaryError extends Error {
-    cause;
-    constructor(message, cause) {
-        super(message);
-        this.cause = cause;
-        this.name = "TemporaryError";
-    }
-}
 /**
  * Default retry configuration
  */
@@ -52,8 +34,11 @@ export const DEFAULT_RETRY_CONFIG = {
     maxDelay: SYSTEM_LIMITS.DEFAULT_MAX_DELAY,
     backoffMultiplier: SYSTEM_LIMITS.DEFAULT_BACKOFF_MULTIPLIER,
     retryCondition: (error) => {
-        // Retry on network errors, timeouts, and specific HTTP errors
-        if (error instanceof NetworkError || error instanceof TemporaryError) {
+        // Retry on network errors, timeouts, and specific HTTP errors. The
+        // instanceof now matches the canonical types/errors.js NetworkError —
+        // the local shadow class this file used to declare matched nothing the
+        // rest of the SDK ever threw.
+        if (error instanceof NetworkError) {
             return true;
         }
         // Retry on timeout errors

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.26.0",
+  "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": {
@@ -142,7 +142,7 @@
     "// CI tier — fast, no live AI calls, safe for every commit (test:unit; also see the separate provider-safety-net CI job, which runs build + test:providers-mocked + test:provider-structure + test:error-classifier-contract on every PR)": "",
     "test:tool-routing": "pnpm exec tsx test/continuous-test-suite-tool-routing.ts",
     "test:tool-routing-semantic": "pnpm exec tsx test/continuous-test-suite-tool-routing-semantic.ts",
-    "test:unit": "pnpm run test:bugfixes && pnpm run test:mcp:infra && pnpm run test:mcp:spans && pnpm run test:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:tool-routing-semantic && pnpm run test:mcp-result-cache && pnpm run test:model-not-found-retryable && pnpm run test:archive:security && pnpm run test:office:security && pnpm run test:vector-chroma && pnpm run test:vector-pgvector && pnpm run test:vector-pinecone && pnpm run test:provider-wiring && pnpm run test:docs-mcp",
+    "test:unit": "pnpm run test:bugfixes && pnpm run test:mcp:infra && pnpm run test:mcp:spans && pnpm run test:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:classifier-router && pnpm run test:tool-routing-semantic && pnpm run test:mcp-result-cache && pnpm run test:model-not-found-retryable && pnpm run test:archive:security && pnpm run test:office:security && pnpm run test:vector-chroma && pnpm run test:vector-pgvector && pnpm run test:vector-pinecone && pnpm run test:provider-wiring && pnpm run test:docs-mcp",
     "// CI tier — live providers, runs only when API keys are present (test:credentials and test:dynamic make real provider calls when keys are set, so they live here, not in test:unit; test:matrix, a different suite covering the full provider capability matrix, runs nightly via .github/workflows/live-matrix.yml — test:providers itself is still only wired into test:live, not any GitHub Actions workflow)": "",
     "test:live": "pnpm run test:providers && pnpm run test:mcp:http && pnpm run test:mcp:sdk && pnpm run test:mcp:cli && pnpm run test:observability && pnpm run test:context && pnpm run test:memory && pnpm run test:tool-reliability && pnpm run test:evaluation && pnpm run test:autoresearch && pnpm run test:credentials && pnpm run test:dynamic",
     "// CI tier — product output (image/video/TTS/PPT) — costs $$ per run (not wired into any GitHub Actions workflow as of this comment; run manually or add to live-matrix.yml if nightly coverage is needed)": "",
@@ -207,6 +207,7 @@
     "test:archive:security": "pnpm exec tsx test/continuous-test-suite-archive-security.ts",
     "test:office:security": "pnpm exec tsx test/continuous-test-suite-office-security.ts",
     "test:model-pool": "pnpm exec tsx test/continuous-test-suite-model-pool.ts",
+    "test:classifier-router": "pnpm exec tsx test/continuous-test-suite-classifier-router.ts",
     "test:vector-chroma": "pnpm exec tsx test/continuous-test-suite-vector-chroma.ts",
     "test:vector-pgvector": "pnpm exec tsx test/continuous-test-suite-vector-pgvector.ts",
     "test:vector-pinecone": "pnpm exec tsx test/continuous-test-suite-vector-pinecone.ts",