takomi 2.1.30 → 2.1.32

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/.pi/extensions/takomi-context-manager/diagnostics-tools.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import type { ContextManagerState } from "./state";
 import { renderReport } from "./diagnostics";

package/.pi/extensions/takomi-context-manager/index.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { loadConfig, DEFAULT_CONFIG } from "./config";
 import { createState } from "./state";
 import { collectSkillsFromOptions, collectSkillsFromXml, mergeSkills } from "./skill-registry";

package/.pi/extensions/takomi-context-manager/model-policy-gate.ts

@@ -1,7 +1,7 @@
 import { readFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { ContextManagerState } from "./state";
 import { recordBlocked } from "./state";
 import { resolveTakomiRoutingPolicy } from "../takomi-runtime/routing-policy";

package/.pi/extensions/takomi-context-manager/policy-tools.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import type { ContextManagerState } from "./state";
 import { syncReportLedger } from "./state";

package/.pi/extensions/takomi-context-manager/prerequisite-gates.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { ContextManagerConfig } from "./types";
 import type { ContextManagerState } from "./state";
 import { recordBlocked, syncReportLedger } from "./state";

package/.pi/extensions/takomi-context-manager/skill-tools.ts

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import type { ContextManagerState } from "./state";
 import { findSkill, normalizeName, sortedSkills } from "./skill-registry";

package/.pi/extensions/takomi-runtime/commands.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type {
   TakomiLaunchMode,
   TakomiRole,