@juspay/neurolink 11.0.0 → 11.1.0

package/dist/lib/factories/providerFactory.js

@@ -1,29 +1,25 @@
 import { logger } from "../utils/logger.js";
+import { PROVIDER_DESCRIPTORS, PROVIDER_DESCRIPTORS_BY_NAME, PROVIDER_ALIAS_INDEX, } from "./providerDescriptors.js";
 // Pure factory pattern with no hardcoded imports
 // All providers loaded dynamically via registry to avoid circular dependencies
 /**
- * Maps registered provider names to NeurolinkCredentials keys. Most names
- * match (openai, anthropic, vertex, bedrock, etc.) but every kebab-case
- * provider whose canonical credentials key is camelCase — or otherwise
- * spelled differently — MUST be mapped here, otherwise per-call/instance
- * credential overrides silently get dropped (createProvider() looks up
- * credentials["lm-studio"], which is undefined, while the caller wrote
- * credentials.lmStudio).
- */
-export const CREDENTIAL_KEY_MAP = {
-    "google-ai": "googleAiStudio",
-    "openai-compatible": "openaiCompatible",
-    huggingface: "huggingFace",
-    "lm-studio": "lmStudio",
-    "nvidia-nim": "nvidiaNim",
-    "together-ai": "together",
-};
-/**
- * Resolve a registered provider name to its NeurolinkCredentials key.
- * Falls back to the provider name itself when no remapping is needed.
+ * Resolve a registered provider name (or alias) to its NeurolinkCredentials
+ * key. Backed by ProviderFactory.getDescriptor() — PROVIDER_DESCRIPTORS is
+ * the single source of truth for provider identity — instead of a
+ * hand-maintained map, so this can no longer drift out of sync with the
+ * descriptors, and it correctly resolves aliases (e.g. "hf") through
+ * PROVIDER_ALIAS_INDEX, not just canonical names. Falls back to the
+ * lowercased input when no descriptor is found, matching the retired
+ * map's behavior for unknown provider names.
+ *
+ * Referencing ProviderFactory here (defined further down this file) is
+ * safe: this function's body only runs when called, by which point the
+ * module has finished evaluating and ProviderFactory is fully defined —
+ * there is no temporal-dead-zone hazard from the declaration order.
  */
 export function resolveCredentialKey(providerName) {
-    return (CREDENTIAL_KEY_MAP[providerName.toLowerCase()] ?? providerName.toLowerCase());
+    const normalized = providerName.toLowerCase();
+    return (ProviderFactory.getDescriptor(normalized)?.credentialsKey ?? normalized);
 }
 /**
  * True Factory Pattern implementation for AI Providers
@@ -37,11 +33,12 @@ export class ProviderFactory {
      * Register a provider with the factory
      */
     static registerProvider(name, constructor, defaultModel, // Optional - provider can read from env
-    aliases = []) {
+    aliases = [], descriptor) {
         const registration = {
             constructor,
             defaultModel,
             aliases,
+            descriptor,
         };
         // Register main name
         ProviderFactory.providers.set(name.toLowerCase(), registration);
@@ -118,16 +115,42 @@ export class ProviderFactory {
     static getProviderInfo(providerName) {
         return ProviderFactory.providers.get(providerName.toLowerCase());
     }
+    /**
+     * Look up a provider's static descriptor. Checks the built-in
+     * PROVIDER_DESCRIPTORS first (works even before registerAllProviders()
+     * has run, and resolves aliases via PROVIDER_ALIAS_INDEX), then falls
+     * back to whatever descriptor a live custom registration attached via
+     * registerProvider()'s 5th parameter.
+     */
+    static getDescriptor(name) {
+        const normalized = name.toLowerCase();
+        const canonical = PROVIDER_ALIAS_INDEX.get(normalized);
+        if (canonical) {
+            const builtIn = PROVIDER_DESCRIPTORS_BY_NAME.get(canonical);
+            if (builtIn) {
+                return builtIn;
+            }
+        }
+        return ProviderFactory.providers.get(normalized)?.descriptor;
+    }
+    /** All built-in provider descriptors (does not include custom-registered providers that lack a descriptor). */
+    static getAllDescriptors() {
+        return PROVIDER_DESCRIPTORS;
+    }
     /**
      * Normalize provider names using aliases (PHASE 1: Factory Pattern)
      */
     static normalizeProviderName(providerName) {
         const normalized = providerName.toLowerCase();
-        // Check direct registration
         if (ProviderFactory.providers.has(normalized)) {
             return normalized;
         }
-        // Check aliases from all registrations
+        const canonical = PROVIDER_ALIAS_INDEX.get(normalized);
+        if (canonical && ProviderFactory.providers.has(canonical)) {
+            return canonical;
+        }
+        // Fallback for providers registered without a built-in descriptor
+        // (e.g. TTS/STT/media handlers registered outside PROVIDER_DESCRIPTORS).
         for (const [name, registration] of ProviderFactory.providers.entries()) {
             if (registration.aliases?.includes(normalized)) {
                 return name;

package/dist/lib/factories/providerRegistry.js

@@ -1,6 +1,7 @@
 import { ProviderFactory } from "./providerFactory.js";
 import { logger } from "../utils/logger.js";
 import { AIProviderName, GoogleAIModels, OpenAIModels, AnthropicModels, VertexModels, MistralModels, OllamaModels, LiteLLMModels, HuggingFaceModels, DeepSeekModels, NvidiaNimModels, OpenRouterModels, XaiModels, GroqModels, CohereModels, TogetherAIModels, FireworksModels, PerplexityModels, CloudflareModels, VoyageModels, JinaModels, StabilityModels, IdeogramModels, RecraftModels, ReplicateModels, } from "../constants/enums.js";
+import { PROVIDER_DESCRIPTORS_BY_NAME } from "./providerDescriptors.js";
 /**
  * Provider Registry - registers all providers with the factory
  * This is where we migrate providers one by one to the new pattern
@@ -67,26 +68,26 @@ export class ProviderRegistry {
                 const googleAiCreds = credentials;
                 const { GoogleAIStudioProvider } = await import("../providers/googleAiStudio/index.js");
                 return new GoogleAIStudioProvider(modelName, sdk, googleAiCreds);
-            }, GoogleAIModels.GEMINI_2_5_FLASH, ["googleAiStudio", "google", "gemini", "google-ai", "google-ai-studio"]);
+            }, GoogleAIModels.GEMINI_2_5_FLASH, ["googleAiStudio", "google", "gemini", "google-ai", "google-ai-studio"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.GOOGLE_AI));
             // Register OpenAI provider
             ProviderFactory.registerProvider(AIProviderName.OPENAI, async (modelName, _providerName, sdk, _region, credentials) => {
                 const openaiCreds = credentials;
                 const { OpenAIProvider } = await import("../providers/openAI/index.js");
                 return new OpenAIProvider(modelName, sdk, undefined, openaiCreds);
-            }, OpenAIModels.GPT_4O_MINI, ["gpt", "chatgpt"]);
+            }, OpenAIModels.GPT_4O_MINI, ["gpt", "chatgpt"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.OPENAI));
             // Register Anthropic provider
             ProviderFactory.registerProvider(AIProviderName.ANTHROPIC, async (modelName, _providerName, sdk, _region, credentials) => {
                 const anthropicCreds = credentials;
                 const { AnthropicProvider } = await import("../providers/anthropic/index.js");
                 return new AnthropicProvider(modelName, sdk, undefined, anthropicCreds);
-            }, AnthropicModels.CLAUDE_SONNET_4_6, ["claude", "anthropic"]);
+            }, AnthropicModels.CLAUDE_SONNET_4_6, ["claude", "anthropic"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.ANTHROPIC));
             // Register Amazon Bedrock provider
             ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName, _providerName, sdk, region, credentials) => {
                 const bedrockCreds = credentials;
                 const { AmazonBedrockProvider } = await import("../providers/amazonBedrock/index.js");
                 return new AmazonBedrockProvider(modelName, sdk, region, bedrockCreds);
             }, undefined, // Let provider read BEDROCK_MODEL from .env
-            ["bedrock", "aws"]);
+            ["bedrock", "aws"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.BEDROCK));
             // Register Azure OpenAI provider
             ProviderFactory.registerProvider(AIProviderName.AZURE, async (modelName, _providerName, sdk, _region, credentials) => {
                 const azureCreds = credentials;
@@ -96,45 +97,45 @@ export class ProviderRegistry {
                 process.env.AZURE_OPENAI_MODEL ||
                 process.env.AZURE_OPENAI_DEPLOYMENT ||
                 process.env.AZURE_OPENAI_DEPLOYMENT_ID ||
-                "gpt-4o-mini", ["azure", "azureOpenai"]);
+                "gpt-4o-mini", ["azure", "azureOpenai"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.AZURE));
             // Register Google Vertex AI provider
             ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName, providerName, sdk, region, credentials) => {
                 const vertexCreds = credentials;
                 const { GoogleVertexProvider } = await import("../providers/googleVertex/index.js");
                 return new GoogleVertexProvider(modelName, providerName, sdk, region, vertexCreds);
-            }, VertexModels.CLAUDE_4_6_SONNET, ["vertex", "googleVertex"]);
+            }, VertexModels.CLAUDE_4_6_SONNET, ["vertex", "googleVertex"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.VERTEX));
             // Register Hugging Face provider (Unified Router implementation)
             ProviderFactory.registerProvider(AIProviderName.HUGGINGFACE, async (modelName, _providerName, sdk, region, credentials) => {
                 const hfCreds = credentials;
                 const { HuggingFaceProvider } = await import("../providers/huggingFace/index.js");
                 return new HuggingFaceProvider(modelName, sdk, region, hfCreds);
             }, process.env.HUGGINGFACE_MODEL ||
-                HuggingFaceModels.QWEN_2_5_72B_INSTRUCT, ["huggingface", "hf"]);
+                HuggingFaceModels.QWEN_2_5_72B_INSTRUCT, ["huggingface", "hf"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.HUGGINGFACE));
             // Register Mistral AI provider
             ProviderFactory.registerProvider(AIProviderName.MISTRAL, async (modelName, _providerName, sdk, _region, credentials) => {
                 const mistralCreds = credentials;
                 const { MistralProvider } = await import("../providers/mistral.js");
                 return new MistralProvider(modelName, sdk, undefined, mistralCreds);
-            }, MistralModels.MISTRAL_LARGE_LATEST, ["mistral"]);
+            }, MistralModels.MISTRAL_LARGE_LATEST, ["mistral"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.MISTRAL));
             // Register Ollama provider
             ProviderFactory.registerProvider(AIProviderName.OLLAMA, async (modelName, _providerName, sdk, _region, credentials) => {
                 const ollamaCreds = credentials;
                 const { OllamaProvider } = await import("../providers/ollama/index.js");
                 return new OllamaProvider(modelName, sdk, undefined, ollamaCreds);
-            }, process.env.OLLAMA_MODEL || OllamaModels.LLAMA3_2_LATEST, ["ollama", "local"]);
+            }, process.env.OLLAMA_MODEL || OllamaModels.LLAMA3_2_LATEST, ["ollama", "local"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.OLLAMA));
             // Register LiteLLM provider
             ProviderFactory.registerProvider(AIProviderName.LITELLM, async (modelName, _providerName, sdk, _region, credentials) => {
                 const litellmCreds = credentials;
                 const { LiteLLMProvider } = await import("../providers/litellm/index.js");
                 return new LiteLLMProvider(modelName, sdk, undefined, litellmCreds);
-            }, process.env.LITELLM_MODEL || LiteLLMModels.OPENAI_GPT_4O_MINI, ["litellm"]);
+            }, process.env.LITELLM_MODEL || LiteLLMModels.OPENAI_GPT_4O_MINI, ["litellm"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.LITELLM));
             // Register OpenAI Compatible provider
             ProviderFactory.registerProvider(AIProviderName.OPENAI_COMPATIBLE, async (modelName, _providerName, sdk, _region, credentials) => {
                 const openaiCompatCreds = credentials;
                 const { OpenAICompatibleProvider } = await import("../providers/openaiCompatible/index.js");
                 return new OpenAICompatibleProvider(modelName, sdk, undefined, openaiCompatCreds);
             }, process.env.OPENAI_COMPATIBLE_MODEL || undefined, // Enable auto-discovery when no model specified
-            ["openai-compatible", "vllm", "compatible"]);
+            ["openai-compatible", "vllm", "compatible"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.OPENAI_COMPATIBLE));
             // Register OpenRouter provider (300+ models from 60+ providers)
             ProviderFactory.registerProvider(AIProviderName.OPENROUTER, async (modelName, _providerName, sdk, _region, credentials) => {
                 const openrouterCreds = credentials;
@@ -146,117 +147,117 @@ export class ProviderRegistry {
             // for the rationale. Keep the three defaults aligned at the new
             // model (claude-sonnet-4.5) so the registry doesn't override the
             // provider's getDefault.
-            process.env.OPENROUTER_MODEL || OpenRouterModels.CLAUDE_SONNET_4_5, ["openrouter", "or"]);
+            process.env.OPENROUTER_MODEL || OpenRouterModels.CLAUDE_SONNET_4_5, ["openrouter", "or"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.OPENROUTER));
             // Register Amazon SageMaker provider
             ProviderFactory.registerProvider(AIProviderName.SAGEMAKER, async (modelName, _providerName, _sdk, region, credentials) => {
                 const sagemakerCreds = credentials;
                 const { AmazonSageMakerProvider } = await import("../providers/amazonSagemaker.js");
                 return new AmazonSageMakerProvider(modelName, undefined, region, undefined, sagemakerCreds);
-            }, process.env.SAGEMAKER_MODEL || "sagemaker-model", ["sagemaker", "aws-sagemaker"]);
+            }, process.env.SAGEMAKER_MODEL || "sagemaker-model", ["sagemaker", "aws-sagemaker"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.SAGEMAKER));
             // Register DeepSeek provider
             ProviderFactory.registerProvider(AIProviderName.DEEPSEEK, async (modelName, _providerName, sdk, _region, credentials) => {
                 const deepseekCreds = credentials;
                 const { DeepSeekProvider } = await import("../providers/deepseek.js");
                 return new DeepSeekProvider(modelName, sdk, undefined, deepseekCreds);
-            }, process.env.DEEPSEEK_MODEL || DeepSeekModels.DEEPSEEK_CHAT, ["deepseek", "ds"]);
+            }, process.env.DEEPSEEK_MODEL || DeepSeekModels.DEEPSEEK_CHAT, ["deepseek", "ds"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.DEEPSEEK));
             // Register NVIDIA NIM provider
             ProviderFactory.registerProvider(AIProviderName.NVIDIA_NIM, async (modelName, _providerName, sdk, _region, credentials) => {
                 const nimCreds = credentials;
                 const { NvidiaNimProvider } = await import("../providers/nvidiaNim/index.js");
                 return new NvidiaNimProvider(modelName, sdk, undefined, nimCreds);
-            }, process.env.NVIDIA_NIM_MODEL || NvidiaNimModels.LLAMA_3_3_70B_INSTRUCT, ["nvidia", "nim", "nvidia-nim"]);
+            }, process.env.NVIDIA_NIM_MODEL || NvidiaNimModels.LLAMA_3_3_70B_INSTRUCT, ["nvidia", "nim", "nvidia-nim"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.NVIDIA_NIM));
             // Register LM Studio provider (local)
             ProviderFactory.registerProvider(AIProviderName.LM_STUDIO, async (modelName, _providerName, sdk, _region, credentials) => {
                 const lmStudioCreds = credentials;
                 const { LMStudioProvider } = await import("../providers/lmStudio.js");
                 return new LMStudioProvider(modelName, sdk, undefined, lmStudioCreds);
-            }, process.env.LM_STUDIO_MODEL || undefined, ["lmstudio", "lm-studio", "lms"]);
+            }, process.env.LM_STUDIO_MODEL || undefined, ["lmstudio", "lm-studio", "lms"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.LM_STUDIO));
             // Register llama.cpp provider (local)
             ProviderFactory.registerProvider(AIProviderName.LLAMACPP, async (modelName, _providerName, sdk, _region, credentials) => {
                 const llamaCppCreds = credentials;
                 const { LlamaCppProvider } = await import("../providers/llamaCpp.js");
                 return new LlamaCppProvider(modelName, sdk, undefined, llamaCppCreds);
-            }, process.env.LLAMACPP_MODEL || undefined, ["llamacpp", "llama.cpp", "llama-cpp"]);
+            }, process.env.LLAMACPP_MODEL || undefined, ["llamacpp", "llama.cpp", "llama-cpp"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.LLAMACPP));
             // Register xAI Grok provider
             ProviderFactory.registerProvider(AIProviderName.XAI, async (modelName, _providerName, sdk, _region, credentials) => {
                 const xaiCreds = credentials;
                 const { XaiProvider } = await import("../providers/xai.js");
                 return new XaiProvider(modelName, sdk, undefined, xaiCreds);
-            }, process.env.XAI_MODEL || XaiModels.GROK_3, ["xai", "grok"]);
+            }, process.env.XAI_MODEL || XaiModels.GROK_3, ["xai", "grok"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.XAI));
             // Register Groq provider
             ProviderFactory.registerProvider(AIProviderName.GROQ, async (modelName, _providerName, sdk, _region, credentials) => {
                 const groqCreds = credentials;
                 const { GroqProvider } = await import("../providers/groq.js");
                 return new GroqProvider(modelName, sdk, undefined, groqCreds);
-            }, process.env.GROQ_MODEL || GroqModels.LLAMA_3_3_70B_VERSATILE, ["groq"]);
+            }, process.env.GROQ_MODEL || GroqModels.LLAMA_3_3_70B_VERSATILE, ["groq"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.GROQ));
             // Register Cohere provider
             ProviderFactory.registerProvider(AIProviderName.COHERE, async (modelName, _providerName, sdk, _region, credentials) => {
                 const cohereCreds = credentials;
                 const { CohereProvider } = await import("../providers/cohere.js");
                 return new CohereProvider(modelName, sdk, undefined, cohereCreds);
-            }, process.env.COHERE_MODEL || CohereModels.COMMAND_R_PLUS, ["cohere"]);
+            }, process.env.COHERE_MODEL || CohereModels.COMMAND_R_PLUS, ["cohere"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.COHERE));
             // Register Together AI provider
             ProviderFactory.registerProvider(AIProviderName.TOGETHER_AI, async (modelName, _providerName, sdk, _region, credentials) => {
                 const togetherCreds = credentials;
                 const { TogetherAIProvider } = await import("../providers/togetherAi.js");
                 return new TogetherAIProvider(modelName, sdk, undefined, togetherCreds);
             }, process.env.TOGETHER_MODEL ||
-                TogetherAIModels.LLAMA_3_3_70B_INSTRUCT_TURBO, ["together-ai", "together"]);
+                TogetherAIModels.LLAMA_3_3_70B_INSTRUCT_TURBO, ["together-ai", "together"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.TOGETHER_AI));
             // Register Fireworks AI provider
             ProviderFactory.registerProvider(AIProviderName.FIREWORKS, async (modelName, _providerName, sdk, _region, credentials) => {
                 const fireworksCreds = credentials;
                 const { FireworksProvider } = await import("../providers/fireworks.js");
                 return new FireworksProvider(modelName, sdk, undefined, fireworksCreds);
-            }, process.env.FIREWORKS_MODEL || FireworksModels.DEEPSEEK_V4_PRO, ["fireworks"]);
+            }, process.env.FIREWORKS_MODEL || FireworksModels.DEEPSEEK_V4_PRO, ["fireworks"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.FIREWORKS));
             // Register Perplexity provider
             ProviderFactory.registerProvider(AIProviderName.PERPLEXITY, async (modelName, _providerName, sdk, _region, credentials) => {
                 const perplexityCreds = credentials;
                 const { PerplexityProvider } = await import("../providers/perplexity.js");
                 return new PerplexityProvider(modelName, sdk, undefined, perplexityCreds);
-            }, process.env.PERPLEXITY_MODEL || PerplexityModels.SONAR, ["perplexity", "pplx"]);
+            }, process.env.PERPLEXITY_MODEL || PerplexityModels.SONAR, ["perplexity", "pplx"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.PERPLEXITY));
             // Register Cloudflare Workers AI provider
             ProviderFactory.registerProvider(AIProviderName.CLOUDFLARE, async (modelName, _providerName, sdk, _region, credentials) => {
                 const cloudflareCreds = credentials;
                 const { CloudflareProvider } = await import("../providers/cloudflare.js");
                 return new CloudflareProvider(modelName, sdk, undefined, cloudflareCreds);
-            }, process.env.CLOUDFLARE_MODEL || CloudflareModels.LLAMA_3_3_70B_FAST, ["cloudflare", "workers-ai", "cf-ai"]);
+            }, process.env.CLOUDFLARE_MODEL || CloudflareModels.LLAMA_3_3_70B_FAST, ["cloudflare", "workers-ai", "cf-ai"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.CLOUDFLARE));
             // Register Voyage AI embeddings provider
             ProviderFactory.registerProvider(AIProviderName.VOYAGE, async (modelName, _providerName, sdk, _region, credentials) => {
                 const voyageCreds = credentials;
                 const { VoyageProvider } = await import("../providers/voyage.js");
                 return new VoyageProvider(modelName, sdk, undefined, voyageCreds);
-            }, process.env.VOYAGE_MODEL || VoyageModels.VOYAGE_3_5, ["voyage", "voyage-ai"]);
+            }, process.env.VOYAGE_MODEL || VoyageModels.VOYAGE_3_5, ["voyage", "voyage-ai"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.VOYAGE));
             // Register Jina AI embeddings + reranking provider
             ProviderFactory.registerProvider(AIProviderName.JINA, async (modelName, _providerName, sdk, _region, credentials) => {
                 const jinaCreds = credentials;
                 const { JinaProvider } = await import("../providers/jina.js");
                 return new JinaProvider(modelName, sdk, undefined, jinaCreds);
-            }, process.env.JINA_MODEL || JinaModels.JINA_EMBEDDINGS_V3, ["jina", "jina-ai"]);
+            }, process.env.JINA_MODEL || JinaModels.JINA_EMBEDDINGS_V3, ["jina", "jina-ai"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.JINA));
             // Register Stability AI image-gen provider
             ProviderFactory.registerProvider(AIProviderName.STABILITY, async (modelName, _providerName, sdk, _region, credentials) => {
                 const stabilityCreds = credentials;
                 const { StabilityProvider } = await import("../providers/stability.js");
                 return new StabilityProvider(modelName, sdk, undefined, stabilityCreds);
-            }, process.env.STABILITY_MODEL || StabilityModels.STABLE_IMAGE_ULTRA, ["stability", "stability-ai", "sd"]);
+            }, process.env.STABILITY_MODEL || StabilityModels.STABLE_IMAGE_ULTRA, ["stability", "stability-ai", "sd"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.STABILITY));
             // Register Ideogram image-gen provider
             ProviderFactory.registerProvider(AIProviderName.IDEOGRAM, async (modelName, _providerName, sdk, _region, credentials) => {
                 const ideogramCreds = credentials;
                 const { IdeogramProvider } = await import("../providers/ideogram.js");
                 return new IdeogramProvider(modelName, sdk, undefined, ideogramCreds);
-            }, process.env.IDEOGRAM_MODEL || IdeogramModels.IDEOGRAM_V3, ["ideogram"]);
+            }, process.env.IDEOGRAM_MODEL || IdeogramModels.IDEOGRAM_V3, ["ideogram"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.IDEOGRAM));
             // Register Replicate LLM provider (multi-modal — also serves video /
             // avatar / music handlers via dedicated processors registered below)
             ProviderFactory.registerProvider(AIProviderName.REPLICATE, async (modelName, _providerName, sdk, _region, credentials) => {
                 const replicateCreds = credentials;
                 const { ReplicateProvider } = await import("../providers/replicate.js");
                 return new ReplicateProvider(modelName, sdk, undefined, replicateCreds);
-            }, process.env.REPLICATE_MODEL || ReplicateModels.LLAMA_3_70B_INSTRUCT, ["replicate"]);
+            }, process.env.REPLICATE_MODEL || ReplicateModels.LLAMA_3_70B_INSTRUCT, ["replicate"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.REPLICATE));
             // Register Recraft image-gen provider
             ProviderFactory.registerProvider(AIProviderName.RECRAFT, async (modelName, _providerName, sdk, _region, credentials) => {
                 const recraftCreds = credentials;
                 const { RecraftProvider } = await import("../providers/recraft.js");
                 return new RecraftProvider(modelName, sdk, undefined, recraftCreds);
-            }, process.env.RECRAFT_MODEL || RecraftModels.RECRAFT_V3, ["recraft"]);
+            }, process.env.RECRAFT_MODEL || RecraftModels.RECRAFT_V3, ["recraft"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.RECRAFT));
             logger.debug("All AI providers registered successfully");
             // ===== TTS HANDLER REGISTRATION =====
             try {

package/dist/lib/index.d.ts

@@ -33,6 +33,8 @@
  */
 import { AIProviderFactory } from "./core/factory.js";
 export { AIProviderFactory };
+export { ProviderFactory } from "./factories/providerFactory.js";
+export { PROVIDER_DESCRIPTORS, PROVIDER_DESCRIPTORS_BY_NAME, PROVIDER_ALIAS_INDEX, } from "./factories/providerDescriptors.js";
 export { NeuroLinkConfigManager as ConfigManager } from "./config/configManager.js";
 export { BaseFactory, BaseRegistry, NeuroLinkFeatureError, createErrorFactory, withRetry, TypedEventEmitter, } from "./core/infrastructure/index.js";
 export { NeuroLinkClient, createClient, NeuroLinkApiError, } from "./client/httpClient.js";
@@ -396,7 +398,14 @@ export { classifyProviderError, ModelPool, createDefaultRequestRouter, Classifie
  * await server.start();
  * ```
  */
-export { AgentExecuteRequestSchema, AlreadyRunningError, AuthenticationError, AuthorizationError, BaseServerAdapter, ConfigurationError, createAgentRoutes, createAgentWebSocketHandler, createAllRoutes, createAuthMiddleware, createCacheInvalidator, createCacheMiddleware, createCompressionMiddleware, createDataStreamResponse, createDataStreamWriter, createErrorHandlingMiddleware, createErrorResponse, createFieldValidator, createHealthRoutes, createLoggingMiddleware, createMCPRoutes, createMemoryRoutes, createNDJSONHeaders, createOpenAPIGenerator, createRateLimitMiddleware, createRequestIdMiddleware, createRequestValidationMiddleware, createRoleMiddleware, createSecurityHeadersMiddleware, createServer, createSlidingWindowRateLimitMiddleware, createSSEHeaders, createTimingMiddleware, createToolRoutes, ErrorCategory, ErrorRecoveryStrategies, ErrorSeverity, ExpressServerAdapter, FastifyServerAdapter, generateOpenAPIFromConfig, generateOpenAPISpec, HandlerError, HonoServerAdapter, InMemoryCacheStore, InMemoryRateLimitStore, InvalidAuthenticationError, KoaServerAdapter, MissingDependencyError, NotRunningError, pipeAsyncIterableToDataStream, RateLimitError, RouteConflictError, RouteNotFoundError, registerAllRoutes, ServerAdapterError, ServerAdapterErrorCode, ServerAdapterFactory, ServerNameParamSchema, ServerRateLimitError, ServerStartError, ServerStopError, ServerValidationError, SessionIdParamSchema, StreamAbortedError, StreamingError, TimeoutError, ToolArgumentsSchema, ToolExecuteRequestSchema, ToolNameParamSchema, ToolSearchQuerySchema, ValidationError, validateParams, validateQuery, validateRequest, WebSocketConnectionError, WebSocketConnectionManager, WebSocketError, WebSocketMessageRouter, wrapError, } from "./server/index.js";
+export { AgentExecuteRequestSchema, AlreadyRunningError, BaseServerAdapter, ConfigurationError, createAgentRoutes, createAgentWebSocketHandler, createAllRoutes, createAuthMiddleware, createCacheInvalidator, createCacheMiddleware, createCompressionMiddleware, createDataStreamResponse, createDataStreamWriter, createErrorHandlingMiddleware, createErrorResponse, createFieldValidator, createHealthRoutes, createLoggingMiddleware, createMCPRoutes, createMemoryRoutes, createNDJSONHeaders, createOpenAPIGenerator, createRateLimitMiddleware, createRequestIdMiddleware, createRequestValidationMiddleware, createRoleMiddleware, createSecurityHeadersMiddleware, createServer, createSlidingWindowRateLimitMiddleware, createSSEHeaders, createTimingMiddleware, createToolRoutes, ErrorCategory, ErrorRecoveryStrategies, ErrorSeverity, ExpressServerAdapter, FastifyServerAdapter, generateOpenAPIFromConfig, generateOpenAPISpec, HandlerError, HonoServerAdapter, InMemoryCacheStore, InMemoryRateLimitStore, InvalidAuthenticationError, KoaServerAdapter, MissingDependencyError, NotRunningError, pipeAsyncIterableToDataStream, RouteConflictError, RouteNotFoundError, registerAllRoutes, ServerAdapterError, ServerAdapterErrorCode, ServerAdapterFactory, ServerAuthenticationError, ServerAuthorizationError, ServerNameParamSchema, ServerRateLimitError, ServerStartError, ServerStopError, ServerTimeoutError, ServerValidationError, SessionIdParamSchema, StreamAbortedError, StreamingError, ToolArgumentsSchema, ToolExecuteRequestSchema, ToolNameParamSchema, ToolSearchQuerySchema, ValidationError, validateParams, validateQuery, validateRequest, WebSocketConnectionError, WebSocketConnectionManager, WebSocketError, WebSocketMessageRouter, wrapError, } from "./server/index.js";
+/**
+ * @deprecated Use `ServerTimeoutError` instead — renamed to end the naming
+ * collision with the canonical `utils/timeout.ts` `TimeoutError`. Kept as an
+ * alias so existing callers importing `TimeoutError` from `@juspay/neurolink`
+ * are not broken.
+ */
+export { ServerTimeoutError as TimeoutError } from "./server/index.js";
 /**
  * RAG (Retrieval-Augmented Generation) Document Processing
  *

package/dist/lib/index.js

@@ -34,6 +34,9 @@
 // Core exports
 import { AIProviderFactory } from "./core/factory.js";
 export { AIProviderFactory };
+// Provider descriptor exports (single source of truth for provider identity)
+export { ProviderFactory } from "./factories/providerFactory.js";
+export { PROVIDER_DESCRIPTORS, PROVIDER_DESCRIPTORS_BY_NAME, PROVIDER_ALIAS_INDEX, } from "./factories/providerDescriptors.js";
 // Config Manager export
 export { NeuroLinkConfigManager as ConfigManager } from "./config/configManager.js";
 // Core Infrastructure exports (factory + registry patterns)
@@ -613,7 +616,7 @@ export { classifyProviderError, ModelPool, createDefaultRequestRouter, Classifie
  */
 export { 
 // Validation
-AgentExecuteRequestSchema, AlreadyRunningError, AuthenticationError, AuthorizationError, 
+AgentExecuteRequestSchema, AlreadyRunningError, 
 // Framework Adapters
 BaseServerAdapter, ConfigurationError, 
 // Routes
@@ -627,11 +630,18 @@ createServer, createSlidingWindowRateLimitMiddleware, createSSEHeaders, createTi
 // Error Constants
 ErrorCategory, ErrorRecoveryStrategies, ErrorSeverity, ExpressServerAdapter, FastifyServerAdapter, generateOpenAPIFromConfig, generateOpenAPISpec, HandlerError, HonoServerAdapter, InMemoryCacheStore, InMemoryRateLimitStore, InvalidAuthenticationError, KoaServerAdapter, MissingDependencyError, NotRunningError, 
 // OpenAPI
-pipeAsyncIterableToDataStream, RateLimitError, RouteConflictError, RouteNotFoundError, registerAllRoutes, 
+pipeAsyncIterableToDataStream, RouteConflictError, RouteNotFoundError, registerAllRoutes, 
 // Errors
-ServerAdapterError, ServerAdapterErrorCode, ServerAdapterFactory, ServerNameParamSchema, ServerRateLimitError, ServerStartError, ServerStopError, ServerValidationError, SessionIdParamSchema, StreamAbortedError, StreamingError, TimeoutError, ToolArgumentsSchema, ToolExecuteRequestSchema, ToolNameParamSchema, ToolSearchQuerySchema, ValidationError, validateParams, validateQuery, validateRequest, WebSocketConnectionError, 
+ServerAdapterError, ServerAdapterErrorCode, ServerAdapterFactory, ServerAuthenticationError, ServerAuthorizationError, ServerNameParamSchema, ServerRateLimitError, ServerStartError, ServerStopError, ServerTimeoutError, ServerValidationError, SessionIdParamSchema, StreamAbortedError, StreamingError, ToolArgumentsSchema, ToolExecuteRequestSchema, ToolNameParamSchema, ToolSearchQuerySchema, ValidationError, validateParams, validateQuery, validateRequest, WebSocketConnectionError, 
 // WebSocket
 WebSocketConnectionManager, WebSocketError, WebSocketMessageRouter, wrapError, } from "./server/index.js";
+/**
+ * @deprecated Use `ServerTimeoutError` instead — renamed to end the naming
+ * collision with the canonical `utils/timeout.ts` `TimeoutError`. Kept as an
+ * alias so existing callers importing `TimeoutError` from `@juspay/neurolink`
+ * are not broken.
+ */
+export { ServerTimeoutError as TimeoutError } from "./server/index.js";
 // ============================================================================
 // RAG DOCUMENT PROCESSING - Retrieval-Augmented Generation
 // ============================================================================

package/dist/lib/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/lib/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