nexus-ai-pro 2.1.0 → 2.3.0

package/dist-cjs/rag/rerankers.d.ts

@@ -0,0 +1,92 @@
+import type { Reranker } from './retrievers.js';
+/** Raised when a rerank API answers with an error. */
+export declare class RerankerError extends Error {
+    /** The HTTP status the API answered with. */
+    readonly status: number;
+    /** The API's response body, as text. */
+    readonly body?: string | undefined;
+    constructor(message: string, 
+    /** The HTTP status the API answered with. */
+    status: number, 
+    /** The API's response body, as text. */
+    body?: string | undefined);
+}
+/** What every HTTP reranker takes. */
+export interface RerankerHttpOptions {
+    /** Replaces the global `fetch`, for a proxy, retries, or tests. */
+    fetch?: typeof globalThis.fetch;
+    /** Headers added to every request. */
+    headers?: Record<string, string>;
+    /** Aborts a request that takes longer, in milliseconds. Defaults to 30 seconds. */
+    timeoutMs?: number;
+    /** Characters of each chunk sent. Defaults to 4,000. */
+    maxChunkCharacters?: number;
+}
+/** Options for a hosted rerank API. */
+export interface HostedRerankerOptions extends RerankerHttpOptions {
+    /** The API key. */
+    apiKey: string;
+    /** The rerank model, such as `rerank-v3.5`. */
+    model: string;
+    /** Replaces the API's endpoint, for a regional or proxied one. */
+    url?: string;
+}
+/** Options for `httpReranker()`: any rerank API, described by its request and its response. */
+export interface HttpRerankerOptions extends RerankerHttpOptions {
+    /** The endpoint. */
+    url: string;
+    /** The request body for a query and its passages. */
+    body: (query: string, passages: string[]) => unknown;
+    /** Reads the response: each passage's index and score. Passages it leaves out score 0. */
+    scores: (response: unknown) => ReadonlyArray<{
+        index: number;
+        score: number;
+    }>;
+}
+/**
+ * A reranker over any HTTP rerank API: you describe the request body and how to read the scores,
+ * and it handles the rest — truncation, the timeout, cancellation, errors, and scores put back in
+ * the order of the chunks.
+ */
+export declare function httpReranker(options: HttpRerankerOptions): Reranker;
+/** Cohere's rerank API (`/v2/rerank`), such as `rerank-v3.5`. */
+export declare function cohereReranker(options: HostedRerankerOptions): Reranker;
+/** Voyage AI's rerank API (`/v1/rerank`), such as `rerank-2`. */
+export declare function voyageReranker(options: HostedRerankerOptions): Reranker;
+/** Jina AI's rerank API (`/v1/rerank`), such as `jina-reranker-v2-base-multilingual`. */
+export declare function jinaReranker(options: HostedRerankerOptions): Reranker;
+/** Options for `teiReranker()`. */
+export interface TeiRerankerOptions extends RerankerHttpOptions {
+    /** The server, such as `http://localhost:8080`. */
+    url: string;
+}
+/**
+ * A cross-encoder served by Hugging Face's text-embeddings-inference, on your own machine or
+ * cluster: `docker run ... --model-id BAAI/bge-reranker-base`, then `teiReranker({ url })`. The
+ * scores are the model's own, from 0 to 1.
+ */
+export declare function teiReranker(options: TeiRerankerOptions): Reranker;
+/**
+ * A cross-encoder run in process: one score per (query, passage) pair, higher meaning more relevant.
+ * A model from an ONNX runtime or a transformers library fits it in a few lines, so the package
+ * depends on neither.
+ */
+export interface CrossEncoder {
+    /** Scores each pair, in order. */
+    score(pairs: ReadonlyArray<readonly [query: string, passage: string]>): Promise<readonly number[]> | readonly number[];
+}
+/** Options for `crossEncoderReranker()`. */
+export interface CrossEncoderRerankerOptions {
+    /** Pairs scored in one call. Defaults to 32. */
+    batchSize?: number;
+    /** Characters of each chunk scored. Defaults to 2,000. */
+    maxChunkCharacters?: number;
+    /** Maps raw logits to 0–1 with a sigmoid, for a model that returns logits. Defaults to false. */
+    sigmoid?: boolean;
+}
+/**
+ * A reranker over a cross-encoder you run in process: no network call, no per-query price, and the
+ * passages never leave the machine. Pairs are scored in batches, and the run's signal is checked
+ * between batches.
+ */
+export declare function crossEncoderReranker(model: CrossEncoder, options?: CrossEncoderRerankerOptions): Reranker;

