@juspay/neurolink 11.0.0 → 11.1.0

package/dist/providers/openRouter/client.js

@@ -1,10 +1,10 @@
 import { AIProviderName } from "../../constants/enums.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../../types/index.js";
 import { createProxyFetch } from "../../proxy/proxyFetch.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 { TimeoutError } from "../../utils/timeout.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
 import { stripTrailingSlash } from "../openaiChatCompletionsClient.js";
 import { getDefaultOpenRouterModel } from "./utils.js";
@@ -87,63 +87,69 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
         return getDefaultOpenRouterModel();
     }
     formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new NetworkError(`Request timed out: ${error.message}`, "openrouter");
-        }
-        // Check for timeout by error name and message as fallback
-        const errorRecord = error;
-        if (errorRecord?.name === "TimeoutError" ||
-            (typeof errorRecord?.message === "string" &&
-                errorRecord.message.includes("Timeout"))) {
-            return new NetworkError(`Request timed out: ${errorRecord?.message || "Unknown timeout"}`, "openrouter");
-        }
-        if (typeof errorRecord?.message === "string") {
-            if (errorRecord.message.includes("ECONNREFUSED") ||
-                errorRecord.message.includes("Failed to fetch")) {
-                return new NetworkError("OpenRouter API not available. Please check your network connection and try again.", "openrouter");
-            }
-            if (errorRecord.message.includes("API_KEY_INVALID") ||
-                errorRecord.message.includes("Invalid API key") ||
-                errorRecord.message.includes("invalid_api_key") ||
-                errorRecord.message.includes("Unauthorized")) {
-                return new AuthenticationError("Invalid OpenRouter API key. Please check your OPENROUTER_API_KEY environment variable. " +
-                    "Get your key at https://openrouter.ai/keys", "openrouter");
-            }
-            if (errorRecord.message.includes("rate limit")) {
-                return new RateLimitError("OpenRouter rate limit exceeded. Please try again later or upgrade your account at https://openrouter.ai/credits", "openrouter");
-            }
-            if (errorRecord.message.includes("model") &&
-                errorRecord.message.includes("not found")) {
-                return new InvalidModelError(`Model '${this.modelName}' not available on OpenRouter. ` +
-                    "Browse available models at https://openrouter.ai/models", "openrouter");
-            }
-            if (errorRecord.message.includes("insufficient_credits")) {
-                return new ProviderError("Insufficient OpenRouter credits. Add credits at https://openrouter.ai/credits", "openrouter");
-            }
+        const rules = [
+            // Duck-typed timeout detection (name === "TimeoutError" OR message
+            // contains "Timeout", case-sensitive — matches the original's
+            // `.includes("Timeout")`) distinct from the `instanceof TimeoutError`
+            // check classifyProviderError already performs first.
+            {
+                match: (ctx) => ctx.errorName === "TimeoutError" || /Timeout/.test(ctx.message),
+                errorClass: NetworkError,
+                message: (ctx) => `Request timed out: ${ctx.message}`,
+            },
+            {
+                match: (ctx) => /ECONNREFUSED|Failed to fetch/.test(ctx.message),
+                errorClass: NetworkError,
+                message: "OpenRouter API not available. Please check your network connection and try again.",
+            },
+            {
+                match: (ctx) => /API_KEY_INVALID|Invalid API key|invalid_api_key|Unauthorized/.test(ctx.message),
+                errorClass: AuthenticationError,
+                message: "Invalid OpenRouter API key. Please check your OPENROUTER_API_KEY environment variable. " +
+                    "Get your key at https://openrouter.ai/keys",
+            },
+            {
+                match: (ctx) => /rate limit/.test(ctx.message),
+                errorClass: RateLimitError,
+                message: "OpenRouter rate limit exceeded. Please try again later or upgrade your account at https://openrouter.ai/credits",
+            },
+            {
+                match: (ctx) => /model/.test(ctx.message) && /not found/.test(ctx.message),
+                errorClass: InvalidModelError,
+                message: () => `Model '${this.modelName}' not available on OpenRouter. ` +
+                    "Browse available models at https://openrouter.ai/models",
+            },
+            {
+                match: (ctx) => /insufficient_credits/.test(ctx.message),
+                errorClass: ProviderError,
+                message: "Insufficient OpenRouter credits. Add credits at https://openrouter.ai/credits",
+            },
             // "No endpoints found" — model temporarily unavailable or unsupported
             // parameters. Distinct from tool errors: it can happen on any request
             // when the model has no available providers on OpenRouter.
-            if (errorRecord.message.includes("No endpoints found")) {
-                return new InvalidModelError(`No endpoints found for model '${this.modelName}' on OpenRouter. ` +
+            {
+                match: (ctx) => /No endpoints found/.test(ctx.message),
+                errorClass: InvalidModelError,
+                message: () => `No endpoints found for model '${this.modelName}' on OpenRouter. ` +
                     "The model may be temporarily unavailable or does not support the requested parameters. " +
-                    "Try a different model or check availability at https://openrouter.ai/models", "openrouter");
-            }
+                    "Try a different model or check availability at https://openrouter.ai/models",
+            },
             // Tool/function calling errors
-            if (errorRecord.message.includes("tool use") ||
-                errorRecord.message.includes("tool_use") ||
-                errorRecord.message.includes("function_call") ||
-                errorRecord.message.includes("tools are not supported")) {
-                return new ProviderError(`Model '${this.modelName}' does not support tool calling. ` +
+            {
+                match: (ctx) => /tool use|tool_use|function_call|tools are not supported/.test(ctx.message),
+                errorClass: ProviderError,
+                message: () => `Model '${this.modelName}' does not support tool calling. ` +
                     "Use a tool-capable model like:\n" +
                     "  • google/gemini-2.0-flash-exp:free (free)\n" +
                     "  • meta-llama/llama-3.3-70b-instruct:free (free)\n" +
                     "  • anthropic/claude-3.7-sonnet (paid)\n" +
                     "  • openai/gpt-4o (paid)\n" +
                     "Or use --disableTools flag. " +
-                    "See all tool-capable models at https://openrouter.ai/models?supported_parameters=tools", "openrouter");
-            }
-        }
-        return new ProviderError(`OpenRouter error: ${errorRecord?.message || "Unknown error"}`, "openrouter");
+                    "See all tool-capable models at https://openrouter.ai/models?supported_parameters=tools",
+            },
+            ...DEFAULT_ERROR_RULES,
+        ];
+        return classifyProviderError(error, rules, "openrouter", this.modelName);
     }
     // ===========================================================================
     // Optional hooks — provider-specific quirks

