pi-better-harness 0.40.2 → 0.40.4

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

@@ -104,10 +104,14 @@ 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 context limits as a pair that fits the provider window. 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.
+
+  Both candidates share one 1,048,576-token window between input and output, but Pi treats `contextWindow` as the input allowance and `maxTokens` as room beyond it. The router therefore declares an input budget of `1,048,576 - 64,000` beside a 64,000-token output budget, so the two add up to the provider window. Declaring the raw 1,048,576 window beside a large output budget promises capacity no endpoint has: a 746,917-token conversation plus a 384,000-token completion is 1,130,917 tokens, which the provider rejects. The same pair also keeps Pi's compaction trigger below the point where output stops fitting.
+- 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.4",
   "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,107 @@
 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 {
+// Pi needs a declared window 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.
+//
+// Both candidate families share one 1,048,576-token window between input and output, but Pi
+// treats contextWindow as the input allowance and maxTokens as room beyond it. Declaring the
+// raw window beside a large output budget therefore promises capacity the provider does not
+// have: 746,917 tokens of history plus a 384,000-token completion is 1,130,917, and the
+// request is rejected for exceeding 1,048,576. Declare the input budget the shared window
+// leaves after the output budget instead, so both the compaction threshold and the
+// request-time clamp stay inside the real window.
+const PROVIDER_CONTEXT_WINDOW = 1_048_576;
+const MAX_TOKENS = 64_000;
+const CONTEXT_WINDOW = PROVIDER_CONTEXT_WINDOW - MAX_TOKENS;
+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 +112,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.4",
   "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.4",
     "pi-ollama-cloud": "0.13.1",
     "pi-better-sandbox": "0.14.1",
     "pi-better-ssh": "0.1.4",