auto-model-router 0.35.0 → 0.36.0

package/.omp-plugin/marketplace.json

@@ -7,14 +7,14 @@
   },
   "metadata": {
     "description": "auto-model-router: a local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
-    "version": "0.35.0",
+    "version": "0.36.0",
     "pluginRoot": "."
   },
   "plugins": [
     {
       "name": "auto-model-router",
       "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter. Runs in-process, routes per turn by price and task complexity, with budget caps, mid-stream escalation, and cache-aware hysteresis.",
-      "version": "0.35.0",
+      "version": "0.36.0",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.35.0",
+  "version": "0.36.0",
   "private": false,
   "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
   "type": "module",

package/src/config/defaults.ts

@@ -105,6 +105,7 @@ export const DEFAULT_CONFIG: RouterConfig = {
 	filters: {
 		allow: [],
 		deny: [],
+		providerLocks: {},
 		// Free models are rate-limited hard enough that retries cost more than they save.
 		includeFree: false,
 		requireToolSupport: true,

package/src/config/types.ts

@@ -226,6 +226,15 @@ export interface FilterConfig {
 	allow: string[];
 	/** Glob patterns; matching models are dropped. Applied after `allow`. */
 	deny: string[];
+	/**
+	 * Model-glob → provider-glob. A model matching a key may only dispatch
+	 * through a provider whose id matches the value, so a team can keep a
+	 * subscription's models on that subscription instead of its OpenRouter
+	 * twins (`{"anthropic/*": "anthropic-subscription"}`). Applied before
+	 * ranking; a model matching several locks must satisfy each. An empty
+	 * object locks nothing.
+	 */
+	providerLocks: Record<string, string>;
 	/** Consider zero-price models. Off by default: rate limits make them expensive in retries. */
 	includeFree: boolean;
 	/** Require `supported_parameters` to include `tools` whenever the request offers tools. */

package/src/router/candidates.ts

@@ -164,6 +164,12 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 	const relaxTrust = relaxLevel >= 3;
 	const allowRes = filters.allow.map(globToRe);
 	const denyRes = filters.deny.map(globToRe);
+	// Compiled once per turn: pairs of [model glob, provider glob] regexes.
+	// Null when there are no locks, so the common path allocates nothing.
+	const lockRes =
+		filters.providerLocks && Object.keys(filters.providerLocks).length > 0
+			? Object.entries(filters.providerLocks).map(([m, p]) => [globToRe(m), globToRe(p)] as const)
+			: null;
 	const needTools = req.tools.length > 0 && filters.requireToolSupport;
 	const minContext = Math.ceil(features.promptTokens * filters.contextHeadroom) + expectedCompletionTokens;
 	// Task selects the quality axis and capability filters; the tier still
@@ -237,6 +243,17 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 			rejected.push({ slug, reason: "denylisted", detail: "filters.deny" });
 			continue;
 		}
+		// Provider locks: where a model may be served from. Checked like a
+		// filter (a lock the model cannot satisfy drops it before ranking)
+		// rather than at dispatch, so the catalog view, the rejection list and
+		// the turn all agree on what was available.
+		if (lockRes !== null) {
+			const violated = lockRes.find(([modelRe, providerRe]) => modelRe.test(slug) && !providerRe.test(model.provider));
+			if (violated !== undefined) {
+				rejected.push({ slug, reason: "provider_locked", detail: `${slug} is locked to providers matching "${violated[1].source}"` });
+				continue;
+			}
+		}
 		if (model.isFree && !filters.includeFree) {
 			rejected.push({ slug, reason: "free_tier_excluded" });
 			continue;

package/src/router/index.ts

@@ -65,6 +65,10 @@ export function applyRequestPolicy(
 	const outProfile = narrowed ? { ...profile, id: `${profile.id}+policy`, minTier, maxTier } : profile;
 	if (narrowed) reasons.push(`policy: tiers narrowed to [${minTier}..${maxTier}]`);
 	let outCfg = cfg;
+	if (policy.providerLocks !== undefined) {
+		outCfg = { ...cfg, filters: { ...cfg.filters, providerLocks: { ...cfg.filters.providerLocks, ...policy.providerLocks } } };
+		reasons.push(`policy: provider locks ${Object.entries(policy.providerLocks).map(([m, p]) => `${m}→${p}`).join(" ")}`);
+	}
 	if (policy.allow !== undefined || policy.deny !== undefined) {
 		outCfg = { ...cfg, filters: { ...cfg.filters, ...(policy.allow === undefined ? {} : { allow: policy.allow }), ...(policy.deny === undefined ? {} : { deny: [...cfg.filters.deny, ...policy.deny] }) } };
 		reasons.push(`policy: ${policy.allow === undefined ? "" : `allow ${policy.allow.join("|")} `}${policy.deny === undefined ? "" : `deny ${policy.deny.join("|")}`}`.trim());

package/src/router/types.ts

@@ -162,6 +162,8 @@ export type RejectionReason =
 	| "denylisted"
 	| "not_allowlisted"
 	| "free_tier_excluded"
+	/** filters.providerLocks: the model matches a lock whose provider glob excludes its upstream. */
+	| "provider_locked"
 	| "reasoning_mandatory"
 	| "untrusted"
 	/** The turn's `X-Omp-Upstream-Keys` names this model's upstream with an empty credential: it cannot be dispatched to. */

package/src/server/catalog-view.ts

@@ -49,7 +49,7 @@ export interface CatalogView {
 }
 
 /** The filters a turn routes under: the configured ones, or those `applyRequestPolicy` merged a policy into. */
-export type AdmissionFilters = Pick<FilterConfig, "allow" | "deny" | "includeFree" | "requireToolSupport">;
+export type AdmissionFilters = Pick<FilterConfig, "allow" | "deny" | "providerLocks" | "includeFree" | "requireToolSupport">;
 
 export interface CatalogViewArgs {
 	models: readonly CatalogModel[];
@@ -84,11 +84,17 @@ function filterReason(model: CatalogModel, filters: AdmissionFilters, allowRes:
 	if (allowRes.length > 0 && !allowRes.some((re) => re.test(model.slug))) return "not in the allow list";
 	const denied = denyRes.findIndex((re) => re.test(model.slug));
 	if (denied !== -1) return `denied by ${filters.deny[denied]}`;
+	if (filters.providerLocks) {
+		for (const [modelGlob, providerGlob] of Object.entries(filters.providerLocks)) {
+			if (globToRe(modelGlob).test(model.slug) && !globToRe(providerGlob).test(model.provider)) {
+				return `locked to providers matching ${providerGlob} (filters.providerLocks)`;
+			}
+		}
+	}
 	if (model.isFree && !filters.includeFree) return "free models excluded (filters.includeFree)";
 	if (filters.requireToolSupport && !model.supportsTools) return "no tool support (filters.requireToolSupport)";
 	return null;
 }
-
 export function catalogView(args: CatalogViewArgs): CatalogView {
 	const sorted = [...args.models].sort((a, b) => (a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0));
 	const verdict = args.verdict;

package/src/wire/types.ts

@@ -17,6 +17,11 @@ export type WireProtocol = "openai-chat" | "openai-responses" | "anthropic-messa
  * like `filters.allow`/`filters.deny` (a request allow list replaces the
  * configured one; a deny list adds to it); `minTier`/`maxTier` narrow the
  * profile's tier envelope; `pin` forces one slug, like `/router pin`.
+ * `providerLocks` restricts WHERE a model may be served from: a model whose
+ * slug matches the key may only dispatch through a provider whose id matches
+ * the value (`{"anthropic/*": "anthropic-subscription"}` keeps Claude on the
+ * subscription upstream and away from OpenRouter's billed twins). Keys and
+ * values are slug globs; a model matching several locks must satisfy each.
  */
 export interface RequestPolicy {
 	allow?: string[];
@@ -24,6 +29,7 @@ export interface RequestPolicy {
 	minTier?: "trivial" | "simple" | "moderate" | "hard";
 	maxTier?: "trivial" | "simple" | "moderate" | "hard";
 	pin?: string;
+	providerLocks?: Record<string, string>;
 }
 
 export type Role = "system" | "developer" | "user" | "assistant" | "tool";

package/test/catalog-view.test.ts

@@ -137,8 +137,19 @@ describe("catalogView", () => {
 		// So is a pin naming no model.
 		expect(bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, verdict: { filters, pin: "nobody/here" }, unserved: served })).get("anthropic/claude-sonnet-5")!.admitted).toBe(true);
 	});
+
+	test("a provider lock drops a model whose upstream cannot serve it", async () => {
+		// MODELS are all openrouter-served except vllm/ and azure-eu/; a lock
+		// confining anthropic to a named subscription upstream admits only the
+		// models that upstream actually carries.
+		const filters = { ...DEFAULT_CONFIG.filters, providerLocks: { "anthropic/*": "claude-sub" } };
+		const view = bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, verdict: { filters }, unserved: served }));
+		expect(view.get("anthropic/claude-sonnet-5")).toMatchObject({ admitted: false, reason: "locked to providers matching claude-sub (filters.providerLocks)" });
+		expect(view.get("openai/gpt-5")).toMatchObject({ admitted: true }); // no key matches
+	});
 });
 
+
 describe("GET /v1/router/catalog", () => {
 	let handle: StartedServer;
 	let empty: StartedServer;

package/test/failover.test.ts

@@ -48,7 +48,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			data: { axis: "intelligence", minQuality: 0 },
 			chat: { axis: "intelligence", minQuality: 0 },
 		},
-		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, agenticAxisForToolTurns: true, minAgenticForToolTurns: 0, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, reasoningCompletionFloor: 0, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
+		filters: { allow: [], deny: [], providerLocks: {}, includeFree: false, requireToolSupport: true, agenticAxisForToolTurns: true, minAgenticForToolTurns: 0, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, reasoningCompletionFloor: 0, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator", learnedModelPath: "",

package/test/tier-plan.test.ts

@@ -404,6 +404,57 @@ describe("adaptive price ceilings", () => {
 	});
 });
 
+describe("provider locks", () => {
+	const req = parseChatRequest(
+		{
+			model: "auto",
+			messages: [{ role: "user", content: "summarize the release notes" }],
+		},
+		new Headers(),
+	);
+	const features = extractFeatures(req, 100);
+
+	// claude/opus from the subscription upstream (cheap for a subscriber) and
+	// its expensive OpenRouter twin, priced as OpenRouter really bills.
+	const mk = (slug: string, provider: string, inPerMtok: number) => ({
+		slug, canonicalSlug: slug, name: slug, provider, vendor: provider,
+		contextLength: 200_000, maxCompletionTokens: 32_000, supportsTools: true, supportsReasoning: false,
+		reasoningMandatory: false, supportsToolChoice: true, inputModalities: ["text" as const],
+		price: { prompt: inPerMtok / 1e6, completion: (inPerMtok * 3) / 1e6 }, priceTiers: [],
+		quality: { intelligence: 80, coding: 80, agentic: 60 }, tokenizer: "Other",
+		isFree: false, createdAtMs: 0, author: "vendor",
+	});
+	const snap = { models: [mk("anthropic/claude-opus", "anthropic-subscription", 0.5), mk("anthropic/claude-opus-openrouter", "openrouter", 15)], fetchedAtMs: Date.now(), keyScoped: false };
+
+	const run = (locks: Record<string, string>) =>
+		buildCandidates({
+			req, features, tier: "moderate", task: "chat", snapshot: snap,
+			cfg: { ...BASE, filters: { ...BASE.filters, providerLocks: locks } },
+			expectedCompletionTokens: 512, warmSlug: null,
+		});
+
+	test("a model matching a lock key may only come from a provider matching the value", () => {
+		const { candidates, rejected } = run({ "anthropic/*": "anthropic-subscription" });
+		expect(candidates).toHaveLength(1);
+		expect(candidates[0]!.model.slug).toBe("anthropic/claude-opus");
+		expect(candidates[0]!.model.provider).toBe("anthropic-subscription");
+		expect(rejected.some((r) => r.slug === "anthropic/claude-opus-openrouter" && r.reason === "provider_locked")).toBe(true);
+	});
+
+	test("a model no key matches is untouched, and a provider glob keeps other providers serving", () => {
+		const only = { models: [mk("xai/grok", "openrouter", 2), mk("anthropic/claude-opus", "openrouter", 15)], fetchedAtMs: Date.now(), keyScoped: false };
+		const out = buildCandidates({
+			req, features, tier: "moderate", task: "chat", snapshot: only,
+			cfg: { ...BASE, filters: { ...BASE.filters, providerLocks: { "anthropic/*": "anthropic-subscription" } } },
+			expectedCompletionTokens: 512, warmSlug: null,
+		});
+		// grok matches no key: served from openrouter as usual. The claude slug
+		// matches the lock and openrouter does not match the value: dropped.
+		expect(out.candidates.map((c) => c.model.slug)).toEqual(["xai/grok"]);
+		expect(out.rejected.some((r) => r.slug === "anthropic/claude-opus" && r.reason === "provider_locked")).toBe(true);
+	});
+});
+
 describe("quality normalization and capability floor (benchmark findings 4/6)", () => {
 	const req = parseChatRequest(
 		{

package/test/turn.test.ts

@@ -51,7 +51,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			data: { axis: "intelligence", minQuality: 0 },
 			chat: { axis: "intelligence", minQuality: 0 },
 		},
-		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, agenticAxisForToolTurns: true, minAgenticForToolTurns: 0, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, reasoningCompletionFloor: 0, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
+		filters: { allow: [], deny: [], providerLocks: {}, includeFree: false, requireToolSupport: true, agenticAxisForToolTurns: true, minAgenticForToolTurns: 0, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, reasoningCompletionFloor: 0, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator", learnedModelPath: "",