@juspay/neurolink 9.79.2 → 9.80.0

package/dist/lib/providers/googleVertex.js

@@ -22,7 +22,7 @@ import { convertZodToJsonSchema, inlineJsonSchema, ensureNestedSchemaTypes, } fr
 import { createNativeThinkingConfig } from "../utils/thinkingConfig.js";
 import { TimeoutError, withTimeout } from "../utils/async/index.js";
 import { parseTimeout } from "../utils/timeout.js";
-import { createTextChannel, extractThoughtSignature, prependConversationMessages, } from "./googleNativeGemini3.js";
+import { appendStepText, createTextChannel, extractThoughtSignature, mapGeminiFinishReason, prependConversationMessages, } from "./googleNativeGemini3.js";
 import { ATTR, LANGFUSE_ATTR, spanJsonAttribute, tracers, withClientSpan, withClientStreamSpan, withSpan, } from "../telemetry/index.js";
 import { SpanKind, SpanStatusCode, context as otelContext, trace as otelTrace, } from "@opentelemetry/api";
 import { calculateCost } from "../utils/pricing.js";
@@ -786,7 +786,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 // lifecycle callbacks. Pipeline A gets these via the AI SDK
                 // wrapStream middleware; the native path has to fire them here.
                 const wrappedResult = this.wrapStreamResultWithLifecycle(options, result, streamStartTime);
