@juspay/neurolink 10.12.9 → 11.1.0

package/dist/providers/groq.js

@@ -1,7 +1,8 @@
 import { GroqModels } from "../constants/enums.js";
-import { AuthenticationError, InvalidModelError, ProviderError, RateLimitError, } from "../types/index.js";
+import { AuthenticationError, InvalidModelError, ProviderError, } from "../types/index.js";
 import { logger } from "../utils/logger.js";
 import { redactUrlCredentials } from "../utils/logSanitize.js";
+import { classifyProviderError, DEFAULT_ERROR_RULES, } from "../utils/errorClassifier.js";
 import { createGroqConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { TimeoutError } from "../utils/timeout.js";
 import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
@@ -57,29 +58,25 @@ export class GroqProvider extends OpenAIChatCompletionsProvider {
         ];
     }
     formatProviderError(error) {
+        // Groq's TimeoutError maps to plain ProviderError (not NetworkError, the
+        // classifier's built-in default) — intercept before delegating.
         if (error instanceof TimeoutError) {
             return new ProviderError(`Groq request timed out: ${error.message}`, "groq");
         }
-        const errorRecord = error;
-        const message = typeof errorRecord?.message === "string"
-            ? errorRecord.message
-            : "Unknown error";
-        if (message.includes("Invalid API key") ||
-            message.includes("Authentication") ||
-            message.includes("401") ||
-            message.includes("invalid_api_key")) {
-            return new AuthenticationError("Invalid Groq API key. Check GROQ_API_KEY. Get one at https://console.groq.com/keys", "groq");
-        }
-        if (message.includes("rate limit") || message.includes("429")) {
-            return new RateLimitError("Groq rate limit exceeded. Free tier limits are tight; consider upgrading or backing off.", "groq");
-        }
-        if (message.includes("model_not_found") ||
-            message.includes("404") ||
-            message.includes("model_decommissioned")) {
-            return new InvalidModelError(message.includes("model_decommissioned")
-                ? `Groq model '${this.modelName}' was decommissioned. Pick a current model from https://console.groq.com/docs/models.`
-                : `Groq model '${this.modelName}' not found. See https://console.groq.com/docs/models for the current catalog.`, "groq");
-        }
-        return new ProviderError(`Groq error: ${message}`, "groq");
+        const rules = [
+            {
+                match: (ctx) => ctx.statusCode === 401 ||
+                    /Invalid API key|Authentication|invalid_api_key/i.test(ctx.message),
+                errorClass: AuthenticationError,
+                message: "Invalid Groq API key. Check GROQ_API_KEY. Get one at https://console.groq.com/keys",
+            },
+            {
+                match: (ctx) => /model_decommissioned/i.test(ctx.message),
+                errorClass: InvalidModelError,
+                message: (ctx) => `Groq model '${ctx.modelName}' was decommissioned. Pick a current model from https://console.groq.com/docs/models.`,
+            },
+            ...DEFAULT_ERROR_RULES,
+        ];
+        return classifyProviderError(error, rules, "groq", this.modelName);
     }
 }

package/dist/providers/huggingFace/client.d.ts

@@ -14,7 +14,7 @@ import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
  * @see https://huggingface.co/docs/api-inference/index
  */
 export declare class HuggingFaceProvider extends OpenAIChatCompletionsProvider {
-    constructor(modelName?: string, sdk?: unknown, credentials?: NeurolinkCredentials["huggingFace"]);
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["huggingFace"]);
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     protected getFallbackModelName(): string;

package/dist/providers/huggingFace/client.js

