@juspay/neurolink 9.79.2 → 9.80.0

package/dist/lib/routing/classifierStrategies.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Classification strategies for the ClassifierRouter.
+ *
+ * - `classifyHeuristic` — zero-cost, no LLM. Generalizes the existing binary
+ *   task classifier scorer (fast vs reasoning) into five difficulty tiers.
+ * - `classifyLlm` — runs a cheap "classifier model" via an injected generate
+ *   function, asking for a schema-constrained difficulty verdict. Falls back to
+ *   the heuristic on any failure.
+ */
+import type { ClassifierCandidate, ClassifierDecision, ClassifierDifficulty, ClassifierGenerateFn, ClassifierModelRef, ClassifierRouterInput } from "../types/index.js";
+/** Difficulty tiers, ordered easiest → hardest. */
+export declare const CLASSIFIER_DIFFICULTIES: ClassifierDifficulty[];
+/**
+ * Heuristic classifier — maps the binary fast/reasoning scores plus prompt
+ * length into one of five difficulty tiers. Deterministic and dependency-free.
+ */
+export declare function classifyHeuristic(input: ClassifierRouterInput): ClassifierDecision;
+/**
+ * LLM classifier — asks a cheap model for a schema-constrained verdict.
+ * Falls back to the heuristic if the model is unavailable, times out, or
+ * returns output that does not match the schema.
+ */
+export declare function classifyLlm(input: ClassifierRouterInput, generate: ClassifierGenerateFn, classifierModel?: ClassifierModelRef, timeoutMs?: number, candidates?: ClassifierCandidate[]): Promise<ClassifierDecision>;

package/dist/lib/routing/classifierStrategies.js

