pi-better-harness 0.40.2 → 0.40.3

package/node_modules/pi-better-model-router/README.md

@@ -104,10 +104,12 @@ DeepSeek also excludes Chinese public holidays. The bundled holiday list is curr
 - Compare estimated uncached input and output cost using catalog rates, bundled schedules, and policy overrides.
 - On equal cost, prefer DeepSeek by default. If the preferred provider is unavailable, preserve the previous eligible model, then use candidate order.
 - Keep a turn's model while it is still the cheapest, and move the turn to the other provider when that provider becomes strictly cheaper at a price boundary. Equal cost keeps the current provider, so a switch never pays a cold prompt cache for no gain.
-- On a retry after any error, exclude the failed provider for the rest of that user turn, so the retry uses the other candidate.
+- On a retry, send the request to the other candidate. A rejected request, such as a `400`, a bad schema, or an invalid key, keeps that provider out for the rest of the user turn; a timeout, connection failure, `429`, or overloaded endpoint only demotes it, so the turn keeps both routes.
+- When every candidate is excluded but at least one failed transiently, retry the model the turn already uses instead of ending the turn. Only rejected requests can end it with no route left.
 - Preserve the failed model only after a context overflow, because Pi retries that request after compacting the conversation and a switch would pay a cold cache.
-- Report excluded providers as router state only when that list changes, so a long session does not append one state entry per request.
-- Stop with an error when all candidates are unavailable or excluded. A new user turn clears exclusions.
+- Report excluded and demoted providers as router state only when those lists change, so a long session does not append one state entry per request.
+- Declare the virtual model's 1M context window and 384k output limit. Pi reads them whenever a response names no physical model, which is what the router's own routing error looks like, and an undeclared limit counts as zero. A zero window makes every conversation look over the compaction threshold, so Pi would compact after each routing error at any context size.
+- Stop with an error when every candidate is unavailable or rejected. A new user turn clears the exclusions.
 - Direct requests, such as compaction summaries, compare prices independently.
 
 Pi records the physical provider and model on responses and displays its native routed-model indicator. Pi clamps the selected thinking level to the physical model's supported levels.

package/node_modules/pi-better-model-router/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-model-router",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Price-aware virtual model routing for Pi.",
   "type": "module",
   "license": "MIT",

package/node_modules/pi-better-model-router/src/index.ts

@@ -1,56 +1,99 @@
 import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import { loadConfig } from "./config.ts";
-import { chooseCandidate, isCheapest, isContextOverflow, resolveCandidates } from "./routing.ts";
+import { chooseCandidate, isCheapest, isContextOverflow, isTransient, resolveCandidates } from "./routing.ts";
 
 // Structural contract keeps this standalone package buildable alongside the
 // monorepo's older SDK. Pi 1.4's native virtual-model API is required at runtime.
 type Level = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 interface Physical { model: Model<Api>; thinkingLevel?: Level }
+/** Providers this turn left behind. Hard failures end the turn; transient ones stay retryable. */
+export interface RouteState { failedProviders: string[]; transientProviders?: string[] }
 export interface RouteRequest {
   reason: "user" | "continuation" | "retry" | "direct";
   thinkingLevel: Level;
   previous?: Physical;
   failed?: Physical & { message: { errorMessage?: string } };
-  state?: { failedProviders: string[] };
+  state?: RouteState;
 }
-interface RouteResult { model: Model<Api>; thinkingLevel: Level; state?: { failedProviders: string[] } }
+interface RouteResult { model: Model<Api>; thinkingLevel: Level; state?: RouteState }
 export interface VirtualDefinition {
   provider: string; id: string; name: string; thinkingLevels: Level[];
+  contextWindow: number; maxTokens: number;
   route(request: RouteRequest, ctx: ExtensionContext): RouteResult;
 }