@@ -1,8 +1,8 @@
-import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../../types/index.js";
+import { AuthenticationError, InvalidModelError, ProviderError, RateLimitError, } from "../../types/index.js";
+import { classifyProviderError, DEFAULT_ERROR_RULES, } from "../../utils/errorClassifier.js";
 import { logger } from "../../utils/logger.js";
 import { redactUrlCredentials } from "../../utils/logSanitize.js";
 import { createHuggingFaceConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
-import { TimeoutError } from "../../utils/timeout.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
 const HUGGINGFACE_DEFAULT_BASE_URL = "https://router.huggingface.co/v1";
 const getHuggingFaceApiKey = () => validateApiKey(createHuggingFaceConfig());
@@ -20,7 +20,7 @@ const getDefaultHuggingFaceModel = () => getProviderModel("HUGGINGFACE_MODEL", "
  * @see https://huggingface.co/docs/api-inference/index
  */
 export class HuggingFaceProvider extends OpenAIChatCompletionsProvider {
-    constructor(modelName, sdk, credentials) {
+    constructor(modelName, sdk, _region, credentials) {
         const apiKey = credentials?.apiKey?.trim()
             ? credentials.apiKey.trim()
             : getHuggingFaceApiKey();
@@ -74,27 +74,29 @@ export class HuggingFaceProvider extends OpenAIChatCompletionsProvider {
         return toolCapableModels.some((capable) => modelName.includes(capable));
     }
     formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new NetworkError(`Request timed out: ${error.message}`, "huggingface");
-        }
-        const errorObj = error;
-        const message = errorObj?.message && typeof errorObj.message === "string"
-            ? errorObj.message
-            : "Unknown error";
-        // Enhanced error messages with tool calling context
-        if (message.includes("API_TOKEN_INVALID") ||
-            message.includes("Invalid token")) {
-            return new AuthenticationError("Invalid HuggingFace API token. Please check your HUGGINGFACE_API_KEY environment variable.", "huggingface");
-        }
-        if (message.includes("rate limit")) {
-            return new RateLimitError("HuggingFace rate limit exceeded. Consider using a paid plan or try again later.", "huggingface");
-        }
-        if (message.includes("model") && message.includes("not found")) {
-            return new InvalidModelError(`HuggingFace model '${this.modelName}' not found.\n\nSuggestions:\n1. Check model name spelling\n2. Ensure model exists on HuggingFace Hub\n3. For tool calling, use: Llama-3.1-8B-Instruct, Hermes-3-Llama-3.2-3B, or CodeLlama-34b-Instruct-hf`, "huggingface");
-        }
-        if (message.includes("function") || message.includes("tool")) {
-            return new ProviderError(`HuggingFace tool calling error: ${message}\n\nNotes:\n1. Ensure you're using a tool-capable model (Llama-3.1+, Hermes-3+, CodeLlama)\n2. Check that your model supports function calling\n3. Verify tool schema format is correct`, "huggingface");
-        }
-        return new ProviderError(`HuggingFace Provider Error: ${message}`, "huggingface");
+        const rules = [
+            {
+                match: (ctx) => /API_TOKEN_INVALID|Invalid token/.test(ctx.message),
+                errorClass: AuthenticationError,
+                message: "Invalid HuggingFace API token. Please check your HUGGINGFACE_API_KEY environment variable.",
+            },
+            {
+                match: (ctx) => /rate limit/.test(ctx.message),
+                errorClass: RateLimitError,
+                message: "HuggingFace rate limit exceeded. Consider using a paid plan or try again later.",
+            },
+            {
+                match: (ctx) => /model/.test(ctx.message) && /not found/.test(ctx.message),
+                errorClass: InvalidModelError,
+                message: () => `HuggingFace model '${this.modelName}' not found.\n\nSuggestions:\n1. Check model name spelling\n2. Ensure model exists on HuggingFace Hub\n3. For tool calling, use: Llama-3.1-8B-Instruct, Hermes-3-Llama-3.2-3B, or CodeLlama-34b-Instruct-hf`,
+            },
+            {
+                match: (ctx) => /function|tool/.test(ctx.message),
+                errorClass: ProviderError,
+                message: (ctx) => `HuggingFace tool calling error: ${ctx.message}\n\nNotes:\n1. Ensure you're using a tool-capable model (Llama-3.1+, Hermes-3+, CodeLlama)\n2. Check that your model supports function calling\n3. Verify tool schema format is correct`,
+            },
+            ...DEFAULT_ERROR_RULES,
+        ];
+        return classifyProviderError(error, rules, "huggingface", this.modelName);
     }
 }

package/dist/providers/huggingFace/index.d.ts

@@ -1,2 +1 @@
 export * from "./client.js";
-export * from "./utils.js";

package/dist/providers/huggingFace/index.js

@@ -1,2 +1 @@
 export * from "./client.js";
-export * from "./utils.js";

package/dist/providers/jina.d.ts

@@ -56,4 +56,3 @@ export declare class JinaProvider extends BaseProvider {
         baseURL: string;
     };
 }
-export default JinaProvider;

package/dist/providers/jina.js

@@ -214,4 +214,3 @@ export class JinaProvider extends BaseProvider {
         };
     }
 }
-export default JinaProvider;

package/dist/providers/litellm/client.js