@@ -0,0 +1,156 @@
+/**
+ * Classification strategies for the ClassifierRouter.
+ *
+ * - `classifyHeuristic` — zero-cost, no LLM. Generalizes the existing binary
+ *   task classifier scorer (fast vs reasoning) into five difficulty tiers.
+ * - `classifyLlm` — runs a cheap "classifier model" via an injected generate
+ *   function, asking for a schema-constrained difficulty verdict. Falls back to
+ *   the heuristic on any failure.
+ */
+import { z } from "zod";
+import { analyzePrompt, calculateConfidence, } from "../utils/taskClassificationUtils.js";
+import { withTimeout } from "../utils/async/index.js";
+/** Difficulty tiers, ordered easiest → hardest. */
+export const CLASSIFIER_DIFFICULTIES = [
+    "trivial",
+    "simple",
+    "moderate",
+    "hard",
+    "expert",
+];
+/**
+ * Add capability tags implied by the request shape (vision/tools) to a set the
+ * classifier already produced.
+ */
+function withRequestCapabilities(input, base) {
+    const caps = new Set(base ?? []);
+    if (input.requiresVision) {
+        caps.add("vision");
+    }
+    if (input.hasTools) {
+        caps.add("tools");
+    }
+    return caps.size > 0 ? Array.from(caps) : undefined;
+}
+/**
+ * Heuristic classifier — maps the binary fast/reasoning scores plus prompt
+ * length into one of five difficulty tiers. Deterministic and dependency-free.
+ */
+export function classifyHeuristic(input) {
+    const prompt = input.prompt ?? "";
+    const { fastScore, reasoningScore, reasons } = analyzePrompt(prompt);
+    const net = reasoningScore - fastScore;
+    const len = prompt.trim().length;
+    let difficulty;
+    if (fastScore === 0 && reasoningScore === 0) {
+        // No signal — fall back to length as a weak proxy.
+        difficulty = len < 80 ? "simple" : len < 400 ? "moderate" : "hard";
+    }
+    else if (net <= -2) {
+        difficulty = "trivial";
+    }
+    else if (net <= 0) {
+        difficulty = "simple";
+    }
+    else if (net <= 3) {
+        difficulty = "moderate";
+    }
+    else if (net <= 7) {
+        difficulty = "hard";
+    }
+    else {
+        difficulty = "expert";
+    }
+    return {
+        difficulty,
+        confidence: calculateConfidence(fastScore, reasoningScore),
+        requiredCapabilities: withRequestCapabilities(input),
+        reason: `heuristic: net=${net}, len=${len}${reasons.length ? ` (${reasons.slice(0, 3).join("; ")})` : ""}`,
+    };
+}
+/** Schema the LLM classifier is forced to answer with. */
+const classifierOutputSchema = z.object({
+    difficulty: z.enum(["trivial", "simple", "moderate", "hard", "expert"]),
+    confidence: z.number().min(0).max(1).optional(),
+    requiredCapabilities: z.array(z.string()).optional(),
+    suggestedTools: z.array(z.string()).optional(),
+    selectedModelId: z.string().optional(),
+    reason: z.string().optional(),
+});
+const CLASSIFIER_SYSTEM_PROMPT = [
+    "You are a routing classifier inside an AI gateway.",
+    "Classify the user's task by difficulty into EXACTLY one of:",
+    "trivial, simple, moderate, hard, expert.",
+    "Judge by reasoning depth, number of steps, domain expertise required, and ambiguity.",
+    "Greetings/lookups/one-liners are trivial/simple; multi-step analysis, design,",
+    "or expert-domain work is hard/expert.",
+    'Also list required model capabilities (e.g. "vision", "tools", "reasoning")',
+    "and, only if obvious, the names of tools the task needs.",
+    "If a list of available models is provided, also set selectedModelId to the",
+    "single best model id for this task.",
+    "Respond ONLY via the structured schema.",
+].join(" ");
+/**
+ * LLM classifier — asks a cheap model for a schema-constrained verdict.
+ * Falls back to the heuristic if the model is unavailable, times out, or
+ * returns output that does not match the schema.
+ */
+export async function classifyLlm(input, generate, classifierModel, timeoutMs, candidates) {
+    const lines = [
+        "Task to classify:",
+        '"""',
+        (input.prompt ?? "").slice(0, 4000),
+        '"""',
+        `hasTools=${!!input.hasTools} requiresVision=${!!input.requiresVision}`,
+    ];
+    if (candidates && candidates.length > 0) {
+        lines.push("", "Available models — pick the single best `id` for THIS task:");
+        for (const c of candidates) {
+            const bits = [c.provider + (c.model ? `/${c.model}` : "")];
+            if (c.description) {
+                bits.push(c.description);
+            }
+            if (c.tiers && c.tiers.length > 0) {
+                bits.push(`tiers: ${c.tiers.join("/")}`);
+            }
+            if (c.capabilities && c.capabilities.length > 0) {
+                bits.push(`caps: ${c.capabilities.join(",")}`);
+            }
+            lines.push(`- id="${c.id}": ${bits.join(" — ")}`);
+        }
+        lines.push("", "Set selectedModelId to the chosen id (omit if unsure).");
+    }
+    // `timeout` lets the provider abort its own request; withTimeout adds a hard
+    // wall-clock ceiling so a stalled classifier call can never block the turn.
+    // A TimeoutError propagates to ClassifierRouter.classify(), which falls back
+    // to the heuristic (fail-open).
+    const hardTimeoutMs = timeoutMs ?? 8000;
+    const result = await withTimeout(generate({
+        input: { text: lines.join("\n") },
+        systemPrompt: CLASSIFIER_SYSTEM_PROMPT,
+        provider: classifierModel?.provider,
+        model: classifierModel?.model,
+        region: classifierModel?.region,
+        temperature: classifierModel?.temperature ?? 0,
+        disableTools: true,
+        schema: classifierOutputSchema,
+        timeout: hardTimeoutMs,
+        // Marker consumed by NeuroLink.applyClassifierRouting to prevent the
+        // classifier's own generate() call from recursively re-routing.
+        context: { __classifierRouted: true },
+    }), hardTimeoutMs, `Classifier LLM call exceeded ${hardTimeoutMs}ms`);
+    const parsed = classifierOutputSchema.safeParse(result?.structuredData);
+    if (!parsed.success) {
+        return classifyHeuristic(input);
+    }
+    const d = parsed.data;
+    return {
+        difficulty: d.difficulty,
+        confidence: d.confidence ?? 0.7,
+        requiredCapabilities: withRequestCapabilities(input, d.requiredCapabilities),
+        suggestedTools: d.suggestedTools,
+        selectedModelId: d.selectedModelId,
+        reason: d.reason ?? "llm classifier",
+    };
+}
+//# sourceMappingURL=classifierStrategies.js.map

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

