@juspay/neurolink 11.26.2 → 11.27.0

package/dist/models/modelRegistry.js

@@ -6,10 +6,15 @@
 import { DEFAULT_MODEL_ALIASES } from "../types/index.js";
 import { logger } from "../utils/logger.js";
 import { AIProviderName, OpenAIModels, AzureOpenAIModels, GoogleAIModels, AnthropicModels, BedrockModels, MistralModels, OllamaModels, } from "../constants/enums.js";
+import { getAllManifestProviders, getManifestForProvider, } from "./manifestRegistry.js";
 /**
- * Comprehensive model registry
+ * Comprehensive model registry — hand-authored base. Every id defined here
+ * that the manifest doesn't also carry a priced entry for stays exactly as
+ * authored below; see buildManifestDerivedEntries()/MODEL_REGISTRY's
+ * docblock further down for how the two are merged and why (Task 9, model
+ * metadata consolidation plan).
  */
-export const MODEL_REGISTRY = {
+const LEGACY_MODEL_REGISTRY = {
     // OpenAI Models
     [OpenAIModels.GPT_4O]: {
         id: OpenAIModels.GPT_4O,
@@ -2450,6 +2455,129 @@ export const MODEL_REGISTRY = {
     },
     // Note: Azure models like O3, O4-mini, GPT-4o share IDs with OpenAI and use the OpenAI registry entries
 };
+function deriveSpeed(id) {
+    if (/mini|nano|haiku|flash|lite/i.test(id)) {
+        return "fast";
+    }
+    if (/opus|^o1|^o3|-pro$/i.test(id)) {
+        return "slow";
+    }
+    return "medium";
+}
+function deriveQuality(entry) {
+    return entry.reasoning ? "high" : "medium";
+}
+/**
+ * Builds the manifest-derived slice of MODEL_REGISTRY: every manifest model
+ * that carries pricingPerMTok (ModelInfo.pricing is a required field, and
+ * the manifest's pricingPerMTok is deliberately optional for un-priced
+ * models like claude-sonnet-5 — see ProviderModelManifestEntry's docblock),
+ * excluding each provider's synthetic "_default" entry.
+ *
+ * performance/useCases/category use entry.curated verbatim when present —
+ * the ids that already had a hand-tuned LEGACY_MODEL_REGISTRY row before
+ * this migration (5 Anthropic, 20 OpenAI) carry that exact triple forward
+ * unchanged. Every other entry has no curated block and falls back to
+ * mechanical derivation from the tracked capability flags.
+ */
+function buildManifestDerivedEntries() {
+    const entries = {};
+    for (const provider of getAllManifestProviders()) {
+        const manifest = getManifestForProvider(provider);
+        if (!manifest) {
+            continue;
+        }
+        for (const [id, entry] of Object.entries(manifest.models)) {
+            if (id === "_default" || !entry.pricingPerMTok) {
+                continue;
+            }
+            // Keep-first on cross-manifest id collisions (Azure/OpenAI share ids):
+            // getAllManifestProviders() order is deterministic, and silently
+            // overwriting an earlier provider's row would make "which provider owns
+            // this id" depend on iteration order.
+            if (entries[id]) {
+                logger.debug(`[modelRegistry] Manifest id collision: "${id}" already derived from ${entries[id].provider}; keeping first, skipping ${provider}`);
+                continue;
+            }
+            const reasoningScore = entry.reasoning ? 9 : 6;
+            const legacyRow = LEGACY_MODEL_REGISTRY[id];
+            entries[id] = {
+                id,
+                name: entry.displayName ?? id,
+                provider: provider,
+                description: entry.displayName ?? id,
+                capabilities: {
+                    vision: entry.vision,
+                    functionCalling: entry.functionCalling,
+                    codeGeneration: true,
+                    reasoning: entry.reasoning ?? false,
+                    multimodal: entry.vision || entry.nativeAudio === true,
+                    streaming: true,
+                    jsonMode: entry.jsonMode ?? false,
+                    samplingParams: entry.samplingParams,
+                },
+                pricing: {
+                    inputCostPer1K: entry.pricingPerMTok.input / 1000,
+                    outputCostPer1K: entry.pricingPerMTok.output / 1000,
+                    currency: "USD",
+                },
+                performance: entry.curated?.performance ?? {
+                    speed: deriveSpeed(id),
+                    quality: deriveQuality(entry),
+                    accuracy: deriveQuality(entry),
+                },
+                limits: {
+                    maxContextTokens: entry.contextWindow,
+                    maxOutputTokens: entry.maxOutputTokens,
+                    // Rate limits are operational knowledge the manifests don't track;
+                    // carry the hand-authored value forward rather than dropping it.
+                    ...(legacyRow?.limits?.maxRequestsPerMinute !== undefined
+                        ? { maxRequestsPerMinute: legacyRow.limits.maxRequestsPerMinute }
+                        : {}),
+                },
+                useCases: entry.curated?.useCases ?? {
+                    coding: entry.functionCalling ? 8 : 5,
+                    creative: entry.vision ? 7 : 6,
+                    analysis: reasoningScore,
+                    conversation: 7,
+                    reasoning: reasoningScore,
+                    translation: 6,
+                    summarization: 7,
+                },
+                aliases: entry.aliases,
+                // Deprecation and release dates are editorial facts the manifests do
+                // not track — a manifest-priced model must not silently un-deprecate
+                // a row the hand-authored registry explicitly flagged.
+                deprecated: legacyRow?.deprecated ?? false,
+                ...(legacyRow?.releaseDate !== undefined
+                    ? { releaseDate: legacyRow.releaseDate }
+                    : {}),
+                isLocal: provider === "ollama" ||
+                    provider === "lm-studio" ||
+                    provider === "llamacpp",
+                category: entry.curated?.category ??
+                    (entry.reasoning ? "reasoning" : "general"),
+            };
+        }
+    }
+    return entries;
+}
+/**
+ * Public MODEL_REGISTRY: the manifest-derived entries merged over the
+ * hand-authored LEGACY_MODEL_REGISTRY base. Spread order matters — manifest
+ * entries are spread last, so a manifest-priced model wins outright
+ * (whole-entry replacement, not a per-field merge) over a legacy row with
+ * the same id. Any legacy id the manifest doesn't also price (no
+ * pricingPerMTok, or no manifest entry at all — e.g. AnthropicModels.
+ * CLAUDE_OPUS_5/CLAUDE_FABLE_5, which have no manifest counterpart yet)
+ * passes through unchanged, which is what keeps resolveSamplingParams/
+ * modelSupportsSamplingParams behaviour identical for those "non-manifest"
+ * models: their capabilities.samplingParams (or absence of it) is untouched.
+ */
+export const MODEL_REGISTRY = {
+    ...LEGACY_MODEL_REGISTRY,
+    ...buildManifestDerivedEntries(),
+};
 /**
  * Model aliases registry for quick resolution
  */
@@ -2644,14 +2772,21 @@ export function getModelsByProvider(provider) {
     return Object.values(MODEL_REGISTRY).filter((model) => model.provider === provider);
 }
 /**
- * Get available providers
+ * Get available providers.
+ *
+ * Deliberately does NOT derive from MODEL_REGISTRY membership: a registry
+ * keyed only by "real, priced, named models" under-reports providers whose
+ * manifest carries only a `_default` entry (the minimal-tier providers —
+ * e.g. voyage, jina, stability — have no priced named model and so
+ * contribute zero MODEL_REGISTRY rows). Reading getAllManifestProviders()
+ * directly gives every provider NeuroLink actually knows a manifest for,
+ * decoupled from MODEL_REGISTRY membership entirely. Manifest keys are
+ * literally the AIProviderName enum's kebab-case values by construction
+ * (see manifestRegistry.ts), so the cast is a same-value relabel, not a
+ * narrowing assumption.
  */
 export function getAvailableProviders() {
-    const providers = new Set();
-    Object.values(MODEL_REGISTRY).forEach((model) => {
-        providers.add(model.provider);
-    });
-    return Array.from(providers);
+    return getAllManifestProviders();
 }
 /**
  * Calculate estimated cost for a request

package/dist/providers/amazonSagemaker.d.ts

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

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

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

package/dist/utils/pricing.js

@@ -1,3 +1,4 @@
+import { getManifestForProvider, resolveManifestEntryExact, } from "../models/manifestRegistry.js";
 /**
  * Per-token pricing data (USD per token). Updated Feb 2026.
  * Sources:
@@ -728,6 +729,22 @@ function isVersionOnlySuffix(model, key) {
     }
     return VERSION_SUFFIX_RE.test(model.slice(key.length));
 }
+/**
+ * Whether `model` matches a provider manifest by the manifest's own
+ * canonical id or by one of its declared aliases — deliberately excludes
+ * resolveManifestEntryExact's longest-prefix fallback. See the call site in
+ * findRates for why the prefix path is unsafe to use for pricing precedence.
+ */
+function isManifestNamedMatch(provider, model) {
+    const manifest = getManifestForProvider(provider);
+    if (!manifest) {
+        return false;
+    }
+    if (Object.prototype.hasOwnProperty.call(manifest.models, model)) {
+        return true;
+    }
+    return Object.values(manifest.models).some((entry) => entry.aliases.includes(model));
+}
 function findRates(provider, model, 
 /**
  * Set to true when the rates came from a literal table key rather than a
@@ -778,6 +795,40 @@ matchKind) {
     const modelKey = stripped === "bedrock" || stripped === "amazonbedrock"
         ? model.replace(/^.*\banthropic\./, "")
         : model;
+    // Manifest-backed exact/alias match takes precedence over legacy PRICING
+    // (see Task 8 of the model metadata consolidation plan). Deliberately
+    // gated to a NAMED match only (manifest's own id or a declared alias) —
+    // never resolveManifestEntryExact's longest-prefix fallback. The
+    // manifest's model set is coarser-grained than PRICING's for several
+    // live ids today (e.g. openai's manifest names only "gpt-5" while
+    // PRICING.openai carries distinct exact entries for
+    // gpt-5.1/5.4/5.5/5.6-sol/terra/luna); letting the manifest's prefix
+    // match run first would silently steal a more specific PRICING entry's
+    // rate — confirmed: resolveManifestEntryExact("openai", "gpt-5.4")
+    // prefix-matches onto the "gpt-5" entry, $1.25/$10 instead of the
+    // correct $2.5/$15. Everything the manifest doesn't name exactly or
+    // alias — including a named entry with no pricingPerMTok, e.g.
+    // claude-sonnet-5 — falls straight through to PRICING's unchanged
+    // exact+prefix match below, which is exactly "legacy PRICING as the
+    // fallback for entries the manifest lacks."
+    if (isManifestNamedMatch(normalizedProvider, modelKey)) {
+        const manifestEntry = resolveManifestEntryExact(normalizedProvider, modelKey);
+        if (manifestEntry?.pricingPerMTok) {
+            if (matchKind) {
+                matchKind.exact = true;
+            }
+            return {
+                input: manifestEntry.pricingPerMTok.input / 1_000_000,
+                output: manifestEntry.pricingPerMTok.output / 1_000_000,
+                cacheRead: manifestEntry.pricingPerMTok.cacheRead !== undefined
+                    ? manifestEntry.pricingPerMTok.cacheRead / 1_000_000
+                    : undefined,
+                cacheCreation: manifestEntry.pricingPerMTok.cacheWrite !== undefined
+                    ? manifestEntry.pricingPerMTok.cacheWrite / 1_000_000
+                    : undefined,
+            };
+        }
+    }
     // Exact match
     if (providerPricing[modelKey]) {
         if (matchKind) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.26.2",
+  "version": "11.27.0",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {