@juspay/neurolink 9.79.3 → 9.80.0

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

@@ -0,0 +1,193 @@
+/**
+ * ClassifierRouter types — generic "classify → pick model + tools → run".
+ *
+ * A ClassifierRouter inspects an incoming request, classifies it by difficulty
+ * (and optional required capabilities / suggested tools), then selects a
+ * provider/model from a host-declared "available base" pool — routing harder
+ * tasks to more capable models and easier tasks to cheaper/faster ones — and
+ * optionally narrows the tool set for that request.
+ *
+ * It is entirely opt-in (constructor config, `enabled: false` by default) and
+ * fails open: any classifier or selection error leaves the call unrouted.
+ *
+ * Type names are domain-prefixed `Classifier*` to stay globally unique across
+ * `src/lib/types/` (see CLAUDE.md rule 9).
+ */
+/** Coarse difficulty buckets the classifier maps a request into. */
+export type ClassifierDifficulty = "trivial" | "simple" | "moderate" | "hard" | "expert";
+/** Which classification strategy to run. */
+export type ClassifierStrategyKind = "heuristic" | "llm";
+/**
+ * The classifier's verdict for a single request. Strategy-agnostic: produced
+ * by both the heuristic and the LLM classifier.
+ */
+export type ClassifierDecision = {
+    /** The classified difficulty bucket. */
+    difficulty: ClassifierDifficulty;
+    /** Confidence in the classification (0–1). */
+    confidence: number;
+    /** Capability tags the request needs (e.g. "vision", "tools", "reasoning"). */
+    requiredCapabilities?: string[];
+    /** Tool names the classifier thinks the task needs (allowlist hint). */
+    suggestedTools?: string[];
+    /**
+     * When the LLM classifier picks a model directly, the chosen candidate id
+     * (matches a `ClassifierCandidate.id`). Ignored by the heuristic classifier.
+     */
+    selectedModelId?: string;
+    /** Human-readable explanation, emitted at debug level. */
+    reason?: string;
+};
+/**
+ * Lightweight model descriptor handed to the LLM classifier so it can select a
+ * model directly from the pool by `id` — the generic path for custom models.
+ */
+export type ClassifierCandidate = {
+    id: string;
+    provider: string;
+    model?: string;
+    description?: string;
+    tiers?: ClassifierDifficulty[];
+    capabilities?: string[];
+};
+/**
+ * One candidate (provider, model, region) in the available base pool, with
+ * optional routing metadata. When `cost`/`quality`/`capabilities` are omitted,
+ * the router enriches them from the model registry (by `model` name/alias).
+ */
+export type ClassifierRouterPoolMember = {
+    provider: string;
+    model?: string;
+    region?: string;
+    /**
+     * Stable id the LLM classifier references when selecting a model directly.
+     * Defaults to `${provider}/${model}` (or just `provider`) when omitted.
+     */
+    id?: string;
+    /**
+     * Plain-English description of when to use this model (e.g. "cheap & fast,
+     * for simple Q&A" / "powerful reasoning model for complex analysis"). Drives
+     * LLM-based model selection — the only metadata needed for custom models that
+     * are NOT in the registry (LiteLLM, OpenAI-compatible, self-hosted, …).
+     */
+    description?: string;
+    /** Difficulty tiers this member is eligible for. Omit = eligible for all. */
+    tiers?: ClassifierDifficulty[];
+    /** Relative cost (lower = cheaper). Preferred for easy tiers. */
+    cost?: number;
+    /** Relative quality/capability (higher = more capable). Preferred for hard tiers. */
+    quality?: number;
+    /** Capability tags this member supports (e.g. "vision", "tools"). */
+    capabilities?: string[];
+    /** Tiebreak weight when scores are equal. Default: 1. */
+    weight?: number;
+};
+/** Per-difficulty tool policy applied to the request. */
+export type ClassifierToolDirective = {
+    /** Allowlist of tool names to keep (maps to `options.toolFilter`). */
+    toolFilter?: string[];
+    /** Denylist of tool names to drop (appended to `options.excludeTools`). */
+    excludeTools?: string[];
+};
+/** Provider/model the LLM classifier strategy itself runs on. */
+export type ClassifierModelRef = {
+    provider?: string;
+    model?: string;
+    region?: string;
+    temperature?: number;
+};
+/** Constructor-level configuration for the classifier router. */
+export type ClassifierRouterConfig = {
+    /** Master switch. When false/absent, the router is never built. */
+    enabled: boolean;
+    /**
+     * Classification strategy. Default: "heuristic" (no LLM, zero added latency).
+     * "llm" runs a cheap classifier model (see `classifierModel`).
+     */
+    classifier?: ClassifierStrategyKind;
+    /** Model used by the "llm" strategy. Defaults to provider/model auto. */
+    classifierModel?: ClassifierModelRef;
+    /** The available base pool the router selects a model from. */
+    pool: ClassifierRouterPoolMember[];
+    /**
+     * Explicit difficulty → members map. When a difficulty has entries here they
+     * take precedence over metadata scoring of `pool`.
+     */
+    tierMap?: Partial<Record<ClassifierDifficulty, ClassifierRouterPoolMember[]>>;
+    /** Per-difficulty tool directives applied to the request. */
+    toolDirectives?: Partial<Record<ClassifierDifficulty, ClassifierToolDirective>>;
+    /** Hard timeout (ms) for the LLM classifier call. Default: 8000. */
+    timeoutMs?: number;
+};
+/**
+ * The router's combined decision: a provider/model/region override plus an
+ * optional tool narrowing. Any undefined field means "keep what the caller
+ * already configured". Returning `null` from the router is a valid no-op.
+ */
+export type ClassifierRouterDecision = {
+    provider?: string;
+    model?: string;
+    region?: string;
+    /** Allowlist applied to `options.toolFilter`. */
+    toolFilter?: string[];
+    /** Denylist appended to `options.excludeTools`. */
+    excludeTools?: string[];
+    /** The difficulty this decision was made for (debug/telemetry). */
+    difficulty?: ClassifierDifficulty;
+    /** Remaining ranked candidates, best-first, for downstream failover. */
+    modelFallbacks?: ClassifierRouterPoolMember[];
+    /** Human-readable explanation, emitted at debug level. */
+    reason?: string;
+};
+/** Lightweight request snapshot handed to the router. */
+export type ClassifierRouterInput = {
+    prompt: string;
+    estimatedInputTokens?: number;
+    hasTools?: boolean;
+    requiresVision?: boolean;
+    thinkingLevel?: string;
+    sessionId?: string;
+};
+/** Enriched per-model metadata used while ranking pool members. */
+export type ClassifierModelMeta = {
+    cost?: number;
+    quality?: number;
+    capabilities?: string[];
+};
+/** Minimal options accepted by the injected LLM-classifier `generate` fn. */
+export type ClassifierGenerateOptions = {
+    input: {
+        text: string;
+    };
+    systemPrompt?: string;
+    provider?: string;
+    model?: string;
+    region?: string;
+    temperature?: number;
+    maxTokens?: number;
+    disableTools?: boolean;
+    schema?: unknown;
+    timeout?: number | string;
+    context?: Record<string, unknown>;
+};
+/** Minimal result shape the LLM classifier reads back. */
+export type ClassifierGenerateResult = {
+    content?: string;
+    structuredData?: unknown;
+};
+/** Injected LLM caller — typically a bound `NeuroLink.generate`. */
+export type ClassifierGenerateFn = (options: ClassifierGenerateOptions) => Promise<ClassifierGenerateResult>;
+/** Minimal logger surface the router uses (debug/warn). */
+export type ClassifierLogger = {
+    debug: (message: string, meta?: unknown) => void;
+    warn: (message: string, meta?: unknown) => void;
+};
+/**
+ * Injected dependencies — keep `ClassifierRouter` provider-import-free and
+ * unit-testable (mirrors the `toolRouting` generateFn-injection pattern).
+ */
+export type ClassifierRouterDeps = {
+    /** LLM caller for the "llm" strategy. Omit to disable LLM classification. */
+    generate?: ClassifierGenerateFn;
+    logger?: ClassifierLogger;
+};

package/dist/lib/types/classifierRouter.js

@@ -0,0 +1,17 @@
+/**
+ * ClassifierRouter types — generic "classify → pick model + tools → run".
+ *
+ * A ClassifierRouter inspects an incoming request, classifies it by difficulty
+ * (and optional required capabilities / suggested tools), then selects a
+ * provider/model from a host-declared "available base" pool — routing harder
+ * tasks to more capable models and easier tasks to cheaper/faster ones — and
+ * optionally narrows the tool set for that request.
+ *
+ * It is entirely opt-in (constructor config, `enabled: false` by default) and
+ * fails open: any classifier or selection error leaves the call unrouted.
+ *
+ * Type names are domain-prefixed `Classifier*` to stay globally unique across
+ * `src/lib/types/` (see CLAUDE.md rule 9).
+ */
+export {};
+//# sourceMappingURL=classifierRouter.js.map

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

@@ -45,7 +45,7 @@ export type BaseCommandArgs = {
 /**
  * Generate command arguments
  */
-export type GenerateCommandArgs = BaseCommandArgs & CliToolRoutingFlags & {
+export type GenerateCommandArgs = BaseCommandArgs & CliToolRoutingFlags & CliClassifierRouterFlags & {
     /** Input text or prompt */
     input?: string;
     /** AI provider to use */
@@ -110,7 +110,7 @@ export type GenerateCommandArgs = BaseCommandArgs & CliToolRoutingFlags & {
 /**
  * Stream command arguments
  */
-export type StreamCommandArgs = BaseCommandArgs & CliToolRoutingFlags & {
+export type StreamCommandArgs = BaseCommandArgs & CliToolRoutingFlags & CliClassifierRouterFlags & {
     /** Input text or prompt */
     input?: string;
     /** AI provider to use */
@@ -137,7 +137,7 @@ export type StreamCommandArgs = BaseCommandArgs & CliToolRoutingFlags & {
 /**
  * Batch command arguments
  */
-export type BatchCommandArgs = BaseCommandArgs & CliToolRoutingFlags & {
+export type BatchCommandArgs = BaseCommandArgs & CliToolRoutingFlags & CliClassifierRouterFlags & {
     /** Input file path */
     file?: string;
     /** AI provider to use */
@@ -1526,3 +1526,27 @@ export type CliToolRoutingFlags = {
      */
     toolRoutingServers?: string;
 };
+/**
+ * CLI flags for the classifier router (`--classifier-*`). Builds a
+ * ClassifierRouterConfig that is injected at SDK construction time.
+ */
+export type CliClassifierRouterFlags = {
+    /** Master enable switch (--classifier-router). */
+    classifierRouter?: boolean;
+    /** Strategy: "heuristic" (default) or "llm" (--classifier-strategy). */
+    classifierStrategy?: string;
+    /** LLM-classifier provider override (--classifier-model-provider). */
+    classifierModelProvider?: string;
+    /** LLM-classifier model override (--classifier-model-name). */
+    classifierModelName?: string;
+    /** LLM-classifier region override (--classifier-model-region). */
+    classifierModelRegion?: string;
+    /**
+     * Path to a JSON file OR inline JSON array of pool members
+     * (--classifier-pool). Each entry: { provider, model?, region?, description?,
+     * tiers?, cost?, quality?, capabilities?, id? }.
+     */
+    classifierPool?: string;
+    /** LLM-classifier hard timeout in ms (--classifier-timeout). */
+    classifierTimeout?: number;
+};

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

@@ -11,6 +11,7 @@ import type { AuthProvider, AuthProviderType, AuthProviderConfig, Auth0Config, C
 import type { NeurolinkCredentials } from "./providers.js";
 import type { ModelPoolConfig } from "./modelPool.js";
 import type { RequestRouter } from "./requestRouter.js";
+import type { ClassifierRouterConfig } from "./classifierRouter.js";
 /**
  * Main NeuroLink configuration type
  */
@@ -104,6 +105,15 @@ export type NeurolinkConstructorConfig = {
      * error proceeds unrouted.
      */
     requestRouter?: RequestRouter;
+    /**
+     * Pre-call classifier router: classifies each request by difficulty and
+     * selects a provider/model from a configured "available base" pool — routing
+     * harder tasks to more capable models and easier tasks to cheaper/faster
+     * ones — and optionally narrows the tool set. Opt-in (`enabled: false` by
+     * default) and fails open. Skipped when a `modelPool` is configured or the
+     * caller pinned both `provider` and `model`. See {@link ClassifierRouterConfig}.
+     */
+    classifierRouter?: ClassifierRouterConfig;
 };
 /**
  * Configuration for MCP enhancement modules wired into generate()/stream() paths.

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

@@ -71,3 +71,4 @@ export * from "./replicate.js";
 export * from "./safeFetch.js";
 export * from "./modelPool.js";
 export * from "./requestRouter.js";
+export * from "./classifierRouter.js";

package/dist/lib/types/index.js

@@ -80,4 +80,6 @@ export * from "./safeFetch.js";
 export * from "./modelPool.js";
 // RequestRouter — pluggable pre-call provider/model selection (M9.x+)
 export * from "./requestRouter.js";
+// ClassifierRouter — classify → pick model + tools from a base pool (M9.x+)
+export * from "./classifierRouter.js";
 //# sourceMappingURL=index.js.map

package/dist/neurolink.d.ts

@@ -112,6 +112,7 @@ export declare class NeuroLink {
     private readonly fallbackConfig;
     private readonly modelPool;
     private readonly requestRouter;
+    private readonly classifierRouter;
     /**
      * Merge instance-level credentials with per-call credentials.
      *
@@ -634,6 +635,19 @@ export declare class NeuroLink {
      * @param thinkingLevel — optional thinking level string from the call options.
      */
     private applyRequestRouter;
+    /**
+     * Applies the host-configured `classifierRouter` to `options` in place.
+     *
+     * Classifies the request by difficulty and selects a provider/model from the
+     * configured base pool (cheaper/faster for easy tasks, more capable for hard
+     * ones), and optionally narrows the tool set via `toolFilter`/`excludeTools`.
+     *
+     * Skipped when: no router is configured; the inbound call is the classifier's
+     * own generate() (marked `__classifierRouted`); the caller pinned BOTH
+     * provider and model; or a ModelPool is configured (the pool owns selection).
+     * Fails open — any error leaves options unchanged.
+     */
+    private applyClassifierRouting;
     private prepareGenerateAugmentations;
     private buildGenerateTextOptions;
     private finalizeGenerateRequestResult;

package/dist/neurolink.js

@@ -87,6 +87,7 @@ import { isNonNullObject } from "./utils/typeUtils.js";
 import { getWorkflow } from "./workflow/core/workflowRegistry.js";
 import { runWorkflow } from "./workflow/core/workflowRunner.js";
 import { ModelPool, classifyProviderError } from "./routing/index.js";
+import { ClassifierRouter } from "./routing/classifierRouter.js";
 import { looksLikeModelAccessDenied as sharedLooksLikeModelAccessDenied, isNonRetryableProviderError as sharedIsNonRetryableProviderError, } from "./utils/providerErrorClassification.js";
 /**
  * NL-002: Classify MCP error messages into categories for AI disambiguation.
@@ -388,6 +389,9 @@ export class NeuroLink {
     // RequestRouter: pluggable pre-call provider/model selector.
     // Stored directly from config.requestRouter; null when not configured.
     requestRouter;
+    // ClassifierRouter: opt-in "classify → pick model + tools" pre-call router.
+    // Built from config.classifierRouter; null when not configured.
+    classifierRouter;
     /**
      * Merge instance-level credentials with per-call credentials.
      *
@@ -796,6 +800,17 @@ export class NeuroLink {
         this.modelPool = config?.modelPool ? new ModelPool(config.modelPool) : null;
         // RequestRouter: store the host-supplied function; null when not configured.
         this.requestRouter = config?.requestRouter ?? null;
+        // ClassifierRouter: opt-in. The LLM strategy reuses this instance's
+        // generate() (marked so it never recursively re-routes). Fails open.
+        this.classifierRouter = config?.classifierRouter?.enabled
+            ? new ClassifierRouter(config.classifierRouter, {
+                generate: (genOptions) => this.generate(genOptions),
+                logger: {
+                    debug: (message, meta) => logger.debug(message, meta),
+                    warn: (message, meta) => logger.warn(message, meta),
+                },
+            })
+            : null;
         logger.setEventEmitter(this.emitter);
         // Read tool cache duration from environment variables, with a default
         const cacheDurationEnv = process.env.NEUROLINK_TOOL_CACHE_DURATION;
@@ -3105,6 +3120,13 @@ Current user's request: ${currentInput}`;
     }
     async runStandardGenerateRequest(options, originalPrompt, generateSpan) {
         const startTime = Date.now();
+        // Pre-call classifier router: opt-in. Classifies the request and selects a
+        // provider/model from the configured base pool (and optionally narrows the
+        // tool set) BEFORE orchestration/requestRouter, so it takes precedence.
+        // Fails open.
+        await this.applyClassifierRouting(options, options.input?.text ?? originalPrompt ?? "", !options.disableTools &&
+            (!!(options.tools && Object.keys(options.tools).length > 0) ||
+                this.getCustomTools().size > 0), !!(options.input?.images && options.input.images.length > 0), options.thinkingConfig?.thinkingLevel);
         await this.maybeApplyGenerateOrchestration(options);
         // Pre-call request router: opt-in, only when the caller did not set both
         // provider+model. Fails open (any router error leaves options unchanged).
@@ -3241,6 +3263,12 @@ Current user's request: ${currentInput}`;
         if (!this.requestRouter) {
             return;
         }
+        // Stand down if the classifier router already selected a provider/model on
+        // this turn — one explicit precedence order: classifierRouter wins.
+        if (options.context
+            ?.__classifierRouted) {
+            return;
+        }
         // Skip if the caller explicitly set both provider AND model — they know
         // what they want; the router should not override an intentional choice.
         if (options.provider && options.model) {
@@ -3307,6 +3335,103 @@ Current user's request: ${currentInput}`;
             });
         }
     }
+    /**
+     * Applies the host-configured `classifierRouter` to `options` in place.
+     *
+     * Classifies the request by difficulty and selects a provider/model from the
+     * configured base pool (cheaper/faster for easy tasks, more capable for hard
+     * ones), and optionally narrows the tool set via `toolFilter`/`excludeTools`.
+     *
+     * Skipped when: no router is configured; the inbound call is the classifier's
+     * own generate() (marked `__classifierRouted`); the caller pinned BOTH
+     * provider and model; or a ModelPool is configured (the pool owns selection).
+     * Fails open — any error leaves options unchanged.
+     */
+    async applyClassifierRouting(options, promptText, hasTools, requiresVision, thinkingLevel) {
+        if (!this.classifierRouter) {
+            return;
+        }
+        const opt = options;
+        // Prevent recursion: the LLM classifier itself calls generate() with this
+        // marker set. Also respect any explicit prior routing decision.
+        if (opt.context?.__classifierRouted) {
+            return;
+        }
+        // Honor an intentional caller choice of BOTH provider and model.
+        if (options.provider && options.model) {
+            return;
+        }
+        // A ModelPool overrides provider/model per member unconditionally; let it
+        // own selection (mirrors applyRequestRouter precedence).
+        if (this.modelPool) {
+            logger.debug("[NeuroLink] applyClassifierRouting: skipped — modelPool takes precedence");
+            return;
+        }
+        const sessionId = typeof opt.context?.sessionId === "string"
+            ? opt.context.sessionId
+            : undefined;
+        try {
+            const decision = await this.classifierRouter.route({
+                prompt: promptText,
+                estimatedInputTokens: Math.ceil((promptText?.length ?? 0) / 4),
+                hasTools,
+                requiresVision,
+                thinkingLevel,
+                sessionId,
+            });
+            if (!decision) {
+                return;
+            }
+            // Apply provider/model/region as a coherent set (same discipline as
+            // applyRequestRouter): only fill fields the caller did not pin.
+            if (decision.provider && !options.provider) {
+                options.provider = decision.provider;
+                if (decision.model && !options.model) {
+                    options.model = decision.model;
+                }
+                if (decision.region && !options.region) {
+                    options.region = decision.region;
+                }
+            }
+            else if (!decision.provider && decision.model && !options.model) {
+                options.model = decision.model;
+            }
+            // Narrow tools unless the caller disabled tools entirely.
+            if (!opt.disableTools) {
+                if (decision.excludeTools && decision.excludeTools.length > 0) {
+                    opt.excludeTools = Array.from(new Set([...(opt.excludeTools ?? []), ...decision.excludeTools]));
+                }
+                if (decision.toolFilter && decision.toolFilter.length > 0) {
+                    const allow = decision.toolFilter;
+                    opt.toolFilter =
+                        opt.toolFilter && opt.toolFilter.length > 0
+                            ? opt.toolFilter.filter((t) => allow.includes(t))
+                            : [...allow];
+                }
+            }
+            // Mark routed so orchestration/requestRouter stand down this turn.
+            if (decision.provider || decision.model) {
+                const ctx = opt.context ?? {};
+                ctx.__classifierRouted = true;
+                opt.context = ctx;
+            }
+            if (decision.reason) {
+                logger.debug("[NeuroLink] classifierRouter decision", {
+                    reason: decision.reason,
+                    difficulty: decision.difficulty,
+                    provider: options.provider,
+                    model: options.model,
+                });
+            }
+        }
+        catch (classifierErr) {
+            logger.warn("[NeuroLink] classifierRouter threw — proceeding unrouted", {
+                error: classifierErr instanceof Error
+                    ? classifierErr.message
+                    : String(classifierErr),
+            });
+        }
+    }
     async prepareGenerateAugmentations(options) {
         if (options.rag?.files?.length) {
             try {
@@ -5829,6 +5954,12 @@ Current user's request: ${currentInput}`;
             // classify correctly. After the workflow short-circuit, so workflow
             // streams skip it.
             await context.with(streamSpanContext, () => this.setLangfuseContextFromOptions(options, () => this.applyToolRoutingExclusions(options, originalPrompt)));
+            // Pre-call classifier router for stream: opt-in, fails open. Runs before
+            // the request router so it takes precedence.
+            await this.applyClassifierRouting(options, originalPrompt, !options.disableTools &&
+                (!!(options.tools && Object.keys(options.tools).length > 0) ||
+                    this.getCustomTools().size > 0), !!(options.input?.images && options.input.images.length > 0), options
+                .thinking?.thinkingLevel);
             // Pre-call request router for stream: opt-in, fails open.
             await this.applyRequestRouter(options, originalPrompt, !options.disableTools &&
                 (!!(options.tools && Object.keys(options.tools).length > 0) ||

package/dist/routing/classifierRouter.d.ts

@@ -0,0 +1,52 @@
+/**
+ * ClassifierRouter — the single "classify → pick model + tools → run" engine.
+ *
+ * Given a request snapshot it (1) classifies difficulty (heuristic or a cheap
+ * LLM), (2) selects the best provider/model from the host-declared base pool —
+ * cheaper/faster for easy tiers, more capable for hard tiers — enriching pool
+ * members with real cost/quality metadata from the model registry, and
+ * (3) narrows the tool set via per-difficulty directives or classifier hints.
+ *
+ * Pure of provider imports (mirrors ModelPool): the LLM caller is injected.
+ * The only data dependency is the read-only `ModelResolver` registry lookup,
+ * used purely for metadata enrichment and never for provider construction.
+ */
+import type { ClassifierRouterConfig, ClassifierRouterDecision, ClassifierRouterDeps, ClassifierRouterInput } from "../types/index.js";
+export declare class ClassifierRouter {
+    private readonly config;
+    private readonly deps;
+    private readonly metaCache;
+    constructor(config: ClassifierRouterConfig, deps?: ClassifierRouterDeps);
+    /**
+     * Classify the request and produce a combined model + tool decision, or
+     * `null` when nothing should change. Never throws (fails open).
+     */
+    route(input: ClassifierRouterInput): Promise<ClassifierRouterDecision | null>;
+    /** Run the configured strategy; LLM falls back to heuristic on failure. */
+    private classify;
+    /**
+     * Build LLM-facing model descriptors + an id→member map so the classifier can
+     * pick a model directly. Works for ANY pool, registry-backed or not.
+     */
+    private buildCandidates;
+    /**
+     * Resolve the ranked model list for a decision. Prefers the LLM's direct pick
+     * (`selectedModelId`); otherwise falls back to difficulty-based tierMap /
+     * metadata scoring.
+     */
+    private selectModels;
+    /** Candidate members for a difficulty: explicit tierMap or eligible pool. */
+    private candidatesFor;
+    /** Drop members that cannot satisfy the required capabilities (lenient). */
+    private filterByCapabilities;
+    /** Rank candidates best-first for the difficulty's strategy. */
+    private rank;
+    /** Tool narrowing: per-difficulty directive, then classifier hints. */
+    private selectTools;
+    /**
+     * Resolve cost/quality/capabilities for a member. Declared values win;
+     * gaps are filled from the model registry (by model name/alias) when known.
+     * Results are cached per (provider/model) for the router's lifetime.
+     */
+    private metaFor;
+}