-function sameList(left: readonly string[], right: readonly string[]): boolean {
+// Both candidate families declare a 1M context window, so the router declares the shared
+// floor. Pi needs it whenever a response names no physical model, which is exactly the
+// router's own routing error: with no declared limit Pi falls back to a zero window, sees
+// every conversation as over the threshold, and compacts after each routing error.
+const CONTEXT_WINDOW = 1_000_000;
+const MAX_TOKENS = 384_000;
+function sameList(left: readonly string[] = [], right: readonly string[] = []): boolean {
   return left.length === right.length && left.every((value, index) => value === right[index]);
 }
+function sameState(left: RouteState, right: RouteState): boolean {
+  return sameList(left.failedProviders, right.failedProviders) &&
+    sameList(left.transientProviders, right.transientProviders);
+}
+function addProvider(list: readonly string[], provider: string): string[] {
+  return [...new Set([...list.filter(entry => entry !== provider), provider])];
+}
+function withoutProvider(list: readonly string[], provider: string): string[] {
+  return list.filter(entry => entry !== provider);
+}
 export function route(request: RouteRequest, ctx: ExtensionContext, now = new Date()): RouteResult {
   const config = loadConfig(getAgentDir(), ctx.cwd);
   const models = ctx.modelRegistry.getAvailable();
   const available = resolveCandidates(models, config);
   const find = (physical?: Physical) => physical && available.find(c =>
     c.provider === physical.model.provider && c.model === physical.model.id);
-  let failedProviders = request.reason === "user" || request.reason === "direct"
-    ? [] : request.state?.failedProviders ?? [];
+  // Pi retries a context overflow after compacting the conversation. That retry keeps the
+  // failed model, because a switch would pay a cold cache right after compaction.
+  if (request.reason === "retry" && request.failed && isContextOverflow(request.failed.message.errorMessage ?? "")) {
+    if (!find(request.failed)) throw new Error("Model router: failed model is no longer available.");
+    return { model: request.failed.model, thinkingLevel: request.failed.thinkingLevel ?? request.thinkingLevel };
+  }
+  const startsTurn = request.reason === "user" || request.reason === "direct";
+  // A new user turn clears every exclusion. Inside a turn a hard failure keeps that
+  // provider out; a transient one only sends the next attempt to the other candidate.
+  let failedProviders = startsTurn ? [] : request.state?.failedProviders ?? [];
+  let transientProviders = startsTurn ? [] : request.state?.transientProviders ?? [];
   if (request.reason === "retry" && request.failed) {
-    const errorMessage = request.failed.message.errorMessage ?? "";
-    if (isContextOverflow(errorMessage)) {
-      if (!find(request.failed)) throw new Error("Model router: failed model is no longer available.");
-      return { model: request.failed.model, thinkingLevel: request.failed.thinkingLevel ?? request.thinkingLevel };
+    const { provider } = request.failed.model;
+    if (isTransient(request.failed.message.errorMessage ?? "")) {
+      transientProviders = addProvider(transientProviders, provider);
+      failedProviders = withoutProvider(failedProviders, provider);
+    } else {
+      failedProviders = addProvider(failedProviders, provider);
+      transientProviders = withoutProvider(transientProviders, provider);
     }
-    // Any other failed request moves to the other candidate for the rest of the turn.
-    failedProviders = [...new Set([...failedProviders, request.failed.model.provider])];
   }
-  const eligible = available.filter(c => !failedProviders.includes(c.provider));
-  const sticky = request.reason === "continuation" ? find(request.previous) : undefined;
+  const previous = find(request.previous);
+  let eligible = available.filter(c => !failedProviders.includes(c.provider) && !transientProviders.includes(c.provider));
+  let recovered = false;
+  if (!eligible.length && transientProviders.length) {
+    // Retrying a provider that timed out beats ending the turn with no route at all.
+    eligible = available.filter(c => !failedProviders.includes(c.provider));
+    transientProviders = [];
+    recovered = true;
+  }
+  const sticky = request.reason === "continuation" ? previous : undefined;
   const keep = sticky !== undefined && eligible.includes(sticky) && isCheapest(config, sticky, eligible, now);
-  const candidate = keep ? sticky! : chooseCandidate(config, eligible, now, request.previous?.model);
+  // Reusing the model the turn already used preserves its prompt cache; the price policy
+  // can still move the turn at the next price boundary.
+  let reuse: typeof previous;
+  if (keep) reuse = sticky;
+  else if (recovered && previous !== undefined && eligible.includes(previous)) reuse = previous;
+  const candidate = reuse ?? chooseCandidate(config, eligible, now, request.previous?.model);
   const model = models.find(m => m.provider === candidate.provider && m.id === candidate.model)!;
+  const state: RouteState = { failedProviders, ...(transientProviders.length ? { transientProviders } : {}) };
   // Pi appends a session entry for every state object it receives, so report the
   // excluded providers only when that list changes.
-  const stored = request.state?.failedProviders ?? [];
   return {
     model,
-    thinkingLevel: keep ? request.previous?.thinkingLevel ?? request.thinkingLevel : request.thinkingLevel,
-    ...(sameList(stored, failedProviders) ? {} : { state: { failedProviders } }),
+    thinkingLevel: reuse !== undefined
+      ? request.previous?.thinkingLevel ?? request.thinkingLevel : request.thinkingLevel,
+    ...(sameState(request.state ?? { failedProviders: [] }, state) ? {} : { state }),
   };
 }
 export default function (pi: ExtensionAPI) {
@@ -61,6 +104,7 @@ export default function (pi: ExtensionAPI) {
   host.registerVirtualModel({
     provider: "router", id: "deepseek-flash-auto", name: "DeepSeek Flash Auto",
     thinkingLevels: ["off", "minimal", "low", "medium", "high", "xhigh", "max"],
+    contextWindow: CONTEXT_WINDOW, maxTokens: MAX_TOKENS,
     route,
   });
 }

package/node_modules/pi-better-model-router/src/routing.ts

@@ -95,8 +95,11 @@ export function chooseCandidate(config: RouterConfig, available: Candidate[], no
   return tied.find(candidate => candidate.provider === config.preferredProvider)
     ?? tied.find(candidate => candidate.provider === previous?.provider && candidate.model === previous.id) ?? tied[0];
 }
+// A retry can repair these: throttling, an overloaded or unreachable endpoint, or a
+// connection that failed before the provider answered. Everything else is final for the
+// turn, because the provider rejected the request itself.
 export function isTransient(error: string): boolean {
-  return /\b429\b|\b50[0234]\b|rate.?limit|overload|temporar(?:y|ily)|service unavailable|timed? ?out|ECONNRESET|ECONNREFUSED|fetch failed/i.test(error);
+  return /\b429\b|\b50[0234]\b|rate.?limit|overload|temporar(?:y|ily)|service unavailable|timed? ?out|connection (?:error|reset|refused|closed|lost)|socket hang up|upstream http|operation was aborted|\bterminated\b|E(?:PIPE|NOTFOUND|AI_AGAIN)|ECONNRESET|ECONNREFUSED|fetch failed/i.test(error);
 }
 // Pi retries a context overflow after compacting the conversation. That retry keeps
 // the failed model, because a switch would pay a cold cache right after compaction.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-harness",
-  "version": "0.40.2",
+  "version": "0.40.3",
   "description": "Pi extension bundle for a write sandbox, subagents, background tasks, SSH, goals, model routing, and Outcome & Todo.",
   "license": "MIT",
   "type": "module",
@@ -57,7 +57,7 @@
   "dependencies": {
     "pi-better-background-tasks": "0.14.2",
     "pi-better-goal": "0.12.1",
-    "pi-better-model-router": "0.1.2",
+    "pi-better-model-router": "0.1.3",
     "pi-ollama-cloud": "0.13.1",
     "pi-better-sandbox": "0.14.1",
     "pi-better-ssh": "0.1.4",