pi-bedrouter 0.4.1 → 0.7.0

package/README.md

@@ -4,7 +4,7 @@ A [Pi](https://pi.dev) extension for [bedrouter](https://github.com/bmelton/bedr
 
 - **finds bedrouter** (a configured checkout, or the npm dependency this package ships with) and installs or builds it when it is missing
 - **starts the server** when it is not already running, seeding `.env` and `bedrouter.json` from bedrouter's examples on first run
-- **registers a `bedrouter` provider** in Pi whose models come straight from `bedrouter.json`: the `auto` aliases (the router decides everything) plus each rung of each ladder
+- **registers a `bedrouter` provider** in Pi whose models come straight from `bedrouter.json`: one `auto` model plus each enabled rung in the stack
 - **switches the session to `bedrouter/auto`** when the server is healthy, so nobody has to pick a model
 - **shows what served each request in the footer**, live: routed model vs requested, class and deciding signal, the classifier's note, and the session's running cost against what the requested model would have cost
 - **totals the whole session**: every request carries Pi's session id (`x-bedrouter-session`), so bedrouter can add up the session across conversation keys, compaction and sub-agent calls; `/bedrouter usage` shows spend, what the asked-for model would have cost, and the breakdown by route
@@ -36,7 +36,7 @@ Bedrouter needs AWS credentials that can call Bedrock; see its README for the `a
 | `home` | `path` if set, else `~/.bedrouter` | Working directory for the server: `.env`, `bedrouter.json`, `bedrouter.log.jsonl`, `server.log` |
 | `port` | `20129` | Port to run / expect the server on (`BEDROUTER_PORT` overrides) |
 | `autoStart` | `true` | Start the server on session start when it is not running |
-| `autoSelect` | `"auto"` | Model id to switch the session to when bedrouter is healthy (`"auto"`, `"auto-oss"`, a rung alias, or `false` to leave the model alone) |
+| `autoSelect` | `"auto"` | Model id to select when no higher-precedence choice exists (`"auto"`, a rung alias, or `false` to leave the model alone) |
 | `debug` | `false` | Start the server with `BEDROUTER_DEBUG=1` (per-request trace in `server.log`) |
 | `footer` | `true` | Show the routing status line in Pi's footer |
 | `providerName` | `"bedrouter"` | Provider name registered in Pi |
@@ -46,9 +46,18 @@ Bedrouter needs AWS credentials that can call Bedrock; see its README for the `a
 Example for a developer with a checkout:
 
 ```json
-{ "path": "~/projects/ai/bedrouter", "autoSelect": "auto-oss" }
+{ "path": "~/projects/ai/bedrouter", "autoSelect": "auto" }
 ```
 
+Automatic selection applies only when the session did not name a provider or
+model and Pi's `defaultProvider` is absent or `bedrouter`. An explicit
+`--provider`/`--model` choice or a different `defaultProvider` leaves the session
+on that provider and does not start the bedrouter server. Set
+`PI_BEDROUTER_AUTOSELECT=0` to disable automatic startup and selection for one
+process. The provider remains registered, so `/model`, `--list-models`, and a
+later switch to `bedrouter/*` still work; switching later starts the server when
+`autoStart` is enabled.
+
 ## Commands
 
 | Command | Does |
@@ -56,12 +65,12 @@ Example for a developer with a checkout:
 | `/bedrouter` or `/bedrouter status` | Install location, server health (pid, version, region, classifier), registered models, current model, last decision |
 | `/bedrouter start` / `stop` / `restart` | Manage the server. It is shared by every Pi session, so `stop` affects all of them; see `stopOnExit` for what happens when Pi quits |
 | `/bedrouter install` | `npm install` the dependency, or `npm run build` a checkout that has no `dist/` |
-| `/bedrouter doctor` | Which credential source resolved, expiry, the loaded ladder |
+| `/bedrouter doctor` | Which credential source resolved, expiry, and the loaded stack |
 | `/bedrouter probe` | One 1-token request per rung: which models this AWS account can actually invoke |
 | `/bedrouter usage` | This Pi session so far: requests, tokens, spend (models + classifier), what the asked-for model would have cost, saved/over, and a per-route table. Whole-session totals need bedrouter ≥ 0.3; against an older server it shows the current conversation and says so. `usage all` lists recent sessions on the server (`*` marks this one) |
 | `/bedrouter report [--since t] [--session key] [--json]` | Savings report over the decision log (all clients, all sessions; `--session` narrows it to one) |
 | `/bedrouter log [n]` | The last n routing decisions, one line each |
-| `/bedrouter models` | Re-read `bedrouter.json` and re-register the provider (after editing the ladder) |
+| `/bedrouter models` | Re-read `bedrouter.json` and re-register the provider (after editing the stack) |
 | `/bedrouter fitnotes` | Merge model notes into `~/.pi/agent/workflows.json` so the pi-agents planner defaults to `bedrouter/auto` and only pins premium rungs for planning/review |
 | `/bedrouter config` | Show (and create) the settings file |
 
@@ -73,7 +82,7 @@ Under a coding agent every request carries tools and a large system prompt, so y
 
 ## Model ids
 
-From bedrouter's example config: `auto` (Anthropic ladder, router decides), `auto-oss` (gpt-oss ladder), and the rungs `haiku`, `sonnet`, `opus`, `gpt-oss-20b`, `gpt-oss-120b`. Picking a rung is a floor: bedrouter may still go up (explore, escalation) but not below it. Picking `auto` hands it the whole decision. The `cost` Pi shows for `auto` is the family's execute rung; bedrouter's log and `/bedrouter report` have what was actually charged.
+`auto` hands the whole choice to bedrouter's ordered, capability-filtered stack. Every enabled rung is also registered for explicit pinning. Pi reads each model's API, input modes, context window, output cap, and price from the capability block returned by `/v1/models`; bedrouter's log and `/bedrouter report` record what was actually charged.
 
 If your `~/.pi/agent/settings.json` has an `enabledModels` allowlist, add `bedrouter/auto` (and any rungs you want visible) or the provider's models will be hidden.
 

package/extensions/index.ts

@@ -15,9 +15,10 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { loadSettings, saveSettings, settingsPath, agentDir, type Settings } from "../src/settings.js";
 import * as br from "../src/bedrouter.js";
 import { fitNotes, piModels } from "../src/models.js";
+import { wantsUs } from "../src/selection.js";
 import { downLine, fromHeaders, readyLine, restartingLine, sessionsTable, statusLine, usageReport, type CostTotals, type LastDecision, type Paint } from "../src/footer.js";
 
-export default async function (pi: ExtensionAPI) {
+export async function activate(pi: ExtensionAPI, runtime: typeof br = br) {
   let settings = loadSettings();
   let last: LastDecision | null = null;
   let stats: CostTotals | null = null;            // footer totals: the session when the server supports it, else the last conversation
@@ -33,8 +34,8 @@ export default async function (pi: ExtensionAPI) {
   /** Whole-session totals from bedrouter (>= 0.3); falls back to the last conversation on older servers. */
   async function refreshStats(ctx: ExtensionContext): Promise<{ session: br.SessionStats | null; conversation: br.ConversationStats | null }> {
     const id = sessionId(ctx);
-    const session = id ? await br.session(settings, id) : null;
-    const conversation = !session && last?.conversation ? await br.conversation(settings, last.conversation) : null;
+    const session = id ? await runtime.session(settings, id) : null;
+    const conversation = !session && last?.conversation ? await runtime.conversation(settings, last.conversation) : null;
     stats = session ?? conversation ?? stats;
     return { session, conversation };
   }
@@ -47,24 +48,24 @@ export default async function (pi: ExtensionAPI) {
 
   /**
    * Register (or re-register) the provider. Source, in order: the running server's /v1/models (always right for the
-   * ladder that is actually serving), then bedrouter.json (home dir, then the checkout), then the shipped default.
+   * stack that is actually serving), then bedrouter.json (home dir, then the checkout), then the shipped default.
    */
   async function registerProvider(loc: br.Found | null): Promise<string> {
     let cfg: br.BedrouterConfig | null = null;
     let source = "";
-    const live = await br.liveConfig(settings);
-    if (live && Object.keys(live.families).length) { cfg = live; source = `${br.baseUrl(settings)}/v1/models`; }
+    const live = await runtime.liveConfig(settings);
+    if (live?.stack.length) { cfg = live; source = `${br.baseUrl(settings)}/v1/models`; }
     if (!cfg) {
-      const file = br.readConfig(settings, loc);
+      const file = runtime.readConfig(settings, loc);
       if ("config" in file) { cfg = file.config; source = file.path; }
     }
-    if (!cfg) { cfg = br.FALLBACK_CONFIG; source = "built-in default ladder (no server, no bedrouter.json yet)"; }
+    if (!cfg) { cfg = runtime.FALLBACK_CONFIG; source = "built-in default stack (no server, no bedrouter.json yet)"; }
     const models = piModels(cfg, br.baseUrl(settings));
     pi.registerProvider(settings.providerName, {
       name: "bedrouter (Bedrock, routed)",
       baseUrl: br.baseUrl(settings),
       apiKey: process.env.BEDROUTER_API_KEY || "bedrouter",
-      api: "anthropic-messages",
+      api: "openai-completions",
       models,
     });
     registeredModelIds = models.map((m) => m.id);
@@ -76,25 +77,25 @@ export default async function (pi: ExtensionAPI) {
   /** Locate → (install) → start → register. Returns a human summary. Never throws. */
   async function bringUp(ctx: ExtensionContext | null, opts: { install?: boolean; start?: boolean } = {}): Promise<{ ok: boolean; lines: string[] }> {
     const lines: string[] = [];
-    let loc = br.locate(settings);
+    let loc = runtime.locate(settings);
     if (!loc.found && opts.install) {
       lines.push(`bedrouter not found (${loc.reason}); installing…`);
-      const r = br.install(settings);
+      const r = runtime.install(settings);
       lines.push(r.log.trim().split("\n").slice(-6).join("\n"));
-      loc = br.locate(settings);
+      loc = runtime.locate(settings);
     }
     if (!loc.found) { lines.push(`bedrouter is not installed: ${loc.reason}. Run /bedrouter install (or: ${loc.installCmd}).`); return { ok: false, lines }; }
     if (!loc.cli && opts.install) {
       lines.push(`bedrouter at ${loc.dir} is not built; building…`);
-      const r = br.install(settings);
+      const r = runtime.install(settings);
       lines.push(r.log.trim().split("\n").slice(-6).join("\n"));
-      loc = br.locate(settings);
+      loc = runtime.locate(settings);
     }
     lines.push(await registerProvider(loc as br.Found));
     if (opts.start) {
-      const before = await br.health(settings);
-      const r = await br.start(settings, loc as br.Found);
-      for (const f of r.created) lines.push(`created ${f} from the example; edit it for this machine (AWS_PROFILE, ladder)`);
+      const before = await runtime.health(settings);
+      const r = await runtime.start(settings, loc as br.Found);
+      for (const f of r.created) lines.push(`created ${f} from the example; edit it for this machine (AWS_PROFILE, stack)`);
       if (r.ok) {
         if (!before?.ok) startedHere = true;
         lines.push(`bedrouter ${r.health.version} up on ${br.baseUrl(settings)} (pid ${r.health.pid}, region ${r.health.region}, classifier ${r.health.classifier ?? "off"})${!before?.ok ? `; started by this session, on quit: ${exitPolicyText()}` : "; was already running (not started here, left alone on quit)"}`);
@@ -106,6 +107,7 @@ export default async function (pi: ExtensionAPI) {
   async function autoSelect(ctx: ExtensionContext) {
     if (settings.autoSelect === false || !ctx.hasUI) return;
     if (isOurs(ctx)) return;
+    if (!wantsUs(settings)) return;
     const want = registeredModelIds.includes(settings.autoSelect) ? settings.autoSelect : registeredModelIds.find((id) => id.startsWith("auto")) ?? registeredModelIds[0];
     if (!want) return;
     const model = ctx.modelRegistry.find(settings.providerName, want);
@@ -118,7 +120,7 @@ export default async function (pi: ExtensionAPI) {
   // The factory is async, so pi waits for this: the provider exists for `pi --list-models` and `--provider bedrouter`
   // whether or not the server or a checkout is present yet.
   {
-    const loc = br.locate(settings);
+    const loc = runtime.locate(settings);
     await registerProvider(loc.found ? loc : null);
   }
 
@@ -126,22 +128,31 @@ export default async function (pi: ExtensionAPI) {
     lastCtx = ctx;
     if (ev.reason !== "startup" && ev.reason !== "new") { if (isOurs(ctx)) setStatus(ctx, statusLine(last, stats, paint(ctx))); return; }
     last = null; stats = null;
-    const h = await br.health(settings);
+    const h = await runtime.health(settings);
     serverUp = !!h?.ok;
-    if (!h?.ok && settings.autoStart) {
+    const intended = wantsUs(settings);
+    if (!h?.ok && settings.autoStart && intended) {
       const r = await bringUp(ctx, { install: true, start: true });
       serverUp = r.ok;
       if (!r.ok) { notify(ctx, `bedrouter: ${r.lines[r.lines.length - 1]}`, "warning"); setStatus(ctx, downLine("/bedrouter start", paint(ctx))); return; }
       const created = r.lines.filter((l) => l.startsWith("created "));
       if (created.length) notify(ctx, created.join("\n"), "warning");
-    } else if (!h?.ok) { setStatus(ctx, downLine("/bedrouter start", paint(ctx))); return; }
+    } else if (!h?.ok && intended) { setStatus(ctx, downLine("/bedrouter start", paint(ctx))); return; }
+    else if (!intended) { setStatus(ctx, undefined); return; }
     await autoSelect(ctx);
     if (isOurs(ctx)) setStatus(ctx, readyText(ctx));
   });
 
   pi.on("model_select", async (ev, ctx) => {
-    if (ev.model.provider === settings.providerName) setStatus(ctx, statusLine(last, stats, paint(ctx)));
-    else setStatus(ctx, undefined);
+    if (ev.model.provider !== settings.providerName) { setStatus(ctx, undefined); return; }
+    const h = await runtime.health(settings);
+    serverUp = !!h?.ok;
+    if (!h?.ok && settings.autoStart) {
+      const r = await bringUp(ctx, { install: true, start: true });
+      serverUp = r.ok;
+      if (!r.ok) { notify(ctx, `bedrouter: ${r.lines[r.lines.length - 1]}`, "warning"); setStatus(ctx, downLine("/bedrouter start", paint(ctx))); return; }
+    }
+    setStatus(ctx, serverUp ? statusLine(last, stats, paint(ctx)) : downLine("/bedrouter start", paint(ctx)));
   });
 
   // ---- live routing display ------------------------------------------------------------------------------------
@@ -176,7 +187,7 @@ export default async function (pi: ExtensionAPI) {
   async function checkHealth() {
     const ctx = lastCtx;
     if (!ctx || !isOurs(ctx)) return;
-    const h = await br.health(settings);
+    const h = await runtime.health(settings);
     const up = !!h?.ok;
     if (up === serverUp) return;
     serverUp = up;
@@ -301,8 +312,10 @@ export default async function (pi: ExtensionAPI) {
           break;
         }
         default:
-          show("bedrouter", `/bedrouter ${SUB.join(" | ")}\n\nstatus    install, server, provider, current model, last decision\nstart     start the server if needed (seeds .env / bedrouter.json on first run)\nstop      stop the server (shared by all Pi sessions)\ninstall   npm install / build the bedrouter dependency\ndoctor    credential source + loaded ladder;  probe: 1-token call per rung\nreport    savings report over the decision log (args pass through: --since, --json)\nlog [n]   last n routing decisions\nmodels    re-read bedrouter.json and re-register the provider\nfitnotes  write pi-agents model notes so the planner defaults to the router\nconfig    show/create ${settingsPath()}`);
+          show("bedrouter", `/bedrouter ${SUB.join(" | ")}\n\nstatus    install, server, provider, current model, last decision\nstart     start the server if needed (seeds .env / bedrouter.json on first run)\nstop      stop the server (shared by all Pi sessions)\ninstall   npm install / build the bedrouter dependency\ndoctor    credential source + loaded stack;  probe: 1-token call per rung\nreport    savings report over the decision log (args pass through: --since, --json)\nlog [n]   last n routing decisions\nmodels    re-read bedrouter.json and re-register the provider\nfitnotes  write pi-agents model notes so the planner defaults to the router\nconfig    show/create ${settingsPath()}`);
       }
     },
   });
 }
+
+export default activate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-bedrouter",
-  "version": "0.4.1",
+  "version": "0.7.0",
   "description": "Pi extension for bedrouter: starts the cost-aware Bedrock model router, registers it as a provider, and shows which model served each request",
   "keywords": [
     "pi-package",
@@ -43,7 +43,7 @@
     "prepublishOnly": "npm test && npm run typecheck"
   },
   "dependencies": {
-    "bedrouter": "^0.4.1"
+    "bedrouter": "^0.9.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.85.0"

package/src/bedrouter.ts

@@ -10,8 +10,9 @@ export type Health = { ok: boolean; region: string; pid: number; version: string
 export type ConversationStats = { key: string; requests: number; costUsd: number; requestedCostUsd: number; classifierCostUsd: number; inputTokens: number; outputTokens: number; escalations: number; class: string | null; routedModel: string | null; requestedModel: string | null; lastTs: string };
 /** Per-session totals from GET /v1/sessions/:key (bedrouter >= 0.3): every request this Pi session sent, across conversations. */
 export type SessionStats = { key: string; requests: number; errors: number; conversations: number; costUsd: number; requestedCostUsd: number; classifierCostUsd: number; inputTokens: number; outputTokens: number; cacheReadTokens: number; escalations: number; byRoute: Record<string, { requests: number; costUsd: number; requestedCostUsd: number; inputTokens: number; outputTokens: number }>; firstTs: string; lastTs: string };
-export type Rung = { alias: string; bedrockId: string; inputPerM: number; outputPerM: number };
-export type BedrouterConfig = { families: Record<string, Rung[]>; aliases?: Record<string, string>; routing?: { enabled?: boolean; classes?: Record<string, Record<string, string>>; classifier?: { enabled?: boolean; model?: string } } };
+export type Capabilities = { transport: "bedrock-runtime"; api: "converse"; toolUse: boolean; streaming: boolean; imageInput: boolean; structuredOutputs: boolean; promptCaching: boolean; contextWindow: number; maxOutput: number };
+export type Rung = { alias: string; bedrockId: string; vendor: string; enabled: boolean; inputPerM: number; outputPerM: number; serves: ("trivial" | "execute" | "explore")[]; capabilities: Capabilities };
+export type BedrouterConfig = { stack: Rung[]; aliases?: Record<string, string>; routing?: { enabled?: boolean; classifier?: { enabled?: boolean; model?: string } } };
 
 export type Found = { found: true; dir: string; cli: string | null; source: "settings.path" | "dependency"; version: string };
 export type Install = Found | { found: false; reason: string; installCmd: string };
@@ -91,39 +92,28 @@ export const health = (s: Settings) => getJson<Health>(`${baseUrl(s)}/health`);
 
 /** Reconstruct a BedrouterConfig from a running server's /v1/models, so the provider can be registered with no local files. */
 export async function liveConfig(s: Settings): Promise<BedrouterConfig | null> {
-  type M = { id: string; bedrock_id: string; bedrouter?: { family: string; rung: string; auto: boolean; inputPerM: number; outputPerM: number } };
+  type M = { id: string; bedrock_id: string; bedrouter?: Omit<Rung, "alias" | "bedrockId"> & { rung: string; auto: boolean } };
   const r = await getJson<{ data: M[] }>(`${baseUrl(s)}/v1/models`);
   if (!r?.data) return null;
-  const families: Record<string, Rung[]> = {};
+  const stack: Rung[] = [];
   const aliases: Record<string, string> = {};
   for (const m of r.data) {
     const b = m.bedrouter;
     if (!b) continue;
-    if (b.auto) { aliases[m.id] = `auto:${b.family}`; continue; }
-    const fam = (families[b.family] ??= []);
-    if (m.id === b.rung) { if (!fam.some((x) => x.alias === b.rung)) fam.push({ alias: b.rung, bedrockId: m.bedrock_id, inputPerM: b.inputPerM, outputPerM: b.outputPerM }); }
+    if (b.auto) continue;
+    if (m.id === b.rung && !stack.some((x) => x.alias === b.rung)) stack.push({ alias: b.rung, bedrockId: m.bedrock_id, vendor: b.vendor, enabled: b.enabled, serves: b.serves, capabilities: b.capabilities, inputPerM: b.inputPerM, outputPerM: b.outputPerM });
     else aliases[m.id] = b.rung;
   }
-  // /v1/models is a map, so ladder order is lost; restore cheapest-first by input price (what bedrouter's ladders are)
-  for (const fam of Object.values(families)) fam.sort((a, b) => a.inputPerM - b.inputPerM);
-  return { families, aliases };
+  return { stack, aliases };
 }
 
-/** Last resort when neither a server nor a config file is available: the shipped example ladder. */
+/** Last resort when neither a server nor a config file is available. */
 export const FALLBACK_CONFIG: BedrouterConfig = {
-  families: {
-    anthropic: [
-      { alias: "haiku", bedrockId: "us.anthropic.claude-haiku-4-5-20251001-v1:0", inputPerM: 1.1, outputPerM: 5.5 },
-      { alias: "sonnet", bedrockId: "us.anthropic.claude-sonnet-5", inputPerM: 2.2, outputPerM: 11 },
-      { alias: "opus", bedrockId: "us.anthropic.claude-opus-5", inputPerM: 5.5, outputPerM: 27.5 },
-    ],
-    openai: [
-      { alias: "gpt-oss-20b", bedrockId: "openai.gpt-oss-20b-1:0", inputPerM: 0.07, outputPerM: 0.2 },
-      { alias: "gpt-oss-120b", bedrockId: "openai.gpt-oss-120b-1:0", inputPerM: 0.15, outputPerM: 0.6 },
-    ],
-  },
-  aliases: { auto: "auto:anthropic", "auto-oss": "auto:openai" },
-  routing: { classes: { anthropic: { trivial: "haiku", execute: "sonnet", explore: "opus" }, openai: { execute: "gpt-oss-20b", explore: "gpt-oss-120b" } } },
+  stack: [
+    { alias:"nova-micro",bedrockId:"us.amazon.nova-micro-v1:0",vendor:"amazon",enabled:true,inputPerM:.035,outputPerM:.14,serves:["trivial"],capabilities:{transport:"bedrock-runtime",api:"converse",toolUse:true,streaming:true,imageInput:false,structuredOutputs:false,promptCaching:true,contextWindow:128000,maxOutput:5000}},
+    { alias:"gpt-oss-120b",bedrockId:"openai.gpt-oss-120b-1:0",vendor:"openai",enabled:true,inputPerM:.15,outputPerM:.6,serves:["execute"],capabilities:{transport:"bedrock-runtime",api:"converse",toolUse:true,streaming:true,imageInput:false,structuredOutputs:true,promptCaching:false,contextWindow:128000,maxOutput:16000}},
+    { alias:"glm-5",bedrockId:"zai.glm-5",vendor:"zai",enabled:true,inputPerM:1,outputPerM:3.2,serves:["execute","explore"],capabilities:{transport:"bedrock-runtime",api:"converse",toolUse:false,streaming:true,imageInput:false,structuredOutputs:true,promptCaching:false,contextWindow:200000,maxOutput:128000}}
+  ]
 };
 export const conversation = (s: Settings, key: string) => getJson<ConversationStats>(`${baseUrl(s)}/v1/conversations/${key}`);
 export const session = (s: Settings, key: string) => getJson<SessionStats>(`${baseUrl(s)}/v1/sessions/${encodeURIComponent(key)}`);

package/src/models.ts

@@ -1,50 +1,6 @@
-// Turn bedrouter's config into Pi provider model definitions.
 import type { BedrouterConfig, Rung } from "./bedrouter.js";
-
-export type PiModel = {
-  id: string; name: string; api: "anthropic-messages" | "openai-completions"; baseUrl: string; reasoning: boolean;
-  input: ("text" | "image")[]; cost: { input: number; output: number; cacheRead: number; cacheWrite: number }; contextWindow: number; maxTokens: number;
-};
-
-const FAMILY: Record<string, { api: PiModel["api"]; path: string; input: PiModel["input"]; contextWindow: number; maxTokens: number }> = {
-  anthropic: { api: "anthropic-messages", path: "", input: ["text", "image"], contextWindow: 200_000, maxTokens: 64_000 },
-  openai: { api: "openai-completions", path: "/v1", input: ["text"], contextWindow: 128_000, maxTokens: 32_000 },
-};
-
-const cost = (r: Rung) => ({ input: r.inputPerM, output: r.outputPerM, cacheRead: +(r.inputPerM * 0.1).toFixed(4), cacheWrite: +(r.inputPerM * 1.25).toFixed(4) });
-
-/** `auto` aliases first (what most people should pick), then each family's rungs. Client aliases (claude-sonnet-5 → sonnet) are omitted to keep /model short. */
-export function piModels(cfg: BedrouterConfig, base: string): PiModel[] {
-  const out: PiModel[] = [];
-  for (const [alias, target] of Object.entries(cfg.aliases ?? {})) {
-    const m = /^auto:(\w+)$/.exec(target);
-    if (!m) continue;
-    const family = m[1], rungs = cfg.families[family], f = FAMILY[family];
-    if (!rungs?.length || !f) continue;
-    const exec = cfg.routing?.classes?.[family]?.execute;
-    const rep = rungs.find((r) => r.alias === exec) ?? rungs[0];
-    out.push({ id: alias, name: `Auto · ${family} ladder (${rungs.map((r) => r.alias).join(" → ")})`, api: f.api, baseUrl: base + f.path, reasoning: true, input: f.input, cost: cost(rep), contextWindow: f.contextWindow, maxTokens: f.maxTokens });
-  }
-  for (const [family, rungs] of Object.entries(cfg.families)) {
-    const f = FAMILY[family];
-    if (!f) continue;
-    for (const r of rungs) out.push({ id: r.alias, name: `${r.alias} · ${family} (${r.bedrockId})`, api: f.api, baseUrl: base + f.path, reasoning: true, input: f.input, cost: cost(r), contextWindow: f.contextWindow, maxTokens: f.maxTokens });
-  }
-  return out;
-}
-
-/** pi-agents "fit notes" (~/.pi/agent/workflows.json → models) so the planner prefers the router and never pins premium rungs by default. */
-export function fitNotes(cfg: BedrouterConfig, provider: string): Record<string, string> {
-  const notes: Record<string, string> = {};
-  for (const [alias, target] of Object.entries(cfg.aliases ?? {})) {
-    if (/^auto:/.test(target)) notes[`${provider}/${alias}`] = "default for every node: bedrouter picks the cheapest adequate model per request and escalates on failure";
-  }
-  for (const [family, rungs] of Object.entries(cfg.families)) {
-    const classes = cfg.routing?.classes?.[family] ?? {};
-    for (const r of rungs) {
-      const cls = Object.entries(classes).find(([, a]) => a === r.alias)?.[0];
-      notes[`${provider}/${r.alias}`] = cls === "explore" ? "pin only for planning, final review, reduces" : cls === "trivial" ? "pin only for titles, summaries, extraction" : cls === "execute" ? "pin only when a node must not be routed; ordinary implementation" : "pinned rung, bypasses routing";
-    }
-  }
-  return notes;
-}
+export type PiModel={id:string;name:string;api:"openai-completions";baseUrl:string;reasoning:boolean;input:("text"|"image")[];cost:{input:number;output:number;cacheRead:number;cacheWrite:number};contextWindow:number;maxTokens:number};
+const cost=(r:Rung)=>({input:r.inputPerM,output:r.outputPerM,cacheRead:+(r.inputPerM*.1).toFixed(4),cacheWrite:+(r.inputPerM*1.25).toFixed(4)});
+const model=(id:string,r:Rung,base:string,name:string):PiModel=>({id,name,api:"openai-completions",baseUrl:base+"/v1",reasoning:true,input:r.capabilities.imageInput?["text","image"]:["text"],cost:cost(r),contextWindow:r.capabilities.contextWindow,maxTokens:r.capabilities.maxOutput});
+export function piModels(cfg:BedrouterConfig,base:string):PiModel[]{const enabled=cfg.stack.filter(r=>r.enabled),rep=enabled.find(r=>r.serves.includes("execute"))??enabled[0],out:PiModel[]=[];if(rep){const auto={...rep,capabilities:{...rep.capabilities,imageInput:enabled.some(r=>r.capabilities.imageInput),contextWindow:Math.max(...enabled.map(r=>r.capabilities.contextWindow)),maxOutput:Math.max(...enabled.map(r=>r.capabilities.maxOutput))}};out.push(model("auto",auto,base,`Auto · stack (${enabled.map(r=>r.alias).join(" → ")})`))}for(const r of enabled)out.push(model(r.alias,r,base,`${r.alias} · ${r.vendor} (${r.bedrockId})`));return out}
+export function fitNotes(cfg:BedrouterConfig,provider:string):Record<string,string>{const notes:Record<string,string>={[`${provider}/auto`]:"default for every node: bedrouter picks the first eligible model serving the request class and escalates on failure"};for(const r of cfg.stack.filter(r=>r.enabled)){const s=r.serves;notes[`${provider}/${r.alias}`]=s.includes("explore")?"pin only for planning or final review; ordinary work should use bedrouter/auto":s.includes("execute")?"pin only when a node must bypass routing; ordinary implementation should use bedrouter/auto":"pin only for titles, summaries, or extraction"}return notes}

package/src/selection.ts

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+import path from "node:path";
+import { agentDir, type Settings } from "./settings.js";
+
+/** True when this Pi process was launched with an explicit provider or model choice. */
+export function launchedWithExplicitModel(argv: string[] = process.argv.slice(2)): boolean {
+  for (const arg of argv) {
+    if (arg === "--") break;
+    if (arg === "--provider" || arg === "--model") return true;
+    if (arg.startsWith("--provider=") || arg.startsWith("--model=")) return true;
+  }
+  return false;
+}
+
+export function defaultProvider(): string | undefined {
+  try {
+    const value = JSON.parse(fs.readFileSync(path.join(agentDir(), "settings.json"), "utf8"));
+    return typeof value.defaultProvider === "string" ? value.defaultProvider : undefined;
+  } catch { return undefined; }
+}
+
+/** Whether automatic startup/selection should claim this session for bedrouter. */
+export function wantsUs(
+  settings: Pick<Settings, "providerName">,
+  options: { argv?: string[]; env?: NodeJS.ProcessEnv; defaultProvider?: () => string | undefined } = {},
+): boolean {
+  const env = options.env ?? process.env;
+  if (env.PI_BEDROUTER_AUTOSELECT === "0") return false;
+  if (launchedWithExplicitModel(options.argv ?? process.argv.slice(2))) return false;
+  const provider = (options.defaultProvider ?? defaultProvider)();
+  return !provider || provider === settings.providerName;
+}

package/src/settings.ts

@@ -12,7 +12,7 @@ export type Settings = {
   port: number;
   /** Start the server on session start when it is not running. */
   autoStart: boolean;
-  /** Model id (from bedrouter's aliases, e.g. "auto" or "auto-oss") to switch the session to when bedrouter is healthy; false to leave the model alone. */
+  /** Model id (from bedrouter's aliases) to select only when no higher-precedence provider/model choice exists; false leaves the model alone. */
   autoSelect: string | false;
   /** Start the server with BEDROUTER_DEBUG=1 (per-request trace in server.log). */
   debug: boolean;