takomi 2.1.31 → 2.1.33

package/.pi/extensions/oauth-router/README.md

@@ -28,6 +28,7 @@ Pi extension that auto-loads and registers an `oauth-router` provider with multi
   - 429 cooldowns
   - transient failure penalties
   - client/network transport failure tracking without default account cooldown
+  - live Pi UI footer/notification updates when an upstream attempt, retry delay, failover, or final router error happens
   - 5 router-level client/network retries by default before pre-output failover, starting at 5s and doubling
   - auth failure quarantine
   - safe pre-output failover
@@ -47,7 +48,7 @@ The extension ships with two default upstream profiles:
    - api: `openai-responses`
    - default models: `gpt-4o`, `gpt-4.1`, `o4-mini`
 
-Edit `~/.pi/agent/oauth-router/config.json` to add more upstreams, swap endpoints, change model catalogs, or tune retry behavior. By default client-side transport failures such as `Codex SSE response headers timed out after 10000ms` retry the same account 5 times with exponential backoff (`5s`, `10s`, `20s`, `40s`, then capped at `60s`) before router failover. These failures are recorded but do not cool down an account unless `clientNetworkPenaltyMs` is set above `0`.
+Edit `~/.pi/agent/oauth-router/config.json` to add more upstreams, swap endpoints, change model catalogs, or tune retry behavior. By default client-side transport failures such as `Codex SSE response headers timed out after 10000ms` retry the same account 5 times with exponential backoff (`5s`, `10s`, `20s`, `40s`, then capped at `60s`) before router failover. While this is happening, Pi's footer shows the active retry/failover/error state so the UI no longer looks frozen. These failures are recorded but do not cool down an account unless `clientNetworkPenaltyMs` is set above `0`.
 
 ## Setup
 

package/.pi/extensions/oauth-router/config.ts

@@ -9,6 +9,10 @@ export const CONFIG_PATH = join(DATA_ROOT, "config.json");
 export const CREDENTIALS_PATH = join(DATA_ROOT, "credentials.json");
 export const STATE_PATH = join(DATA_ROOT, "state.json");
 