@@ -2,13 +2,14 @@ import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { registerRuntimeContextWindow, registerRuntimeOutputCeiling, } from "../../constants/contextWindows.js";
 import { createProxyFetch } from "../../proxy/proxyFetch.js";
 import { AuthenticationError, InvalidModelError, ModelAccessDeniedError, NetworkError, ProviderError, RateLimitError, isModelAccessDeniedMessage, parseAllowedModels, } from "../../types/index.js";
+import { classifyProviderError, DEFAULT_ERROR_RULES, } from "../../utils/errorClassifier.js";
 import { isAbortError } from "../../utils/errorHandling.js";
 import { logger } from "../../utils/logger.js";
 import { redactUrlCredentials } from "../../utils/logSanitize.js";
 import { isGemini25Model as isCanonicalGemini25Model } from "../../utils/modelDetection.js";
 import { calculateCost } from "../../utils/pricing.js";
 import { getProviderModel } from "../../utils/providerConfig.js";
-import { createTimeoutController, TimeoutError } from "../../utils/timeout.js";
+import { createTimeoutController } from "../../utils/timeout.js";
 import { stripTrailingSlash } from "../openaiChatCompletionsClient.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
 const streamTracer = trace.getTracer("neurolink.provider.litellm");
@@ -320,46 +321,60 @@ export class LiteLLMProvider extends OpenAIChatCompletionsProvider {
         };
     }
     formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new NetworkError(`Request timed out: ${error.message}`, this.providerName);
-        }
+        // Curator P1-1: detect "team not allowed to access model" responses and
+        // surface as ModelAccessDeniedError with the allowed_models array parsed
+        // from the body. Must run before classification (not just before the
+        // "API key" rule) because ModelAccessDeniedError's constructor takes an
+        // `{ provider, requestedModel, allowedModels }` options object rather
+        // than the `(message, provider?)` shape ProviderErrorRule expects, so it
+        // can't be expressed as a declarative rule. No realistic overlap with the
+        // timeout/ECONNREFUSED checks below (disjoint wording), so running this
+        // first is behaviorally identical to the original nesting order.
         const errorRecord = error;
