@juspay/neurolink 11.26.0 → 11.26.1

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/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/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.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": {
@@ -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",