@juspay/neurolink 10.12.9 → 11.1.0

package/dist/lib/utils/providerHealth.js

@@ -4,10 +4,11 @@
  */
 import { logger } from "./logger.js";
 import { AIProviderName, OpenAIModels, GoogleAIModels, AnthropicModels, BedrockModels, } from "../constants/enums.js";
-import { API_KEY_LENGTHS, PROJECT_ID_FORMAT } from "./providerConfig.js";
+import { PROJECT_ID_FORMAT } from "./providerConfig.js";
 import { basename } from "path";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { DEFAULT_OLLAMA_MODEL } from "../providers/ollama/constants.js";
+import { ProviderFactory } from "../factories/providerFactory.js";
 export class ProviderHealthChecker {
     static healthCache = new Map();
     static DEFAULT_TIMEOUT = 5000; // 5 seconds
@@ -172,55 +173,36 @@ export class ProviderHealthChecker {
             logger.debug("Vertex AI authentication check starting", {
                 providerName,
             });
-            // Method 1: Check GOOGLE_APPLICATION_CREDENTIALS (file-based)
-            const credentialsFile = process.env.GOOGLE_APPLICATION_CREDENTIALS;
-            let fileBasedAuthValid = false;
-            if (credentialsFile) {
-                logger.debug("Checking GOOGLE_APPLICATION_CREDENTIALS file");
-                try {
-                    const { promises: fs } = await import("fs");
-                    try {
-                        await fs.access(credentialsFile);
-                        fileBasedAuthValid = true;
-                    }
-                    catch {
-                        fileBasedAuthValid = false;
-                    }
-                    logger.debug("File auth check result", {
-                        fileExists: fileBasedAuthValid,
-                    });
-                }
-                catch (error) {
-                    logger.debug("File auth check error", {
-                        error: String(error),
-                    });
-                    fileBasedAuthValid = false;
-                }
-            }
-            // Method 2: Check individual environment variables
-            const hasIndividualAuth = !!(process.env.GOOGLE_AUTH_CLIENT_EMAIL &&
-                process.env.GOOGLE_AUTH_PRIVATE_KEY);
-            logger.debug("Individual auth check", {
-                hasClientEmail: !!process.env.GOOGLE_AUTH_CLIENT_EMAIL,
-                hasPrivateKey: !!process.env.GOOGLE_AUTH_PRIVATE_KEY,
-                hasIndividualAuth,
-            });
-            // Vertex is valid if EITHER auth method works
-            const hasValidAuth = fileBasedAuthValid || hasIndividualAuth;
-            logger.debug("Vertex auth final result", {
-                fileBasedAuthValid,
-                hasIndividualAuth,
-                hasValidAuth,
-            });
+            // Derive auth-var acceptance from the vertex descriptor instead of a
+            // hand-maintained var list, so this stays in sync with the real
+            // gating logic (hasGoogleCredentials() in googleVertex/client.ts and
+            // googleVertex/utils.ts): extraRequired.every(...) ||
+            // extraRequiredFallbacks.some(...), the same pattern used by
+            // hasProviderEnvVars() (providerUtils.ts), setup.ts, and
+            // environmentManager.ts. The old two-method check here only
+            // recognized GOOGLE_APPLICATION_CREDENTIALS or the
+            // GOOGLE_AUTH_CLIENT_EMAIL + GOOGLE_AUTH_PRIVATE_KEY pair — missing
+            // GOOGLE_SERVICE_ACCOUNT_KEY and, most importantly,
+            // GOOGLE_APPLICATION_CREDENTIALS_NEUROLINK, the descriptor's
+            // documented first-priority fallback. A user configured via that
+            // var alone had a fully working Vertex provider but was reported
+            // unhealthy here. Note: this is a presence-only check — it no
+            // longer verifies the GOOGLE_APPLICATION_CREDENTIALS file actually
+            // exists on disk (the old file-based method did via fs.access),
+            // matching the presence-only semantics already used by the other
+            // three callers of this pattern.
+            const descriptor = ProviderFactory.getDescriptor(AIProviderName.VERTEX);
+            const { extraRequired, extraRequiredFallbacks } = descriptor?.envVars ?? {};
+            const hasValidAuth = (extraRequired ?? []).every((v) => !!process.env[v]) ||
+                (extraRequiredFallbacks ?? []).some((v) => !!process.env[v]);
+            logger.debug("Vertex auth final result", { hasValidAuth });
             if (hasValidAuth) {
                 healthStatus.hasApiKey = true;
-                logger.debug("Vertex auth SUCCESS", {
-                    authMethod: fileBasedAuthValid ? "file-based" : "individual-env-vars",
-                });
+                logger.debug("Vertex auth SUCCESS");
             }
             else {
                 healthStatus.hasApiKey = false;
-                healthStatus.configurationIssues.push(`Vertex AI authentication not found: neither GOOGLE_APPLICATION_CREDENTIALS file nor individual credentials (GOOGLE_AUTH_CLIENT_EMAIL + GOOGLE_AUTH_PRIVATE_KEY) are properly configured`);
+                healthStatus.configurationIssues.push("Vertex AI authentication not found: set GOOGLE_APPLICATION_CREDENTIALS, GOOGLE_APPLICATION_CREDENTIALS_NEUROLINK, GOOGLE_SERVICE_ACCOUNT_KEY, or both GOOGLE_AUTH_CLIENT_EMAIL and GOOGLE_AUTH_PRIVATE_KEY");
                 logger.debug("Vertex auth FAILED", {
                     reason: "No valid auth method found",
                 });
@@ -359,104 +341,115 @@ export class ProviderHealthChecker {
             }
         }
     }
+    /**
+     * Providers whose credential model can't be reduced to "every one of
+     * these exact env vars must be literally set" — the check in
+     * checkEnvironmentConfiguration() below ANDs every entry in the
+     * returned list together, which can't express Vertex's file-OR-
+     * individual-creds-OR-service-account auth, Bedrock's AWS SDK default
+     * provider chain (profile / IAM role, no env vars at all), or
+     * LiteLLM's documented zero-config local proxy. Their real requirement
+     * is validated by checkProviderSpecificConfig()'s dedicated per-provider
+     * checks instead — matches the original hand-written switch's
+     * deliberate `return []` for exactly these three. Naively deriving
+     * [apiKey, ...extraRequired] from the descriptor here (as for the other
+     * 27 providers) would make checkEnvironmentConfiguration() push a false
+     * "missing environment variables" issue — and therefore isHealthy=false
+     * — for legitimate fallback-based Vertex auth, AWS_PROFILE/IAM-role
+     * Bedrock auth, and unauthenticated local LiteLLM proxies. See
+     * hasProviderEnvVars() in providerUtils.ts for the equivalent OR-aware
+     * check used for auto-select gating.
+     */
+    static ENV_CHECK_DELEGATED_TO_SPECIFIC_CONFIG = new Set([
+        AIProviderName.VERTEX,
+        AIProviderName.BEDROCK,
+        AIProviderName.LITELLM,
+    ]);
     /**
      * Get required environment variables for a provider
      */
     static getRequiredEnvironmentVariables(providerName) {
-        switch (providerName) {
-            case AIProviderName.ANTHROPIC:
-                return ["ANTHROPIC_API_KEY"];
-            case AIProviderName.OPENAI:
-                return ["OPENAI_API_KEY"];
-            case AIProviderName.VERTEX:
-                // Vertex AI requires authentication, but not via a single environment variable.
-                // Authentication can be provided via a credential file or individual credentials + project.
-                // The required authentication is checked in checkProviderSpecificConfig instead of here.
-                // Returning an empty array here does NOT mean authentication is not required.
-                return [];
-            case AIProviderName.GOOGLE_AI:
-                return ["GOOGLE_AI_API_KEY"];
-            case AIProviderName.BEDROCK:
-                // Bedrock credentials are resolved via AWS SDK default provider chain.
-                // Region/auth validated in provider-specific checks.
-                return [];
-            case AIProviderName.AZURE:
-                return ["AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT"];
-            case AIProviderName.LITELLM:
-                return [];
-            case AIProviderName.OLLAMA:
-                return []; // Ollama typically doesn't require API keys
-            default:
-                return [];
-        }
+        // Resolve the descriptor FIRST so the delegation-Set check below is
+        // keyed on the canonical, alias-resolved `descriptor.name` — not the
+        // raw, possibly-aliased `providerName` argument. Checking the raw
+        // input here would let documented aliases (e.g. "googleVertex" for
+        // vertex, "aws" for bedrock) skip the delegation and fall through to
+        // the naive [apiKey, ...extraRequired] derivation below, reproducing
+        // the exact false "missing environment variables" regression this
+        // Set exists to prevent.
+        const descriptor = ProviderFactory.getDescriptor(providerName);
+        if (!descriptor) {
+            return [];
+        }
+        if (this.ENV_CHECK_DELEGATED_TO_SPECIFIC_CONFIG.has(descriptor.name)) {
+            return [];
+        }
+        const { apiKey, extraRequired } = descriptor.envVars;
+        return [...(apiKey ? [apiKey] : []), ...(extraRequired ?? [])];
     }
     /**
-     * Get API key environment variable for a provider
+     * Get API key environment variable for a provider.
+     *
+     * Dead code at its sole call site today (checkApiKeyValidity() early-
+     * returns for VERTEX/OLLAMA/BEDROCK/LITELLM before reaching this), but
+     * now `static` (public) so a future direct caller is plausible — hence
+     * the two intentional diffs from the original hand-written switch are
+     * documented here rather than left silent:
+     *   - vertex: old switch returned "GOOGLE_APPLICATION_CREDENTIALS"
+     *     (one of several valid auth vars); the descriptor's `envVars.apiKey`
+     *     is "GOOGLE_CLOUD_PROJECT_ID" instead — the actual identity var for
+     *     the provider, not one specific credential-supply mechanism.
+     *   - ollama: old switch returned "OLLAMA_BASE_URL"; the descriptor has
+     *     no `envVars.apiKey` for ollama (it's a local, unauthenticated
+     *     runtime), so this now returns "".
+     * Both are kept deliberately (semantically truer identity vars) rather
+     * than reproduced byte-for-byte from the old switch.
      */
     static getApiKeyEnvironmentVariable(providerName) {
-        switch (providerName) {
-            case AIProviderName.ANTHROPIC:
-                return "ANTHROPIC_API_KEY";
-            case AIProviderName.OPENAI:
-                return "OPENAI_API_KEY";
-            case AIProviderName.VERTEX:
-                return "GOOGLE_APPLICATION_CREDENTIALS";
-            case AIProviderName.GOOGLE_AI:
-                return "GOOGLE_AI_API_KEY";
-            case AIProviderName.BEDROCK:
-                return "AWS_ACCESS_KEY_ID";
-            case AIProviderName.AZURE:
-                return "AZURE_OPENAI_API_KEY";
-            case AIProviderName.LITELLM:
-                return "LITELLM_API_KEY";
-            case AIProviderName.OLLAMA:
-                return "OLLAMA_BASE_URL";
-            default:
-                return "";
-        }
+        return ProviderFactory.getDescriptor(providerName)?.envVars.apiKey ?? "";
     }
     /**
      * Validate API key format for a provider
      */
     static validateApiKeyFormat(providerName, apiKey) {
-        switch (providerName) {
-            case AIProviderName.ANTHROPIC:
-                return (apiKey.startsWith("sk-ant-") &&
-                    apiKey.length >= API_KEY_LENGTHS.ANTHROPIC_MIN);
-            case AIProviderName.OPENAI:
-                return (apiKey.startsWith("sk-") &&
-                    apiKey.length >= API_KEY_LENGTHS.OPENAI_MIN);
-            case AIProviderName.GOOGLE_AI:
-                return apiKey.length >= API_KEY_LENGTHS.GOOGLE_AI_EXACT; // Basic length check
-            case AIProviderName.VERTEX:
-                return apiKey.endsWith(".json") || apiKey.includes("type"); // JSON key format
-            case AIProviderName.BEDROCK:
-                return apiKey.length >= API_KEY_LENGTHS.AWS_ACCESS_KEY; // AWS access key length
-            case AIProviderName.AZURE:
-                return apiKey.length >= API_KEY_LENGTHS.AZURE_MIN; // Azure OpenAI API key length
-            case AIProviderName.LITELLM:
-                return apiKey.length > 0;
-            case AIProviderName.OLLAMA:
-                return true; // Ollama usually doesn't require specific format
-            default:
-                return true; // Default to true for unknown providers
+        // Vertex's "API key" is really a credentials file path (or an inline
+        // JSON blob via GOOGLE_SERVICE_ACCOUNT_KEY) — never governed by the
+        // shared API_KEY_FORMATS regexes. Preserved exactly from the original
+        // switch even though checkApiKeyValidity() early-returns before ever
+        // reaching this call for Vertex today; kept correct for any other/
+        // future caller.
+        if (providerName === AIProviderName.VERTEX) {
+            return apiKey.endsWith(".json") || apiKey.includes("type");
+        }
+        const descriptor = ProviderFactory.getDescriptor(providerName);
+        if (!descriptor?.apiKeyFormatPattern) {
+            // Providers with no documented format (or local runtimes / providers
+            // usable with zero configuration) are accepted as-is — matches the
+            // old switch's per-provider `default: true`/no-format-check branches
+            // (ollama, litellm).
+            if (descriptor?.localRuntime || descriptor?.envVars.optional) {
+                return true;
+            }
+            return apiKey.length > 0;
         }
+        return descriptor.apiKeyFormatPattern.test(apiKey);
     }
     /**
      * Get health check endpoint for connectivity testing
      */
     static getProviderHealthEndpoint(providerName) {
-        switch (providerName) {
-            case AIProviderName.ANTHROPIC:
-                return null; // Anthropic doesn't have a public health endpoint
+        const descriptor = ProviderFactory.getDescriptor(providerName);
+        if (descriptor?.healthCheck !== "models-probe") {
+            return null;
+        }
+        // OpenAI/LiteLLM/Ollama each need a provider-specific URL builder that
+        // isn't pure descriptor data (LiteLLM/Ollama depend on the configured
+        // base URL) — keep the existing per-provider dispatch for the 3
+        // models-probe providers, now gated on the descriptor instead of a
+        // hardcoded name list.
+        switch (descriptor.name) {
             case AIProviderName.OPENAI:
                 return "https://api.openai.com/v1/models";
-            case AIProviderName.GOOGLE_AI:
-                return null; // No public health endpoint
-            case AIProviderName.VERTEX:
-                return null; // Complex authentication required
-            case AIProviderName.BEDROCK:
-                return null; // AWS endpoints vary by region
             case AIProviderName.LITELLM:
                 return this.getLiteLLMModelsUrl();
             case AIProviderName.OLLAMA:

package/dist/lib/utils/providerUtils.js

@@ -8,6 +8,8 @@ import { AIProviderName } from "../constants/enums.js";
 import { ProviderHealthChecker } from "./providerHealth.js";
 import { API_KEY_FORMATS, API_KEY_LENGTHS, PROJECT_ID_FORMAT, } from "./providerConfig.js";
 import { DEFAULT_OLLAMA_MODEL } from "../providers/ollama/constants.js";
+import { ProviderFactory } from "../factories/providerFactory.js";
+import { PROVIDER_DESCRIPTORS } from "../factories/providerDescriptors.js";
 /**
  * Get the best available provider based on real-time availability checks
  * Enhanced version consolidated from providerUtils-fixed.ts
@@ -20,19 +22,6 @@ export async function getBestProvider(requestedProvider) {
         // For explicit provider requests, ALWAYS honor the request
         // Never override explicit provider selection with health-based fallbacks
         logger.debug(`[getBestProvider] Using explicitly requested provider: ${requestedProvider}`);
-        // Optional health check for logging purposes only
-        try {
-            const health = await ProviderHealthChecker.checkProviderHealth(requestedProvider, { includeConnectivityTest: false, cacheResults: true });
-            if (health.isHealthy) {
-                logger.debug(`[getBestProvider] Explicitly requested provider ${requestedProvider} is healthy`);
-            }
-            else {
-                logger.warn(`[getBestProvider] Explicitly requested provider ${requestedProvider} may have issues, but using anyway`, { error: health.error });
-            }
-        }
-        catch (error) {
-            logger.warn(`[getBestProvider] Health check failed for explicitly requested provider ${requestedProvider}, using anyway`, { error: error instanceof Error ? error.message : String(error) });
-        }
         // ALWAYS return the explicitly requested provider
         return requestedProvider;
     }
@@ -73,18 +62,9 @@ export async function getBestProvider(requestedProvider) {
      * - Other providers are ordered based on a combination of reliability, feature set, and historical performance.
      * Please update this comment if the order is changed in the future, and document the rationale for maintainability.
      */
-    const providers = [
-        "litellm", // Prioritize self-hosted proxy deployments first
-        "ollama", // Local models when the configured runtime target is installed
-        "vertex", // Google Cloud AI (enterprise)
-        "google-ai", // Google AI ecosystem support
-        "openai", // Reliable with broad model support
-        "anthropic",
-        "bedrock",
-        "azure",
-        "mistral",
-        "huggingface",
-    ];
+    const providers = PROVIDER_DESCRIPTORS.filter((d) => d.autoSelectPriority !== undefined)
+        .sort((a, b) => (a.autoSelectPriority ?? 0) - (b.autoSelectPriority ?? 0))
+        .map((d) => d.name);
     for (const provider of providers) {
         if (await isProviderAvailable(provider)) {
             logger.debug(`[getBestProvider] Selected provider: ${provider}`);
@@ -345,75 +325,29 @@ function isValidUrl(url) {
  * @returns True if the provider has required environment variables
  */
 export function hasProviderEnvVars(provider) {
-    switch (provider.toLowerCase()) {
-        case "bedrock":
-        case "amazon":
-        case "aws":
-            return !!(process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY);
-        case "vertex":
-        case "googlevertex":
-        case "google":
-        case "gemini":
-            return !!((process.env.GOOGLE_CLOUD_PROJECT_ID ||
-                process.env.VERTEX_PROJECT_ID ||
-                process.env.GOOGLE_VERTEX_PROJECT ||
-                process.env.GOOGLE_CLOUD_PROJECT) &&
-                (process.env.GOOGLE_APPLICATION_CREDENTIALS ||
-                    process.env.GOOGLE_SERVICE_ACCOUNT_KEY ||
-                    (process.env.GOOGLE_AUTH_CLIENT_EMAIL &&
-                        process.env.GOOGLE_AUTH_PRIVATE_KEY)));
-        case "openai":
-        case "gpt":
-            return !!process.env.OPENAI_API_KEY;
-        case "anthropic":
-        case "claude":
-            return !!process.env.ANTHROPIC_API_KEY;
-        case "azure":
-        case "azureopenai":
-            return !!process.env.AZURE_OPENAI_API_KEY;
-        case "google-ai":
-        case "google-studio":
-            return !!(process.env.GOOGLE_AI_API_KEY ||
-                process.env.GOOGLE_GENERATIVE_AI_API_KEY);
-        case "huggingface":
-        case "hugging-face":
-        case "hf":
-            return !!(process.env.HUGGINGFACE_API_KEY || process.env.HF_TOKEN);
-        case "ollama":
-        case "local":
-        case "local-ollama":
-            // For Ollama, we check if the service is potentially available
-            // This is a basic check - actual connectivity will be verified during usage
-            return true; // Ollama doesn't require environment variables, just local service
-        case "mistral":
-        case "mistral-ai":
-        case "mistralai":
-            return !!process.env.MISTRAL_API_KEY;
-        case "litellm":
-            // LiteLLM requires a proxy server, which can be checked for availability
-            // Default base URL is assumed, or can be configured via environment
-            return true; // LiteLLM proxy availability will be checked during usage
-        default:
-            return false;
+    const descriptor = ProviderFactory.getDescriptor(provider);
+    if (!descriptor) {
+        return false;
+    }
+    if (descriptor.envVars.optional || descriptor.localRuntime) {
+        // Ollama / LiteLLM / LM Studio / llama.cpp: usable with defaults.
+        return true;
+    }
+    const { apiKey, fallbacks, extraRequired, extraRequiredFallbacks } = descriptor.envVars;
+    const hasPrimary = !!apiKey &&
+        (!!process.env[apiKey] || (fallbacks ?? []).some((v) => !!process.env[v]));
+    if (!hasPrimary) {
+        return false;
     }
+    return ((extraRequired ?? []).every((v) => !!process.env[v]) ||
+        (extraRequiredFallbacks ?? []).some((v) => !!process.env[v]));
 }
 /**
  * Get available provider names
  * @returns Array of available provider names
  */
 export function getAvailableProviders() {
-    return [
-        "bedrock",
-        "vertex",
-        "openai",
-        "anthropic",
-        "azure",
-        "google-ai",
-        "litellm",
-        "huggingface",
-        "ollama",
-        "mistral",
-    ];
+    return PROVIDER_DESCRIPTORS.map((d) => d.name);
 }
 /**
  * Validate provider name

package/dist/models/anthropicModels.d.ts

@@ -242,13 +242,6 @@ export declare function getContextWindow(model: string): number;
  * @returns The max output tokens, or 0 if model not found
  */
 export declare function getMaxOutputTokens(model: string): number;
-/**
- * Check if a model supports vision/image input
- *
- * @param model - The model ID
- * @returns true if the model supports vision
- */
-export declare function supportsVision(model: string): boolean;
 /**
  * Check if a model supports extended thinking
  *

package/dist/models/anthropicModels.js

@@ -531,15 +531,6 @@ export function getContextWindow(model) {
 export function getMaxOutputTokens(model) {
     return MODEL_METADATA[model]?.maxOutputTokens ?? 0;
 }
-/**
- * Check if a model supports vision/image input
- *
- * @param model - The model ID
- * @returns true if the model supports vision
- */
-export function supportsVision(model) {
-    return MODEL_METADATA[model]?.supportsVision ?? false;
-}
 /**
  * Check if a model supports extended thinking
  *

package/dist/neurolink.js

@@ -35,6 +35,7 @@ import { ToolRoutingCache } from "./core/toolRoutingCache.js";
 import { DEFAULT_RECENT_TURNS, KnowledgeGroundingEngine, } from "./knowledge/index.js";
 import { AIProviderFactory } from "./core/factory.js";
 import { createToolEventPayload } from "./core/toolEvents.js";
+import { ProviderFactory } from "./factories/providerFactory.js";
 import { ProviderRegistry } from "./factories/providerRegistry.js";
 import { FileReferenceRegistry } from "./files/fileReferenceRegistry.js";
 import { createFileTools } from "./files/fileTools.js";
@@ -298,30 +299,24 @@ export function markStreamProviderEmittedGenerationEnd(options) {
  */
 export const NEUROLINK_BRAND = Symbol.for("@juspay/neurolink/sdk-brand");
 /**
- * Providers whose native tool-calling support is model-dependent or absent —
- * i.e. every provider that overrides `supportsTools()` and can return false
- * (verified against src/lib/providers: ollama and openrouter are
- * model-dependent; huggingface is deployment-dependent; the rest are
- * image/embedding providers). Only these still receive the full tool listing
- * in the system prompt on the generate path, where no provider instance
- * exists yet to ask directly; every other provider gets tool definitions
- * natively via its `tools` parameter, so repeating them in the prompt was
- * pure token duplication. The stream path asks the provider instance
- * (`provider.supportsTools()`) instead of this list. BaseProvider resolves its
- * default through MODEL_REGISTRY's `modelSupports()` facade; keep this list in
- * sync with provider-specific `supportsTools()` overrides when adding providers.
+ * True when a provider needs tools described in the prompt rather than
+ * passed via the API's native tool-calling parameter (ollama/openrouter
+ * are model-dependent; huggingface is deployment-dependent; the
+ * image/embedding providers don't support tool calling at all). Only these
+ * still receive the full tool listing in the system prompt on the generate
+ * path, where no provider instance exists yet to ask directly; every other
+ * provider gets tool definitions natively via its `tools` parameter, so
+ * repeating them in the prompt was pure token duplication. The stream path
+ * asks the provider instance (`provider.supportsTools()`) instead of this
+ * check. Derived from ProviderDescriptor.toolSupport instead of a
+ * hand-maintained Set — see PROVIDER_DESCRIPTORS in
+ * src/lib/factories/providerDescriptors.ts for the underlying data;
+ * BaseProvider resolves its own runtime default through MODEL_REGISTRY's
+ * `modelSupports()` facade.
  */
-const PROMPT_ONLY_TOOL_PROVIDERS = new Set([
-    "ollama",
-    "huggingface",
-    "openrouter",
-    "ideogram",
-    "recraft",
-    "replicate",
-    "stability",
-    "jina",
-    "voyage",
-]);
+function isPromptOnlyToolProvider(providerName) {
+    return ProviderFactory.getDescriptor(providerName)?.toolSupport !== "native";
+}
 /**
  * Type-guard for opaque values that should be a {@link NeuroLink} instance.
  *
@@ -5452,7 +5447,7 @@ Current user's request: ${currentInput}`;
         }
         // Providers with native tool calling receive full definitions via their
         // `tools` parameter; only prompt-based providers still get the listing.
-        const nativeToolSupport = !PROMPT_ONLY_TOOL_PROVIDERS.has(String(providerName).toLowerCase());
+        const nativeToolSupport = !isPromptOnlyToolProvider(String(providerName).toLowerCase());
         const enhancedSystemPrompt = options.skipToolPromptInjection
             ? (options.systemPrompt || "") + circuitBreakerNote
             : this.createToolAwareSystemPrompt(options.systemPrompt, availableTools, nativeToolSupport) + circuitBreakerNote;
@@ -10351,19 +10346,12 @@ Current user's request: ${currentInput}`;
         // Keep references to prevent unused variable warnings
         void AIProviderFactory;
         void hasProviderEnvVars;
-        const providers = [
-            "openai",
-            "bedrock",
-            "vertex",
-            "googleVertex",
-            "anthropic",
-            "azure",
-            "google-ai",
-            "huggingface",
-            "ollama",
-            "mistral",
-            "litellm",
-        ];
+        // Derived from the descriptor registry instead of a hand-maintained
+        // list — covers all real providers (was previously hardcoded to 11,
+        // including "googleVertex" as a duplicate entry alongside "vertex";
+        // that alias remains resolvable via PROVIDER_ALIAS_INDEX/CLI choices,
+        // it just no longer gets its own separate status-check entry).
+        const providers = ProviderFactory.getAllDescriptors().map((d) => d.name);
         // Test providers with controlled concurrency
         // This reduces total time from 16s (sequential) to ~3s (parallel) while preventing resource exhaustion
         const limit = pLimit(SYSTEM_LIMITS.DEFAULT_CONCURRENCY_LIMIT);

package/dist/providers/amazonBedrock/client.js

@@ -4,6 +4,7 @@ import { createAnalytics } from "../../core/analytics.js";
 import { BaseProvider } from "../../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../../core/constants.js";
 import { AuthenticationError, ProviderError, RateLimitError, } from "../../types/index.js";
+import { classifyProviderError } from "../../utils/errorClassifier.js";
 import { isAbortError, withTimeout } from "../../utils/errorHandling.js";
 import { emitToolEndFromStepFinish } from "../../utils/toolEndEmitter.js";
 import { logger } from "../../utils/logger.js";
@@ -1724,22 +1725,39 @@ export class AmazonBedrockProvider extends BaseProvider {
         }
     }
     formatProviderError(error) {
-        // Handle AWS SDK specific errors
-        const message = error instanceof Error ? error.message : String(error);
-        if (message.includes("AccessDeniedException")) {
-            return new AuthenticationError("AWS Bedrock access denied. Check your credentials and permissions.", this.providerName);
-        }
-        if (message.includes("ValidationException")) {
-            return new ProviderError(`Validation error: ${message}`, this.providerName);
-        }
-        // Check for AWS-specific throttling BEFORE generic mapping
-        const errName = error?.name ?? "";
-        const errCode = error?.code ?? "";
-        if (errName === "ThrottlingException" ||
-            errCode === "ThrottlingException") {
-            return new RateLimitError(`Bedrock rate limit (throttled): ${error instanceof Error ? error.message : String(error)}`, "bedrock");
-        }
-        return new ProviderError(`AWS Bedrock error: ${message}`, this.providerName);
+        const rules = [
+            {
+                match: (ctx) => /AccessDeniedException/i.test(ctx.message),
+                errorClass: AuthenticationError,
+                message: "AWS Bedrock access denied. Check your credentials and permissions.",
+            },
+            {
+                // Checked before the generic ValidationException fallback — a
+                // throttling error can be shaped like a validation error in some
+                // AWS SDK error message templates, but .name/.code are authoritative.
+                match: (ctx) => ctx.errorName === "ThrottlingException" ||
+                    ctx.errorCode === "ThrottlingException",
+                errorClass: RateLimitError,
+                message: (ctx) => `Bedrock rate limit (throttled): ${ctx.message}`,
+            },
+            {
+                match: (ctx) => /ValidationException/i.test(ctx.message),
+                errorClass: ProviderError,
+                message: (ctx) => `Validation error: ${ctx.message}`,
+            },
+            {
+                match: () => true,
+                errorClass: ProviderError,
+                message: (ctx) => `AWS Bedrock error: ${ctx.message}`,
+            },
+        ];
+        // this.providerName resolves to the literal "bedrock" (getProviderName()
+        // returns it directly, and the constructor only overrides providerName
+        // when an explicit providerName is passed in) — verified matches the
+        // pre-migration hardcoded "bedrock" literal in the throttling branch, so
+        // a single classifyProviderError call using this.providerName for every
+        // rule (rather than a per-rule literal) is not a behavior change.
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     /**
      * Generate embeddings for text using Amazon Bedrock embedding models

package/dist/providers/amazonSagemaker.d.ts

@@ -69,7 +69,7 @@ export declare class AmazonSageMakerProvider extends BaseProvider {
         provider: string;
         specificationVersion: "v2";
         endpointName: string;
-        modelType: "huggingface" | "mistral" | "custom" | "llama" | "claude" | "jumpstart" | undefined;
+        modelType: "huggingface" | "mistral" | "custom" | "claude" | "llama" | "jumpstart" | undefined;
         region: string;
     } | {
         capabilities: {