-                this.emitStreamEnd(modelName, streamStartTime, true);
+                this.emitStreamEnd(modelName, streamStartTime, true, undefined, result.finishReason);
                 return wrappedResult;
             }
             catch (error) {
@@ -801,7 +801,7 @@ export class GoogleVertexProvider extends BaseProvider {
      * `model.generation` span for native Vertex stream traffic. Mirrors
      * `emitGenerationEnd` (used by `generate()`).
      */
-    emitStreamEnd(modelName, startTime, success, error) {
+    emitStreamEnd(modelName, startTime, success, error, resolvedFinishReason) {
         const emitter = this.neurolink?.getEventEmitter();
         if (!emitter) {
             return;
@@ -815,7 +815,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 usage: { input: 0, output: 0, total: 0 },
                 model: modelName,
                 provider: this.providerName,
-                finishReason: success ? "stop" : "error",
+                finishReason: success ? (resolvedFinishReason ?? "stop") : "error",
             },
             success,
             ...(error
@@ -1156,7 +1156,10 @@ export class GoogleVertexProvider extends BaseProvider {
             : Math.min(DEFAULT_MAX_STEPS, 100);
         const currentContents = [...contents];
         let finalText = "";
-        let lastStepText = ""; // Track text from last step for maxSteps termination
+        // Last SDK finish reason seen across steps (Bug 2: previously never read,
+        // so callers fell back to "unknown"). Last non-empty value wins — the
+        // terminal chunk is authoritative.
+        let lastFinishReason;
         const allToolCalls = [];
         // Mirrors the generate-path shape so StreamResult.toolExecutions can be
         // populated (parity with AI-SDK-driven providers) and so the storage
@@ -1200,6 +1203,12 @@ export class GoogleVertexProvider extends BaseProvider {
                     const chunkRecord = chunk;
                     const candidates = chunkRecord.candidates;
                     const firstCandidate = candidates?.[0];
+                    // Capture the SDK finish reason (Bug 2: previously dropped). Last
+                    // non-empty value across chunks wins.
+                    const chunkFinishReason = firstCandidate?.finishReason;
+                    if (typeof chunkFinishReason === "string" && chunkFinishReason) {
+                        lastFinishReason = chunkFinishReason;
+                    }
                     const chunkContent = firstCandidate?.content;
                     if (chunkContent && Array.isArray(chunkContent.parts)) {
                         for (const part of chunkContent.parts) {
@@ -1253,8 +1262,6 @@ export class GoogleVertexProvider extends BaseProvider {
                         break;
                     }
                 }
-                // Track the last step text for maxSteps termination
-                lastStepText = stepText;
                 // Execute function calls
                 logger.debug(`[GoogleVertex] Executing ${stepFunctionCalls.length} function calls`);
                 // Add model response with ALL parts (including thoughtSignature) to history
@@ -1426,14 +1433,50 @@ export class GoogleVertexProvider extends BaseProvider {
                 throw this.handleProviderError(error);
             }
         }
-        // Handle maxSteps termination - if we exited the loop due to maxSteps being reached
+        // Handle maxSteps termination — the loop exited because the step cap was
+        // reached while the model was still calling tools. Surface a real answer
+        // instead of the canned placeholder (Bug 1) and a meaningful finishReason
+        // (Bug 2).
+        let hitStepLimit = false;
+        let synthesizedFinalAnswer = false;
         if (step >= maxSteps && !finalText) {
-            logger.warn(`[GoogleVertex] Tool call loop terminated after reaching maxSteps (${maxSteps}). ` +
-                `Model was still calling tools. Using accumulated text from last step.`);
-            finalText =
-                lastStepText ||
-                    `[Tool execution limit reached after ${maxSteps} steps. The model continued requesting tool calls beyond the limit.]`;
+            hitStepLimit = true;
+            // The consumer receives text via `incrementalTextChunks`; any text the
+            // model emitted across steps is already preserved there. Only synthesize
+            // when NOTHING was produced (the pure-functionCall case that otherwise
+            // surfaces the placeholder) so we never waste a round-trip whose output
+            // the stream would ignore.
+            if (incrementalTextChunks.length === 0) {
+                logger.warn(`[GoogleVertex] Tool call loop terminated after reaching maxSteps (${maxSteps}) ` +
+                    `with no text; synthesizing a final answer with tools disabled.`);
+                const synth = await this.synthesizeFinalAnswerWithoutTools(client, modelName, config, currentContents, useFinalResultTool, parseTimeout(options.timeout) ?? 300_000);
+                if (synth.text) {
+                    synthesizedFinalAnswer = true;
+                    finalText = synth.text;
+                    incrementalTextChunks.push(synth.text);
+                    totalInputTokens += synth.inputTokens;
+                    totalOutputTokens += synth.outputTokens;
+                    if (synth.finishReason) {
+                        lastFinishReason = synth.finishReason;
+                    }
+                }
+                else {
+                    finalText = `[Tool execution limit reached after ${maxSteps} steps. The model continued requesting tool calls beyond the limit.]`;
+                }
+            }
+            else {
+                logger.warn(`[GoogleVertex] Tool call loop terminated after reaching maxSteps (${maxSteps}); ` +
+                    `returning text already gathered from prior steps.`);
+            }
         }
+        // Unified finish reason: a step-cap exhaustion that did NOT end in a clean
+        // synthesized answer is reported as "tool-calls" (the model still wanted
+        // tools) — NOT "length", which neurolink.ts treats as token truncation
+        // (jsonTruncated + WARNING span). A clean completion maps from the SDK
+        // finish reason.
+        const resolvedFinishReason = hitStepLimit && !synthesizedFinalAnswer
+            ? "tool-calls"
+            : mapGeminiFinishReason(lastFinishReason);
         const responseTime = Date.now() - startTime;
         // Yield each text part separately so the CLI receives multiple stream
         // chunks instead of a single coalesced buffer. The SDK already gave us
@@ -1460,6 +1503,7 @@ export class GoogleVertexProvider extends BaseProvider {
             stream: createTextStream(),
             provider: this.providerName,
             model: modelName,
+            finishReason: resolvedFinishReason,
             usage: {
                 input: totalInputTokens,
                 output: totalOutputTokens,
@@ -1791,7 +1835,11 @@ export class GoogleVertexProvider extends BaseProvider {
             : Math.min(DEFAULT_MAX_STEPS, 100);
         const currentContents = [...contents];
         let finalText = "";
-        let lastStepText = ""; // Track text from last step for maxSteps termination
+        // Cross-step text accumulation + last SDK finish reason, so the
+        // maxSteps-exhaustion exit can surface real gathered text (Bug 1) and a
+        // meaningful finishReason (Bug 2) instead of a placeholder / "unknown".
+        let accumulatedText = "";
+        let lastFinishReason;
         const allToolCalls = [];
         const toolExecutions = [];
         let step = 0;
@@ -1826,6 +1874,12 @@ export class GoogleVertexProvider extends BaseProvider {
                     const chunkRecord = chunk;
                     const candidates = chunkRecord.candidates;
                     const firstCandidate = candidates?.[0];
+                    // Capture the SDK finish reason (Bug 2: previously dropped). Last
+                    // non-empty value across chunks wins.
+                    const chunkFinishReason = firstCandidate?.finishReason;
+                    if (typeof chunkFinishReason === "string" && chunkFinishReason) {
+                        lastFinishReason = chunkFinishReason;
+                    }
                     const chunkContent = firstCandidate?.content;
                     if (chunkContent && Array.isArray(chunkContent.parts)) {
                         rawResponseParts.push(...chunkContent.parts);
@@ -1874,8 +1928,11 @@ export class GoogleVertexProvider extends BaseProvider {
                         break;
                     }
                 }
-                // Track the last step text for maxSteps termination
-                lastStepText = stepText;
+                // Accumulate non-empty step text across steps so the
+                // maxSteps-exhaustion exit can surface the prose the model produced
+                // instead of a canned placeholder (Bug 1). Mirrors the Vertex-Claude
+                // loop's text accumulation.
+                accumulatedText = appendStepText(accumulatedText, stepText);
                 // Execute function calls
                 logger.debug(`[GoogleVertex] Generate executing ${stepFunctionCalls.length} function calls`);
                 // Add model response with ALL parts (including thoughtSignature) to history
@@ -2036,14 +2093,49 @@ export class GoogleVertexProvider extends BaseProvider {
                 throw this.handleProviderError(error);
             }
         }
-        // Handle maxSteps termination - if we exited the loop due to maxSteps being reached
+        // Handle maxSteps termination — the loop exited because the step cap was
+        // reached while the model was still calling tools. Surface a real answer
+        // instead of the canned placeholder (Bug 1) and a meaningful finishReason
+        // (Bug 2).
+        let hitStepLimit = false;
+        let synthesizedFinalAnswer = false;
         if (step >= maxSteps && !finalText) {
-            logger.warn(`[GoogleVertex] Generate tool call loop terminated after reaching maxSteps (${maxSteps}). ` +
-                `Model was still calling tools. Using accumulated text from last step.`);
-            finalText =
-                lastStepText ||
-                    `[Tool execution limit reached after ${maxSteps} steps. The model continued requesting tool calls beyond the limit.]`;
+            hitStepLimit = true;
+            if (accumulatedText) {
+                // Prefer the prose the model already produced across steps.
+                logger.warn(`[GoogleVertex] Generate tool call loop terminated after reaching maxSteps (${maxSteps}); ` +
+                    `returning text already gathered from prior steps.`);
+                finalText = accumulatedText;
+            }
+            else {
+                // Pure functionCall turns leave no text — make one tools-disabled call
+                // so the model answers from the gathered tool results instead of the
+                // canned placeholder.
+                logger.warn(`[GoogleVertex] Generate tool call loop terminated after reaching maxSteps (${maxSteps}) ` +
+                    `with no text; synthesizing a final answer with tools disabled.`);
+                const synth = await this.synthesizeFinalAnswerWithoutTools(client, modelName, config, currentContents, useFinalResultTool, parseTimeout(options.timeout) ?? 300_000);
+                if (synth.text) {
+                    synthesizedFinalAnswer = true;
+                    finalText = synth.text;
+                    totalInputTokens += synth.inputTokens;
+                    totalOutputTokens += synth.outputTokens;
+                    if (synth.finishReason) {
+                        lastFinishReason = synth.finishReason;
+                    }
+                }
+                else {
+                    finalText = `[Tool execution limit reached after ${maxSteps} steps. The model continued requesting tool calls beyond the limit.]`;
+                }
+            }
         }
+        // Unified finish reason: a step-cap exhaustion that did NOT end in a clean
+        // synthesized answer is reported as "tool-calls" (the model still wanted
+        // tools) — NOT "length", which neurolink.ts treats as token truncation
+        // (jsonTruncated + WARNING span). A clean completion maps from the SDK
+        // finish reason.
+        const resolvedFinishReason = hitStepLimit && !synthesizedFinalAnswer
+            ? "tool-calls"
+            : mapGeminiFinishReason(lastFinishReason);
         const responseTime = Date.now() - startTime;
         // Filter out final_result from tool calls and executions as it's an internal pattern
         const externalToolCalls = allToolCalls.filter((tc) => tc.toolName !== "final_result");
@@ -2053,6 +2145,7 @@ export class GoogleVertexProvider extends BaseProvider {
             content: finalText,
             provider: this.providerName,
             model: modelName,
+            finishReason: resolvedFinishReason,
             usage: {
                 input: totalInputTokens,
                 output: totalOutputTokens,
@@ -2073,6 +2166,89 @@ export class GoogleVertexProvider extends BaseProvider {
         // Vertex Gemini generate path.
         return this.enhanceResult(result, options, startTime);
     }
+    /**
+     * One-shot, tools-disabled model call used when a native Gemini agentic loop
+     * is force-terminated by the step cap with no text produced. Lets the model
+     * synthesize a final answer from the function results already in `contents`
+     * instead of returning a canned placeholder (Bug 1, part b).
+     *
+     * Tools are disabled by OMITTING `config.tools` — the codebase's established
+     * mechanism. `@google/genai`'s `FunctionCallingConfigMode.NONE` is documented
+     * as equivalent to passing no function declarations, and `functionCallingConfig`
+     * is not used anywhere in this codebase. When the structured-output
+     * (`final_result`) pattern was active, a trailing instruction countermands the
+     * earlier "you MUST call final_result" directive so the model answers in plain
+     * text. Never throws — returns empty text so the caller falls back to the
+     * placeholder, guaranteeing no new failure path.
+     */
+    async synthesizeFinalAnswerWithoutTools(client, modelName, config, contents, useFinalResultTool, timeoutMs) {
+        try {
+            // Shallow clone so the loop's config is never mutated; dropping the
+            // top-level `tools` key is sufficient (nested thinkingConfig /
+            // systemInstruction are intentionally preserved).
+            const synthConfig = { ...config };
+            delete synthConfig.tools;
+            if (useFinalResultTool) {
+                const baseSystemInstruction = typeof synthConfig.systemInstruction === "string"
+                    ? synthConfig.systemInstruction
+                    : "";
+                synthConfig.systemInstruction =
+                    baseSystemInstruction +
+                        "\n\nThe final_result tool is no longer available. Provide your " +
+                        "final answer directly as plain text now, using the information " +
+                        "gathered so far.";
+            }
+            // Bound the whole connect + drain with a timeout. The surrounding
+            // try/catch only catches throws, not hangs, so without this a stalled
+            // Vertex endpoint would hang the maxSteps recovery path indefinitely.
+            // On timeout withTimeout rejects (TimeoutError) and the catch below
+            // falls back to the placeholder — no new failure path is introduced.
+            return await withTimeout((async () => {
+                const stream = await client.models.generateContentStream({
+                    model: modelName,
+                    contents,
+                    config: synthConfig,
+                });
+                const parts = [];
+                let finishReason;
+                let inputTokens = 0;
+                let outputTokens = 0;
+                for await (const chunk of stream) {
+                    const chunkRecord = chunk;
+                    const candidates = chunkRecord.candidates;
+                    const firstCandidate = candidates?.[0];
+                    const chunkFinishReason = firstCandidate?.finishReason;
+                    if (typeof chunkFinishReason === "string" && chunkFinishReason) {
+                        finishReason = chunkFinishReason;
+                    }
+                    const chunkContent = firstCandidate?.content;
+                    if (chunkContent && Array.isArray(chunkContent.parts)) {
+                        parts.push(...chunkContent.parts);
+                    }
+                    const usageMetadata = chunkRecord.usageMetadata;
+                    if (usageMetadata) {
+                        if (usageMetadata.promptTokenCount !== undefined &&
+                            usageMetadata.promptTokenCount > 0) {
+                            inputTokens = usageMetadata.promptTokenCount;
+                        }
+                        if (usageMetadata.candidatesTokenCount !== undefined &&
+                            usageMetadata.candidatesTokenCount > 0) {
+                            outputTokens = usageMetadata.candidatesTokenCount;
+                        }
+                    }
+                }
+                const text = parts
+                    .filter((part) => typeof part.text === "string")
+                    .map((part) => part.text)
+                    .join("");
+                return { text, finishReason, inputTokens, outputTokens };
+            })(), timeoutMs, "Gemini synthesis call timed out");
+        }
+        catch (error) {
+            logger.warn("[GoogleVertex] Tools-disabled synthesis call failed; falling back to placeholder", { error: error instanceof Error ? error.message : String(error) });
+            return { text: "", inputTokens: 0, outputTokens: 0 };
+        }
+    }
     /**
      * Create native AnthropicVertex client for Claude models
      */
@@ -3685,7 +3861,7 @@ export class GoogleVertexProvider extends BaseProvider {
                     }
                     : undefined,
                 duration: Date.now() - startTime,
-                finishReason: "stop",
+                finishReason: result?.finishReason ?? "stop",
             });
             Promise.resolve(callbackResult).catch((err) => logger.warn(`[GoogleVertex] onFinish callback rejected: ${err instanceof Error ? err.message : String(err)}`));
         }
@@ -3890,7 +4066,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 usage,
                 model: modelName,
                 provider: this.providerName,
-                finishReason: success ? "stop" : "error",
+                finishReason: success ? (result?.finishReason ?? "stop") : "error",
             },
             success,
             ...(error

package/dist/lib/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;
+}

package/dist/lib/routing/classifierRouter.js

@@ -0,0 +1,269 @@
+/**
+ * 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 { classifyHeuristic, classifyLlm } from "./classifierStrategies.js";
+import { ModelResolver } from "../models/modelResolver.js";
+/** Maps a registry quality enum to a comparable numeric score. */
+const QUALITY_SCORE = { high: 3, medium: 2, low: 1 };
+/** How each difficulty ranks candidate members. */
+const DIFFICULTY_RANK_MODE = {
+    trivial: "cost-asc",
+    simple: "cost-asc",
+    moderate: "balanced",
+    hard: "quality-desc",
+    expert: "quality-desc",
+};
+/** Neutral default for an unknown numeric metric (keeps ordering stable). */
+const NEUTRAL = 0.5;
+/**
+ * Cap on the per-(provider,model) metadata cache so it can't grow unbounded in
+ * long-lived processes with large or dynamic pools. FIFO eviction.
+ */
+const MAX_META_CACHE_ENTRIES = 1000;
+export class ClassifierRouter {
+    config;
+    deps;
+    metaCache = new Map();
+    constructor(config, deps = {}) {
+        this.config = config;
+        this.deps = deps;
+    }
+    /**
+     * Classify the request and produce a combined model + tool decision, or
+     * `null` when nothing should change. Never throws (fails open).
+     */
+    async route(input) {
+        try {
+            // For the LLM strategy, hand the pool to the classifier so it can select
+            // a model directly — the generic path for custom/registry-less models.
+            const useLlm = this.config.classifier === "llm" && !!this.deps.generate;
+            const built = useLlm ? this.buildCandidates() : undefined;
+            const decision = await this.classify(input, built?.descriptors);
+            const ranked = this.selectModels(decision, built?.byId);
+            const primary = ranked[0];
+            const { toolFilter, excludeTools } = this.selectTools(decision);
+            if (!primary && !toolFilter && !excludeTools) {
+                return null;
+            }
+            return {
+                provider: primary?.provider,
+                model: primary?.model,
+                region: primary?.region,
+                difficulty: decision.difficulty,
+                modelFallbacks: ranked.slice(1),
+                toolFilter,
+                excludeTools,
+                reason: decision.reason,
+            };
+        }
+        catch (err) {
+            this.deps.logger?.warn?.("[ClassifierRouter] route failed — no-op", {
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return null;
+        }
+    }
+    /** Run the configured strategy; LLM falls back to heuristic on failure. */
+    async classify(input, candidates) {
+        if (this.config.classifier === "llm" && this.deps.generate) {
+            try {
+                return await classifyLlm(input, this.deps.generate, this.config.classifierModel, this.config.timeoutMs, candidates);
+            }
+            catch (err) {
+                this.deps.logger?.warn?.("[ClassifierRouter] LLM classify failed — using heuristic", { error: err instanceof Error ? err.message : String(err) });
+            }
+        }
+        return classifyHeuristic(input);
+    }
+    /**
+     * 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.
+     */
+    buildCandidates() {
+        const pool = this.config.pool ?? [];
+        const byId = new Map();
+        const used = new Set();
+        const descriptors = [];
+        pool.forEach((m, i) => {
+            let id = m.id ?? (m.model ? `${m.provider}/${m.model}` : m.provider);
+            if (used.has(id)) {
+                id = `${id}#${i}`;
+            }
+            used.add(id);
+            byId.set(id, m);
+            descriptors.push({
+                id,
+                provider: m.provider,
+                model: m.model,
+                description: m.description,
+                tiers: m.tiers,
+                capabilities: this.metaFor(m).capabilities,
+            });
+        });
+        return { descriptors, byId };
+    }
+    /**
+     * Resolve the ranked model list for a decision. Prefers the LLM's direct pick
+     * (`selectedModelId`); otherwise falls back to difficulty-based tierMap /
+     * metadata scoring.
+     */
+    selectModels(decision, byId) {
+        if (decision.selectedModelId && byId) {
+            const picked = byId.get(decision.selectedModelId);
+            if (picked) {
+                const rest = (this.config.pool ?? []).filter((m) => m !== picked);
+                const rankedRest = this.rank(this.filterByCapabilities(rest, decision.requiredCapabilities), decision.difficulty);
+                return [picked, ...rankedRest];
+            }
+        }
+        const eligible = this.candidatesFor(decision);
+        const capable = this.filterByCapabilities(eligible, decision.requiredCapabilities);
+        return this.rank(capable, decision.difficulty);
+    }
+    /** Candidate members for a difficulty: explicit tierMap or eligible pool. */
+    candidatesFor(decision) {
+        const tierMembers = this.config.tierMap?.[decision.difficulty];
+        if (tierMembers && tierMembers.length > 0) {
+            return tierMembers;
+        }
+        const pool = this.config.pool ?? [];
+        const eligible = pool.filter((m) => !m.tiers || m.tiers.includes(decision.difficulty));
+        return eligible.length > 0 ? eligible : pool;
+    }
+    /** Drop members that cannot satisfy the required capabilities (lenient). */
+    filterByCapabilities(members, required) {
+        if (!required || required.length === 0) {
+            return members;
+        }
+        const kept = members.filter((m) => {
+            const caps = this.metaFor(m).capabilities;
+            // Unknown capabilities → keep (don't starve the pool on missing metadata).
+            if (!caps || caps.length === 0) {
+                return true;
+            }
+            return required.every((c) => caps.includes(c));
+        });
+        return kept.length > 0 ? kept : members;
+    }
+    /** Rank candidates best-first for the difficulty's strategy. */
+    rank(members, difficulty) {
+        const mode = DIFFICULTY_RANK_MODE[difficulty];
+        const originalIndex = new Map(members.map((m, i) => [m, i]));
+        const num = (v) => (typeof v === "number" ? v : NEUTRAL);
+        return [...members].sort((a, b) => {
+            const ma = this.metaFor(a);
+            const mb = this.metaFor(b);
+            let delta;
+            if (mode === "cost-asc") {
+                delta = num(ma.cost) - num(mb.cost);
+            }
+            else if (mode === "quality-desc") {
+                delta = num(mb.quality) - num(ma.quality);
+            }
+            else {
+                // balanced: maximize quality-minus-cost
+                delta =
+                    num(mb.quality) - num(mb.cost) - (num(ma.quality) - num(ma.cost));
+            }
+            if (delta !== 0) {
+                return delta;
+            }
+            const weightDelta = (b.weight ?? 1) - (a.weight ?? 1);
+            if (weightDelta !== 0) {
+                return weightDelta;
+            }
+            // Stable: preserve declared pool order on a tie.
+            return (originalIndex.get(a) ?? 0) - (originalIndex.get(b) ?? 0);
+        });
+    }
+    /** Tool narrowing: per-difficulty directive, then classifier hints. */
+    selectTools(decision) {
+        const directive = this.config.toolDirectives?.[decision.difficulty];
+        let toolFilter = directive?.toolFilter
+            ? [...directive.toolFilter]
+            : undefined;
+        const excludeTools = directive?.excludeTools
+            ? [...directive.excludeTools]
+            : undefined;
+        // When no explicit allowlist is configured, honor the classifier's hint.
+        if ((!toolFilter || toolFilter.length === 0) &&
+            decision.suggestedTools &&
+            decision.suggestedTools.length > 0) {
+            toolFilter = [...decision.suggestedTools];
+        }
+        return { toolFilter, excludeTools };
+    }
+    /**
+     * 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.
+     */
+    metaFor(member) {
+        const key = `${member.provider}::${member.model ?? ""}`;
+        const cached = this.metaCache.get(key);
+        if (cached) {
+            return cached;
+        }
+        let cost = member.cost;
+        let quality = member.quality;
+        let capabilities = member.capabilities
+            ? [...member.capabilities]
+            : undefined;
+        const needsEnrichment = cost === undefined || quality === undefined || capabilities === undefined;
+        if (needsEnrichment && member.model) {
+            try {
+                const info = ModelResolver.resolveModel(member.model);
+                if (info) {
+                    if (cost === undefined) {
+                        cost = info.pricing.inputCostPer1K + info.pricing.outputCostPer1K;
+                    }
+                    if (quality === undefined) {
+                        quality = QUALITY_SCORE[info.performance.quality] ?? NEUTRAL;
+                    }
+                    if (capabilities === undefined) {
+                        const caps = [];
+                        if (info.capabilities.vision) {
+                            caps.push("vision");
+                        }
+                        if (info.capabilities.functionCalling) {
+                            caps.push("tools");
+                        }
+                        if (info.capabilities.reasoning) {
+                            caps.push("reasoning");
+                        }
+                        if (info.capabilities.codeGeneration) {
+                            caps.push("code");
+                        }
+                        if (info.capabilities.multimodal) {
+                            caps.push("multimodal");
+                        }
+                        capabilities = caps;
+                    }
+                }
+            }
+            catch {
+                // Enrichment is best-effort; ignore registry lookup failures.
+            }
+        }
+        const meta = { cost, quality, capabilities };
+        if (this.metaCache.size >= MAX_META_CACHE_ENTRIES) {
+            const oldest = this.metaCache.keys().next().value;
+            if (oldest !== undefined) {
+                this.metaCache.delete(oldest);
+            }
+        }
+        this.metaCache.set(key, meta);
+        return meta;
+    }
+}
+//# sourceMappingURL=classifierRouter.js.map