+const LEGACY_CODEX_CONTEXT_WINDOW = 272000;
+const SAFE_CODEX_CONTEXT_WINDOW = 240000;
+const CODEX_MODEL_IDS = new Set(["gpt-5.1", "gpt-5.4", "gpt-5.4-mini", "gpt-5.5"]);
+
 const DEFAULT_MODELS: RouterModelConfig[] = [
   {
     id: "gpt-4o",
@@ -43,7 +47,7 @@ const DEFAULT_MODELS: RouterModelConfig[] = [
     reasoning: true,
     input: ["text", "image"],
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    contextWindow: 272000,
+    contextWindow: SAFE_CODEX_CONTEXT_WINDOW,
     maxTokens: 128000,
   },
   {
@@ -52,7 +56,7 @@ const DEFAULT_MODELS: RouterModelConfig[] = [
     reasoning: true,
     input: ["text", "image"],
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    contextWindow: 272000,
+    contextWindow: SAFE_CODEX_CONTEXT_WINDOW,
     maxTokens: 128000,
   },
   {
@@ -61,7 +65,7 @@ const DEFAULT_MODELS: RouterModelConfig[] = [
     reasoning: true,
     input: ["text", "image"],
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    contextWindow: 272000,
+    contextWindow: SAFE_CODEX_CONTEXT_WINDOW,
     maxTokens: 128000,
   },
   {
@@ -70,7 +74,7 @@ const DEFAULT_MODELS: RouterModelConfig[] = [
     reasoning: true,
     input: ["text", "image"],
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    contextWindow: 272000,
+    contextWindow: SAFE_CODEX_CONTEXT_WINDOW,
     maxTokens: 128000,
   },
 ];
@@ -210,7 +214,12 @@ function mergeModelConfigs(candidateModels: RouterModelConfig[] | undefined): Ro
     const previous = merged.get(model.id) ?? ({} as RouterModelConfig);
     merged.set(model.id, { ...previous, ...deepClone(model), id: model.id });
   }
-  return Array.from(merged.values());
+  return Array.from(merged.values()).map((model) => {
+    if (CODEX_MODEL_IDS.has(model.id) && model.contextWindow === LEGACY_CODEX_CONTEXT_WINDOW) {
+      return { ...model, contextWindow: SAFE_CODEX_CONTEXT_WINDOW };
+    }
+    return model;
+  });
 }
 
 function mergeUpstreamConfigs(candidateUpstreams: RouterUpstreamConfig[] | undefined): RouterUpstreamConfig[] {

package/.pi/extensions/oauth-router/index.ts

@@ -1,23 +1,112 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { registerRouterCommands, formatStatusReport } from "./commands.ts";
 import { registerRouterProvider, RouterRuntime } from "./provider.ts";
+import type { RouterUiEvent } from "./types.ts";
 
-function updateFooter(pi: ExtensionAPI, runtime: RouterRuntime, notify = false) {
-  pi.on("session_start", async (_event, ctx) => {
-    const rows = runtime.getStatusRows();
-    const healthy = rows.filter((row) => {
-      if (!row.enabled) return false;
-      if (row.authHealth !== "ok") return false;
-      if (row.cooldownUntil && row.cooldownUntil > Date.now()) return false;
-      if (row.penaltyUntil && row.penaltyUntil > Date.now()) return false;
-      return true;
-    }).length;
-
-    ctx.ui.setStatus("oauth-router", `oauth-router ${healthy}/${rows.length || 0} healthy | ${runtime.getPolicy()}`);
-    if (notify) {
-      ctx.ui.notify("oauth-router loaded", "info");
+function getHealthSummary(runtime: RouterRuntime) {
+  const rows = runtime.getStatusRows();
+  const healthy = rows.filter((row) => {
+    if (!row.enabled) return false;
+    if (row.authHealth !== "ok") return false;
+    if (row.cooldownUntil && row.cooldownUntil > Date.now()) return false;
+    if (row.penaltyUntil && row.penaltyUntil > Date.now()) return false;
+    return true;
+  }).length;
+
+  return `oauth-router ${healthy}/${rows.length || 0} healthy | ${runtime.getPolicy()}`;
+}
+
+function formatDuration(ms?: number): string {
+  if (!ms || ms <= 0) return "now";
+  if (ms < 1_000) return `${Math.round(ms)}ms`;
+  return `${Math.round(ms / 1_000)}s`;
+}
+
+function truncate(text: string | undefined, max = 110): string {
+  if (!text) return "";
+  const clean = text.replace(/\s+/g, " ").trim();
+  return clean.length > max ? `${clean.slice(0, Math.max(0, max - 1))}…` : clean;
+}
+
+function formatRoute(event: RouterUiEvent): string {
+  const parts = [event.accountLabel || event.accountId, event.upstreamId].filter(Boolean);
+  return parts.length ? parts.join(" @ ") : "router";
+}
+
+function formatActivityStatus(event: RouterUiEvent): string {
+  const route = formatRoute(event);
+  const model = event.modelId ? `${event.modelId} ` : "";
+  const reason = truncate(event.message, 70);
+
+  switch (event.phase) {
+    case "attempt": {
+      const retry = event.retryAttempt && event.maxRetries
+        ? ` retry ${event.retryAttempt}/${event.maxRetries}`
+        : "";
+      return `oauth-router contacting ${model}via ${route}${retry}`;
+    }
+    case "retry":
+      return `oauth-router retry ${event.retryAttempt}/${event.maxRetries} in ${formatDuration(event.delayMs)} | ${reason || event.failureKind || "network error"}`;
+    case "failover":
+      return `oauth-router failover from ${route} | ${reason || event.failureKind || "upstream error"}`;
+    case "success":
+      return `oauth-router ok: ${model}via ${route}`;
+    case "error":
+      return `oauth-router error | ${reason || event.failureKind || "request failed"}`;
+  }
+}
+
+function notifyActivity(ctx: ExtensionContext, event: RouterUiEvent) {
+  if (event.phase === "attempt" || event.phase === "success") return;
+
+  const message = formatActivityStatus(event);
+  const level = event.phase === "error" ? "error" : "info";
+  ctx.ui.notify(message, level);
+}
+
+function installRouterUiBridge(pi: ExtensionAPI, runtime: RouterRuntime, notifyOnLoad = false) {
+  let activeCtx: ExtensionContext | undefined;
+
+  const setBaseStatus = (ctx: ExtensionContext) => {
+    activeCtx = ctx;
+    if (ctx.hasUI) ctx.ui.setStatus("oauth-router", getHealthSummary(runtime));
+  };
+
+  runtime.setUiReporter((event) => {
+    const ctx = activeCtx;
+    if (!ctx?.hasUI) return;
+    try {
+      ctx.ui.setStatus("oauth-router", formatActivityStatus(event));
+      notifyActivity(ctx, event);
+    } catch {
+      // Best-effort UI only; never disturb provider streaming.
     }
   });
+
+  pi.on("session_start", async (_event, ctx) => {
+    setBaseStatus(ctx);
+    if (notifyOnLoad) ctx.ui.notify("oauth-router loaded", "info");
+  });
+
+  pi.on("agent_start", async (_event, ctx) => {
+    setBaseStatus(ctx);
+  });
+
+  pi.on("turn_start", async (_event, ctx) => {
+    setBaseStatus(ctx);
+  });
+
+  pi.on("turn_end", async (_event, ctx) => {
+    setBaseStatus(ctx);
+  });
+
+  pi.on("agent_end", async (_event, ctx) => {
+    setBaseStatus(ctx);
+  });
+
+  pi.on("session_shutdown", async () => {
+    activeCtx = undefined;
+  });
 }
 
 export default function (pi: ExtensionAPI) {
@@ -25,7 +114,7 @@ export default function (pi: ExtensionAPI) {
 
   registerRouterProvider(pi, runtime);
   registerRouterCommands(pi, runtime);
-  updateFooter(pi, runtime, false);
+  installRouterUiBridge(pi, runtime, false);
 
   pi.registerCommand("router-debug-report", {
     description: "Emit a detailed oauth-router report",

package/.pi/extensions/oauth-router/provider.ts

@@ -25,6 +25,8 @@ import type {
   RouterErrorMessageInput,
   RouterModelConfig,
   RouterStatusRow,
+  RouterUiEvent,
+  RouterUiReporter,
   RouterUpstreamConfig,
   RoutingPolicyName,
   StoredRouterAccount,
@@ -122,6 +124,20 @@ function isClientNetworkFailure(lower: string): boolean {
   ].some((token) => lower.includes(token));
 }
 
+function isContextOverflowFailure(lower: string): boolean {
+  return [
+    "context_length_exceeded",
+    "context length exceeded",
+    "context window exceeded",
+    "exceeds the context window",
+    "exceeds the model's maximum context length",
+    "exceeds model's maximum context length",
+    "maximum context length",
+    "too many tokens",
+    "token limit exceeded",
+  ].some((token) => lower.includes(token));
+}
+
 function classifyFailure(
   status: number | undefined,
   headers: Record<string, string>,
@@ -135,6 +151,10 @@ function classifyFailure(
     return { kind: "rate-limit", status: status ?? 429, retryAfterMs, message };
   }
 
+  if (isContextOverflowFailure(lower)) {
+    return { kind: "context-overflow", status, message };
+  }
+
   if (status === 401 || status === 403 || lower.includes("unauthorized") || lower.includes("forbidden")) {
     return { kind: "auth", status: status ?? 401, message };
   }
@@ -176,6 +196,7 @@ export class RouterRuntime {
   private config: RouterConfig;
   private accounts: RouterAccountStore;
   private state: RouterStateStore;
+  private uiReporter?: RouterUiReporter;
 
   constructor() {
     this.config = loadRouterConfig();
@@ -190,6 +211,18 @@ export class RouterRuntime {
     this.state.pruneAccountIds(this.accounts.list().map((account) => account.id));
   }
 
+  setUiReporter(reporter?: RouterUiReporter) {
+    this.uiReporter = reporter;
+  }
+
+  private emitUi(event: RouterUiEvent) {
+    try {
+      this.uiReporter?.(event);
+    } catch {
+      // UI updates must never affect model streaming or retry behavior.
+    }
+  }
+
   getConfig(): RouterConfig {
     this.reloadConfig();
     return this.config;
@@ -446,6 +479,11 @@ export class RouterRuntime {
           this.state.recordClientNetworkFailure(accountId, failure.status, failure.message);
         }
         break;
+      case "context-overflow":
+        // Context-size failures are request-level, not account-health failures.
+        // Do not cool down or quarantine accounts; Pi needs the overflow error surfaced
+        // directly so its built-in compaction recovery can compact and retry.
+        break;
       case "fatal":
         this.state.markTransientFailure(accountId, this.config.transientPenaltyMs, failure.status ?? 500, failure.message);
         break;
@@ -468,17 +506,40 @@ export class RouterRuntime {
   ): Promise<{ completed: boolean; emittedMeaningfulOutput: boolean; failure?: FailureClassification }> {
     for (let retryIndex = 0; ; retryIndex += 1) {
       const result = await this.trySingleAccount(selection, outerStream, context, options);
+      const failure = result.failure;
       const canRetry =
         !result.completed &&
         !result.emittedMeaningfulOutput &&
-        result.failure?.kind === "client-network" &&
+        failure?.kind === "client-network" &&
         retryIndex < this.config.clientNetworkMaxRetries;
 
-      if (!canRetry) return result;
+      if (!canRetry || !failure) return result;
 
       const delayMs = this.getClientNetworkRetryDelayMs(retryIndex);
+      this.emitUi({
+        phase: "retry",
+        modelId,
+        accountId: selection.account.id,
+        accountLabel: selection.account.label,
+        upstreamId: selection.account.upstreamId,
+        failureKind: failure.kind,
+        status: failure.status,
+        message: failure.message,
+        retryAttempt: retryIndex + 1,
+        maxRetries: this.config.clientNetworkMaxRetries,
+        delayMs,
+      });
       await sleep(delayMs, options?.signal);
       this.state.markAttempt(selection.account.id, modelId);
+      this.emitUi({
+        phase: "attempt",
+        modelId,
+        accountId: selection.account.id,
+        accountLabel: selection.account.label,
+        upstreamId: selection.account.upstreamId,
+        retryAttempt: retryIndex + 2,
+        maxRetries: this.config.clientNetworkMaxRetries,
+      });
     }
   }
 
@@ -521,10 +582,20 @@ export class RouterRuntime {
             reason: "aborted",
             error: { ...event.error, stopReason: "aborted", errorMessage: message },
           });
-          return { completed: true, emittedMeaningfulOutput };
+          return {
+            completed: true,
+            emittedMeaningfulOutput,
+            failure: { kind: "fatal", status: responseStatus, message },
+          };
         }
 
         const failure = classifyFailure(responseStatus, responseHeaders, message, this.config);
+
+        if (failure.kind === "context-overflow") {
+          outerStream.push(event);
+          return { completed: true, emittedMeaningfulOutput, failure };
+        }
+
         this.markFailure(selection.account.id, failure);
 
         if (!emittedMeaningfulOutput) {
@@ -596,6 +667,13 @@ export class RouterRuntime {
             const message = lastFailure
               ? `No healthy oauth-router accounts remaining after failover. Last error: ${lastFailure.message}`
               : `No healthy oauth-router accounts are configured for model ${model.id}. Add accounts with /router-login add.`;
+            this.emitUi({
+              phase: "error",
+              modelId: model.id,
+              failureKind: lastFailure?.kind,
+              status: lastFailure?.status,
+              message,
+            });
             outer.push({ type: "error", reason: "error", error: createErrorMessage({ model, message }) });
             outer.end();
             return;
@@ -604,6 +682,13 @@ export class RouterRuntime {
           this.state.advanceCursor(policy, picked.nextCursor);
           tried.add(picked.selected.account.id);
           this.state.markAttempt(picked.selected.account.id, model.id);
+          this.emitUi({
+            phase: "attempt",
+            modelId: model.id,
+            accountId: picked.selected.account.id,
+            accountLabel: picked.selected.account.label,
+            upstreamId: picked.selected.account.upstreamId,
+          });
 
           let selection: DelegateSelection;
           try {
@@ -617,11 +702,39 @@ export class RouterRuntime {
             }
             lastFailure = { kind: "auth", status: 401, message };
             this.markFailure(picked.selected.account.id, lastFailure);
+            this.emitUi({
+              phase: "failover",
+              modelId: model.id,
+              accountId: picked.selected.account.id,
+              accountLabel: picked.selected.account.label,
+              upstreamId: picked.selected.account.upstreamId,
+              failureKind: lastFailure.kind,
+              status: lastFailure.status,
+              message: lastFailure.message,
+            });
             continue;
           }
 
           const result = await this.tryAccountWithClientNetworkRetries(selection, outer, context, model.id, options);
           if (result.completed) {
+            this.emitUi(result.failure
+              ? {
+                phase: "error",
+                modelId: model.id,
+                accountId: selection.account.id,
+                accountLabel: selection.account.label,
+                upstreamId: selection.account.upstreamId,
+                failureKind: result.failure.kind,
+                status: result.failure.status,
+                message: result.failure.message,
+              }
+              : {
+                phase: "success",
+                modelId: model.id,
+                accountId: selection.account.id,
+                accountLabel: selection.account.label,
+                upstreamId: selection.account.upstreamId,
+              });
             outer.end();
             return;
           }
@@ -630,13 +743,41 @@ export class RouterRuntime {
           lastFailure = result.failure;
 
           if (emittedMeaningfulOutput) {
+            this.emitUi({
+              phase: "error",
+              modelId: model.id,
+              accountId: selection.account.id,
+              accountLabel: selection.account.label,
+              upstreamId: selection.account.upstreamId,
+              failureKind: lastFailure?.kind,
+              status: lastFailure?.status,
+              message: lastFailure?.message ?? "Upstream failed after partial output; failover is unsafe.",
+            });
             outer.end();
             return;
           }
+
+          if (lastFailure) {
+            this.emitUi({
+              phase: "failover",
+              modelId: model.id,
+              accountId: selection.account.id,
+              accountLabel: selection.account.label,
+              upstreamId: selection.account.upstreamId,
+              failureKind: lastFailure.kind,
+              status: lastFailure.status,
+              message: lastFailure.message,
+            });
+          }
         }
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         const aborted = isAbortLike(message, options?.signal);
+        this.emitUi({
+          phase: "error",
+          modelId: model.id,
+          message: aborted ? "Request was aborted" : message,
+        });
         outer.push({ type: "error", reason: aborted ? "aborted" : "error", error: createErrorMessage({ model, message, stopReason: aborted ? "aborted" : "error" }) });
         outer.end();
       }