package/dist-cjs/rag/rerankers.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RerankerError = void 0;
+exports.httpReranker = httpReranker;
+exports.cohereReranker = cohereReranker;
+exports.voyageReranker = voyageReranker;
+exports.jinaReranker = jinaReranker;
+exports.teiReranker = teiReranker;
+exports.crossEncoderReranker = crossEncoderReranker;
+const signals_js_1 = require("../utils/signals.js");
+class RerankerError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = 'RerankerError';
+    }
+}
+exports.RerankerError = RerankerError;
+function httpReranker(options) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const limit = options.maxChunkCharacters ?? 4_000;
+    return async (query, chunks, signal) => {
+        if (chunks.length === 0)
+            return [];
+        const passages = chunks.map((chunk) => chunk.content.slice(0, limit));
+        const linked = (0, signals_js_1.linkSignals)([AbortSignal.timeout(options.timeoutMs ?? 30_000), signal]);
+        try {
+            const response = await fetchImpl(options.url, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json', ...options.headers },
+                body: JSON.stringify(options.body(query, passages)),
+                signal: linked.signal,
+            });
+            const text = await response.text();
+            if (!response.ok)
+                throw new RerankerError(`The rerank API answered ${response.status}`, response.status, text);
+            const scores = new Array(chunks.length).fill(0);
+            for (const { index, score } of options.scores(JSON.parse(text))) {
+                if (Number.isInteger(index) && index >= 0 && index < scores.length)
+                    scores[index] = Number(score);
+            }
+            return scores;
+        }
+        finally {
+            linked.dispose();
+        }
+    };
+}
+const bearer = (options) => ({ authorization: `Bearer ${options.apiKey}`, ...options.headers });
+const readScored = (list) => (list ?? []).map((item) => ({ index: item.index, score: item.relevance_score }));
+function cohereReranker(options) {
+    return httpReranker({
+        ...options,
+        url: options.url ?? 'https://api.cohere.com/v2/rerank',
+        headers: bearer(options),
+        body: (query, documents) => ({ model: options.model, query, documents, top_n: documents.length }),
+        scores: (response) => readScored(response.results),
+    });
+}
+function voyageReranker(options) {
+    return httpReranker({
+        ...options,
+        url: options.url ?? 'https://api.voyageai.com/v1/rerank',
+        headers: bearer(options),
+        body: (query, documents) => ({ model: options.model, query, documents, top_k: documents.length }),
+        scores: (response) => readScored(response.data),
+    });
+}
+function jinaReranker(options) {
+    return httpReranker({
+        ...options,
+        url: options.url ?? 'https://api.jina.ai/v1/rerank',
+        headers: bearer(options),
+        body: (query, documents) => ({ model: options.model, query, documents, top_n: documents.length }),
+        scores: (response) => readScored(response.results),
+    });
+}
+function teiReranker(options) {
+    return httpReranker({
+        ...options,
+        url: `${options.url.replace(/\/+$/, '')}/rerank`,
+        body: (query, texts) => ({ query, texts, raw_scores: false, truncate: true }),
+        scores: (response) => response,
+    });
+}
+function crossEncoderReranker(model, options = {}) {
+    const batchSize = Math.max(1, options.batchSize ?? 32);
+    const limit = options.maxChunkCharacters ?? 2_000;
+    return async (query, chunks, signal) => {
+        const pairs = chunks.map((chunk) => [query, chunk.content.slice(0, limit)]);
+        const scores = [];
+        for (let start = 0; start < pairs.length; start += batchSize) {
+            signal?.throwIfAborted();
+            const batch = pairs.slice(start, start + batchSize);
+            const result = await model.score(batch);
+            if (result.length !== batch.length) {
+                throw new RangeError(`The cross-encoder returned ${result.length} scores for ${batch.length} pairs`);
+            }
+            for (const raw of result)
+                scores.push(options.sigmoid ? 1 / (1 + Math.exp(-raw)) : raw);
+        }
+        return scores;
+    };
+}