@@ -5,3 +5,5 @@
  */
 export { classifyProviderError, ModelPool } from "./modelPool.js";
 export { createDefaultRequestRouter } from "./requestRouter.js";
+export { ClassifierRouter } from "./classifierRouter.js";
+export { classifyHeuristic, classifyLlm } from "./classifierStrategies.js";

package/dist/lib/routing/index.js

@@ -5,4 +5,6 @@
  */
 export { classifyProviderError, ModelPool } from "./modelPool.js";
 export { createDefaultRequestRouter } from "./requestRouter.js";
+export { ClassifierRouter } from "./classifierRouter.js";
+export { classifyHeuristic, classifyLlm } from "./classifierStrategies.js";
 //# sourceMappingURL=index.js.map

package/dist/lib/session/globalSessionState.d.ts

@@ -1,10 +1,12 @@
 import { NeuroLink } from "../neurolink.js";
-import type { ConversationMemoryConfig, LoopSessionState, SessionVariableValue, ToolRoutingConfig } from "../types/index.js";
+import type { ClassifierRouterConfig, ConversationMemoryConfig, LoopSessionState, SessionVariableValue, ToolRoutingConfig } from "../types/index.js";
 export declare class GlobalSessionManager {
     private static instance;
     private loopSession;
     /** Optional tool-routing config set by CLI handlers before SDK construction. */
     private _toolRoutingConfig;
+    /** Optional classifier-router config set by CLI handlers before SDK construction. */
+    private _classifierRouterConfig;
     static getInstance(): GlobalSessionManager;
     setLoopSession(config?: ConversationMemoryConfig): string;
     /**
@@ -42,6 +44,13 @@ export declare class GlobalSessionManager {
      * already exists).
      */
     setToolRoutingConfig(config: ToolRoutingConfig): void;
+    /**
+     * Store a classifier-router config to be injected at SDK construction time.
+     * Call this BEFORE `getOrCreateNeuroLink()` inside a command handler.
+     * When a loop session is already active the config is ignored (the instance
+     * already exists).
+     */
+    setClassifierRouterConfig(config: ClassifierRouterConfig): void;
     getOrCreateNeuroLink(): NeuroLink;
     getCurrentSessionId(): string | undefined;
     setSessionVariable(key: string, value: SessionVariableValue): void;

package/dist/lib/session/globalSessionState.js

@@ -33,6 +33,8 @@ export class GlobalSessionManager {
     loopSession = null;
     /** Optional tool-routing config set by CLI handlers before SDK construction. */
     _toolRoutingConfig = undefined;
+    /** Optional classifier-router config set by CLI handlers before SDK construction. */
+    _classifierRouterConfig = undefined;
     static getInstance() {
         if (!GlobalSessionManager.instance) {
             GlobalSessionManager.instance = new GlobalSessionManager();
@@ -141,6 +143,18 @@ export class GlobalSessionManager {
         }
         this._toolRoutingConfig = config;
     }
+    /**
+     * Store a classifier-router config to be injected at SDK construction time.
+     * Call this BEFORE `getOrCreateNeuroLink()` inside a command handler.
+     * When a loop session is already active the config is ignored (the instance
+     * already exists).
+     */
+    setClassifierRouterConfig(config) {
+        if (this.hasActiveSession()) {
+            return;
+        }
+        this._classifierRouterConfig = config;
+    }
     getOrCreateNeuroLink() {
         const session = this.getLoopSession();
         if (session) {
@@ -160,6 +174,10 @@ export class GlobalSessionManager {
             options.toolRouting = this._toolRoutingConfig;
             this._toolRoutingConfig = undefined;
         }
+        if (this._classifierRouterConfig) {
+            options.classifierRouter = this._classifierRouterConfig;
+            this._classifierRouterConfig = undefined;
+        }
         return new NeuroLink(Object.keys(options).length ? options : undefined);
     }
     getCurrentSessionId() {

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;