package/dist/providers/openaiChatCompletionsBase.js

@@ -17,6 +17,7 @@
  * Nothing here imports from "ai" or "@ai-sdk/*". The base class is a
  * direct HTTP client + multi-step tool-execution loop driven by SSE.
  */
+import { trace } from "@opentelemetry/api";
 import { getAvailableInputTokens, getRuntimeContextWindow, getRuntimeOutputCeiling, registerRuntimeContextWindow, } from "../constants/contextWindows.js";
 import { guardOpenAICompatConversation } from "../context/openaiCompatLoopGuard.js";
 import { isContextOverflowError, parseProviderOverflowDetails, } from "../context/errorDetection.js";
@@ -33,6 +34,7 @@ import { composeAbortSignalsScoped, createTimeoutController, mergeAbortSignals,
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
 import { transformToolExecutions } from "../utils/transformationUtils.js";
+import { withProviderRetry } from "../utils/providerRetry.js";
 import { resolveDeferredTool } from "../tools/toolDiscovery.js";
 import { buildAPIError, buildBody, buildToolsForOpenAI, buildWireToolNameMaps, createChunkQueue, createDeferredAnalytics, ensureJsonWordInBody, estimateWireTokens, mapNeuroLinkToolChoice, mergeUsage, messageBuilderToOpenAI, parseSSEStream, stringifyToolOutput, stripTrailingSlash, v3ResponseFormatToOpenAI, v3ToolChoiceToOpenAI, v3ToolsToOpenAI, } from "./openaiChatCompletionsClient.js";
 /**
@@ -932,22 +934,44 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 : {}),
             streaming: true,
         }), args.modelId));
-        let res = await args.fetchImpl(args.url, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...this.getAuthHeaders(),
-            },
-            body: JSON.stringify(body),
-            ...(args.abortSignal ? { signal: args.abortSignal } : {}),
-        });
-        if (!res.ok) {
-            const apiErr = await buildAPIError(args.url, body, res);
-            // One-shot 400 retry — overflow corrector first (re-fits max_tokens
-            // from the provider's own numbers + self-heals the window registry),
-            // then the subclass hook (e.g. NIM strips chat_template /
-            // reasoning_budget when a model rejects them).
-            const retryBody = res.status === 400
+        // The initial fetch gets 429/5xx retry-with-backoff via the same
+        // primitive the non-streaming path already uses (withProviderRetry).
+        // `doFetch` throws the classified APIError (buildAPIError attaches
+        // .statusCode + .responseHeaders, which withProviderRetry's duck-typing
+        // reads directly) so a non-ok response is what drives the retry
+        // decision, not a return value.
+        const doFetch = async () => {
+            const attemptRes = await args.fetchImpl(args.url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...this.getAuthHeaders(),
+                },
+                body: JSON.stringify(body),
+                ...(args.abortSignal ? { signal: args.abortSignal } : {}),
+            });
+            if (!attemptRes.ok) {
+                throw await buildAPIError(args.url, body, attemptRes);
+            }
+            return attemptRes;
+        };
+        let res;
+        try {
+            res = await withProviderRetry(doFetch, trace.getActiveSpan() ?? undefined, `${this.providerName} stream`);
+        }
+        catch (err) {
+            // The one-shot 400 context-overflow fallback lives outside
+            // withProviderRetry (400 isn't retryable there anyway — see
+            // isRetryableProviderError), so it fires on the classified error's
+            // .statusCode. The raw Response is no longer in scope here: it was
+            // consumed inside doFetch's closure, either returned on success or
+            // discarded after buildAPIError read its body on failure.
+            const apiErr = err;
+            // Overflow corrector first (re-fits max_tokens from the provider's
+            // own numbers + self-heals the window registry), then the subclass
+            // hook (e.g. NIM strips chat_template / reasoning_budget when a model
+            // rejects them).
+            const retryBody = apiErr.statusCode === 400
                 ? (this.correctBodyAfterContextOverflow(body, apiErr) ??
                     this.adjustBodyAfter400(body, apiErr))
                 : undefined;

package/dist/providers/openaiCompatible/client.js

@@ -1,7 +1,7 @@
-import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../../types/index.js";
+import { AuthenticationError, InvalidModelError, NetworkError, } from "../../types/index.js";
 import { logger } from "../../utils/logger.js";
 import { redactUrlCredentials } from "../../utils/logSanitize.js";
-import { TimeoutError } from "../../utils/timeout.js";
+import { classifyProviderError, DEFAULT_ERROR_RULES, } from "../../utils/errorClassifier.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
 import { FALLBACK_OPENAI_COMPATIBLE_MODEL } from "./constants.js";
 import { getDefaultOpenAICompatibleModel, getOpenAICompatibleConfig, } from "./utils.js";
@@ -52,35 +52,39 @@ export class OpenAICompatibleProvider extends OpenAIChatCompletionsProvider {
         ];
     }
     formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new NetworkError(`Request timed out: ${error.message}`, "openai-compatible");
-        }
-        const errorRecord = error;
-        if (errorRecord?.name === "TimeoutError" ||
-            (typeof errorRecord?.message === "string" &&
-                errorRecord.message.includes("Timeout"))) {
-            return new NetworkError(`Request timed out: ${errorRecord?.message || "Unknown timeout"}`, "openai-compatible");
-        }
-        if (typeof errorRecord?.message === "string") {
-            if (errorRecord.message.includes("ECONNREFUSED") ||
-                errorRecord.message.includes("Failed to fetch")) {
-                return new NetworkError(`OpenAI Compatible endpoint not available. Please check your OPENAI_COMPATIBLE_BASE_URL: ${redactUrlCredentials(this.config.baseURL)}`, "openai-compatible");
-            }
-            if (errorRecord.message.includes("API_KEY_INVALID") ||
-                errorRecord.message.includes("Invalid API key") ||
-                errorRecord.message.includes("Unauthorized")) {
-                return new AuthenticationError("Invalid OpenAI Compatible API key. Please check your OPENAI_COMPATIBLE_API_KEY environment variable.", "openai-compatible");
-            }
-            if (errorRecord.message.includes("rate limit")) {
-                return new RateLimitError("OpenAI Compatible rate limit exceeded. Please try again later.", "openai-compatible");
-            }
-            if (errorRecord.message.includes("model") &&
-                (errorRecord.message.includes("not found") ||
-                    errorRecord.message.includes("does not exist"))) {
-                return new InvalidModelError(`Model '${this.modelName}' not available on OpenAI Compatible endpoint. ` +
-                    "Please check available models or use getAvailableModels() to see supported models.", "openai-compatible");
-            }
-        }
-        return new ProviderError(`OpenAI Compatible error: ${errorRecord?.message || "Unknown error"}`, "openai-compatible");
+        const rules = [
+            // Duck-typed timeout check (name === "TimeoutError" or a "Timeout"
+            // substring) — broader than classifyProviderError's built-in
+            // `instanceof TimeoutError` handling, so it's preserved as an
+            // explicit rule rather than relying on the default.
+            {
+                match: (ctx) => ctx.errorName === "TimeoutError" || /Timeout/.test(ctx.message),
+                errorClass: NetworkError,
+                message: (ctx) => `Request timed out: ${ctx.message}`,
+            },
+            {
+                match: (ctx) => /ECONNREFUSED|Failed to fetch/i.test(ctx.message),
+                errorClass: NetworkError,
+                message: () => `OpenAI Compatible endpoint not available. Please check your OPENAI_COMPATIBLE_BASE_URL: ${redactUrlCredentials(this.config.baseURL)}`,
+            },
+            {
+                match: (ctx) => ctx.statusCode === 401 ||
+                    /API_KEY_INVALID|Invalid API key|Unauthorized/i.test(ctx.message),
+                errorClass: AuthenticationError,
+                message: "Invalid OpenAI Compatible API key. Please check your OPENAI_COMPATIBLE_API_KEY environment variable.",
+            },
+            // "does not exist" isn't covered by DEFAULT_ERROR_RULES's
+            // model_not_found/"model not found" pattern — preserved verbatim.
+            {
+                match: (ctx) => /model/i.test(ctx.message) &&
+                    (/not found/i.test(ctx.message) ||
+                        /does not exist/i.test(ctx.message)),
+                errorClass: InvalidModelError,
+                message: (ctx) => `Model '${ctx.modelName}' not available on OpenAI Compatible endpoint. ` +
+                    "Please check available models or use getAvailableModels() to see supported models.",
+            },
+            ...DEFAULT_ERROR_RULES,
+        ];
+        return classifyProviderError(error, rules, "openai-compatible", this.modelName);
     }
 }

package/dist/providers/perplexity.js

@@ -1,9 +1,9 @@
 import { PerplexityModels } 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 { createPerplexityConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
-import { TimeoutError } from "../utils/timeout.js";
 import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 const PERPLEXITY_DEFAULT_BASE_URL = "https://api.perplexity.ai";
 const getPerplexityApiKey = () => validateApiKey(createPerplexityConfig());
@@ -54,24 +54,15 @@ export class PerplexityProvider extends OpenAIChatCompletionsProvider {
         ];
     }
     formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new NetworkError(`Request timed out: ${error.message}`, "perplexity");
-        }
-        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")) {
-            return new AuthenticationError("Invalid Perplexity API key. Get one at https://www.perplexity.ai/settings/api", "perplexity");
-        }
-        if (message.includes("rate limit") || message.includes("429")) {
-            return new RateLimitError("Perplexity rate limit exceeded. Back off and retry.", "perplexity");
-        }
-        if (message.includes("model_not_found") || message.includes("404")) {
-            return new InvalidModelError(`Perplexity model '${this.modelName}' not found. Use sonar, sonar-pro, sonar-reasoning, sonar-reasoning-pro, or sonar-deep-research.`, "perplexity");
-        }
-        return new ProviderError(`Perplexity error: ${message}`, "perplexity");
+        const rules = [
+            {
+                match: (ctx) => ctx.statusCode === 401 ||
+                    /Invalid API key|Authentication/i.test(ctx.message),
+                errorClass: AuthenticationError,
+                message: "Invalid Perplexity API key. Get one at https://www.perplexity.ai/settings/api",
+            },
+            ...DEFAULT_ERROR_RULES,
+        ];
+        return classifyProviderError(error, rules, "perplexity", this.modelName);
     }
 }

package/dist/providers/sagemaker/language-model.d.ts

@@ -153,7 +153,7 @@ export declare class SageMakerLanguageModel implements SageMakerAsLanguageModel
         provider: string;
         specificationVersion: "v2";
         endpointName: string;
-        modelType: "huggingface" | "mistral" | "custom" | "llama" | "claude" | "jumpstart" | undefined;
+        modelType: "huggingface" | "mistral" | "custom" | "claude" | "llama" | "jumpstart" | undefined;
         region: string;
     };
     /**
@@ -200,7 +200,7 @@ export declare class SageMakerLanguageModel implements SageMakerAsLanguageModel
         provider: string;
         specificationVersion: "v2";
         endpointName: string;
-        modelType: "huggingface" | "mistral" | "custom" | "llama" | "claude" | "jumpstart" | undefined;
+        modelType: "huggingface" | "mistral" | "custom" | "claude" | "llama" | "jumpstart" | undefined;
         region: string;
     };
 }

package/dist/providers/togetherAi.js

@@ -1,9 +1,9 @@
 import { TogetherAIModels } 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 { createTogetherAIConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
-import { TimeoutError } from "../utils/timeout.js";
 import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 const TOGETHER_DEFAULT_BASE_URL = "https://api.together.xyz/v1";
 const getTogetherApiKey = () => validateApiKey(createTogetherAIConfig());
@@ -58,24 +58,15 @@ export class TogetherAIProvider extends OpenAIChatCompletionsProvider {
         ];
     }
     formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new NetworkError(`Request timed out: ${error.message}`, "together-ai");
-        }
-        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")) {
-            return new AuthenticationError("Invalid Together AI API key. Get one at https://api.together.xyz/settings/api-keys", "together-ai");
-        }
-        if (message.includes("rate limit") || message.includes("429")) {
-            return new RateLimitError("Together AI rate limit exceeded. Back off and retry.", "together-ai");
-        }
-        if (message.includes("model_not_found") || message.includes("404")) {
-            return new InvalidModelError(`Together AI model '${this.modelName}' not found. Browse the catalog at https://api.together.xyz/models`, "together-ai");
-        }
-        return new ProviderError(`Together AI error: ${message}`, "together-ai");
+        const rules = [
+            {
+                match: (ctx) => ctx.statusCode === 401 ||
+                    /Invalid API key|Authentication/i.test(ctx.message),
+                errorClass: AuthenticationError,
+                message: "Invalid Together AI API key. Get one at https://api.together.xyz/settings/api-keys",
+            },
+            ...DEFAULT_ERROR_RULES,
+        ];
+        return classifyProviderError(error, rules, "together-ai", this.modelName);
     }
 }

package/dist/providers/xai.js

@@ -1,9 +1,9 @@
 import { XaiModels } from "../constants/enums.js";
-import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
+import { AuthenticationError, 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 { createXaiConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
-import { TimeoutError } from "../utils/timeout.js";
 import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 const XAI_DEFAULT_BASE_URL = "https://api.x.ai/v1";
 const getXaiApiKey = () => validateApiKey(createXaiConfig());
@@ -57,29 +57,20 @@ export class XaiProvider extends OpenAIChatCompletionsProvider {
         ];
     }
     formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new NetworkError(`Request timed out: ${error.message}`, "xai");
-        }
-        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 xAI API key. Please check your XAI_API_KEY environment variable. Get one at https://console.x.ai/", "xai");
-        }
-        if (message.includes("rate limit") || message.includes("429")) {
-            return new RateLimitError("xAI rate limit exceeded. Back off and retry.", "xai");
-        }
-        if (message.includes("model_not_found") || message.includes("404")) {
-            return new InvalidModelError(`xAI model '${this.modelName}' not found. Use grok-2-latest, grok-3, grok-3-mini, grok-2-vision-latest, or grok-beta.`, "xai");
-        }
-        if (message.includes("insufficient_quota") ||
-            message.includes("quota exceeded")) {
-            return new ProviderError("xAI account has insufficient quota. Top up at https://console.x.ai/", "xai");
-        }
-        return new ProviderError(`xAI error: ${message}`, "xai");
+        const rules = [
+            {
+                match: (ctx) => ctx.statusCode === 401 ||
+                    /Invalid API key|Authentication|invalid_api_key/i.test(ctx.message),
+                errorClass: AuthenticationError,
+                message: "Invalid xAI API key. Please check your XAI_API_KEY environment variable. Get one at https://console.x.ai/",
+            },
+            {
+                match: (ctx) => /insufficient_quota|quota exceeded/i.test(ctx.message),
+                errorClass: ProviderError,
+                message: "xAI account has insufficient quota. Top up at https://console.x.ai/",
+            },
+            ...DEFAULT_ERROR_RULES,
+        ];
+        return classifyProviderError(error, rules, "xai", this.modelName);
     }
 }

package/dist/server/errors.d.ts

@@ -88,7 +88,7 @@ export declare class RateLimitError extends ServerAdapterError {
 /**
  * Timeout error
  */
-export declare class TimeoutError extends ServerAdapterError {
+export declare class ServerTimeoutError extends ServerAdapterError {
     constructor(timeoutMs: number, operation?: string, requestId?: string);
 }
 /**

package/dist/server/errors.js

@@ -206,7 +206,7 @@ export class RateLimitError extends ServerAdapterError {
 /**
  * Timeout error
  */
-export class TimeoutError extends ServerAdapterError {
+export class ServerTimeoutError extends ServerAdapterError {
     constructor(timeoutMs, operation, requestId) {
         super(`Operation timed out after ${timeoutMs}ms${operation ? `: ${operation}` : ""}`, ServerAdapterErrorCode.TIMEOUT, {
             category: ErrorCategory.EXECUTION,
@@ -215,7 +215,7 @@ export class TimeoutError extends ServerAdapterError {
             requestId,
             details: { timeoutMs, operation },
         });
-        this.name = "TimeoutError";
+        this.name = "ServerTimeoutError";
     }
 }
 /**

package/dist/server/index.d.ts

@@ -27,7 +27,7 @@ export { ExpressServerAdapter } from "./adapters/expressAdapter.js";
 export { FastifyServerAdapter } from "./adapters/fastifyAdapter.js";
 export { HonoServerAdapter } from "./adapters/honoAdapter.js";
 export { KoaServerAdapter } from "./adapters/koaAdapter.js";
-export { AlreadyRunningError, AuthenticationError, AuthorizationError, ConfigurationError, ErrorRecoveryStrategies, HandlerError, InvalidAuthenticationError, MissingDependencyError, NotRunningError, RateLimitError as ServerRateLimitError, RouteConflictError, RouteNotFoundError, ServerAdapterError, ServerStartError, ServerStopError, StreamAbortedError, StreamingError, TimeoutError, ValidationError as ServerValidationError, WebSocketConnectionError, WebSocketError, wrapError, } from "./errors.js";
+export { AlreadyRunningError, AuthenticationError as ServerAuthenticationError, AuthorizationError as ServerAuthorizationError, ConfigurationError, ErrorRecoveryStrategies, HandlerError, InvalidAuthenticationError, MissingDependencyError, NotRunningError, RateLimitError as ServerRateLimitError, RouteConflictError, RouteNotFoundError, ServerAdapterError, ServerStartError, ServerStopError, StreamAbortedError, StreamingError, ServerTimeoutError, ValidationError as ServerValidationError, WebSocketConnectionError, WebSocketError, wrapError, } from "./errors.js";
 export { createServer, ServerAdapterFactory, } from "./factory/serverAdapterFactory.js";
 export { createAbortSignalMiddleware, createExpressAbortMiddleware, } from "./middleware/abortSignal.js";
 export { createAuthMiddleware, createRoleMiddleware, } from "./middleware/auth.js";
@@ -35,7 +35,7 @@ export { createCacheInvalidator, createCacheMiddleware, InMemoryCacheStore, } fr
 export { createCompressionMiddleware, createErrorHandlingMiddleware, createLoggingMiddleware, createRequestIdMiddleware, createSecurityHeadersMiddleware, createTimingMiddleware, } from "./middleware/common.js";
 export { createDeprecationMiddleware } from "./middleware/deprecation.js";
 export { createMCPBodyAttachmentMiddleware, fastifyMCPBodyHook, } from "./middleware/mcpBodyAttachment.js";
-export { createRateLimitMiddleware, createSlidingWindowRateLimitMiddleware, InMemoryRateLimitStore, RateLimitError, } from "./middleware/rateLimit.js";
+export { createRateLimitMiddleware, createSlidingWindowRateLimitMiddleware, InMemoryRateLimitStore, } from "./middleware/rateLimit.js";
 export { CommonSchemas, createFieldValidator, createRequestValidationMiddleware, ValidationError, } from "./middleware/validation.js";
 export { AgentExecuteRequestSchema as OpenAPIAgentExecuteRequestSchema, AgentExecuteResponseSchema, AgentInputSchema, ApiKeySecurityScheme, BasicSecurityScheme, BearerSecurityScheme, CommonParameters, ConversationMessageSchema, createApiInfo, createDeleteOperation, createErrorResponse as createOpenAPIErrorResponse, createGetOperation, createHeaderParameter, createOpenAPIGenerator, createPathParameter, createPostOperation, createQueryParameter, createServer as createOpenAPIServer, createStreamingPostOperation, createStreamingResponse, createSuccessResponse, DefaultServers, ErrorResponseSchema, generateOpenAPIFromConfig, generateOpenAPISpec, HealthResponseSchema, MCPServerStatusSchema, MCPServersListResponseSchema, MCPServerToolSchema, MetricsResponseSchema, NeuroLinkApiInfo, OpenAPIGenerator, OpenAPISchemas, ProviderInfoSchema, ReadyResponseSchema, SessionSchema, SessionsListResponseSchema, StandardErrorResponses, StandardTags, TokenUsageSchema, ToolCallSchema, ToolDefinitionSchema, ToolExecuteRequestSchema as OpenAPIToolExecuteRequestSchema, ToolExecuteResponseSchema, ToolListResponseSchema, ToolParameterSchema, } from "./openapi/index.js";
 export { createAgentRoutes, createAllRoutes, createHealthRoutes, createMCPRoutes, createMemoryRoutes, createOpenApiRoutes, createToolRoutes, registerAllRoutes, } from "./routes/index.js";

package/dist/server/index.js

@@ -38,7 +38,9 @@ export { KoaServerAdapter } from "./adapters/koaAdapter.js";
 // ============================================
 export { AlreadyRunningError, 
 // Authentication/Authorization errors
-AuthenticationError, AuthorizationError, 
+// (aliased: the bare names resolve to the provider-error classes of the
+// same name from types/ on the public @juspay/neurolink surface)
+AuthenticationError as ServerAuthenticationError, AuthorizationError as ServerAuthorizationError, 
 // Configuration errors
 ConfigurationError, 
 // Error recovery
@@ -56,7 +58,7 @@ ServerStartError, ServerStopError, StreamAbortedError,
 // Streaming errors
 StreamingError, 
 // Timeout errors
-TimeoutError, 
+ServerTimeoutError, 
 // Validation errors
 ValidationError as ServerValidationError, WebSocketConnectionError, 
 // WebSocket errors
@@ -76,7 +78,7 @@ export { createCacheInvalidator, createCacheMiddleware, InMemoryCacheStore, } fr
 export { createCompressionMiddleware, createErrorHandlingMiddleware, createLoggingMiddleware, createRequestIdMiddleware, createSecurityHeadersMiddleware, createTimingMiddleware, } from "./middleware/common.js";
 export { createDeprecationMiddleware } from "./middleware/deprecation.js";
 export { createMCPBodyAttachmentMiddleware, fastifyMCPBodyHook, } from "./middleware/mcpBodyAttachment.js";
-export { createRateLimitMiddleware, createSlidingWindowRateLimitMiddleware, InMemoryRateLimitStore, RateLimitError, } from "./middleware/rateLimit.js";
+export { createRateLimitMiddleware, createSlidingWindowRateLimitMiddleware, InMemoryRateLimitStore, } from "./middleware/rateLimit.js";
 export { CommonSchemas, createFieldValidator, createRequestValidationMiddleware, ValidationError, } from "./middleware/validation.js";
 // ============================================
 // OpenAPI

package/dist/server/middleware/rateLimit.d.ts

@@ -40,10 +40,6 @@ export declare class InMemoryRateLimitStore implements RateLimitStore {
  * ```
  */
 export declare function createRateLimitMiddleware(config: RateLimitMiddlewareConfig): MiddlewareDefinition;
-/**
- * Re-export RateLimitError from errors for convenience
- */
-export { RateLimitError } from "../errors.js";
 /**
  * Create a sliding window rate limiter
  * More accurate than fixed window but slightly more complex

package/dist/server/middleware/rateLimit.js

@@ -114,10 +114,6 @@ function defaultKeyGenerator(ctx) {
         ctx.headers["x-real-ip"] ||
         "unknown");
 }
-/**
- * Re-export RateLimitError from errors for convenience
- */
-export { RateLimitError } from "../errors.js";
 /**
  * Create a sliding window rate limiter
  * More accurate than fixed window but slightly more complex

package/dist/types/errors.d.ts

@@ -47,6 +47,41 @@ export declare class RateLimitError extends ProviderError {
 export declare class InvalidModelError extends ProviderError {
     constructor(message: string, provider?: string);
 }
+/**
+ * Everything a ProviderErrorRule's `match`/`message` functions can inspect
+ * about a raw thrown error, pre-extracted once so every rule doesn't
+ * re-derive the same duck-typed fields.
+ */
+export type ProviderErrorContext = {
+    /** The raw thrown value, for rules that need custom inspection beyond the extracted fields. */
+    error: unknown;
+    /** `.message` off the raw error, or "Unknown error" if absent/non-string. */
+    message: string;
+    /** HTTP status code, duck-typed from `.statusCode` / `.status`. */
+    statusCode: number | undefined;
+    /** `.name` off the raw error (e.g. AWS SDK exception names like "ThrottlingException"). */
+    errorName: string | undefined;
+    /** `.code` off the raw error (e.g. AWS SDK / Node network error codes). */
+    errorCode: string | undefined;
+    /** Provider key passed to classifyProviderError (e.g. "mistral", "vertex"). */
+    provider: string;
+    /** Model name in effect for this call, when the caller has one available. */
+    modelName: string | undefined;
+};
+/**
+ * One row of a provider's error-classification table. Rules are tried in
+ * array order; the first `match` to return true wins. `errorClass` must be
+ * `ProviderError` or one of its subclasses (AuthenticationError,
+ * RateLimitError, InvalidModelError, NetworkError, ...) sharing its
+ * `(message, provider?)` constructor shape. `message` can be a static
+ * string or a function of the context, for providers that need to
+ * interpolate a model name, a scraped retry-delay, or an AWS error code.
+ */
+export type ProviderErrorRule = {
+    match: (ctx: ProviderErrorContext) => boolean;
+    errorClass: new (message: string, provider?: string) => ProviderError;
+    message: string | ((ctx: ProviderErrorContext) => string);
+};
 /**
  * Base class for OAuth-specific errors
  */