package/dist-cjs/rag/retrievers.d.ts

@@ -19,6 +19,17 @@ export interface Retriever {
     /** The chunks that best answer a query, best first. */
     retrieve(query: string, options?: RetrieveOptions): Promise<VectorSearchResult[]>;
 }
+/**
+ * Keyword search that holds its own chunks: an in-memory BM25 `KeywordIndex`, Postgres full-text
+ * search, a search engine. It is a `Retriever`, so `hybridRetriever()` fuses it with vector search,
+ * and it takes writes, so ingestion keeps it in step with a vector store.
+ */
+export interface SparseRetriever extends Retriever {
+    /** Adds chunks, or replaces those whose id exists. */
+    add(chunks: readonly RagChunk[]): Promise<void> | void;
+    /** Removes chunks by id. An id that is not held is ignored. */
+    delete(ids: readonly string[]): Promise<void> | void;
+}
 /** A client that runs one completion — a `NexusAI` instance, or anything with the same `complete()`. */
 export interface RetrievalModelClient {
     /** Runs one completion and returns its text. */
@@ -47,7 +58,7 @@ export declare function tokenize(text: string): string[];
  * codes, error numbers, names — that keyword search finds; `hybridRetriever()` fuses the two.
  * Adding a chunk whose id exists replaces it, as in a vector store.
  */
-export declare class KeywordIndex implements Retriever {
+export declare class KeywordIndex implements SparseRetriever {
     private readonly chunks;
     private readonly postings;
     private totalLength;

package/dist-cjs/router/auto-router.d.ts

@@ -1,14 +1,37 @@
 import type { RouterContext, RouteDecision } from './types.js';
+/**
+ * Ranks configured providers' models for a request routed as `auto`.
+ *
+ * Everything that depends only on configuration — which models are candidates, which pass the
+ * allow and deny lists and the capability requirements, and how each scores for the strategy — is
+ * computed once into a plan and kept until the configuration changes. A request pays only for what
+ * can differ between requests: which circuits are open, and provider health.
+ */
 export declare class AutoRouter {
+    private readonly plans;
+    private readonly patterns;
+    private readonly registryIds;
+    /** Routes one request: the best candidate first, every other as a fallback in order. */
     route(ctx: RouterContext): RouteDecision;
+    /** Plans cached by this router, for tests and diagnostics. */
+    get planCount(): number;
+    /** The plan for a request's configuration, built on first use and kept until the configuration changes. */
+    private plan;
     /**
-     * Drops providers whose circuit is open.
-     *
-     * If that would leave nothing to route to, the original list is kept instead. Every circuit being
-     * open usually means a shared dependency is down rather than every provider individually, and
-     * attempting one call is strictly better than failing the request without trying anything.
+     * What a plan depends on, normalized into a string: the routing settings, the model settings, and
+     * the configured providers. A registry is identified by its object, so replacing
+     * `models.registry` builds a new plan; changing one in place does not.
      */
-    private withoutOpenCircuits;
+    private planKey;
+    private registryId;
+    private buildPlan;
+    /**
+     * The plan's candidates in order for this request. Providers whose circuit is open are left out,
+     * unless that would leave nothing: every circuit open usually means a shared dependency is down,
+     * and one attempt is strictly better than failing without trying. Health moves a whole provider
+     * up or down, so the per-provider lists are merged by their adjusted scores rather than re-sorted.
+     */
+    private rank;
     private getCandidates;
     /**
      * Scores a model for a strategy. For privacy, a model counts as local when its name says so or when
@@ -16,15 +39,19 @@ export declare class AutoRouter {
      * is preferred without renaming its models.
      */
     private score;
+    private capabilitiesOf;
     private localFallbackCapabilities;
     private costScore;
     private speedScore;
     private qualityScore;
     private preferencesForProvider;
     private isAllowed;
+    /** Whether a model meets the routing requirements: the boolean ones as two bitmask tests, the rest by value. */
     private matchesRequirements;
+    /** Whether a model name matches an allow or deny entry, with `*` as a wildcard. Patterns are compiled once. */
     private matchesModelPattern;
     private isProviderRunnable;
-    private healthScore;
+    /** Each provider's health adjustment for this request, or nothing when health does not apply. */
+    private healthOffsets;
 }
 export declare function routeDirectModel(model: string, ctx: RouterContext): RouteDecision;

package/dist-cjs/router/auto-router.js

@@ -3,38 +3,140 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutoRouter = void 0;
 exports.routeDirectModel = routeDirectModel;
 const registry_js_1 = require("../models/registry.js");
+const PLAN_LIMIT = 16;
+const BOOLEAN_CAPABILITIES = ['streaming', 'toolCalling', 'structuredOutputs', 'jsonMode', 'reasoning'];
 class AutoRouter {
+    plans = new Map();
+    patterns = new Map();
+    registryIds = new WeakMap();
     route(ctx) {
-        const strategy = ctx.config.routing?.strategy || 'quality';
-        const candidates = this.withoutOpenCircuits(this.getCandidates(ctx), ctx).map((candidate) => ({
-            ...candidate,
-            score: this.score(candidate.model, strategy, ctx.config, ctx.providers.get(candidate.providerName)?.info?.isLocal === true) +
-                candidate.weight +
-                this.healthScore(candidate.providerName, ctx),
-            reason: `auto route by ${strategy} score`,
-        }));
-        candidates.sort((a, b) => b.score - a.score);
-        const winner = candidates[0];
+        const plan = this.plan(ctx);
+        const ranked = this.rank(plan, ctx);
+        const winner = ranked[0];
         if (!winner) {
             throw new Error('No configured providers are available for routing');
         }
         return {
             providerName: winner.providerName,
             model: winner.model,
-            reason: `${winner.reason}: ${winner.model}`,
-            fallbacks: candidates.slice(1).map((c) => ({ providerName: c.providerName, model: c.model })),
+            reason: `auto route by ${plan.strategy} score: ${winner.model}`,
+            fallbacks: ranked.slice(1).map((candidate) => candidate.attempt),
         };
     }
-    withoutOpenCircuits(candidates, ctx) {
-        if (!ctx.openCircuits?.length)
-            return candidates;
-        const open = new Set(ctx.openCircuits);
-        const remaining = candidates.filter((candidate) => !open.has(candidate.providerName));
-        return remaining.length > 0 ? remaining : candidates;
+    get planCount() {
+        return this.plans.size;
+    }
+    plan(ctx) {
+        const key = this.planKey(ctx);
+        const cached = this.plans.get(key);
+        if (cached) {
+            this.plans.delete(key);
+            this.plans.set(key, cached);
+            return cached;
+        }
+        const plan = this.buildPlan(ctx);
+        this.plans.set(key, plan);
+        if (this.plans.size > PLAN_LIMIT)
+            this.plans.delete(this.plans.keys().next().value);
+        return plan;
+    }
+    planKey(ctx) {
+        const routing = ctx.config.routing;
+        const models = ctx.config.models;
+        const providers = [];
+        for (const [name, provider] of ctx.providers)
+            providers.push(`${name}${provider.info?.isLocal === true ? '+local' : ''}`);
+        return JSON.stringify([
+            routing?.strategy ?? 'quality',
+            routing?.candidateModels ?? null,
+            routing?.modelPreferences ?? null,
+            routing?.allowModels ?? null,
+            routing?.denyModels ?? null,
+            normalizedRequirements(routing?.requiredCapabilities),
+            models?.includeDefaults ?? null,
+            models?.aliases ?? null,
+            models?.registry ? this.registryId(models.registry) : 0,
+            providers,
+        ]);
     }
-    getCandidates(ctx) {
+    registryId(registry) {
+        let id = this.registryIds.get(registry);
+        if (id === undefined) {
+            id = this.registryIds.get(this.registryIds) ?? 1;
+            this.registryIds.set(registry, id);
+            this.registryIds.set(this.registryIds, id + 1);
+        }
+        return id;
+    }
+    buildPlan(ctx) {
+        const strategy = ctx.config.routing?.strategy || 'quality';
+        const registry = (0, registry_js_1.getModelRegistry)(ctx.config);
+        const requirements = compileRequirements(ctx.config.routing?.requiredCapabilities);
+        const candidates = this.getCandidates(ctx, registry, requirements);
+        const planned = candidates.map((candidate, index) => ({
+            providerName: candidate.providerName,
+            model: candidate.model,
+            base: this.score(candidate.model, strategy, registry, ctx.providers.get(candidate.providerName)?.info?.isLocal === true) + candidate.weight,
+            index,
+            attempt: Object.freeze({ providerName: candidate.providerName, model: candidate.model }),
+        }));
+        const ranked = [...planned].sort(byScore);
+        const byProvider = new Map();
+        for (const candidate of ranked) {
+            const list = byProvider.get(candidate.providerName);
+            if (list)
+                list.push(candidate);
+            else
+                byProvider.set(candidate.providerName, [candidate]);
+        }
+        return { strategy, ranked, byProvider };
+    }
+    rank(plan, ctx) {
+        let excluded;
+        if (ctx.openCircuits?.length) {
+            const open = new Set(ctx.openCircuits);
+            if (plan.ranked.some((candidate) => !open.has(candidate.providerName)))
+                excluded = open;
+        }
+        const offsets = this.healthOffsets(ctx);
+        if (!offsets) {
+            return excluded ? plan.ranked.filter((candidate) => !excluded.has(candidate.providerName)) : plan.ranked;
+        }
+        const lists = [];
+        let total = 0;
+        for (const [providerName, list] of plan.byProvider) {
+            if (excluded?.has(providerName))
+                continue;
+            lists.push({ list, offset: offsets.get(providerName) ?? 0, at: 0 });
+            total += list.length;
+        }
+        const merged = new Array(total);
+        for (let position = 0; position < total; position += 1) {
+            let best = -1;
+            let bestScore = Number.NEGATIVE_INFINITY;
+            let bestIndex = Number.POSITIVE_INFINITY;
+            for (let which = 0; which < lists.length; which += 1) {
+                const head = lists[which];
+                const candidate = head.list[head.at];
+                if (!candidate)
+                    continue;
+                const score = candidate.base + head.offset;
+                if (score > bestScore || (score === bestScore && candidate.index < bestIndex)) {
+                    best = which;
+                    bestScore = score;
+                    bestIndex = candidate.index;
+                }
+            }
+            const chosen = lists[best];
+            merged[position] = chosen.list[chosen.at];
+            chosen.at += 1;
+        }
+        return merged;
+    }
+    getCandidates(ctx, registry, requirements) {
         const candidates = [];
         const configuredModels = ctx.config.routing?.candidateModels;
+        const passes = (model) => !requirements || this.matchesRequirements(model, registry, requirements);
         if (configuredModels?.length) {
             for (const model of configuredModels) {
                 const resolved = (0, registry_js_1.resolveModel)(model, ctx.config);
@@ -43,23 +145,19 @@ class AutoRouter {
                     candidates.push({ providerName, model: resolved.model, weight: 0 });
                 }
             }
-            return candidates.filter((candidate) => this.matchesRequirements(candidate.model, ctx.config));
+            return candidates.filter((candidate) => passes(candidate.model));
         }
         const preferences = ctx.config.routing?.modelPreferences?.[ctx.config.routing?.strategy || 'quality'];
         for (const providerName of ctx.providers.keys()) {
-            const preferred = this.preferencesForProvider(providerName, preferences, ctx.config);
+            const preferred = this.preferencesForProvider(providerName, preferences, ctx.config, registry);
             if (preferred.length) {
                 candidates.push(...preferred);
             }
         }
-        return candidates.filter((candidate) => {
-            return this.isAllowed(candidate.model, ctx.config) && this.matchesRequirements(candidate.model, ctx.config);
-        });
+        return candidates.filter((candidate) => this.isAllowed(candidate.model, ctx.config) && passes(candidate.model));
     }
-    score(model, strategy, config, providerIsLocal = false) {
-        const registry = (0, registry_js_1.getModelRegistry)(config);
-        const normalized = model.startsWith('ollama/') ? model.slice(7) : model;
-        const caps = registry[model] || registry[normalized] || this.localFallbackCapabilities(model);
+    score(model, strategy, registry, providerIsLocal = false) {
+        const caps = this.capabilitiesOf(model, registry);
         if (strategy === 'privacy')
             return providerIsLocal || isLocalModel(model) ? 100 : 30;
         if (strategy === 'speed')
@@ -68,6 +166,10 @@ class AutoRouter {
             return this.costScore(model, caps);
         return this.qualityScore(model, caps);
     }
+    capabilitiesOf(model, registry) {
+        const normalized = model.startsWith('ollama/') ? model.slice(7) : model;
+        return registry[model] || registry[normalized] || this.localFallbackCapabilities(model);
+    }
     localFallbackCapabilities(model) {
         return {
             inputModalities: ['text'],
@@ -113,7 +215,7 @@ class AutoRouter {
             return 65;
         return Math.min(85, caps.maxContextTokens / 2000);
     }
-    preferencesForProvider(providerName, preferences, config) {
+    preferencesForProvider(providerName, preferences, config, registry) {
         if (preferences?.length) {
             return preferences
                 .map((preference) => typeof preference === 'string'
@@ -132,7 +234,7 @@ class AutoRouter {
         const registryModels = (0, registry_js_1.listModelsForProvider)(providerName, config);
         if (registryModels.length) {
             return registryModels
-                .filter((model) => this.isProviderRunnable(providerName, model, config))
+                .filter((model) => this.isProviderRunnable(providerName, model, registry))
                 .map((model) => ({ providerName, model, weight: 0 }));
         }
         if (providerName === 'ollama') {
@@ -173,52 +275,44 @@ class AutoRouter {
             return false;
         return !deny.some((entry) => this.matchesModelPattern(model, entry));
     }
-    matchesRequirements(model, config) {
-        const requirements = config.routing?.requiredCapabilities;
-        if (!requirements)
-            return true;
-        const registry = (0, registry_js_1.getModelRegistry)(config);
-        const normalized = model.startsWith('ollama/') ? model.slice(7) : model;
-        const caps = registry[model] || registry[normalized] || this.localFallbackCapabilities(model);
-        if (requirements.streaming !== undefined && caps.streaming !== requirements.streaming)
-            return false;
-        if (requirements.toolCalling !== undefined && caps.toolCalling !== requirements.toolCalling)
-            return false;
-        if (requirements.structuredOutputs !== undefined && caps.structuredOutputs !== requirements.structuredOutputs)
+    matchesRequirements(model, registry, requirements) {
+        const caps = this.capabilitiesOf(model, registry);
+        const { mustBe, mustNotBe } = capabilityMasks(caps);
+        if ((mustBe & requirements.mustBe) !== requirements.mustBe)
             return false;
-        if (requirements.jsonMode !== undefined && caps.jsonMode !== requirements.jsonMode)
+        if ((mustNotBe & requirements.mustNotBe) !== requirements.mustNotBe)
             return false;
-        if (requirements.reasoning !== undefined && Boolean(caps.reasoning) !== requirements.reasoning)
+        const source = requirements.source;
+        if (source.minContextTokens && caps.maxContextTokens < source.minContextTokens)
             return false;
-        if (requirements.minContextTokens && caps.maxContextTokens < requirements.minContextTokens)
+        if (source.maxInputCostPer1k !== undefined && caps.costPer1kInput > source.maxInputCostPer1k)
             return false;
-        if (requirements.maxInputCostPer1k !== undefined && caps.costPer1kInput > requirements.maxInputCostPer1k)
+        if (source.maxOutputCostPer1k !== undefined && caps.costPer1kOutput > source.maxOutputCostPer1k)
             return false;
-        if (requirements.maxOutputCostPer1k !== undefined && caps.costPer1kOutput > requirements.maxOutputCostPer1k)
+        if (source.statuses?.length && caps.status && !source.statuses.includes(caps.status))
             return false;
-        if (requirements.statuses?.length && caps.status && !requirements.statuses.includes(caps.status))
+        if (source.inputModalities?.some((modality) => !caps.inputModalities.includes(modality)))
             return false;
-        if (requirements.inputModalities?.some((modality) => !caps.inputModalities.includes(modality)))
-            return false;
-        if (requirements.outputModalities?.some((modality) => !caps.outputModalities.includes(modality)))
+        if (source.outputModalities?.some((modality) => !caps.outputModalities.includes(modality)))
             return false;
         return true;
     }
     matchesModelPattern(model, pattern) {
         if (pattern === model)
             return true;
-        if (!pattern.includes('*'))
-            return false;
-        const regex = new RegExp(`^${pattern
-            .split('*')
-            .map((part) => {
-            return part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        })
-            .join('.*')}$`);
-        return regex.test(model);
+        let regex = this.patterns.get(pattern);
+        if (regex === undefined) {
+            regex = pattern.includes('*')
+                ? new RegExp(`^${pattern
+                    .split('*')
+                    .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+                    .join('.*')}$`)
+                : null;
+            this.patterns.set(pattern, regex);
+        }
+        return regex ? regex.test(model) : false;
     }
-    isProviderRunnable(providerName, model, config) {
-        const registry = (0, registry_js_1.getModelRegistry)(config);
+    isProviderRunnable(providerName, model, registry) {
         const caps = registry[model];
         if (!caps?.endpoints)
             return true;
@@ -230,16 +324,55 @@ class AutoRouter {
             return caps.endpoints.includes('generateContent');
         return true;
     }
-    healthScore(providerName, ctx) {
+    healthOffsets(ctx) {
         if (!ctx.config.health?.enabled || !ctx.health?.length)
-            return 0;
-        const snapshot = ctx.health.find((item) => item.providerName === providerName);
-        if (!snapshot)
-            return 0;
-        return snapshot.healthy ? snapshot.score / 10 : -100;
+            return undefined;
+        const offsets = new Map();
+        for (const snapshot of ctx.health) {
+            if (offsets.has(snapshot.providerName))
+                continue;
+            offsets.set(snapshot.providerName, snapshot.healthy ? snapshot.score / 10 : -100);
+        }
+        return offsets;
     }
 }
 exports.AutoRouter = AutoRouter;
+function compileRequirements(requirements) {
+    if (!requirements)
+        return undefined;
+    let mustBe = 0;
+    let mustNotBe = 0;
+    BOOLEAN_CAPABILITIES.forEach((name, bit) => {
+        const wanted = requirements[name];
+        if (wanted === true)
+            mustBe |= 1 << bit;
+        else if (wanted === false)
+            mustNotBe |= 1 << bit;
+    });
+    return { mustBe, mustNotBe, source: requirements };
+}
+function capabilityMasks(caps) {
+    let mustBe = 0;
+    let mustNotBe = 0;
+    BOOLEAN_CAPABILITIES.forEach((name, bit) => {
+        const value = name === 'reasoning' ? Boolean(caps.reasoning) : caps[name];
+        if (value === true)
+            mustBe |= 1 << bit;
+        else if (value === false)
+            mustNotBe |= 1 << bit;
+    });
+    return { mustBe, mustNotBe };
+}
+function normalizedRequirements(requirements) {
+    if (!requirements)
+        return null;
+    return Object.keys(requirements)
+        .sort()
+        .map((key) => [key, requirements[key]]);
+}
+function byScore(a, b) {
+    return b.base - a.base || a.index - b.index;
+}
 function isLocalModel(model) {
     return (model.startsWith('ollama/') ||
         model.startsWith('lmstudio/') ||