@juspay/neurolink 11.26.2 → 11.28.0

package/dist/models/manifestRegistry.js

@@ -105,6 +105,29 @@ function applyFamilyRules(manifest, model, base) {
  * "llama3.2:latest" or OpenRouter's "openai/gpt-4o"), then undefined.
  * Family rules are applied on top of whichever entry matched.
  */
+/**
+ * Like resolveManifestEntryExact but WITHOUT the longest-prefix fallback:
+ * exact canonical id or declared alias only. For consumers where a prefix
+ * hit can steal precedence from a more-specific legacy row — boolean
+ * capability checks above all (a manifest "gpt-4" prefix match must never
+ * shadow the legacy table's explicit "gpt-4-vision-preview" vision row).
+ * Family rules still apply to a real match.
+ */
+export function resolveManifestEntryStrict(provider, model) {
+    const manifest = MANIFEST_REGISTRY[provider];
+    if (!manifest) {
+        return undefined;
+    }
+    const exact = manifest.models[model];
+    if (exact) {
+        return applyFamilyRules(manifest, model, exact);
+    }
+    const aliasMatch = Object.entries(manifest.models).find(([canonicalId, entry]) => canonicalId !== "_default" && entry.aliases.includes(model));
+    if (aliasMatch) {
+        return applyFamilyRules(manifest, model, aliasMatch[1]);
+    }
+    return undefined;
+}
 export function resolveManifestEntryExact(provider, model) {
     const manifest = MANIFEST_REGISTRY[provider];
     if (!manifest) {

package/dist/models/manifests/anthropic.js

@@ -28,9 +28,11 @@ export const anthropicManifest = {
             displayName: "Claude Sonnet 5",
             contextWindow: 1_000_000,
             maxOutputTokens: 64_000,
-            // No pricingPerMTok: genuinely absent from PRICING.anthropic today.
-            // Do not invent a rate — hasPricing()/findRates() (pricing.ts) must
-            // keep reporting this model as unpriced.
+            // No pricingPerMTok DELIBERATELY: PRICING.anthropic carries real
+            // rates for this id, and findRates() is manifest-first with a legacy
+            // fallback — omitting the rate here defers to that table instead of
+            // duplicating it, and keeps this entry out of the manifest-derived
+            // MODEL_REGISTRY rows (which only admit priced entries).
             vision: true,
             functionCalling: true,
             reasoning: true,

package/dist/models/manifests/azure.js

@@ -77,7 +77,12 @@ export const azureManifest = {
             contextWindow: 200000,
             maxOutputTokens: 32768,
             pricingPerMTok: { input: 1.25, output: 10 },
-            vision: true,
+            // Azure publishes no such model (the registry row is deprecated for
+            // exactly that reason, modelRegistry.ts ~2550), and vision was
+            // deliberately removed from VISION_CAPABILITIES for it — this entry
+            // was generated from the registry BEFORE that fix and must not
+            // re-advertise a capability an undeployable id cannot have.
+            vision: false,
             functionCalling: true,
             reasoning: true,
             jsonMode: true,

package/dist/models/modelRegistry.d.ts

@@ -6,7 +6,16 @@
 import { AIProviderName } from "../constants/enums.js";
 import type { JsonValue, ModelCapabilities, ModelInfo } from "../types/index.js";
 /**
- * Comprehensive model registry
+ * 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 declare const MODEL_REGISTRY: Record<string, ModelInfo>;
 /**
@@ -61,7 +70,18 @@ export declare function resolveSamplingParams(provider: string, model: string |
  */
 export declare function getModelsByProvider(provider: AIProviderName): ModelInfo[];
 /**
- * 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 declare function getAvailableProviders(): AIProviderName[];
 /**

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

@@ -7,9 +7,12 @@
  * Use `MusicProcessor.generate(provider, options)` to dispatch to the
  * registered handler for `provider`.
  *
- * Importing this module also auto-registers every shipped music handler
- * whose backing API key is present in `process.env`. Registration is
- * idempotent and silently skipped if a provider is already registered or
+ * Importing this module does NOT register any handlers as a side effect.
+ * Call `registerDefaultMusicHandlers()` explicitly (or go through
+ * `ProviderRegistry.registerAllProviders()`, which every documented
+ * `NeuroLink` entry point already calls) to register every shipped music
+ * handler whose backing API key is present in `process.env`. Registration
+ * is idempotent and silently skipped if a provider is already registered or
  * its constructor throws (e.g. missing optional native dependency).
  *
  * @module music

package/dist/music/index.js

@@ -7,13 +7,17 @@
  * Use `MusicProcessor.generate(provider, options)` to dispatch to the
  * registered handler for `provider`.
  *
- * Importing this module also auto-registers every shipped music handler
- * whose backing API key is present in `process.env`. Registration is
- * idempotent and silently skipped if a provider is already registered or
+ * Importing this module does NOT register any handlers as a side effect.
+ * Call `registerDefaultMusicHandlers()` explicitly (or go through
+ * `ProviderRegistry.registerAllProviders()`, which every documented
+ * `NeuroLink` entry point already calls) to register every shipped music
+ * handler whose backing API key is present in `process.env`. Registration
+ * is idempotent and silently skipped if a provider is already registered or
  * its constructor throws (e.g. missing optional native dependency).
  *
  * @module music
  */
+import { MEDIA_HANDLER_CATALOG } from "../factories/mediaHandlerCatalog.js";
 import { logger } from "../utils/logger.js";
 import { MusicProcessor } from "../utils/musicProcessor.js";
 export { MUSIC_ERROR_CODES, MusicError, MusicProcessor, } from "../utils/musicProcessor.js";
@@ -31,20 +35,21 @@ import { BeatovenMusic } from "./providers/BeatovenMusic.js";
 import { ElevenLabsMusic } from "./providers/ElevenLabsMusic.js";
 import { LyriaMusic } from "./providers/LyriaMusic.js";
 import { ReplicateMusic } from "./providers/ReplicateMusic.js";
-const MUSIC_HANDLER_CANDIDATES = [
-    { name: "beatoven", factory: () => new BeatovenMusic() },
-    {
-        name: "elevenlabs-music",
-        aliases: ["elevenlabs-sound"],
-        factory: () => new ElevenLabsMusic(),
-    },
-    { name: "lyria", factory: () => new LyriaMusic() },
-    {
-        name: "replicate",
-        aliases: ["musicgen"],
-        factory: () => new ReplicateMusic(),
-    },
-];
+// Provider names + aliases are the Task-8 catalog's job — only the factory
+// (which needs the imported handler class) stays local to this module.
+const MUSIC_HANDLER_FACTORIES = {
+    beatoven: () => new BeatovenMusic(),
+    "elevenlabs-music": () => new ElevenLabsMusic(),
+    lyria: () => new LyriaMusic(),
+    replicate: () => new ReplicateMusic(),
+};
+const MUSIC_HANDLER_CANDIDATES = MEDIA_HANDLER_CATALOG.filter((entry) => entry.kind === "music").map((entry) => {
+    const factory = MUSIC_HANDLER_FACTORIES[entry.name];
+    if (!factory) {
+        throw new Error(`[music] no handler factory for catalog entry "${entry.name}"`);
+    }
+    return { name: entry.name, aliases: entry.aliases, factory };
+});
 /**
  * Register every shipped music handler whose backing credentials are
  * present in the environment. Safe to call multiple times — existing
@@ -87,7 +92,3 @@ export function registerDefaultMusicHandlers() {
         }
     }
 }
-// Run once at module import so consumers who follow the documented
-// `nl.generate(...)` flow get every configured handler without manually
-// calling `registerHandler`.
-registerDefaultMusicHandlers();

package/dist/neurolink.js

@@ -4382,6 +4382,13 @@ Current user's request: ${currentInput}`;
         if (!providerName) {
             throw new Error('output.music.provider is required (e.g. "beatoven", "elevenlabs-music", "lyria", "replicate").');
         }
+        // This early-dispatch path never creates an AI provider, so
+        // ProviderRegistry.registerAllProviders() has NOT necessarily run —
+        // with the module-scope auto-registration retired, the handlers must
+        // be registered here explicitly. registerDefaultMusicHandlers() is
+        // idempotent (skip-if-registered), so the repeat call is free.
+        const { registerDefaultMusicHandlers } = await import("./music/index.js");
+        registerDefaultMusicHandlers();
         const { MusicProcessor } = await import("./utils/musicProcessor.js");
         const musicResult = await MusicProcessor.generate(providerName, {
             ...musicOptions,
@@ -4414,6 +4421,11 @@ Current user's request: ${currentInput}`;
         if (!providerName) {
             throw new Error('output.avatar.provider is required (e.g. "d-id", "heygen", "replicate").');
         }
+        // Same early-dispatch registration as generateWithMusic above: no AI
+        // provider is created on this path, so the retired module-scope
+        // auto-run must be replaced by an explicit (idempotent) call here.
+        const { registerDefaultAvatarHandlers } = await import("./avatar/index.js");
+        registerDefaultAvatarHandlers();
         const { AvatarProcessor } = await import("./utils/avatarProcessor.js");
         const avatarResult = await AvatarProcessor.generate(providerName, avatarOptions);
         generateSpan.setAttribute("neurolink.avatar.provider", providerName);

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

@@ -79,6 +79,7 @@ export * from "./video.js";
 export * from "./avatar.js";
 export * from "./music.js";
 export * from "./replicate.js";
+export * from "./mediaCatalog.js";
 export * from "./safeFetch.js";
 export * from "./modelPool.js";
 export * from "./requestRouter.js";

package/dist/types/index.js

@@ -85,6 +85,7 @@ export * from "./video.js";
 export * from "./avatar.js";
 export * from "./music.js";
 export * from "./replicate.js";
+export * from "./mediaCatalog.js";
 // Safe-fetch helper types (SSRF-hardened download)
 export * from "./safeFetch.js";
 // ModelPool — multi-provider failover with per-member cooldown (M9.x+)

package/dist/types/mediaCatalog.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Types backing the static media-handler catalog
+ * (src/lib/factories/mediaHandlerCatalog.ts) — the single source of truth
+ * for provider names/aliases across the six media-generation ecosystems
+ * (TTS, STT, Realtime, Video, Avatar, Music).
+ */
+export type MediaHandlerKind = "tts" | "stt" | "realtime" | "video" | "avatar" | "music";
+export type MediaHandlerDescriptor = {
+    readonly kind: MediaHandlerKind;
+    readonly name: string;
+    readonly aliases?: readonly string[];
+};

package/dist/types/mediaCatalog.js

@@ -0,0 +1,7 @@
+/**
+ * Types backing the static media-handler catalog
+ * (src/lib/factories/mediaHandlerCatalog.ts) — the single source of truth
+ * for provider names/aliases across the six media-generation ecosystems
+ * (TTS, STT, Realtime, Video, Avatar, Music).
+ */
+export {};

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/dist/voice/index.d.ts

@@ -8,9 +8,13 @@
  * Use STTProcessor (src/lib/utils/sttProcessor.ts) for STT.
  * Use RealtimeProcessor for realtime voice sessions.
  *
- * Importing this module also auto-registers every shipped TTS / STT /
- * Realtime handler whose backing API key is present in `process.env`.
- * Registration is idempotent and silently skipped on failure.
+ * Importing this module does NOT register any handlers as a side effect.
+ * Call `registerDefaultTTSHandlers()` / `registerDefaultSTTHandlers()` /
+ * `registerDefaultRealtimeHandlers()` explicitly (or go through
+ * `ProviderRegistry.registerAllProviders()`, which every documented
+ * `NeuroLink` entry point already calls) to register every shipped handler
+ * whose backing API key is present in `process.env`. Registration is
+ * idempotent and silently skipped on failure.
  *
  * @module voice
  */