-        if (errorRecord?.name === "TimeoutError" ||
-            (typeof errorRecord?.message === "string" &&
-                errorRecord.message.toLowerCase().includes("timeout"))) {
-            return new NetworkError(`Request timed out: ${errorRecord?.message || "Unknown timeout"}`, this.providerName);
-        }
-        if (typeof errorRecord?.message === "string") {
-            if (errorRecord.message.includes("ECONNREFUSED") ||
-                errorRecord.message.includes("Failed to fetch")) {
-                return new NetworkError("LiteLLM proxy server not available. Please start the LiteLLM proxy server at " +
-                    `${process.env.LITELLM_BASE_URL || "http://localhost:4000"}`, this.providerName);
-            }
-            // Curator P1-1: detect "team not allowed to access model" responses and
-            // surface as ModelAccessDeniedError with the allowed_models array parsed
-            // from the body. Must run before the generic "API key" check because
-            // LiteLLM phrases this as a 403 distinct from auth.
-            if (isModelAccessDeniedMessage(errorRecord.message)) {
-                return new ModelAccessDeniedError(errorRecord.message, {
-                    provider: this.providerName,
-                    requestedModel: this.modelName,
-                    allowedModels: parseAllowedModels(errorRecord.message),
-                });
-            }
-            if (errorRecord.message.includes("API_KEY_INVALID") ||
-                errorRecord.message.includes("Invalid API key")) {
-                return new AuthenticationError("Invalid LiteLLM configuration. Please check your LITELLM_API_KEY environment variable.", this.providerName);
-            }
-            if (errorRecord.message.toLowerCase().includes("rate limit")) {
-                return new RateLimitError("LiteLLM rate limit exceeded. Please try again later.", this.providerName);
-            }
-            if (errorRecord.message.toLowerCase().includes("model") &&
-                errorRecord.message.toLowerCase().includes("not found")) {
-                return new InvalidModelError(`Model '${this.modelName}' not available in LiteLLM proxy. ` +
-                    "Please check your LiteLLM configuration and ensure the model is configured.", this.providerName);
-            }
+        if (typeof errorRecord?.message === "string" &&
+            isModelAccessDeniedMessage(errorRecord.message)) {
+            return new ModelAccessDeniedError(errorRecord.message, {
+                provider: this.providerName,
+                requestedModel: this.modelName,
+                allowedModels: parseAllowedModels(errorRecord.message),
+            });
         }
-        return new ProviderError(`LiteLLM error: ${errorRecord?.message || "Unknown error"}`, this.providerName);
+        const rules = [
+            // Duck-typed timeout detection (name === "TimeoutError" OR message
+            // contains "timeout") distinct from the `instanceof TimeoutError` check
+            // classifyProviderError already performs first — preserved because
+            // some rejection paths produce a plain object/Error with that shape
+            // rather than a real TimeoutError instance.
+            {
+                match: (ctx) => ctx.errorName === "TimeoutError" || /timeout/i.test(ctx.message),
+                errorClass: NetworkError,
+                message: (ctx) => `Request timed out: ${ctx.message}`,
+            },
+            {
+                match: (ctx) => /ECONNREFUSED|Failed to fetch/.test(ctx.message),
+                errorClass: NetworkError,
+                message: () => "LiteLLM proxy server not available. Please start the LiteLLM proxy server at " +
+                    `${process.env.LITELLM_BASE_URL || "http://localhost:4000"}`,
+            },
+            {
+                match: (ctx) => /API_KEY_INVALID|Invalid API key/.test(ctx.message),
+                errorClass: AuthenticationError,
+                message: "Invalid LiteLLM configuration. Please check your LITELLM_API_KEY environment variable.",
+            },
+            {
+                match: (ctx) => /rate limit/i.test(ctx.message),
+                errorClass: RateLimitError,
+                message: "LiteLLM rate limit exceeded. Please try again later.",
+            },
+            {
+                match: (ctx) => /model/i.test(ctx.message) && /not found/i.test(ctx.message),
+                errorClass: InvalidModelError,
+                message: () => `Model '${this.modelName}' not available in LiteLLM proxy. ` +
+                    "Please check your LiteLLM configuration and ensure the model is configured.",
+            },
+            ...DEFAULT_ERROR_RULES,
+        ];
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     /**
      * Get available models from LiteLLM proxy `/v1/models` endpoint.

package/dist/providers/litellm/index.d.ts

@@ -1,3 +1 @@
 export * from "./client.js";
-export * from "./constants.js";
-export * from "./utils.js";

package/dist/providers/litellm/index.js

@@ -1,3 +1 @@
 export * from "./client.js";
-export * from "./constants.js";
-export * from "./utils.js";

package/dist/providers/llamaCpp.d.ts

@@ -15,6 +15,7 @@ import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
  */
 export declare class LlamaCppProvider extends OpenAIChatCompletionsProvider {
     constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["llamacpp"]);
+    validateConfiguration(): Promise<boolean>;
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     protected getFallbackModelName(): string;

package/dist/providers/llamaCpp.js

@@ -1,7 +1,7 @@
 import { NetworkError, ProviderError } from "../types/index.js";
+import { classifyProviderError, DEFAULT_ERROR_RULES, } from "../utils/errorClassifier.js";
 import { logger } from "../utils/logger.js";
 import { redactUrlCredentials } from "../utils/logSanitize.js";
-import { TimeoutError } from "../utils/timeout.js";
 import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 const LLAMACPP_DEFAULT_BASE_URL = "http://localhost:8080/v1";
 const LLAMACPP_PLACEHOLDER_KEY = "llamacpp";
@@ -36,6 +36,9 @@ export class LlamaCppProvider extends OpenAIChatCompletionsProvider {
             baseURL: redactUrlCredentials(this.config.baseURL),
         });
     }
+    async validateConfiguration() {
+        return this.probeModelsEndpoint(this.getAuthHeaders());
+    }
     getProviderName() {
         return "llamacpp";
     }
@@ -49,25 +52,28 @@ export class LlamaCppProvider extends OpenAIChatCompletionsProvider {
         return ["loaded-model"];
     }
     formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new NetworkError(`Request timed out: ${error.message}`, "llamacpp");
-        }
+        // `code`/`cause.code` aren't part of ProviderErrorContext, so they're read
+        // off the raw error here (mirrors ollama's `responseBody` extraction) for
+        // the ECONNREFUSED rule below, which the pre-migration code also checked
+        // via a duck-typed error code in addition to the message text.
         const errorRecord = error;
-        const message = typeof errorRecord?.message === "string"
-            ? errorRecord.message
-            : "Unknown error";
         const cause = errorRecord?.cause ?? {};
         const code = (errorRecord?.code ?? cause?.code);
