@juspay/neurolink 11.26.1 → 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/anthropic/client.js

@@ -15,6 +15,7 @@ import { getCapturedLimitSnapshot, getCapturedResponseHeaders, logClaudeLimitSna
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../../types/index.js";
 import { classifyProviderError } from "../../utils/errorClassifier.js";
 import { logger } from "../../utils/logger.js";
+import { drainDetachedPump } from "../../utils/drainDetachedPump.js";
 import { ANTHROPIC_ELISION_NOTE, planAnthropicLoopReclaim, previewAnthropicToolResultText, } from "../../context/anthropicLoopGuard.js";
 import { getAvailableInputTokens } from "../../constants/contextWindows.js";
 import { estimateTokens } from "../../utils/tokenEstimation.js";
@@ -1749,15 +1750,15 @@ export class AnthropicProvider extends BaseProvider {
             // formatted one the caller received, which is why the existing
             // `loopPromise.catch` guard below does not cover it.
             //
-            // Same shape googleAiStudio/client.ts and googleVertex/client.ts already
-            // use at every one of their pump sites; Anthropic was the only provider
-            // missing it.
+            // Every detached-drain site in the codebase now goes through
+            // drainDetachedPump(), which adopts the rejection and logs the reason at
+            // debug instead of discarding it silently.
             let result;
             try {
                 result = await resultPromise;
             }
             catch (error) {
-                await pump.catch(() => { });
+                await drainDetachedPump(pump, "Anthropic");
                 throw error;
             }
             await pump;

package/dist/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 { drainDetachedPump } from "../../utils/drainDetachedPump.js";
 import { createGeminiLoopAdapter } from "../../core/geminiLoopAdapter.js";
 import { runAgenticLoop } from "../../core/loopEngine.js";
 import { DEFAULT_TOOL_MAX_RETRIES } from "../../core/constants.js";
@@ -861,7 +862,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                             engineResult = await resultPromise;
                         }
                         catch (error) {
-                            await pump.catch(() => { });
+                            await drainDetachedPump(pump, "GoogleAIStudio");
                             logger.error("[GoogleAIStudio] Native SDK error", error);
                             throw this.handleProviderError(error);
                         }
@@ -1173,7 +1174,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                     engineResult = await resultPromise;
                 }
                 catch (error) {
-                    await drain.catch(() => { });
+                    await drainDetachedPump(drain, "GoogleAIStudio");
                     logger.error("[GoogleAIStudio] Native SDK generate error", error);
                     throw this.handleProviderError(error);
                 }

package/dist/providers/googleVertex/client.js

@@ -20,6 +20,7 @@ import { applyVertexAnthropicCacheBreakpoints } from "../../utils/anthropicCache
 import { FileDetector } from "../../utils/fileDetector.js";
 import { mergeMediaFileAliases, normalizeVisionImageFormats, processUnifiedFilesArray, } from "../../utils/messageBuilder.js";
 import { logger } from "../../utils/logger.js";
+import { drainDetachedPump } from "../../utils/drainDetachedPump.js";
 import { GEMINI_ELISION_NOTE, planGeminiLoopReclaim, previewGeminiToolResponseText, } from "../../context/geminiLoopGuard.js";
 import { ANTHROPIC_ELISION_NOTE, planAnthropicLoopReclaim, previewAnthropicToolResultText, } from "../../context/anthropicLoopGuard.js";
 import { hasRestrictedOutputLimit, RESTRICTED_OUTPUT_TOKEN_LIMIT, toVertexAnthropicModelId, } from "../../utils/modelDetection.js";
