@juspay/neurolink 11.0.0 → 11.1.1

package/dist/lib/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 { isToolsSchemaExclusionInForce } from "../../core/modules/structuredOutputPolicy.js";
 import { GEMINI_ELISION_NOTE, planGeminiLoopReclaim, previewGeminiToolResponseText, } from "../../context/geminiLoopGuard.js";
 import { getAvailableInputTokens, getContextWindowSize, } from "../../constants/contextWindows.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../../utils/timeout.js";
@@ -18,7 +19,7 @@ import { createProxyFetch } from "../../proxy/proxyFetch.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
 // Import proper types for multimodal message handling
 // Create Google GenAI client
-async function createGoogleGenAIClient(apiKey) {
+async function createGoogleGenAIClient(apiKey, baseURL) {
     const mod = await import("@google/genai");
     const ctor = mod.GoogleGenAI;
     if (!ctor) {
@@ -32,11 +33,17 @@ async function createGoogleGenAIClient(apiKey) {
         });
     }
     const Ctor = ctor;
-    // Include httpOptions with proxy fetch for corporate network support
+    // Include httpOptions with proxy fetch for corporate network support.
+    // baseUrl is only included when resolved — verified against
+    // @google/genai's ApiClient (dist/node/index.cjs) that it falls back to
+    // its own default whenever httpOptions.baseUrl is undefined, so omitting
+    // the key and passing `baseUrl: undefined` behave identically; the key is
+    // still omitted outright for a cleaner outbound config object.
     return new Ctor({
         apiKey,
         httpOptions: {
             fetch: createProxyFetch(),
+            ...(baseURL ? { baseUrl: baseURL } : {}),
         },
     });
 }
