omp-llm-role 1.1.0 → 1.2.0

package/src/settings.ts

@@ -359,7 +359,7 @@ export function deriveSettingsSchema(): Record<string, PluginSettingSchema> {
     }
     schema[`${p}.preferOwnProvider`] = {
       type: "boolean",
-      description: `Price ${name} models on their own lab's route where one exists (soft preference; never drops a model)`,
+      description: `Bind ${name} requests to each model's best provider route (soft preference; never drops a model)`,
       default: false,
     };
     schema[`${p}.required`] = {
@@ -395,6 +395,12 @@ export function deriveSettingsSchema(): Record<string, PluginSettingSchema> {
       default: def.filters?.maxPriceUsdPerM ?? 0,
       min: 0,
     };
+    schema[`${p}.filters.preferredMinThroughput`] = {
+      type: "number",
+      description: `Soft throughput floor for ${name} routes (tok/s; 0 = off) — a below-floor route sorts last but is never dropped`,
+      default: def.filters?.preferredMinThroughput ?? 0,
+      min: 0,
+    };
     schema[`${p}.lambda`] = {
       type: "number",
       description: `Explicit λ ($ per quality point) override for ${name}`,
@@ -647,7 +653,7 @@ export function resolveSettings(raw: Record<string, unknown>): { settings: Resol
         if (rdef.filters.tools !== undefined && typeof rdef.filters.tools !== "boolean") {
           errors.push(`role ${name}: filters.tools must be a boolean`);
         }
-        for (const key of ["minContextTokens", "minOutputTokens", "maxPriceUsdPerM"] as const) {
+        for (const key of ["minContextTokens", "minOutputTokens", "maxPriceUsdPerM", "preferredMinThroughput"] as const) {
           const v = rdef.filters[key];
           if (v !== undefined && (typeof v !== "number" || !Number.isFinite(v) || v < 0)) {
             errors.push(`role ${name}: filters.${key} must be a number ≥ 0`);

package/src/updater.ts

@@ -15,8 +15,8 @@
 
 import { readFileSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { computeRankings, endpointFilterDrops, loadRankData, META_LEVELS, providerPinDrops, type Ranked, type RankData } from "./engine.ts";
-import { currentRankingId, enrichThinkingLevels, fetchKeyAvailability, fetchKeyMeta, filterCatalog, probeModel, resolveVariant, THINKING_LEVELS, tierGate, type CatalogEntry, type KeyAvailability, type KeyMeta, type ProbeVerdict } from "./availability.ts";
+import { autoPinApplies, bestRoute, computeRankings, endpointFilterDrops, loadRankData, META_LEVELS, providerPinDrops, rankedRoutes, type Ranked, type RankData, type RoleDef } from "./engine.ts";
+import { currentRankingId, enrichThinkingLevels, fetchAllowedProviders, fetchKeyAvailability, fetchKeyMeta, filterCatalog, probeModel, providerAllowed, resolveVariant, THINKING_LEVELS, tierGate, type CatalogEntry, type KeyAvailability, type KeyMeta, type ProbeVerdict } from "./availability.ts";
 import { ConfigEditError, parseConfig, patchConfig, writeConfigAtomic, type ConfigPatch } from "./config-edit.ts";
 import { PLUGIN_SETTINGS_PATH, projectLockPath, readPluginSettingsMap, resolveSettings, roleUniverse, type ResolvedSettings } from "./settings.ts";
 import { discoverAgentPins } from "./agent-pins.ts";
@@ -68,6 +68,11 @@ export type Trigger = "session-start" | "manual";
 /** A ranked model resolved to a concrete catalog id. */
 type Candidate = { ranked: Ranked; catalogId: string };
 
+/** Per managed role: its bare chain key, role suffix, provider pin, the pool it
+ * was chosen from, and the inputs the auto-pin chain builder needs (the expanded
+ * def for `rankedRoutes`, and whether the pin was auto-derived). */
+type ChainPlan = { key: string; suffix: string | undefined; pin: string; pool: Candidate[]; chosenIdx: number; def: RoleDef; autoPin: boolean };
+
 export type Deps = {
   getToken(): Promise<string>;
   getCatalog(): Promise<CatalogEntry[]>;
@@ -80,6 +85,13 @@ export type Deps = {
   probeModel?(token: string, catalogId: string): Promise<ProbeVerdict>;
   /** DI seam like `getKeyMeta`/`probeModel`; production defaults to `fetchKeyAvailability` (never throws). */
   getKeyAvailability?(token: string): Promise<KeyAvailability>;
+  /**
+   * DI seam like `getKeyAvailability`; production defaults to
+   * `fetchAllowedProviders` (never throws). Returns the account's
+   * allowed-providers privacy whitelist, or null when there is none (or the
+   * harvest failed) — a null result leaves every route pool untouched.
+   */
+  getAllowedProviders?(token: string, modelId: string): Promise<Set<string> | null>;
   /**
    * Host coupling (extension only): apply a concrete selector to the live
    * session model. Receives the final `default` selector (with thinking
@@ -319,9 +331,38 @@ export async function runUpdater(trigger: Trigger, deps: Deps, opts?: { force?:
         `omp-llm-role: OpenRouter keyed catalog ${availability.reason === "no-filter" ? "not filtering" : "unavailable"} — enable OpenRouter → Settings → "Filter the model catalog for API keys" to skip probing key-blocked models; the probe walk is still in use`,
       );
     }
+
+    // Allowed-providers privacy whitelist (spec #65): harvested once per run
+    // with a valid catalog model id (the canary 404s, so it bills no tokens).
+    // The whitelist is invisible to /api/v1/key and the catalog endpoints, so a
+    // route on a provider outside it would be written into config.yml and 404
+    // at request time. Pruning every model's route pool to allowed providers
+    // before ranking makes the soft basis, the auto-pin and the fallback chains
+    // whitelist-aware through the single `m.routes` seam. A null result (no
+    // whitelist set / harvest failed) leaves the pools untouched.
+    const canaryModelId = eligible[0]?.id;
+    const allowed =
+      canaryModelId === undefined
+        ? null
+        : await (deps.getAllowedProviders ? deps.getAllowedProviders(token, canaryModelId) : fetchAllowedProviders(token, canaryModelId));
+    if (allowed !== null) {
+      let prunedCount = 0;
+      const pruned = rank.models.map((m) => {
+        const routes = m.routes;
+        if (routes === undefined) return m;
+        const kept = routes.filter((r) => providerAllowed(allowed, r.providerSlug));
+        prunedCount += routes.length - kept.length;
+        return { ...m, routes: kept };
+      });
+      rank = { ...rank, models: pruned };
+      notes.push(
+        `omp-llm-role: OpenRouter allowed-providers whitelist active — ${allowed.size} providers; ${prunedCount} routes pruned`,
+      );
+    } else {
+      notes.push(`omp-llm-role: OpenRouter allowed-providers whitelist: no whitelist`);
+    }
     const poolByRole: Record<string, Candidate[]> = {};
-    /** Per managed role: its bare chain key, role suffix, provider pin, and the pool it was chosen from. */
-    const chainPlanByRole: Record<string, { key: string; suffix: string | undefined; pin: string; pool: Candidate[]; chosenIdx: number }> = {};
+    const chainPlanByRole: Record<string, ChainPlan> = {};
     /** Roles whose `providerPin` matched no route: left unchanged, their current chain preserved. */
     const pinUnmatched: string[] = [];
     const probe = deps.probeModel ?? probeModel;
@@ -436,7 +477,16 @@ export async function runUpdater(trigger: Trigger, deps: Deps, opts?: { force?:
       // thinking level (`openrouter/<id>@<slug>:<level>`) — omp's
       // `splitUpstreamRouting` parses the trailing `@<slug>` and applies
       // `compat.openRouterRouting = { only: [slug] }`.
-      const pin = def.providerPin !== undefined ? `@${def.providerPin}` : "";
+      //
+      // Auto-pin (spec #58): with the soft `preferOwnProvider` capability on and
+      // no manual pin, the chosen model's best route by the role's own value
+      // rides as that suffix, so the price the ranking assumed is the price the
+      // request pays. A manual `providerPin` is a hard gate and always wins; a
+      // model with no candidate route keeps default routing (bare selector).
+      const manualPin = def.providerPin;
+      const autoRoute = autoPinApplies(def) ? bestRoute(chosen.ranked.model, def) : null;
+      const pinSlug = manualPin ?? autoRoute?.providerSlug;
+      const pin = pinSlug !== undefined ? `@${pinSlug}` : "";
       const chosenRow = rowById.get(chosen.catalogId);
       // Append only a level the model's catalog thinking[] actually supports —
       // omp clamps unsupported levels, so an unsupported pin would run at a
@@ -463,7 +513,7 @@ export async function runUpdater(trigger: Trigger, deps: Deps, opts?: { force?:
       // came from. Values are built after the loop, once every key claim is known.
       if (settings.writeFallbackChains) {
         const key = suffix !== undefined && finalSelector.endsWith(`:${suffix}`) ? finalSelector.slice(0, -(suffix.length + 1)) : finalSelector;
-        chainPlanByRole[role] = { key, suffix, pin, pool, chosenIdx: pool.indexOf(chosen) };
+        chainPlanByRole[role] = { key, suffix, pin, pool, chosenIdx: pool.indexOf(chosen), def, autoPin: autoRoute !== null };
       }
     }
 
@@ -492,13 +542,41 @@ export async function runUpdater(trigger: Trigger, deps: Deps, opts?: { force?:
         const cheaper = after.filter((p) => p.ranked.priceEff <= chosenPrice);
         const pricier = after.filter((p) => p.ranked.priceEff > chosenPrice);
         const chainPool = [...cheaper, ...pricier].slice(0, settings.fallbackChainDepth);
-        chainUpserts[plan.key] = [
-          ...new Set(chainPool.map((p) => {
-            const row = rowById.get(p.catalogId);
-            const level = suffix !== undefined && row !== undefined && (META_LEVELS[suffix] === true || row.thinking.includes(suffix)) ? `:${suffix}` : "";
-            return `openrouter/${p.catalogId}${plan.pin}${level}`;
-          })),
-        ].filter((v) => v !== plan.key);
+        // A chain value's thinking level is appended only when the target's
+        // catalog entry advertises support (or the level is a meta level).
+        const levelFor = (catalogId: string): string => {
+          const row = rowById.get(catalogId);
+          return suffix !== undefined && row !== undefined && (META_LEVELS[suffix] === true || row.thinking.includes(suffix)) ? `:${suffix}` : "";
+        };
+        const values: string[] = [];
+        if (plan.autoPin) {
+          // Auto-pin chain (spec #58, expanded by #69): every gate-passing route
+          // of the primary model (all but the pinned best), then every
+          // gate-passing route of each fallback model, in the role's
+          // value-for-money score order (`rankedRoutes`, spec #71) — every entry
+          // bound to its route's provider, so a down primary
+          // provider falls back to the same model on another provider rather
+          // than a different model. `rankedRoutes` already applies every gate
+          // (non-degraded, endpoint filters, usable billed price, the
+          // maxPriceUsdPerM cap, the allowed-providers whitelist), so the chain
+          // carries exactly the routes the role can use. The dedup below
+          // collapses two routes that share a provider slug (same chain value),
+          // so the chain length is (R_primary − 1) + Σ R_fallback over distinct
+          // gate-passing provider slugs.
+          const chosenCandidate = plan.pool[plan.chosenIdx];
+          for (const r of rankedRoutes(chosenCandidate.ranked.model, plan.def).slice(1)) {
+            values.push(`openrouter/${chosenCandidate.catalogId}@${r.providerSlug}${levelFor(chosenCandidate.catalogId)}`);
+          }
+          for (const p of chainPool) {
+            for (const r of rankedRoutes(p.ranked.model, plan.def)) {
+              values.push(`openrouter/${p.catalogId}@${r.providerSlug}${levelFor(p.catalogId)}`);
+            }
+          }
+        } else {
+          // Manual pin (every value carries it) or no pin (bare values).
+          for (const p of chainPool) values.push(`openrouter/${p.catalogId}${plan.pin}${levelFor(p.catalogId)}`);
+        }
+        chainUpserts[plan.key] = [...new Set(values)].filter((v) => v !== plan.key);
         referenced.add(plan.key);
       }
       // Locked roles keep their current chain: the plugin neither rewrites nor

package/web/app.js

@@ -154,6 +154,7 @@ const TIPS = {
   focusProvenance: "Provenance: the benchmark's owner (the catalog row's dataset_org_id, falling back to dataset_slug) and the source's own per-entry org mix (the dominant lab and its share). A cross-check on the pool-derived composition axis: agree/disagree records whether the two concur. An annotation, never a gate — a vendor-populated source is warned but never drops a candidate; unknown means there is neither an owner nor a payload org mix.",
   focusCrossSource: "Cross-source: the zeroeval per-entry price/context compared against the plugin's own price/context for the models carrying the metric (the median relative divergence, within a 0.5 tolerance). The speed figure is informational only (rps vs tok/s). An annotation, never a gate — it never feeds the 1/price² blend; unknown means no model joined or the payload carried none of the four fields.",
   imageFilter: "Require image input (filters.image) — the gate that shrinks the vision role's eligible set.",
+  providerPin: "Hard provider pin: the OpenRouter provider slug this role's requests are routed to (a tiered slug like deepinfra/fp8 is accepted verbatim). Setting it opts the role out of the automatic best-route pin; empty = default OpenRouter routing.",
   features: "Opt-in capability presets (issue #40). Each flag applies the plugin's recommended settings for that capability to this role; an explicit knob value always wins. Export writes the flag, not the expanded values, so a future change to the recommendation keeps reaching the role.",
   featureState: "inherit = use the global flag (features.<id> in the lock file); on/off = a per-role override (roles.<role>.features.<id>) that beats the global in either direction.",
   featureKnob: "An individual knob the capability's recommended bundle fills. Leave it at inherit to take the recommendation; set a value to override it (an explicit value always wins over the flag).",
@@ -507,6 +508,15 @@ function renderExplain() {
   if (ex.keyReason !== "active") keyLine += " (reason: " + ex.keyReason + ")";
   panel.append(el("p", { class: "sub key-line", "data-tip": TIPS.key, text: keyLine }));
 
+  // The pin basis: a manual pin (from the edited def) overrides the automatic
+  // best-route pin the updater would write. Read-only here.
+  const manualPin = state.defs[state.role]?.providerPin;
+  if (manualPin) {
+    panel.append(el("p", { class: "sub pin-line", "data-tip": TIPS.providerPin, text: "pin: " + manualPin + " (manual)" }));
+  } else if (ex.autoPin) {
+    panel.append(el("p", { class: "sub pin-line", "data-tip": TIPS.providerPin, text: "auto pin: " + ex.autoPin }));
+  }
+
   panel.append(el("h3", { "data-tip": TIPS.composition, text: "Value composition" }));
   const comp = el("table", { class: "comp" });
   comp.append(
@@ -549,7 +559,7 @@ function renderExplain() {
   panel.append(el("p", { class: "cost", "data-tip": TIPS.lambda, text: "λ = " + ex.role.lambda.toFixed(5) + " $/quality-point" + (derived ? " (derived = " + LAMBDA_DERIVATION + ")" : " (override)") }));
   const thinkNote = ex.role.thinking === undefined ? "bare" : ":" + ex.role.thinking;
   const cacheNote = ex.role.cacheHitRate > 0 ? " · cache " + ex.role.cacheHitRate : "";
-  const ownNote = ex.ownProvider ? " · own lab" : "";
+  const ownNote = ex.ownProvider ? " · best route" : "";
   panel.append(el("p", { class: "cost", "data-tip": TIPS.costPenalty, text: "eff price $" + fmt(ex.cost.priceEff, 2) + "/M" + (ex.cost.priceEff !== ex.cost.billedPrice ? " (billed $" + fmt(ex.cost.billedPrice, 2) + " × " + thinkNote + ")" : " (" + thinkNote + ")") + cacheNote + ownNote + " · penalty = λ·price = " + fmt(ex.cost.penalty, 4) + " · value = q − penalty = " + fmt(ex.cost.value, 4) }));
 
   panel.append(el("h3", { "data-tip": TIPS.whyNotHigher, text: "Why not higher" }));
@@ -1011,6 +1021,19 @@ function renderEditor() {
   });
   panel.append(el("label", { class: "check" }, [imgCb, el("span", { "data-tip": TIPS.imageFilter, text: "requires image input (filters.image)" })]));
 
+  panel.append(el("h3", { "data-tip": TIPS.providerPin, text: "Provider pin" }));
+  const pin = el("input", { type: "text", class: "desc", "data-tip": TIPS.providerPin, value: def.providerPin || "", placeholder: "provider slug, e.g. deepinfra/fp8" });
+  pin.addEventListener("change", () => {
+    // Empty clears the key (default routing); a tiered slug is kept verbatim.
+    const value = pin.value.trim();
+    if (value === "") delete def.providerPin;
+    else def.providerPin = value;
+    renderEditor();
+    renderRoles();
+    scheduleRecompute();
+  });
+  panel.append(el("div", { class: "row-controls" }, [pin]));
+
   renderFeatures(panel);
 
   panel.append(el("h3", { "data-tip": TIPS.thinking, text: "Thinking level" }));