@juspay/neurolink 11.3.0 → 11.4.0

package/dist/lib/models/manifests/sagemaker.js

@@ -0,0 +1,19 @@
+/**
+ * Minimal manifest: sagemaker has no MODEL_REGISTRY entries today, so
+ * only the provider-wide fallback is known. Named models can be added here
+ * incrementally without touching any consumer — see Task 5 of the model
+ * metadata consolidation plan.
+ */
+export const sagemakerManifest = {
+    defaultContextWindow: 128000,
+    models: {
+        _default: {
+            aliases: [],
+            contextWindow: 128000,
+            maxOutputTokens: 64000,
+            vision: false,
+            functionCalling: false,
+        },
+    },
+};
+//# sourceMappingURL=sagemaker.js.map

package/dist/lib/models/manifests/stability.d.ts

@@ -0,0 +1,8 @@
+import type { ProviderModelManifest } from "../../types/index.js";
+/**
+ * Minimal manifest: stability has no MODEL_REGISTRY entries today, so
+ * only the provider-wide fallback is known. Named models can be added here
+ * incrementally without touching any consumer — see Task 5 of the model
+ * metadata consolidation plan.
+ */
+export declare const stabilityManifest: ProviderModelManifest;

package/dist/lib/models/manifests/stability.js

@@ -0,0 +1,19 @@
+/**
+ * Minimal manifest: stability has no MODEL_REGISTRY entries today, so
+ * only the provider-wide fallback is known. Named models can be added here
+ * incrementally without touching any consumer — see Task 5 of the model
+ * metadata consolidation plan.
+ */
+export const stabilityManifest = {
+    defaultContextWindow: 2000,
+    models: {
+        _default: {
+            aliases: [],
+            contextWindow: 2000,
+            maxOutputTokens: 2000,
+            vision: false,
+            functionCalling: false,
+        },
+    },
+};
+//# sourceMappingURL=stability.js.map

package/dist/lib/models/manifests/together-ai.d.ts

@@ -0,0 +1,8 @@
+import type { ProviderModelManifest } from "../../types/index.js";
+/**
+ * Minimal manifest: together-ai has no MODEL_REGISTRY entries today, so
+ * only the provider-wide fallback is known. Named models can be added here
+ * incrementally without touching any consumer — see Task 5 of the model
+ * metadata consolidation plan.
+ */
+export declare const togetherAiManifest: ProviderModelManifest;

package/dist/lib/models/manifests/together-ai.js

@@ -0,0 +1,19 @@
+/**
+ * Minimal manifest: together-ai has no MODEL_REGISTRY entries today, so
+ * only the provider-wide fallback is known. Named models can be added here
+ * incrementally without touching any consumer — see Task 5 of the model
+ * metadata consolidation plan.
+ */
+export const togetherAiManifest = {
+    defaultContextWindow: 128000,
+    models: {
+        _default: {
+            aliases: [],
+            contextWindow: 128000,
+            maxOutputTokens: 64000,
+            vision: false,
+            functionCalling: false,
+        },
+    },
+};
+//# sourceMappingURL=together-ai.js.map

package/dist/lib/models/manifests/vertex.d.ts

@@ -0,0 +1,8 @@
+import type { ProviderModelManifest } from "../../types/index.js";
+/**
+ * Minimal manifest: vertex has no MODEL_REGISTRY entries today, so
+ * only the provider-wide fallback is known. Named models can be added here
+ * incrementally without touching any consumer — see Task 5 of the model
+ * metadata consolidation plan.
+ */
+export declare const vertexManifest: ProviderModelManifest;

package/dist/lib/models/manifests/vertex.js

@@ -0,0 +1,19 @@
+/**
+ * Minimal manifest: vertex has no MODEL_REGISTRY entries today, so
+ * only the provider-wide fallback is known. Named models can be added here
+ * incrementally without touching any consumer — see Task 5 of the model
+ * metadata consolidation plan.
+ */
+export const vertexManifest = {
+    defaultContextWindow: 1048576,
+    models: {
+        _default: {
+            aliases: [],
+            contextWindow: 1048576,
+            maxOutputTokens: 64000,
+            vision: false,
+            functionCalling: false,
+        },
+    },
+};
+//# sourceMappingURL=vertex.js.map

package/dist/lib/models/manifests/voyage.d.ts