@@ -256,7 +263,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
         // Use the @google/genai client for image generation
         let client;
         try {
-            client = await createGoogleGenAIClient(apiKey);
+            client = await createGoogleGenAIClient(apiKey, this.getBaseURL());
         }
         catch {
             throw new AuthenticationError("Missing '@google/genai'. Install with: npm install @google/genai", this.providerName);
@@ -563,7 +570,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
         // generate() does, or attached files are dropped on this path alone.
         await this.preprocessNativeFileInput(options);
         // Structured output (analysisSchema, JSON format, or schema) is incompatible with tools on Gemini.
-        const wantsStructuredOutput = analysisSchema || options.output?.format === "json" || options.schema;
+        const wantsStructuredOutput = Boolean(analysisSchema || options.output?.format === "json" || options.schema);
         // Tool filter (a0269210): trust options.tools — caller (BaseProvider.stream)
         // already merged MCP/built-in tools with user tools and applied any
         // enabledToolNames filter. Re-attaching getAllTools() here would clobber
@@ -575,12 +582,10 @@ export class GoogleAIStudioProvider extends BaseProvider {
             ...options,
             tools: optionTools,
         };
-        // Check for tools + JSON schema conflict (Gemini limitation)
+        // Tools + JSON conflict (Gemini), via the shared predicate.
         const wantsJsonOutput = options.output?.format === "json" || options.schema;
-        if (wantsJsonOutput &&
-            mergedOptions.tools &&
-            Object.keys(mergedOptions.tools).length > 0 &&
-            !mergedOptions.disableTools) {
+        const exclusionInForce = isToolsSchemaExclusionInForce(this.providerName, modelName, !mergedOptions.disableTools, Object.keys(mergedOptions.tools ?? {}).length);
+        if (wantsJsonOutput && exclusionInForce) {
             logger.warn("[GoogleAIStudio] Gemini does not support tools and JSON schema output simultaneously. Disabling tools for this request.");
             mergedOptions = { ...mergedOptions, disableTools: true, tools: {} };
         }
@@ -618,7 +623,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
             const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
             try {
                 const apiKey = this.getApiKey();
-                const client = await createGoogleGenAIClient(apiKey);
+                const client = await createGoogleGenAIClient(apiKey, this.getBaseURL());
                 logger.debug("[GoogleAIStudio] Using native @google/genai for Gemini 3", {
                     model: modelName,
                     hasTools: !!options.tools && Object.keys(options.tools).length > 0,
@@ -956,7 +961,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
             const timeoutController = createTimeoutController(timeout, this.providerName, "generate");
             try {
                 const apiKey = this.getApiKey();
-                const client = await createGoogleGenAIClient(apiKey);
+                const client = await createGoogleGenAIClient(apiKey, this.getBaseURL());
                 logger.debug("[GoogleAIStudio] Using native @google/genai for Gemini 3 generate", {
                     model: modelName,
                     hasTools: !!options.tools && Object.keys(options.tools).length > 0,
@@ -985,7 +990,16 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 let originalNameMap = new Map();
                 let declarationsResult;
                 const shouldUseTools = !options.disableTools;
-                if (shouldUseTools) {
+                // Structured output (JSON format or schema) is incompatible with
+                // tools on Gemini — routed through the shared predicate so this
+                // decision matches stream()'s orchestrator (previously this path
+                // had no proactive check and silently dropped the schema instead).
+                const wantsNativeJsonRequested = Boolean(options.output?.format === "json" || options.schema);
+                const exclusionInForce = isToolsSchemaExclusionInForce(this.providerName, modelName, shouldUseTools, Object.keys(options.tools || {}).length);
+                if (wantsNativeJsonRequested && exclusionInForce) {
+                    logger.warn("[GoogleAIStudio] Gemini does not support tools and JSON schema output simultaneously. Disabling tools for this request (generate()).");
+                }
+                if (shouldUseTools && !exclusionInForce) {
                     const tools = options.tools || {};
                     if (Object.keys(tools).length > 0) {
                         const result = buildNativeToolDeclarations(tools);
@@ -1002,8 +1016,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 // Native JSON / schema enforcement (generate path). Mirrors the
                 // stream block above; only set when no tools are being sent
                 // because Gemini cannot combine function calling with JSON mime.
-                const wantsNativeJson = !toolsConfig &&
-                    (options.output?.format === "json" || !!options.schema);
+                const wantsNativeJson = !toolsConfig && wantsNativeJsonRequested;
                 const nativeResponseSchema = wantsNativeJson && options.schema
                     ? buildGeminiResponseSchema(options.schema)
                     : undefined;
@@ -1332,7 +1345,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
         // Dynamic import to avoid hard dependency unless audio streaming is used
         let client;
         try {
-            client = await createGoogleGenAIClient(apiKey);
+            client = await createGoogleGenAIClient(apiKey, this.getBaseURL());
         }
         catch {
             throw new AuthenticationError("Missing '@google/genai'. Install with: pnpm add @google/genai", this.providerName);
@@ -1522,7 +1535,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
         });
         try {
             const apiKey = this.getApiKey();
-            const client = await createGoogleGenAIClient(apiKey);
+            const client = await createGoogleGenAIClient(apiKey, this.getBaseURL());
             const result = await client.models.embedContent({
                 model: embeddingModelName,
                 contents: [text],
@@ -1562,7 +1575,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
         });
         try {
             const apiKey = this.getApiKey();
-            const client = await createGoogleGenAIClient(apiKey);
+            const client = await createGoogleGenAIClient(apiKey, this.getBaseURL());
             const result = await client.models.embedContent({
                 model: embeddingModelName,
                 contents: texts,
@@ -1594,6 +1607,15 @@ export class GoogleAIStudioProvider extends BaseProvider {
         }
         return apiKey;
     }
+    // Mirrors mistral.ts's baseURL precedence (credentials override, then env,
+    // then unset — the SDK's own default applies when unset). Blank/whitespace
+    // values are treated as unset so an empty override can't accidentally
+    // clobber the default.
+    getBaseURL() {
+        const baseURL = this.credentials?.baseURL?.trim() ||
+            process.env.GOOGLE_AI_BASE_URL?.trim();
+        return baseURL && baseURL.length > 0 ? baseURL : undefined;
+    }
 }
 export default GoogleAIStudioProvider;
 //# sourceMappingURL=client.js.map

package/dist/lib/providers/googleVertex/client.js

@@ -13,6 +13,7 @@ import { isSchemaComplexityError } from "../../core/modules/structuredOutputPoli
 import { redactUrlForError, stringifyContentSafe, } from "../../utils/logSanitize.js";
 import { createProxyFetch } from "../../proxy/proxyFetch.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../../types/index.js";
+import { classifyProviderError } from "../../utils/errorClassifier.js";
 import { ERROR_CODES, NeuroLinkError } from "../../utils/errorHandling.js";
 import { applyVertexAnthropicCacheBreakpoints } from "../../utils/anthropicCacheBreakpoints.js";
 import { FileDetector } from "../../utils/fileDetector.js";
@@ -6098,110 +6099,117 @@ export class GoogleVertexProvider extends BaseProvider {
     }
     formatProviderError(error) {
         const errorRecord = error;
-        if (typeof errorRecord?.name === "string" &&
-            errorRecord.name === "TimeoutError") {
-            return new NetworkError(`Google Vertex AI request timed out. Consider increasing timeout or using a lighter model.`, this.providerName);
-        }
-        const message = typeof errorRecord?.message === "string"
-            ? errorRecord.message
-            : "Unknown error occurred";
         const statusCode = typeof errorRecord?.status === "number"
             ? errorRecord.status
             : typeof errorRecord?.statusCode === "number"
                 ? errorRecord.statusCode
                 : undefined;
-        // Authentication and permission errors
-        if (message.includes("PERMISSION_DENIED") ||
-            message.includes("UNAUTHENTICATED") ||
-            message.includes("Invalid API key") ||
-            statusCode === 401 ||
-            statusCode === 403) {
-            return new AuthenticationError(`Google Vertex AI Permission Denied. Your Google Cloud credentials don't have permission to access Vertex AI. ` +
-                `Required Steps: 1. Ensure your service account has Vertex AI User role ` +
-                `2. Check if Vertex AI API is enabled in your project ` +
-                `3. Verify your project ID is correct ` +
-                `4. Confirm your location/region has Vertex AI available`, this.providerName);
-        }
-        // Model not found errors
-        if (message.includes("NOT_FOUND") ||
-            message.includes("model not found") ||
-            message.includes("Model not found") ||
-            statusCode === 404) {
-            const modelSuggestions = this.getModelSuggestions(this.modelName);
-            return new InvalidModelError(`Model '${this.modelName}' is not available in region ${this.location}. ` +
-                `Suggested alternatives: ${modelSuggestions}. ` +
-                `Troubleshooting: 1. Check model name spelling and format ` +
-                `2. Verify model is available in your region ` +
-                `3. Ensure your project has access to the model ` +
-                `4. For Claude models, enable Anthropic integration in Google Cloud Console`, this.providerName);
-        }
-        // Rate limit / quota / capacity errors. Anthropic-on-Vertex capacity
-        // exhaustion surfaces as overloaded_error (HTTP 529) — same operational
-        // meaning as a 429, so classify it here instead of the generic 5xx branch.
-        if (message.includes("QUOTA_EXCEEDED") ||
-            message.includes("RATE_LIMIT_EXCEEDED") ||
-            message.includes("rate limit") ||
-            message.includes("429") ||
-            statusCode === 429 ||
-            statusCode === 529 ||
-            /overloaded/i.test(message)) {
-            // Surface retry guidance when the SDK error carries it. @google/genai
-            // ApiError nests RetryInfo inside the JSON error body's details array,
-            // so fall back to scraping retryDelay out of the raw message.
-            const retryDelay = typeof errorRecord?.retryDelay === "string"
-                ? errorRecord.retryDelay
-                : (/["']?retryDelay["']?\s*[:=]\s*["']?(\d+(?:\.\d+)?s)/.exec(message)?.[1] ?? undefined);
-            // Prefer the per-request context the native catches attach to the
-            // error (this.modelName can be stale when options.model overrides the
-            // instance default). Gemini models are force-routed to the "global"
-            // endpoint regardless of configured location — report the region the
-            // request actually hit.
-            const requestModel = typeof errorRecord?.requestModel === "string"
-                ? errorRecord.requestModel
-                : this.modelName;
-            const effectiveRegion = typeof errorRecord?.requestRegion === "string"
-                ? errorRecord.requestRegion
-                : resolveVertexRegionForModel(requestModel, this.location);
-            return new RateLimitError(`Google Vertex AI rate limit / shared-capacity exhausted (429 RESOURCE_EXHAUSTED / overloaded) ` +
-                `for model '${requestModel}' in region '${effectiveRegion}'.` +
-                (retryDelay
-                    ? ` Upstream suggests retrying after ${retryDelay}.`
-                    : "") +
-                ` Solutions: 1. Retry with backoff ` +
-                `2. Check your Vertex AI quotas in Google Cloud Console (shared-capacity 429s can occur below quota) ` +
-                `3. Try a different region or model ` +
-                `4. Request provisioned throughput for sustained load`, this.providerName);
-        }
-        // Network connectivity errors
-        if (message.includes("ECONNRESET") ||
-            message.includes("ENOTFOUND") ||
-            message.includes("ETIMEDOUT") ||
-            message.includes("ECONNREFUSED") ||
-            message.includes("network") ||
-            message.includes("connection")) {
-            return new NetworkError(`Connection error: ${message}`, this.providerName);
-        }
-        // Server errors (5xx)
-        if (message.includes("500") ||
-            message.includes("502") ||
-            message.includes("503") ||
-            message.includes("504") ||
-            message.includes("server error") ||
-            message.includes("Internal Server Error") ||
-            message.includes("INTERNAL") ||
-            message.includes("UNAVAILABLE") ||
-            (statusCode && statusCode >= 500 && statusCode < 600)) {
-            return new ProviderError(`Google Vertex AI server error: ${message}. Please try again later.`, this.providerName);
-        }
-        // Invalid argument errors
-        if (message.includes("INVALID_ARGUMENT")) {
-            return new ProviderError(`Google Vertex AI Invalid Request: ${message}. ` +
-                `Check: 1. Request parameters are within model limits ` +
-                `2. Input text is properly formatted ` +
-                `3. Temperature and other settings are valid ` +
-                `4. Model supports your request type`, this.providerName);
-        }
-        return new ProviderError(`Google Vertex AI error: ${message}`, this.providerName);
+        const rules = [
+            {
+                // Duck-typed on .name rather than `instanceof TimeoutError` —
+                // Vertex's own `withTimeout` (../../utils/async/index.js) throws a
+                // TimeoutError class distinct from the one classifyProviderError's
+                // built-in fast path checks (../../utils/timeout.js), so that fast
+                // path never fires for a real Vertex timeout. This rule preserves
+                // the pre-migration duck-typed match (both classes set
+                // `.name = "TimeoutError"`) and the original Vertex-specific
+                // message — see task-4-report.md for the full writeup.
+                match: (ctx) => ctx.errorName === "TimeoutError",
+                errorClass: NetworkError,
+                message: "Google Vertex AI request timed out. Consider increasing timeout or using a lighter model.",
+            },
+            {
+                match: (ctx) => /PERMISSION_DENIED|UNAUTHENTICATED|Invalid API key/i.test(ctx.message) ||
+                    statusCode === 401 ||
+                    statusCode === 403,
+                errorClass: AuthenticationError,
+                message: () => `Google Vertex AI Permission Denied. Your Google Cloud credentials don't have permission to access Vertex AI. ` +
+                    `Required Steps: 1. Ensure your service account has Vertex AI User role ` +
+                    `2. Check if Vertex AI API is enabled in your project ` +
+                    `3. Verify your project ID is correct ` +
+                    `4. Confirm your location/region has Vertex AI available`,
+            },
+            {
+                match: (ctx) => /NOT_FOUND|model not found|Model not found/i.test(ctx.message) ||
+                    statusCode === 404,
+                errorClass: InvalidModelError,
+                message: () => {
+                    const modelSuggestions = this.getModelSuggestions(this.modelName);
+                    return (`Model '${this.modelName}' is not available in region ${this.location}. ` +
+                        `Suggested alternatives: ${modelSuggestions}. ` +
+                        `Troubleshooting: 1. Check model name spelling and format ` +
+                        `2. Verify model is available in your region ` +
+                        `3. Ensure your project has access to the model ` +
+                        `4. For Claude models, enable Anthropic integration in Google Cloud Console`);
+                },
+            },
+            {
+                // Rate limit / quota / capacity errors. Anthropic-on-Vertex capacity
+                // exhaustion surfaces as overloaded_error (HTTP 529) — same
+                // operational meaning as a 429, so classify it here instead of the
+                // generic 5xx branch below.
+                match: (ctx) => /QUOTA_EXCEEDED|RATE_LIMIT_EXCEEDED|rate limit|429/i.test(ctx.message) ||
+                    statusCode === 429 ||
+                    statusCode === 529 ||
+                    /overloaded/i.test(ctx.message),
+                errorClass: RateLimitError,
+                message: (ctx) => {
+                    // Surface retry guidance when the SDK error carries it.
+                    // @google/genai ApiError nests RetryInfo inside the JSON error
+                    // body's details array, so fall back to scraping retryDelay out
+                    // of the raw message.
+                    const retryDelay = typeof errorRecord?.retryDelay === "string"
+                        ? errorRecord.retryDelay
+                        : (/["']?retryDelay["']?\s*[:=]\s*["']?(\d+(?:\.\d+)?s)/.exec(ctx.message)?.[1] ?? undefined);
+                    // Prefer the per-request context the native catches attach to the
+                    // error (this.modelName can be stale when options.model overrides
+                    // the instance default). Gemini models are force-routed to the
+                    // "global" endpoint regardless of configured location — report
+                    // the region the request actually hit.
+                    const requestModel = typeof errorRecord?.requestModel === "string"
+                        ? errorRecord.requestModel
+                        : this.modelName;
+                    const effectiveRegion = typeof errorRecord?.requestRegion === "string"
+                        ? errorRecord.requestRegion
+                        : resolveVertexRegionForModel(requestModel, this.location);
+                    return (`Google Vertex AI rate limit / shared-capacity exhausted (429 RESOURCE_EXHAUSTED / overloaded) ` +
+                        `for model '${requestModel}' in region '${effectiveRegion}'.` +
+                        (retryDelay
+                            ? ` Upstream suggests retrying after ${retryDelay}.`
+                            : "") +
+                        ` Solutions: 1. Retry with backoff ` +
+                        `2. Check your Vertex AI quotas in Google Cloud Console (shared-capacity 429s can occur below quota) ` +
+                        `3. Try a different region or model ` +
+                        `4. Request provisioned throughput for sustained load`);
+                },
+            },
+            {
+                match: (ctx) => /ECONNRESET|ENOTFOUND|ETIMEDOUT|ECONNREFUSED|network|connection/i.test(ctx.message),
+                errorClass: NetworkError,
+                message: (ctx) => `Connection error: ${ctx.message}`,
+            },
+            {
+                match: (ctx) => /500|502|503|504|server error|Internal Server Error|INTERNAL|UNAVAILABLE/i.test(ctx.message) ||
+                    (statusCode !== undefined && statusCode >= 500 && statusCode < 600),
+                errorClass: ProviderError,
+                message: (ctx) => `Google Vertex AI server error: ${ctx.message}. Please try again later.`,
+            },
+            {
+                match: (ctx) => /INVALID_ARGUMENT/i.test(ctx.message),
+                errorClass: ProviderError,
+                message: (ctx) => `Google Vertex AI Invalid Request: ${ctx.message}. ` +
+                    `Check: 1. Request parameters are within model limits ` +
+                    `2. Input text is properly formatted ` +
+                    `3. Temperature and other settings are valid ` +
+                    `4. Model supports your request type`,
+            },
+            {
+                match: () => true,
+                errorClass: ProviderError,
+                message: (ctx) => `Google Vertex AI error: ${ctx.message}`,
+            },
+        ];
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     /**
      * Memory-safe cache management for model configurations

package/dist/lib/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,30 +58,26 @@ 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);
     }
 }
 //# sourceMappingURL=groq.js.map

package/dist/lib/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());
@@ -74,28 +74,30 @@ 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);
     }
 }
 //# sourceMappingURL=client.js.map