@@ -1814,7 +1815,7 @@ export class GoogleVertexProvider extends BaseProvider {
             // rethrow the very error the branch below has already decided to absorb —
             // which is what turned both turn-clock cases into failures instead of
             // clean deadline exits.
-            await pump.catch(() => { });
+            await drainDetachedPump(pump, "GoogleVertex");
             if (turnFailure !== undefined) {
                 // A mid-drain abort surfaces as an AbortError. End gracefully into the
                 // terminal block instead of re-throwing — a re-throw would route the
@@ -2598,7 +2599,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 engineResult = await resultPromise;
             }
             catch (error) {
-                await pump.catch(() => { });
+                await drainDetachedPump(pump, "GoogleVertex");
                 // A mid-drain abort surfaces as an AbortError. End gracefully into the
                 // terminal block instead of re-throwing — a re-throw would route the
                 // caller's abort into a second unbounded fallback stream().
@@ -3687,7 +3688,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 // Drained tolerantly and exactly once: when a turn ends by abort the
                 // channel rejects too, and re-awaiting a settled rejection would rethrow
                 // the error the branch below has already decided to absorb.
-                await pump.catch(() => { });
+                await drainDetachedPump(pump, "GoogleVertex");
                 if (turnFailure !== undefined) {
                     if (internalAbort.signal.aborted || isAbortError(turnFailure)) {
                         wasAborted = true;
@@ -4686,7 +4687,7 @@ export class GoogleVertexProvider extends BaseProvider {
         catch (error) {
             turnFailure = error;
         }
-        await pump.catch(() => { });
+        await drainDetachedPump(pump, "GoogleVertex");
         if (turnFailure !== undefined) {
             if (internalAbort.signal.aborted || isAbortError(turnFailure)) {
                 wasAborted = true;

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/drainDetachedPump.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Await a detached stream pump, swallowing its rejection but not its evidence.
+ *
+ * Several providers drain their engine's channel with a pump started outside
+ * the promise chain the caller awaits:
+ *
+ *   const pump = (async () => { for await (const chunk of stream) { ... } })();
+ *   const result = await resultPromise;   // can throw
+ *   await pump;                           // never reached if it does
+ *
+ * When the turn fails, `resultPromise` and the pump reject together — the
+ * engine calls `channel.error(err)` before closing — so the pump must be
+ * adopted on the error path too. Nothing adopting it is not a cosmetic leak:
+ * an unhandled rejection TERMINATES the process, so a caller who correctly
+ * try/catches the streaming error still dies. That was a real bug in the
+ * Anthropic path.
+ *
+ * The established remedy is `await pump.catch(() => {})`, which every site
+ * already uses. The gap this closes is the second half: `() => {}` throws the
+ * reason away, so the raw upstream error — the one carrying the provider's
+ * actual wire response — was invisible in traces at every one of the seven
+ * sites (six named `pump`, plus one named `drain` in googleAiStudio's
+ * non-streaming path, which a search for `pump` does not find). It is logged at DEBUG rather than WARN deliberately: on a failing turn
+ * this reason is almost always a duplicate of the error the caller is already
+ * being handed, and on an aborted turn it is the expected AbortError. It is
+ * diagnostic detail, not a new event worth alerting on.
+ *
+ * Behaviour is otherwise identical to `await pump.catch(() => {})`: it awaits,
+ * it never rethrows.
+ */
+export declare function drainDetachedPump(pump: Promise<unknown>, providerLabel: string): Promise<void>;

package/dist/utils/drainDetachedPump.js

@@ -0,0 +1,39 @@
+import { logger } from "./logger.js";
+/**
+ * Await a detached stream pump, swallowing its rejection but not its evidence.
+ *
+ * Several providers drain their engine's channel with a pump started outside
+ * the promise chain the caller awaits:
+ *
+ *   const pump = (async () => { for await (const chunk of stream) { ... } })();
+ *   const result = await resultPromise;   // can throw
+ *   await pump;                           // never reached if it does
+ *
+ * When the turn fails, `resultPromise` and the pump reject together — the
+ * engine calls `channel.error(err)` before closing — so the pump must be
+ * adopted on the error path too. Nothing adopting it is not a cosmetic leak:
+ * an unhandled rejection TERMINATES the process, so a caller who correctly
+ * try/catches the streaming error still dies. That was a real bug in the
+ * Anthropic path.
+ *
+ * The established remedy is `await pump.catch(() => {})`, which every site
+ * already uses. The gap this closes is the second half: `() => {}` throws the
+ * reason away, so the raw upstream error — the one carrying the provider's
+ * actual wire response — was invisible in traces at every one of the seven
+ * sites (six named `pump`, plus one named `drain` in googleAiStudio's
+ * non-streaming path, which a search for `pump` does not find). It is logged at DEBUG rather than WARN deliberately: on a failing turn
+ * this reason is almost always a duplicate of the error the caller is already
+ * being handed, and on an aborted turn it is the expected AbortError. It is
+ * diagnostic detail, not a new event worth alerting on.
+ *
+ * Behaviour is otherwise identical to `await pump.catch(() => {})`: it awaits,
+ * it never rethrows.
+ */
+export async function drainDetachedPump(pump, providerLabel) {
+    try {
+        await pump;
+    }
+    catch (error) {
+        logger.debug(`[${providerLabel}] detached stream pump rejected; reason absorbed because the turn's own error is authoritative`, error);
+    }
+}

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.1",
+  "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": {