takomi 2.1.31 → 2.1.32

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/index.ts

@@ -1,41 +1,130 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { registerRouterCommands, formatStatusReport } from "./commands.ts";
-import { registerRouterProvider, RouterRuntime } from "./provider.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");
-    }
-  });
-}
-
-export default function (pi: ExtensionAPI) {
-  const runtime = new RouterRuntime();
-
-  registerRouterProvider(pi, runtime);
-  registerRouterCommands(pi, runtime);
-  updateFooter(pi, runtime, false);
-
-  pi.registerCommand("router-debug-report", {
-    description: "Emit a detailed oauth-router report",
-    handler: async () => {
-      pi.sendMessage({
-        customType: "oauth-router",
-        content: formatStatusReport(runtime),
-        display: true,
-        details: { source: "oauth-router", debug: true },
-      });
-    },
-  });
-}
+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 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) {
+  const runtime = new RouterRuntime();
+
+  registerRouterProvider(pi, runtime);
+  registerRouterCommands(pi, runtime);
+  installRouterUiBridge(pi, runtime, false);
+
+  pi.registerCommand("router-debug-report", {
+    description: "Emit a detailed oauth-router report",
+    handler: async () => {
+      pi.sendMessage({
+        customType: "oauth-router",
+        content: formatStatusReport(runtime),
+        display: true,
+        details: { source: "oauth-router", debug: true },
+      });
+    },
+  });
+}

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

@@ -25,6 +25,8 @@ import type {
   RouterErrorMessageInput,
   RouterModelConfig,
   RouterStatusRow,
+  RouterUiEvent,
+  RouterUiReporter,
   RouterUpstreamConfig,
   RoutingPolicyName,
   StoredRouterAccount,
@@ -176,6 +178,7 @@ export class RouterRuntime {
   private config: RouterConfig;
   private accounts: RouterAccountStore;
   private state: RouterStateStore;
+  private uiReporter?: RouterUiReporter;
 
   constructor() {
     this.config = loadRouterConfig();
@@ -190,6 +193,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;
@@ -468,17 +483,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,7 +559,11 @@ 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);
@@ -596,6 +638,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 +653,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 +673,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 +714,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();
       }

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

@@ -231,6 +231,24 @@ export interface RouterStreamInput {
   options?: SimpleStreamOptions;
 }
 
+export type RouterUiEventPhase = "attempt" | "retry" | "failover" | "success" | "error";
+
+export interface RouterUiEvent {
+  phase: RouterUiEventPhase;
+  modelId?: string;
+  accountId?: string;
+  accountLabel?: string;
+  upstreamId?: string;
+  failureKind?: FailureClassification["kind"];
+  status?: number;
+  message?: string;
+  retryAttempt?: number;
+  maxRetries?: number;
+  delayMs?: number;
+}
+
+export type RouterUiReporter = (event: RouterUiEvent) => void;
+
 export interface RouterErrorMessageInput {
   model: Model<Api>;
   message: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "takomi",
-  "version": "2.1.31",
+  "version": "2.1.32",
   "description": "🎯 Stop wrestling with AI. Start building with purpose. The artisan's toolkit for agent workflows, Codex skills, and original Takomi capabilities like 21st.dev integration.",
   "type": "module",
   "bin": {

package/src/pi-harness.js

@@ -209,8 +209,26 @@ export async function inspectInstalledTakomiPiHarness(home = HOME) {
   };
 }
 
-function runCommand(command, args) {
-  return spawnSync(command, args, { stdio: 'pipe', encoding: 'utf8', shell: process.platform === 'win32' });
+function quoteWindowsCommandArg(value) {
+  const text = String(value);
+  if (text.length === 0) return '""';
+  if (!/[\s"&|<>^()%!]/.test(text)) return text;
+  return `"${text.replace(/"/g, '\\"')}"`;
+}
+
+function resolveCommandForSpawn(command, args = []) {
+  if (process.platform !== 'win32') return { command, args };
+  if (/\.(exe|com)$/i.test(command)) return { command, args };
+
+  return {
+    command: 'cmd.exe',
+    args: ['/d', '/s', '/c', [command, ...args].map(quoteWindowsCommandArg).join(' ')],
+  };
+}
+
+export function runCommand(command, args) {
+  const resolved = resolveCommandForSpawn(command, args);
+  return spawnSync(resolved.command, resolved.args, { stdio: 'pipe', encoding: 'utf8', shell: false });
 }
 
 function runCommandWithTimeout(command, args, timeoutMs) {
@@ -220,9 +238,10 @@ function runCommandWithTimeout(command, args, timeoutMs) {
     let settled = false;
     let timedOut = false;
 
-    const child = spawn(command, args, {
+    const resolved = resolveCommandForSpawn(command, args);
+    const child = spawn(resolved.command, resolved.args, {
       stdio: ['ignore', 'pipe', 'pipe'],
-      shell: process.platform === 'win32',
+      shell: false,
       windowsHide: true,
     });
 
@@ -235,10 +254,17 @@ function runCommandWithTimeout(command, args, timeoutMs) {
 
     const timer = setTimeout(() => {
       timedOut = true;
-      try { child.kill(); } catch {}
-      setTimeout(() => {
-        try { child.kill('SIGKILL'); } catch {}
-      }, 1500).unref?.();
+      if (process.platform === 'win32' && child.pid) {
+        try { spawnSync('taskkill', ['/pid', String(child.pid), '/t', '/f'], { stdio: 'ignore' }); } catch {}
+      } else {
+        try { child.kill(); } catch {}
+        setTimeout(() => {
+          try { child.kill('SIGKILL'); } catch {}
+        }, 1500).unref?.();
+      }
+      try { child.stdout?.destroy(); } catch {}
+      try { child.stderr?.destroy(); } catch {}
+      finish({ status: null });
     }, timeoutMs);
     timer.unref?.();
 

package/src/pi-optional-features.js

@@ -1,8 +1,7 @@
 import fs from 'fs-extra';
-import { spawnSync } from 'child_process';
 import prompts from 'prompts';
 import pc from 'picocolors';
-import { detectPiCommand, getPiGlobalTargets } from './pi-harness.js';
+import { detectPiCommand, getPiGlobalTargets, runCommand } from './pi-harness.js';
 
 export const TAKOMI_PI_OPTIONAL_FEATURES = [
   {
@@ -43,10 +42,6 @@ export const TAKOMI_PI_OPTIONAL_FEATURES = [
   },
 ];
 
-function runCommand(command, args) {
-  return spawnSync(command, args, { stdio: 'pipe', encoding: 'utf8', shell: process.platform === 'win32' });
-}
-
 function packageIdentity(packageSpec) {
   if (!packageSpec.startsWith('npm:')) return packageSpec;
   const withoutPrefix = packageSpec.slice(4);