nexus-ai-pro 2.1.0 → 2.2.0

package/dist/postgres/store.d.ts

@@ -1,5 +1,7 @@
 import type { Store, StoreIndexOptions, StoreItem, StoreNamespace, StorePutOptions, StoreSearchOptions } from '../types/store.js';
+import type { MigrationResult, SchemaMigration } from '../utils/schema-migrations.js';
 import { type PostgresLikeClient } from './client.js';
+import type { PostgresMigrateOptions } from './migrations.js';
 /** Options for the Postgres store. */
 export interface PostgresStoreOptions {
     /** Table name, optionally schema-qualified. Defaults to `nexus_store`. */
@@ -15,6 +17,10 @@ export interface PostgresStoreOptions {
     /** Replaces the system clock, for tests. */
     now?: () => Date;
 }
+/**
+ * The versioned schema, which `migrate()` and `nexus db migrate` apply. Version 1 is the 2.0 schema.
+ */
+export declare function storeMigrations(options?: Pick<PostgresStoreOptions, 'table' | 'vectorDimensions'>): SchemaMigration[];
 /** The schema, as statements. With `vectorDimensions`, pgvector's extension is created too. */
 export declare function storeMigration(options?: Pick<PostgresStoreOptions, 'table' | 'vectorDimensions'>): string[];
 /**
@@ -31,8 +37,11 @@ export declare class PostgresStore implements Store {
     private readonly table;
     private readonly now;
     constructor(client: PostgresLikeClient, options?: PostgresStoreOptions);
-    /** Creates the table, indexes, and pgvector extension if configured. Never runs implicitly. */
-    migrate(): Promise<void>;
+    /**
+     * Applies this store's pending migrations, recorded in `nexus_schema_migrations`, under a lock.
+     * Never runs implicitly. Safe on a database an older release created: what exists is kept.
+     */
+    migrate(options?: PostgresMigrateOptions): Promise<MigrationResult>;
     /** Stores an item, keeping its original `createdAt` when it replaces one. */
     put<V>(namespace: StoreNamespace, key: string, value: V, options?: StorePutOptions): Promise<void>;
     /** Reads an item, or `undefined` when it does not exist or has expired. */

package/dist/postgres/store.js

@@ -1,8 +1,18 @@
 import { cosine, textOf } from '../store/helpers.js';
-import { fromJson, quoteDerived, quoteTable, runStatements } from './client.js';
+import { fromJson, quoteDerived, quoteTable } from './client.js';
 import { jsonFieldEquals, likePrefix, SqlParams } from './sql.js';
 const DEFAULT_TABLE = 'nexus_store';
 const SEPARATOR = '\u001f';
+export function storeMigrations(options = {}) {
+    return [
+        {
+            component: `store:${options.table ?? DEFAULT_TABLE}`,
+            version: 1,
+            name: 'create the store table',
+            statements: storeMigration(options),
+        },
+    ];
+}
 export function storeMigration(options = {}) {
     const name = options.table ?? DEFAULT_TABLE;
     const table = quoteTable(name);
@@ -38,8 +48,9 @@ export class PostgresStore {
         this.table = quoteTable(options.table ?? DEFAULT_TABLE);
         this.now = options.now ?? (() => new Date());
     }
-    async migrate() {
-        await runStatements(this.client, storeMigration(this.options));
+    async migrate(options = {}) {
+        const { applyPostgresMigrations } = await import('./migrations.js');
+        return applyPostgresMigrations(this.client, storeMigrations(this.options), options);
     }
     async put(namespace, key, value, options = {}) {
         if (!key.trim())

package/dist/postgres/traces.d.ts

@@ -1,12 +1,19 @@
 import type { Run, RunFeedback, RunQuery, RunTree, TraceStore } from '../types/tracing.js';
+import type { MigrationResult, SchemaMigration } from '../utils/schema-migrations.js';
 import { type PostgresLikeClient } from './client.js';
+import type { PostgresMigrateOptions } from './migrations.js';
 /** Options for the Postgres trace store. */
 export interface PostgresTraceStoreOptions {
     /** Table name, optionally schema-qualified. Defaults to `nexus_runs`. */
     table?: string;
 }
-/** The schema, as statements. */
+/** The schema, as statements: every migration's, in order. */
 export declare function traceStoreMigration(options?: PostgresTraceStoreOptions): string[];
+/**
+ * The versioned schema, which `migrate()` and `nexus db migrate` apply. Version 1 is the 2.0 table;
+ * version 2 indexes runs by `metadata.tenantId`, which a tenant-scoped trace store filters on.
+ */
+export declare function traceStoreMigrations(options?: PostgresTraceStoreOptions): SchemaMigration[];
 /**
  * Traces in Postgres.
  *
@@ -20,8 +27,11 @@ export declare class PostgresTraceStore implements TraceStore {
     private readonly options;
     private readonly table;
     constructor(client: PostgresLikeClient, options?: PostgresTraceStoreOptions);
-    /** Creates the table and indexes if they do not exist. Never runs implicitly. */
-    migrate(): Promise<void>;
+    /**
+     * Applies this store's pending migrations, recorded in `nexus_schema_migrations`, under a lock.
+     * Never runs implicitly. Safe on a database an older release created: what exists is kept.
+     */
+    migrate(options?: PostgresMigrateOptions): Promise<MigrationResult>;
     /** Stores a run, replacing an earlier version with the same id. */
     save(run: Run): Promise<void>;
     /** Reads a run. */

package/dist/postgres/traces.js

@@ -1,10 +1,27 @@
 import { assembleTree } from '../tracing/query.js';
-import { fromJson, quoteDerived, quoteTable, runStatements } from './client.js';
+import { fromJson, quoteDerived, quoteTable } from './client.js';
 import { jsonFieldEquals, SqlParams } from './sql.js';
 const DEFAULT_TABLE = 'nexus_runs';
 export function traceStoreMigration(options = {}) {
+    return traceStoreMigrations(options).flatMap((migration) => [...migration.statements]);
+}
+export function traceStoreMigrations(options = {}) {
     const name = options.table ?? DEFAULT_TABLE;
     const table = quoteTable(name);
+    const component = `traces:${name}`;
+    return [
+        { component, version: 1, name: 'create the runs table', statements: createStatements(name, table) },
+        {
+            component,
+            version: 2,
+            name: 'index runs by tenant',
+            statements: [
+                `CREATE INDEX IF NOT EXISTS ${quoteDerived(name, 'tenant_started')} ON ${table} ((doc #>> '{metadata,tenantId}'), started_at DESC)`,
+            ],
+        },
+    ];
+}
+function createStatements(name, table) {
     return [
         `CREATE TABLE IF NOT EXISTS ${table} (
   id text PRIMARY KEY,
@@ -34,8 +51,9 @@ export class PostgresTraceStore {
         this.options = options;
         this.table = quoteTable(options.table ?? DEFAULT_TABLE);
     }
-    async migrate() {
-        await runStatements(this.client, traceStoreMigration(this.options));
+    async migrate(options = {}) {
+        const { applyPostgresMigrations } = await import('./migrations.js');
+        return applyPostgresMigrations(this.client, traceStoreMigrations(this.options), options);
     }
     async save(run) {
         await this.client.query(`INSERT INTO ${this.table} (id, trace_id, parent_id, name, kind, status, started_at, latency_ms, cost, model, provider, doc)
@@ -93,6 +111,10 @@ export class PostgresTraceStore {
             where.push(`EXISTS (SELECT 1 FROM jsonb_array_elements(coalesce(doc -> 'feedback', '[]'::jsonb)) AS item WHERE item ->> 'key' = ${params.add(query.feedbackKey)})`);
         }
         for (const [field, expected] of Object.entries(query.metadata ?? {})) {
+            if (field === 'tenantId' && typeof expected === 'string') {
+                where.push(`doc #>> '{metadata,tenantId}' = ${params.add(expected)} AND jsonb_typeof(doc #> '{metadata,tenantId}') = 'string'`);
+                continue;
+            }
             where.push(jsonFieldEquals(`(doc -> 'metadata')`, field, expected, params));
         }
         const { rows } = await this.client.query(`SELECT doc::text AS doc FROM ${this.table}

package/dist/postgres/vectors.d.ts

@@ -1,5 +1,7 @@
 import { type EmbeddingProvider, type VectorDocument, type VectorSearchOptions, type VectorSearchResult, type VectorStore } from '../hallucination/retrieval.js';
+import type { MigrationResult, SchemaMigration } from '../utils/schema-migrations.js';
 import { type PostgresLikeClient } from './client.js';
+import type { PostgresMigrateOptions } from './migrations.js';
 /** Options for the pgvector store. */
 export interface PostgresVectorStoreOptions {
     /** Width of every vector. Must match the embedding function's output. */
@@ -15,6 +17,10 @@ export interface PostgresVectorStoreOptions {
      */
     index?: 'hnsw' | 'none';
 }
+/**
+ * The versioned schema, which `migrate()` and `nexus db migrate` apply. Version 1 is the 2.0 schema.
+ */
+export declare function vectorStoreMigrations(options: Omit<PostgresVectorStoreOptions, 'embed'>): SchemaMigration[];
 /** The schema, as statements: the pgvector extension, the table, and its index. */
 export declare function vectorStoreMigration(options: Omit<PostgresVectorStoreOptions, 'embed'>): string[];
 /**
@@ -30,8 +36,11 @@ export declare class PostgresVectorStore implements VectorStore {
     private readonly table;
     private readonly embed;
     constructor(client: PostgresLikeClient, options: PostgresVectorStoreOptions);
-    /** Creates the extension, table, and index. Never runs implicitly. */
-    migrate(): Promise<void>;
+    /**
+     * Applies this store's pending migrations, recorded in `nexus_schema_migrations`, under a lock.
+     * Never runs implicitly. Safe on a database an older release created: what exists is kept.
+     */
+    migrate(options?: PostgresMigrateOptions): Promise<MigrationResult>;
     /** Adds chunks, or replaces those whose id exists, embedding those without a vector in one batch. */
     add(documents: VectorDocument[]): Promise<void>;
     /** The chunks most similar to a query, best first. */

package/dist/postgres/vectors.js

@@ -1,7 +1,17 @@
 import { createHashEmbeddings, } from '../hallucination/retrieval.js';
-import { fromJson, quoteDerived, quoteTable, runStatements } from './client.js';
+import { fromJson, quoteDerived, quoteTable } from './client.js';
 import { SqlParams, textArray } from './sql.js';
 const DEFAULT_TABLE = 'nexus_vectors';
+export function vectorStoreMigrations(options) {
+    return [
+        {
+            component: `vectors:${options.table ?? DEFAULT_TABLE}`,
+            version: 1,
+            name: 'create the vectors table',
+            statements: vectorStoreMigration(options),
+        },
+    ];
+}
 export function vectorStoreMigration(options) {
     const dimensions = options.dimensions;
     if (!(Number.isInteger(dimensions) && dimensions > 0))
@@ -38,8 +48,9 @@ export class PostgresVectorStore {
         this.table = quoteTable(options.table ?? DEFAULT_TABLE);
         this.embed = options.embed ?? ((texts) => createHashEmbeddings(texts, options.dimensions));
     }
-    async migrate() {
-        await runStatements(this.client, vectorStoreMigration(this.options));
+    async migrate(options = {}) {
+        const { applyPostgresMigrations } = await import('./migrations.js');
+        return applyPostgresMigrations(this.client, vectorStoreMigrations(this.options), options);
     }
     async add(documents) {
         if (documents.length === 0)

package/dist/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/router/auto-router.js

@@ -1,36 +1,138 @@
 import { getModelRegistry, listModelsForProvider, resolveModel } from '../models/registry.js';
+const PLAN_LIMIT = 16;
+const BOOLEAN_CAPABILITIES = ['streaming', 'toolCalling', 'structuredOutputs', 'jsonMode', 'reasoning'];
 export 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 = 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 = resolveModel(model, ctx.config);
@@ -39,23 +141,19 @@ export 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 = 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')
@@ -64,6 +162,10 @@ export 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'],
@@ -109,7 +211,7 @@ export 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'
@@ -128,7 +230,7 @@ export class AutoRouter {
         const registryModels = 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') {
@@ -169,52 +271,44 @@ export 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 = 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 = getModelRegistry(config);
+    isProviderRunnable(providerName, model, registry) {
         const caps = registry[model];
         if (!caps?.endpoints)
             return true;
@@ -226,15 +320,54 @@ export 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;
     }
 }
+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/') ||