@@ -0,0 +1,8 @@
+import type { ProviderModelManifest } from "../../types/index.js";
+/**
+ * Minimal manifest: voyage has no MODEL_REGISTRY entries today, so
+ * only the provider-wide fallback is known. Named models can be added here
+ * incrementally without touching any consumer — see Task 5 of the model
+ * metadata consolidation plan.
+ */
+export declare const voyageManifest: ProviderModelManifest;

package/dist/lib/models/manifests/voyage.js

@@ -0,0 +1,19 @@
+/**
+ * Minimal manifest: voyage has no MODEL_REGISTRY entries today, so
+ * only the provider-wide fallback is known. Named models can be added here
+ * incrementally without touching any consumer — see Task 5 of the model
+ * metadata consolidation plan.
+ */
+export const voyageManifest = {
+    defaultContextWindow: 32000,
+    models: {
+        _default: {
+            aliases: [],
+            contextWindow: 32000,
+            maxOutputTokens: 32000,
+            vision: false,
+            functionCalling: false,
+        },
+    },
+};
+//# sourceMappingURL=voyage.js.map

package/dist/lib/models/manifests/xai.d.ts

@@ -0,0 +1,8 @@
+import type { ProviderModelManifest } from "../../types/index.js";
+/**
+ * Minimal manifest: xai has no MODEL_REGISTRY entries today, so
+ * only the provider-wide fallback is known. Named models can be added here
+ * incrementally without touching any consumer — see Task 5 of the model
+ * metadata consolidation plan.
+ */
+export declare const xaiManifest: ProviderModelManifest;

package/dist/lib/models/manifests/xai.js

@@ -0,0 +1,19 @@
+/**
+ * Minimal manifest: xai has no MODEL_REGISTRY entries today, so
+ * only the provider-wide fallback is known. Named models can be added here
+ * incrementally without touching any consumer — see Task 5 of the model
+ * metadata consolidation plan.
+ */
+export const xaiManifest = {
+    defaultContextWindow: 131072,
+    models: {
+        _default: {
+            aliases: [],
+            contextWindow: 131072,
+            maxOutputTokens: 64000,
+            vision: false,
+            functionCalling: false,
+        },
+    },
+};
+//# sourceMappingURL=xai.js.map

package/dist/lib/providers/googleVertex/constants.js