-        if (code === "ECONNREFUSED" ||
-            message.includes("ECONNREFUSED") ||
-            message.includes("Failed to fetch") ||
-            message.includes("fetch failed")) {
-            return new NetworkError(`llama.cpp server not reachable at ${redactUrlCredentials(this.config.baseURL)}. ` +
-                "Start it with: ./llama-server -m model.gguf --port 8080", "llamacpp");
-        }
-        if (message.includes("400")) {
-            return new ProviderError("llama.cpp rejected the request. Common cause: model doesn't support tools (start llama-server with --jinja for tool support).", "llamacpp");
-        }
-        return new ProviderError(`llama.cpp error: ${message}`, "llamacpp");
+        const rules = [
+            {
+                match: (ctx) => code === "ECONNREFUSED" ||
+                    /ECONNREFUSED|Failed to fetch|fetch failed/.test(ctx.message),
+                errorClass: NetworkError,
+                message: () => `llama.cpp server not reachable at ${redactUrlCredentials(this.config.baseURL)}. ` +
+                    "Start it with: ./llama-server -m model.gguf --port 8080",
+            },
+            {
+                match: (ctx) => /400/.test(ctx.message),
+                errorClass: ProviderError,
+                message: "llama.cpp rejected the request. Common cause: model doesn't support tools (start llama-server with --jinja for tool support).",
+            },
+            ...DEFAULT_ERROR_RULES,
+        ];
+        return classifyProviderError(error, rules, "llamacpp", this.modelName);
     }
 }

package/dist/providers/lmStudio.js

@@ -1,8 +1,7 @@
-import { createProxyFetch } from "../proxy/proxyFetch.js";
-import { InvalidModelError, NetworkError, ProviderError, } from "../types/index.js";
+import { InvalidModelError, NetworkError } from "../types/index.js";
+import { classifyProviderError, DEFAULT_ERROR_RULES, } from "../utils/errorClassifier.js";
 import { logger } from "../utils/logger.js";
 import { redactUrlCredentials } from "../utils/logSanitize.js";
-import { TimeoutError } from "../utils/timeout.js";
 import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 const LM_STUDIO_DEFAULT_BASE_URL = "http://localhost:1234/v1";
 const LM_STUDIO_PLACEHOLDER_KEY = "lm-studio";
@@ -48,50 +47,34 @@ export class LMStudioProvider extends OpenAIChatCompletionsProvider {
         return FALLBACK_MODEL;
     }
     formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new NetworkError(`Request timed out: ${error.message}`, "lm-studio");
-        }
+        // `code`/`cause.code` aren't part of ProviderErrorContext, so they're read
+        // off the raw error here (mirrors ollama's `responseBody` extraction) for
+        // the ECONNREFUSED rule below, which the pre-migration code also checked
+        // via a duck-typed error code in addition to the message text.
         const errorRecord = error;
-        const message = typeof errorRecord?.message === "string"
-            ? errorRecord.message
-            : "Unknown error";
         const cause = errorRecord?.cause ?? {};
         const code = (errorRecord?.code ?? cause?.code);