@@ -5,7 +5,7 @@ export let cachedCredentialsPath = null;
 export const VERTEX_MODEL_ALIASES = {
     // Claude 4.x shorthand aliases → versioned names
     "claude-sonnet-4-5": "claude-sonnet-4-5@20250929",
-    "claude-opus-4-5": "claude-opus-4-5@20251124",
+    "claude-opus-4-5": "claude-opus-4-5@20251101",
     "claude-haiku-4-5": "claude-haiku-4-5@20251001",
     "claude-sonnet-4": "claude-sonnet-4@20250514",
     "claude-opus-4": "claude-opus-4@20250514",

package/dist/lib/types/model.d.ts

@@ -263,3 +263,80 @@ export type ModelRoutingOptions = {
     /** Fallback strategy if primary choice fails */
     fallbackStrategy?: "fast" | "reasoning" | "auto";
 };
+/**
+ * A single model's metadata inside a provider's manifest. This is the one
+ * canonical shape every model-metadata consumer (context windows, pricing,
+ * MODEL_REGISTRY, vision capability, output-token ceilings) is intended to
+ * migrate onto — this PR is purely additive and does not yet move any
+ * consumer over.
+ *
+ * `pricingPerMTok` is optional by design: a model with no verified price
+ * (e.g. a just-announced model pricing.ts hasn't priced yet) must not report
+ * a fabricated rate. Absence here means "unknown", not "free" — callers that
+ * need to distinguish "free" from "unknown" already have `hasPricing()`
+ * (src/lib/utils/pricing.ts) for that.
+ */
+export type ProviderModelManifestEntry = {
+    /** Alternate identifiers that resolve to this canonical model id. */
+    aliases: string[];
+    /** Human-readable name. Falls back to a mechanical id-derived name when absent. */
+    displayName?: string;
+    contextWindow: number;
+    maxOutputTokens: number;
+    pricingPerMTok?: {
+        input: number;
+        output: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+    };
+    vision: boolean;
+    nativeAudio?: boolean;
+    functionCalling: boolean;
+    reasoning?: boolean;
+    jsonMode?: boolean;
+    /**
+     * Whether the model accepts classic sampling parameters (temperature/topP).
+     * Mirrors ModelCapabilities.samplingParams (src/lib/types/model.ts:131) —
+     * unset means supported.
+     */
+    samplingParams?: boolean;
+    /**
+     * Hand-tuned ModelInfo.performance/useCases/category values, carried
+     * forward verbatim for the ids that already had a MODEL_REGISTRY entry
+     * before this migration. Absent for every id that never had one — those
+     * get performance/useCases/category derived mechanically instead (see
+     * Task 9's buildModelRegistryFromManifests). Never populate this for a
+     * genuinely new model: mechanical derivation is the correct default, and
+     * a fabricated "curated" value would be worse than an honestly-derived one.
+     */
+    curated?: {
+        performance?: ModelPerformance;
+        useCases?: UseCaseSuitability;
+        category?: ModelInfo["category"];
+    };
+};
+/**
+ * A regex-driven patch applied to an unlisted, gateway-shaped model id that
+ * matches `pattern` (e.g. "vertex_ai/claude-sonnet-5@20260203"). Generalizes
+ * the pattern VISION_FAMILY_RULES (src/lib/adapters/providerImageAdapter.ts)
+ * and SAMPLING_PARAM_REJECTING_FAMILIES (src/lib/models/modelRegistry.ts)
+ * already use independently, keyed per-provider instead of globally.
+ */
+export type ManifestFamilyRule = {
+    pattern: RegExp;
+    patch: Partial<ProviderModelManifestEntry>;
+};
+/**
+ * One provider's complete model manifest: every model NeuroLink knows about
+ * for that provider, plus the provider-wide fallback used when a caller
+ * passes a model id the manifest has never seen (a symbolic/local provider
+ * model, or a brand-new release the manifest hasn't been updated for yet).
+ */
+export type ProviderModelManifest = {
+    /** Used for `_default`-key lookups and providers with no named-model list. */
+    defaultContextWindow: number;
+    /** Applied, in order, to the resolved entry (see manifestRegistry.ts). */
+    familyRules?: ManifestFamilyRule[];
+    /** Keyed by canonical model id (the same id `ModelInfo.id` / AIProvider calls use). */
+    models: Record<string, ProviderModelManifestEntry>;
+};

package/dist/models/manifestRegistry.d.ts

@@ -0,0 +1,33 @@
+import type { ProviderModelManifest, ProviderModelManifestEntry } from "../types/index.js";
+/**
+ * Every provider's model manifest, keyed by the exact AIProviderName enum
+ * value (kebab-case) — e.g. "google-ai", "nvidia-nim". Manifests are pure
+ * data with zero heavy dependencies, so they are imported statically here
+ * (Critical Rule 1's dynamic-import mandate targets providerRegistry.ts's
+ * *provider* factories, which pull in real SDK clients — not this).
+ */
+export declare const MANIFEST_REGISTRY: Record<string, ProviderModelManifest>;
+export declare function getManifestForProvider(provider: string): ProviderModelManifest | undefined;
+export declare function getAllManifestProviders(): string[];
+/**
+ * Resolve a model against a provider's manifest WITHOUT ever falling back to
+ * the provider's `_default` entry. Used by callers that need to insert their
+ * own special-case fallback (cross-provider pricing, proxy pass-through)
+ * between "no real match" and "give up" — see resolveManifestEntry's
+ * docblock for why the split exists.
+ *
+ * Resolution order: exact canonical id, then a declared alias, then
+ * longest-prefix match (for tagged/gateway-shaped ids like Ollama's
+ * "llama3.2:latest" or OpenRouter's "openai/gpt-4o"), then undefined.
+ * Family rules are applied on top of whichever entry matched.
+ */
+export declare function resolveManifestEntryExact(provider: string, model: string): ProviderModelManifestEntry | undefined;
+/**
+ * Resolve a model against a provider's manifest, falling back to the
+ * provider's `_default` entry (synthesized from `PROVIDER_MAX_TOKENS`,
+ * clamped to `defaultContextWindow`, when no explicit `_default` model
+ * entry exists) when no real model matches. Family rules are tested
+ * against the ORIGINAL model string even on the `_default` path, so an
+ * unmatched gateway-shaped id still gets patched.
+ */
+export declare function resolveManifestEntry(provider: string, model: string): ProviderModelManifestEntry | undefined;

package/dist/models/manifestRegistry.js

@@ -0,0 +1,173 @@
+import { PROVIDER_MAX_TOKENS } from "../core/constants.js";
+import { anthropicManifest } from "./manifests/anthropic.js";
+import { openaiManifest } from "./manifests/openai.js";
+import { azureManifest } from "./manifests/azure.js";
+import { bedrockManifest } from "./manifests/bedrock.js";
+import { ollamaManifest } from "./manifests/ollama.js";
+import { mistralManifest } from "./manifests/mistral.js";
+import { googleAiManifest } from "./manifests/google-ai.js";
+import { openaiCompatibleManifest } from "./manifests/openai-compatible.js";
+import { openrouterManifest } from "./manifests/openrouter.js";
+import { vertexManifest } from "./manifests/vertex.js";
+import { huggingfaceManifest } from "./manifests/huggingface.js";
+import { litellmManifest } from "./manifests/litellm.js";
+import { sagemakerManifest } from "./manifests/sagemaker.js";
+import { deepseekManifest } from "./manifests/deepseek.js";
+import { nvidiaNimManifest } from "./manifests/nvidia-nim.js";
+import { lmStudioManifest } from "./manifests/lm-studio.js";
+import { llamacppManifest } from "./manifests/llamacpp.js";
+import { xaiManifest } from "./manifests/xai.js";
+import { groqManifest } from "./manifests/groq.js";
+import { cohereManifest } from "./manifests/cohere.js";
+import { togetherAiManifest } from "./manifests/together-ai.js";
+import { fireworksManifest } from "./manifests/fireworks.js";
+import { perplexityManifest } from "./manifests/perplexity.js";
+import { cloudflareManifest } from "./manifests/cloudflare.js";
+import { replicateManifest } from "./manifests/replicate.js";
+import { voyageManifest } from "./manifests/voyage.js";
+import { jinaManifest } from "./manifests/jina.js";
+import { stabilityManifest } from "./manifests/stability.js";
+import { ideogramManifest } from "./manifests/ideogram.js";
+import { recraftManifest } from "./manifests/recraft.js";
+/**
+ * Every provider's model manifest, keyed by the exact AIProviderName enum
+ * value (kebab-case) — e.g. "google-ai", "nvidia-nim". Manifests are pure
+ * data with zero heavy dependencies, so they are imported statically here
+ * (Critical Rule 1's dynamic-import mandate targets providerRegistry.ts's
+ * *provider* factories, which pull in real SDK clients — not this).
+ */
+export const MANIFEST_REGISTRY = {
+    anthropic: anthropicManifest,
+    openai: openaiManifest,
+    azure: azureManifest,
+    bedrock: bedrockManifest,
+    ollama: ollamaManifest,
+    mistral: mistralManifest,
+    "google-ai": googleAiManifest,
+    "openai-compatible": openaiCompatibleManifest,
+    openrouter: openrouterManifest,
+    vertex: vertexManifest,
+    huggingface: huggingfaceManifest,
+    litellm: litellmManifest,
+    sagemaker: sagemakerManifest,
+    deepseek: deepseekManifest,
+    "nvidia-nim": nvidiaNimManifest,
+    "lm-studio": lmStudioManifest,
+    llamacpp: llamacppManifest,
+    xai: xaiManifest,
+    groq: groqManifest,
+    cohere: cohereManifest,
+    "together-ai": togetherAiManifest,
+    fireworks: fireworksManifest,
+    perplexity: perplexityManifest,
+    cloudflare: cloudflareManifest,
+    replicate: replicateManifest,
+    voyage: voyageManifest,
+    jina: jinaManifest,
+    stability: stabilityManifest,
+    ideogram: ideogramManifest,
+    recraft: recraftManifest,
+};
+export function getManifestForProvider(provider) {
+    return MANIFEST_REGISTRY[provider];
+}
+export function getAllManifestProviders() {
+    return Object.keys(MANIFEST_REGISTRY);
+}
+/**
+ * Apply every matching family rule's patch, in declaration order, on top of
+ * a base entry. Later rules win on overlapping fields (last patch applied
+ * wins), matching the "later registrations overwrite earlier ones" idiom
+ * used elsewhere in this subsystem (see registerRuntimeContextWindow's
+ * docblock, src/lib/constants/contextWindows.ts).
+ */
+function applyFamilyRules(manifest, model, base) {
+    if (!manifest.familyRules) {
+        return base;
+    }
+    let result = base;
+    for (const rule of manifest.familyRules) {
+        if (rule.pattern.test(model)) {
+            result = { ...result, ...rule.patch };
+        }
+    }
+    return result;
+}
+/**
+ * Resolve a model against a provider's manifest WITHOUT ever falling back to
+ * the provider's `_default` entry. Used by callers that need to insert their
+ * own special-case fallback (cross-provider pricing, proxy pass-through)
+ * between "no real match" and "give up" — see resolveManifestEntry's
+ * docblock for why the split exists.
+ *
+ * Resolution order: exact canonical id, then a declared alias, then
+ * longest-prefix match (for tagged/gateway-shaped ids like Ollama's
+ * "llama3.2:latest" or OpenRouter's "openai/gpt-4o"), then undefined.
+ * Family rules are applied on top of whichever entry matched.
+ */
+export function resolveManifestEntryExact(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]);
+    }
+    const sortedKeys = Object.keys(manifest.models)
+        .filter((k) => k !== "_default")
+        .sort((a, b) => b.length - a.length);
+    const prefixKey = sortedKeys.find((k) => model.startsWith(k));
+    if (prefixKey) {
+        return applyFamilyRules(manifest, model, manifest.models[prefixKey]);
+    }
+    return undefined;
+}
+/**
+ * Provider-specific output-token ceiling used to synthesize a `_default`
+ * entry when a manifest declares no explicit one (currently every
+ * MODEL_REGISTRY-generated manifest — azure, bedrock, ollama, mistral,
+ * google-ai — since `generateFullManifest` only emits real model ids).
+ * Mirrors the same table + fallback chain the minimal-manifest generator
+ * already uses (scripts/generate-remaining-manifests.ts), so a provider
+ * with no PROVIDER_MAX_TOKENS entry still gets an honest ceiling instead of
+ * `undefined`. Clamped against the manifest's own `defaultContextWindow` —
+ * an output ceiling can never legitimately exceed total context.
+ */
+function defaultMaxOutputTokens(provider, defaultContextWindow) {
+    const providerLimits = PROVIDER_MAX_TOKENS[provider];
+    const rawMax = typeof providerLimits === "number"
+        ? providerLimits
+        : (providerLimits?.default ?? PROVIDER_MAX_TOKENS.default);
+    return Math.min(rawMax, defaultContextWindow);
+}
+/**
+ * Resolve a model against a provider's manifest, falling back to the
+ * provider's `_default` entry (synthesized from `PROVIDER_MAX_TOKENS`,
+ * clamped to `defaultContextWindow`, when no explicit `_default` model
+ * entry exists) when no real model matches. Family rules are tested
+ * against the ORIGINAL model string even on the `_default` path, so an
+ * unmatched gateway-shaped id still gets patched.
+ */
+export function resolveManifestEntry(provider, model) {
+    const exact = resolveManifestEntryExact(provider, model);
+    if (exact) {
+        return exact;
+    }
+    const manifest = MANIFEST_REGISTRY[provider];
+    if (!manifest) {
+        return undefined;
+    }
+    const defaultEntry = manifest.models._default ?? {
+        aliases: [],
+        contextWindow: manifest.defaultContextWindow,
+        maxOutputTokens: defaultMaxOutputTokens(provider, manifest.defaultContextWindow),
+        vision: false,
+        functionCalling: false,
+    };
+    return applyFamilyRules(manifest, model, defaultEntry);
+}

package/dist/models/manifests/anthropic.d.ts

@@ -0,0 +1,9 @@
+import type { ProviderModelManifest } from "../../types/index.js";
+/**
+ * Anthropic model manifest. Canonical ids match AnthropicModels
+ * (src/lib/constants/enums.ts:524+) and MODEL_CONTEXT_WINDOWS.anthropic
+ * (src/lib/constants/contextWindows.ts:160-182). maxOutputTokens values
+ * come from getClaudeMaxOutputTokens (src/lib/utils/tokenLimits.ts) — the
+ * regex ladder already authoritative for native Claude request paths.
+ */
+export declare const anthropicManifest: ProviderModelManifest;