-        if (code === "ECONNREFUSED" ||
-            message.includes("ECONNREFUSED") ||
-            message.includes("Failed to fetch") ||
-            message.includes("fetch failed")) {
-            return new NetworkError(`LM Studio server not reachable at ${redactUrlCredentials(this.config.baseURL)}. ` +
-                `Open the LM Studio app, load a model, and click "Start Server".`, "lm-studio");
-        }
-        if (message.includes("model_not_found") || message.includes("404")) {
-            return new InvalidModelError(`LM Studio model '${this.modelName}' is not loaded. Load it in the LM Studio app first.`, "lm-studio");
-        }
-        return new ProviderError(`LM Studio error: ${message}`, "lm-studio");
+        const rules = [
+            {
+                match: (ctx) => code === "ECONNREFUSED" ||
+                    /ECONNREFUSED|Failed to fetch|fetch failed/.test(ctx.message),
+                errorClass: NetworkError,
+                message: () => `LM Studio server not reachable at ${redactUrlCredentials(this.config.baseURL)}. ` +
+                    `Open the LM Studio app, load a model, and click "Start Server".`,
+            },
+            {
+                match: (ctx) => /model_not_found|404/.test(ctx.message),
+                errorClass: InvalidModelError,
+                message: () => `LM Studio model '${this.modelName}' is not loaded. Load it in the LM Studio app first.`,
+            },
+            ...DEFAULT_ERROR_RULES,
+        ];
+        return classifyProviderError(error, rules, "lm-studio", this.modelName);
     }
     async validateConfiguration() {
-        try {
-            const url = `${this.config.baseURL.replace(/\/$/, "")}/models`;
-            const proxyFetch = createProxyFetch();
-            const r = await proxyFetch(url, {
-                headers: this.config.apiKey && this.config.apiKey !== LM_STUDIO_PLACEHOLDER_KEY
-                    ? { Authorization: `Bearer ${this.config.apiKey}` }
-                    : undefined,
-                signal: AbortSignal.timeout(5000),
-            });
-            if (!r.ok) {
-                return false;
-            }
-            // A 200 with an empty data array means LM Studio is up but no model is
-            // loaded — `resolveModelName()` will fall back to FALLBACK_MODEL and the
-            // first real request will fail. Require at least one loaded model so
-            // health checks honestly reflect whether the provider is usable.
-            const data = (await r.json().catch(() => null));
-            return Boolean(data?.data?.some((m) => typeof m?.id === "string" && m.id.trim().length > 0));
-        }
-        catch {
-            return false;
-        }
+        return this.probeModelsEndpoint(this.config.apiKey && this.config.apiKey !== LM_STUDIO_PLACEHOLDER_KEY
+            ? { Authorization: `Bearer ${this.config.apiKey}` }
+            : {});
     }
     getConfiguration() {
         return {

package/dist/providers/mistral.js

@@ -1,9 +1,9 @@
 import { MistralModels } from "../constants/enums.js";
-import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
+import { AuthenticationError } from "../types/index.js";
 import { logger } from "../utils/logger.js";
 import { redactUrlCredentials } from "../utils/logSanitize.js";
+import { classifyProviderError, DEFAULT_ERROR_RULES, } from "../utils/errorClassifier.js";
 import { createMistralConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
-import { TimeoutError } from "../utils/timeout.js";
 import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 const MISTRAL_DEFAULT_BASE_URL = "https://api.mistral.ai/v1";
 const getMistralApiKey = () => {
@@ -60,28 +60,16 @@ export class MistralProvider extends OpenAIChatCompletionsProvider {
         return getDefaultMistralModel();
     }
     formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new NetworkError(`Request timed out: ${error.message}`, "mistral");
-        }
-        const errorRecord = error;
-        const message = typeof errorRecord?.message === "string"
-            ? errorRecord.message
-            : "Unknown error";
-        if (message.includes("API_KEY_INVALID") ||
-            message.includes("Invalid API key") ||
-            message.includes("Unauthorized") ||
-            message.includes("401")) {
-            return new AuthenticationError("Invalid Mistral API key. Please check your MISTRAL_API_KEY environment variable.", "mistral");
-        }
-        if (message.includes("rate limit") ||
-            message.includes("Rate limit") ||
-            message.includes("429")) {
-            return new RateLimitError("Mistral rate limit exceeded", "mistral");
-        }
-        if (message.includes("model_not_found") || message.includes("404")) {
-            return new InvalidModelError(`Mistral model '${this.modelName}' not found.`, "mistral");
-        }
-        return new ProviderError(`Mistral error: ${message}`, "mistral");
+        const rules = [
+            {
+                match: (ctx) => ctx.statusCode === 401 ||
+                    /API_KEY_INVALID|Invalid API key|Unauthorized/i.test(ctx.message),
+                errorClass: AuthenticationError,
+                message: "Invalid Mistral API key. Please check your MISTRAL_API_KEY environment variable.",
+            },
+            ...DEFAULT_ERROR_RULES,
+        ];
+        return classifyProviderError(error, rules, "mistral", this.modelName);
     }
     // ===========================================================================
     // Optional hooks

package/dist/providers/nvidiaNim/client.js

@@ -1,9 +1,9 @@
 import { NvidiaNimModels } from "../../constants/enums.js";
-import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../../types/index.js";
+import { AuthenticationError, InvalidModelError, ProviderError, RateLimitError, } from "../../types/index.js";
+import { classifyProviderError, DEFAULT_ERROR_RULES, } from "../../utils/errorClassifier.js";
 import { logger } from "../../utils/logger.js";
 import { redactUrlCredentials } from "../../utils/logSanitize.js";
 import { createNvidiaNimConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
-import { TimeoutError } from "../../utils/timeout.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
 /**
  * Decide whether a NIM 400 response body is a rejection of the named
@@ -237,38 +237,41 @@ export class NvidiaNimProvider extends OpenAIChatCompletionsProvider {
         return JSON.parse(serialized);
     }
     formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new NetworkError(`Request timed out: ${error.message}`, "nvidia-nim");
-        }
-        const errorRecord = error;
-        const message = typeof errorRecord?.message === "string"
-            ? errorRecord.message
-            : "Unknown error";
-        // NIM canonically returns HTTP 401/Unauthorized for invalid API keys,
-        // but its OpenAI-compatible gateway sometimes surfaces a bare 400 +
-        // "Bad Request" with no body details for both malformed-credentials
-        // and bad-parameter cases. Because the two are indistinguishable from
-        // the message alone, we DON'T promote bare 400/Bad Request to "invalid
-        // key" here — that would mis-classify legitimate parameter errors
-        // (e.g. unsupported `reasoning_budget`, unsupported `chat_template`)
-        // as auth failures. Tests that probe the auth path (K1) detect
-        // "bad request" / "400" themselves; tests that probe parameter retry
-        // (K5) need the original "Bad Request" message to surface.
-        if (message.includes("Invalid API key") ||
-            message.includes("401") ||
-            message.includes("Unauthorized")) {
-            return new AuthenticationError("Invalid NVIDIA NIM API key. Get one at https://build.nvidia.com/settings/api-keys", "nvidia-nim");
-        }
-        if (message.includes("rate limit") || message.includes("429")) {
-            return new RateLimitError("NVIDIA NIM rate limit exceeded", "nvidia-nim");
-        }
-        if (message.includes("404") || message.includes("model_not_found")) {
-            return new InvalidModelError(`NVIDIA NIM model '${this.modelName}' not available. Browse the catalog at https://build.nvidia.com/models`, "nvidia-nim");
-        }
-        if (message.includes("quota") || message.includes("403")) {
-            return new ProviderError("NVIDIA NIM quota exceeded for your account", "nvidia-nim");
-        }
-        return new ProviderError(`NVIDIA NIM error: ${message}`, "nvidia-nim");
+        const rules = [
+            // NIM canonically returns HTTP 401/Unauthorized for invalid API keys,
+            // but its OpenAI-compatible gateway sometimes surfaces a bare 400 +
+            // "Bad Request" with no body details for both malformed-credentials
+            // and bad-parameter cases. Because the two are indistinguishable from
+            // the message alone, bare 400/"Bad Request" is deliberately NOT
+            // promoted to "invalid key" here — that would mis-classify legitimate
+            // parameter errors (e.g. unsupported `reasoning_budget`, unsupported
+            // `chat_template`) as auth failures. Tests that probe the auth path
+            // (K1) detect "bad request" / "400" themselves; tests that probe
+            // parameter retry (K5) need the original "Bad Request" message to
+            // surface.
+            {
+                match: (ctx) => /Invalid API key|401|Unauthorized/.test(ctx.message),
+                errorClass: AuthenticationError,
+                message: "Invalid NVIDIA NIM API key. Get one at https://build.nvidia.com/settings/api-keys",
+            },
+            {
+                match: (ctx) => /rate limit|429/.test(ctx.message),
+                errorClass: RateLimitError,
+                message: "NVIDIA NIM rate limit exceeded",
+            },
+            {
+                match: (ctx) => /404|model_not_found/.test(ctx.message),
+                errorClass: InvalidModelError,
+                message: () => `NVIDIA NIM model '${this.modelName}' not available. Browse the catalog at https://build.nvidia.com/models`,
+            },
+            {
+                match: (ctx) => /quota|403/.test(ctx.message),
+                errorClass: ProviderError,
+                message: "NVIDIA NIM quota exceeded for your account",
+            },
+            ...DEFAULT_ERROR_RULES,
+        ];
+        return classifyProviderError(error, rules, "nvidia-nim", this.modelName);
     }
     async validateConfiguration() {
         return (typeof this.config.apiKey === "string" &&

package/dist/providers/nvidiaNim/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./client.js";
 export * from "./constants.js";
-export * from "./utils.js";

package/dist/providers/nvidiaNim/index.js

@@ -1,3 +1,2 @@
 export * from "./client.js";
 export * from "./constants.js";
-export * from "./utils.js";