takomi 2.1.25 → 2.1.26

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

@@ -1,4 +1,4 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import type { RouterConfig, RouterModelConfig, RouterUpstreamConfig } from "./types.ts";
@@ -96,6 +96,16 @@ const DEFAULT_UPSTREAMS: RouterUpstreamConfig[] = [
     oauthProviderId: "openai-codex",
     enabled: true,
     modelIds: ["gpt-5.1", "gpt-5.4", "gpt-5.4-mini", "gpt-5.5"],
+    usageProbe: {
+      enabled: true,
+      endpoints: [
+        "/wham/usage",
+        "/codex/usage",
+        "/codex/limits",
+        "/codex/rate_limits",
+        "/codex/subscription",
+      ],
+    },
   },
 ];
 
@@ -110,23 +120,71 @@ export const DEFAULT_CONFIG: RouterConfig = {
   upstreams: DEFAULT_UPSTREAMS,
 };
 
-function applySecurePermissions(path: string, mode: number) {
+function applySecurePermissions(filePath: string, mode: number) {
   try {
-    chmodSync(path, mode);
+    chmodSync(filePath, mode);
   } catch {
     // Best effort only. Windows commonly ignores POSIX chmod semantics.
   }
 }
 
-export function ensureDirectory(path: string) {
-  mkdirSync(path, { recursive: true, mode: 0o700 });
-  applySecurePermissions(path, 0o700);
+export function ensureDirectory(filePath: string) {
+  mkdirSync(filePath, { recursive: true, mode: 0o700 });
+  applySecurePermissions(filePath, 0o700);
 }
 
-export function writeJsonFile(path: string, value: unknown, secure = true) {
-  ensureDirectory(dirname(path));
-  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode: secure ? 0o600 : 0o644 });
-  applySecurePermissions(path, secure ? 0o600 : 0o644);
+function sleepSync(ms: number): void {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+const HELD_JSON_LOCKS = new Set<string>();
+
+export function withJsonFileLock<T>(filePath: string, fn: () => T): T {
+  const lockPath = `${filePath}.lock`;
+  if (HELD_JSON_LOCKS.has(lockPath)) return fn();
+  const started = Date.now();
+  while (true) {
+    try {
+      mkdirSync(lockPath, { mode: 0o700 });
+      break;
+    } catch {
+      try {
+        const ageMs = Date.now() - statSync(lockPath).mtimeMs;
+        if (ageMs > 30_000) rmSync(lockPath, { recursive: true, force: true });
+      } catch {
+        // The lock disappeared between mkdir attempts.
+      }
+      if (Date.now() - started > 10_000) {
+        throw new Error(`Timed out waiting for oauth-router JSON lock: ${lockPath}`);
+      }
+      sleepSync(50);
+    }
+  }
+
+  HELD_JSON_LOCKS.add(lockPath);
+  try {
+    return fn();
+  } finally {
+    HELD_JSON_LOCKS.delete(lockPath);
+    rmSync(lockPath, { recursive: true, force: true });
+  }
+}
+
+export function writeJsonFile(filePath: string, value: unknown, secure = true) {
+  ensureDirectory(dirname(filePath));
+  withJsonFileLock(filePath, () => {
+    const mode = secure ? 0o600 : 0o644;
+    const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    try {
+      writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode });
+      applySecurePermissions(tempPath, mode);
+      renameSync(tempPath, filePath);
+      applySecurePermissions(filePath, mode);
+    } catch (error) {
+      rmSync(tempPath, { force: true });
+      throw error;
+    }
+  });
 }
 
 function deepClone<T>(value: T): T {
@@ -160,7 +218,12 @@ function mergeUpstreamConfigs(candidateUpstreams: RouterUpstreamConfig[] | undef
     }
 
     const modelIds = Array.from(new Set([...(previous.modelIds ?? []), ...(upstream.modelIds ?? [])]));
-    merged.set(upstream.id, { ...previous, ...deepClone(upstream), id: upstream.id, modelIds });
+    const usageProbe = {
+      ...(previous.usageProbe ?? {}),
+      ...(upstream.usageProbe ?? {}),
+      endpoints: Array.from(new Set([...(previous.usageProbe?.endpoints ?? []), ...(upstream.usageProbe?.endpoints ?? [])])),
+    };
+    merged.set(upstream.id, { ...previous, ...deepClone(upstream), id: upstream.id, modelIds, usageProbe });
   }
   return Array.from(merged.values());
 }

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

@@ -1,9 +1,10 @@
 import { spawn } from "node:child_process";
+import { Buffer } from "node:buffer";
 import { randomUUID } from "node:crypto";
-import type { OAuthCredentials } from "@mariozechner/pi-ai";
-import { getOAuthProvider } from "@mariozechner/pi-ai/oauth";
+import type { OAuthCredentials, OAuthSelectPrompt } from "@earendil-works/pi-ai/oauth";
+import { getOAuthProvider } from "@earendil-works/pi-ai/oauth";
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import type { RouterUpstreamConfig, StoredRouterAccount } from "./types.ts";
+import type { RouterProviderQuotaWindow, RouterProviderUsageSnapshot, RouterUpstreamConfig, StoredRouterAccount } from "./types.ts";
 
 function now() {
   return Date.now();
@@ -51,6 +52,17 @@ async function promptRequired(ctx: ExtensionContext, message: string, placeholde
   return response;
 }
 
+async function selectOAuthOption(ctx: ExtensionContext, prompt: OAuthSelectPrompt): Promise<string | undefined> {
+  if (!prompt.options.length) return undefined;
+  if (!ctx.hasUI) return prompt.options[0]?.id;
+
+  const labels = prompt.options.map((option) => `${option.id} — ${option.label}`);
+  const choice = await ctx.ui.select(prompt.message, labels);
+  if (!choice) return undefined;
+  const id = choice.split(" — ")[0]?.trim();
+  return prompt.options.find((option) => option.id === id)?.id;
+}
+
 export async function createAccountFromUpstream(
   upstream: RouterUpstreamConfig,
   label: string,
@@ -91,12 +103,21 @@ export async function createAccountFromUpstream(
       ctx.ui.notify(`${provider.name}: ${info.instructions ?? "Finish login in your browser."}`, "info");
       ctx.ui.notify(info.url, "info");
     },
+    onDeviceCode(info) {
+      openUrlInBrowser(info.verificationUri);
+      ctx.ui.notify(`${provider.name}: device code ${info.userCode}`, "info");
+      ctx.ui.notify(`Open ${info.verificationUri} and enter code ${info.userCode}`, "info");
+    },
     onPrompt(prompt) {
       return promptRequired(ctx, prompt.message, prompt.placeholder);
     },
     onProgress(message) {
       ctx.ui.notify(message, "info");
     },
+    onSelect(prompt) {
+      return selectOAuthOption(ctx, prompt);
+    },
+    signal: ctx.signal,
   });
 
   const normalized = normalizeCredentials(credentials);
@@ -126,6 +147,260 @@ function toCredentials(account: StoredRouterAccount): OAuthCredentials {
   };
 }
 
+function decodeJwtPayload(token: string): Record<string, unknown> | undefined {
+  const [, payload] = token.split(".");
+  if (!payload) return undefined;
+
+  try {
+    const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized.padEnd(normalized.length + ((4 - (normalized.length % 4)) % 4), "=");
+    return JSON.parse(Buffer.from(padded, "base64").toString("utf8")) as Record<string, unknown>;
+  } catch {
+    return undefined;
+  }
+}
+
+function getStringClaim(claims: Record<string, unknown>, key: string): string | undefined {
+  const value = claims[key];
+  return typeof value === "string" && value ? value : undefined;
+}
+
+function getAudience(claims: Record<string, unknown>): string | string[] | undefined {
+  const audience = claims.aud;
+  if (typeof audience === "string") return audience;
+  if (Array.isArray(audience) && audience.every((item) => typeof item === "string")) return audience as string[];
+  return undefined;
+}
+
+function getOpenAIAuthClaim(claims: Record<string, unknown>): Record<string, unknown> | undefined {
+  const value = claims["https://api.openai.com/auth"];
+  return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
+}
+
+export function inspectAccountToken(account: StoredRouterAccount): RouterProviderUsageSnapshot {
+  const claims = decodeJwtPayload(account.access);
+  if (!claims) {
+    return {
+      fetchedAt: now(),
+      source: "unavailable",
+      accountId: typeof account.meta?.accountId === "string" ? account.meta.accountId : undefined,
+      expires: account.expires,
+      message: "Access token is not a readable JWT or exposes no local claims. Provider-side usage needs an authenticated usage endpoint.",
+    };
+  }
+
+  const openaiAuth = getOpenAIAuthClaim(claims);
+  const exp = typeof claims.exp === "number" && Number.isFinite(claims.exp) ? claims.exp * 1000 : account.expires;
+  const accountId =
+    (typeof account.meta?.accountId === "string" ? account.meta.accountId : undefined) ??
+    (openaiAuth && getStringClaim(openaiAuth, "chatgpt_account_id")) ??
+    getStringClaim(claims, "account_id");
+  const planType =
+    (typeof account.meta?.planType === "string" ? account.meta.planType : undefined) ??
+    (openaiAuth && (getStringClaim(openaiAuth, "plan_type") ?? getStringClaim(openaiAuth, "planType"))) ??
+    getStringClaim(claims, "plan_type") ??
+    getStringClaim(claims, "planType");
+
+  return {
+    fetchedAt: now(),
+    source: "token-claims",
+    accountId,
+    planType,
+    email: getStringClaim(claims, "email"),
+    subject: getStringClaim(claims, "sub"),
+    issuer: getStringClaim(claims, "iss"),
+    audience: getAudience(claims),
+    expires: exp,
+    claimKeys: Object.keys(claims).sort(),
+    message: "Token claims expose identity/expiry metadata only. 5h and weekly quota windows are not present in this token snapshot; local router-observed usage is shown separately.",
+  };
+}
+
+function firstNumber(...values: unknown[]): number | undefined {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    if (typeof value === "string" && value.trim() && Number.isFinite(Number(value))) return Number(value);
+  }
+  return undefined;
+}
+
+function firstString(...values: unknown[]): string | undefined {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function walkRecords(value: unknown, visit: (record: Record<string, unknown>) => void, depth = 0) {
+  if (depth > 8) return;
+  if (Array.isArray(value)) {
+    for (const item of value) walkRecords(item, visit, depth + 1);
+    return;
+  }
+  if (!isRecord(value)) return;
+  visit(value);
+  for (const item of Object.values(value)) walkRecords(item, visit, depth + 1);
+}
+
+function normalizeResetAt(record: Record<string, unknown>): number | undefined {
+  const seconds = firstNumber(record.reset_after_seconds, record.resetAfterSeconds, record.resets_in_seconds, record.resetsInSeconds);
+  if (seconds !== undefined) return now() + seconds * 1000;
+  const raw = firstNumber(record.reset_at, record.resetAt, record.resets_at, record.resetsAt, record.next_reset_at, record.nextResetAt);
+  if (raw === undefined) return undefined;
+  return raw < 10_000_000_000 ? raw * 1000 : raw;
+}
+
+function quotaFromRecord(label: string, record: Record<string, unknown>): RouterProviderQuotaWindow | undefined {
+  const limit = firstNumber(record.limit, record.cap, record.total, record.max, record.quota);
+  const remaining = firstNumber(record.remaining, record.available, record.left, record.remaining_messages, record.remainingMessages);
+  const used = firstNumber(record.used, record.consumed, record.current, record.used_messages, record.usedMessages);
+  const usedPercent = firstNumber(record.used_percent, record.usedPercent);
+  const percentRemaining = firstNumber(record.percent_remaining, record.percentRemaining, record.remaining_percent, record.remainingPercent) ?? (usedPercent !== undefined ? 100 - Math.max(0, Math.min(100, usedPercent)) : undefined);
+  const resetAt = normalizeResetAt(record);
+
+  if (limit === undefined && remaining === undefined && used === undefined && percentRemaining === undefined && resetAt === undefined) {
+    return undefined;
+  }
+
+  return {
+    label,
+    used,
+    limit,
+    remaining,
+    percentRemaining: percentRemaining !== undefined ? percentRemaining : limit && remaining !== undefined ? (remaining / limit) * 100 : undefined,
+    resetAt,
+  };
+}
+
+function mergeQuota(previous: RouterProviderQuotaWindow | undefined, next: RouterProviderQuotaWindow | undefined): RouterProviderQuotaWindow | undefined {
+  if (!previous) return next;
+  if (!next) return previous;
+  return { ...previous, ...next };
+}
+
+function extractProviderUsage(json: unknown): Pick<RouterProviderUsageSnapshot, "planType" | "fiveHour" | "weekly"> {
+  let planType: string | undefined;
+  let fiveHour: RouterProviderQuotaWindow | undefined;
+  let weekly: RouterProviderQuotaWindow | undefined;
+
+  walkRecords(json, (record) => {
+    planType ??= firstString(record.plan_type, record.planType, record.plan, record.subscription_plan, record.subscriptionPlan, record.account_plan, record.accountPlan);
+
+    const rateLimit = isRecord(record.rate_limit) ? record.rate_limit : undefined;
+    if (rateLimit) {
+      const primary = isRecord(rateLimit.primary_window) ? rateLimit.primary_window : isRecord(rateLimit.primaryWindow) ? rateLimit.primaryWindow : undefined;
+      const secondary = isRecord(rateLimit.secondary_window) ? rateLimit.secondary_window : isRecord(rateLimit.secondaryWindow) ? rateLimit.secondaryWindow : undefined;
+      fiveHour = mergeQuota(fiveHour, primary ? quotaFromRecord("5h", primary) : undefined);
+      weekly = mergeQuota(weekly, secondary ? quotaFromRecord("weekly", secondary) : undefined);
+    }
+
+    const name = [record.name, record.label, record.bucket, record.window, record.period, record.type, record.key, record.id]
+      .map((value) => (typeof value === "string" ? value.toLowerCase() : ""))
+      .join(" ");
+
+    const directFive = isRecord(record.five_hour) ? record.five_hour : isRecord(record.fiveHour) ? record.fiveHour : isRecord(record["5h"]) ? record["5h"] : undefined;
+    const directWeekly = isRecord(record.weekly) ? record.weekly : isRecord(record.week) ? record.week : isRecord(record["7d"]) ? record["7d"] : undefined;
+    fiveHour = mergeQuota(fiveHour, directFive ? quotaFromRecord("5h", directFive) : undefined);
+    weekly = mergeQuota(weekly, directWeekly ? quotaFromRecord("weekly", directWeekly) : undefined);
+
+    if (/5\s*h|five.?hour|primary.?window/.test(name)) {
+      fiveHour = mergeQuota(fiveHour, quotaFromRecord("5h", record));
+    }
+    if (/week|weekly|7\s*d|secondary.?window/.test(name)) {
+      weekly = mergeQuota(weekly, quotaFromRecord("weekly", record));
+    }
+  });
+
+  return { planType, fiveHour, weekly };
+}
+
+function resolveProbeUrl(baseUrl: string, endpoint: string): string {
+  if (/^https?:\/\//i.test(endpoint)) return endpoint;
+  return `${baseUrl.replace(/\/+$/, "")}/${endpoint.replace(/^\/+/, "")}`;
+}
+
+function collectRateLimitHeaders(headers: Headers): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const [key, value] of headers.entries()) {
+    if (/rate.?limit|reset|remaining|quota/i.test(key)) result[key] = value;
+  }
+  return result;
+}
+
+export async function refreshProviderUsageSnapshot(account: StoredRouterAccount, upstream: RouterUpstreamConfig): Promise<RouterProviderUsageSnapshot> {
+  const base = inspectAccountToken(account);
+  if (account.provider !== "openai-codex" || upstream.usageProbe?.enabled === false) return base;
+
+  const accountId = base.accountId;
+  const endpoints = Array.from(new Set(["/wham/usage", ...(upstream.usageProbe?.endpoints ?? [])]));
+  if (!accountId || endpoints.length === 0) {
+    return { ...base, message: `${base.message ?? "Token inspected."} No provider usage probe endpoints are configured.` };
+  }
+
+  let lastStatus: number | undefined;
+  let lastEndpoint: string | undefined;
+  let lastHeaders: Record<string, string> | undefined;
+  const errors: string[] = [];
+
+  for (const endpoint of endpoints) {
+    const url = resolveProbeUrl(upstream.baseUrl, endpoint);
+    lastEndpoint = url;
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${account.access}`,
+          "ChatGPT-Account-Id": accountId,
+          "chatgpt-account-id": accountId,
+          Originator: "codex_cli_rs",
+          originator: "codex_cli_rs",
+          "User-Agent": "codex_cli_rs/0.133.0 (Windows; x86_64) pi/oauth-router",
+          accept: "application/json",
+        },
+      });
+      lastStatus = response.status;
+      lastHeaders = collectRateLimitHeaders(response.headers);
+      const text = await response.text();
+      const json = text ? JSON.parse(text) : undefined;
+      const extracted = extractProviderUsage(json);
+      const hasQuota = Boolean(extracted.fiveHour || extracted.weekly || extracted.planType);
+      if (response.ok && hasQuota) {
+        return {
+          ...base,
+          source: extracted.fiveHour || extracted.weekly ? "provider" : "token-claims",
+          fetchedAt: now(),
+          planType: extracted.planType ?? base.planType,
+          fiveHour: extracted.fiveHour,
+          weekly: extracted.weekly,
+          endpoint: url,
+          status: response.status,
+          rateLimitHeaders: lastHeaders,
+          message: extracted.fiveHour || extracted.weekly
+            ? "Provider-side quota metadata was extracted from an authenticated ChatGPT/Codex endpoint."
+            : "Provider endpoint responded, but no 5h/weekly quota windows were found; token identity metadata is shown.",
+        };
+      }
+      errors.push(`${endpoint}: HTTP ${response.status}${hasQuota ? " partial metadata only" : " no quota fields"}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push(`${endpoint}: ${message}`);
+    }
+  }
+
+  return {
+    ...base,
+    fetchedAt: now(),
+    endpoint: lastEndpoint,
+    status: lastStatus,
+    rateLimitHeaders: lastHeaders,
+    message: `Provider quota probe did not find 5h/weekly windows. Tried ${endpoints.length} endpoint(s): ${errors.slice(0, 4).join("; ")}${errors.length > 4 ? "; …" : ""}`,
+  };
+}
+
 export async function refreshAccountCredentials(account: StoredRouterAccount): Promise<StoredRouterAccount> {
   if (account.provider === "api-key") return account;
 

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

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
-import { CREDENTIALS_PATH, writeJsonFile } from "./config.ts";
+import { CREDENTIALS_PATH, withJsonFileLock, writeJsonFile } from "./config.ts";
 import type { RouterCredentialStore, StoredRouterAccount } from "./types.ts";
 
 const EMPTY_STORE: RouterCredentialStore = {
@@ -73,6 +73,14 @@ export class RouterAccountStore {
     writeJsonFile(CREDENTIALS_PATH, this.data, true);
   }
 
+  private mutate(fn: () => void) {
+    withJsonFileLock(CREDENTIALS_PATH, () => {
+      this.data = this.load();
+      fn();
+      this.save();
+    });
+  }
+
   reload() {
     this.data = this.load();
   }
@@ -86,21 +94,33 @@ export class RouterAccountStore {
   }
 
   add(account: StoredRouterAccount) {
-    this.data.accounts.push(normalizeAccount(account));
-    this.save();
+    this.mutate(() => {
+      this.data.accounts.push(normalizeAccount(account));
+    });
   }
 
   update(account: StoredRouterAccount) {
-    const index = this.data.accounts.findIndex((item) => item.id === account.id);
-    if (index === -1) throw new Error(`Unknown account: ${account.id}`);
-    this.data.accounts[index] = normalizeAccount(account);
-    this.save();
+    this.mutate(() => {
+      const index = this.data.accounts.findIndex((item) => item.id === account.id);
+      if (index === -1) throw new Error(`Unknown account: ${account.id}`);
+      this.data.accounts[index] = normalizeAccount(account);
+    });
   }
 
   remove(id: string) {
-    const next = this.data.accounts.filter((account) => account.id !== id);
-    this.data.accounts = next;
-    this.save();
+    this.mutate(() => {
+      this.data.accounts = this.data.accounts.filter((account) => account.id !== id);
+    });
+  }
+
+  rename(id: string, label: string) {
+    const account = this.get(id);
+    if (!account) throw new Error(`Unknown account: ${id}`);
+    const nextLabel = label.trim();
+    if (!nextLabel) throw new Error("Account label cannot be empty");
+    account.label = nextLabel;
+    account.updatedAt = Date.now();
+    this.update(account);
   }
 
   setEnabled(id: string, enabled: boolean) {

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

@@ -13,7 +13,7 @@ import {
 } from "@mariozechner/pi-ai";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { loadRouterConfig } from "./config.ts";
-import { refreshAccountCredentials, getApiKeyForAccount } from "./oauth-flow.ts";
+import { refreshAccountCredentials, getApiKeyForAccount, refreshProviderUsageSnapshot } from "./oauth-flow.ts";
 import { RouterAccountStore } from "./oauth-store.ts";
 import { chooseEligibleAccount } from "./policies.ts";
 import { RouterStateStore } from "./state.ts";
@@ -82,6 +82,12 @@ function createErrorMessage({ model, message, stopReason = "error" }: RouterErro
   };
 }
 
+function isAbortLike(message?: string, signal?: AbortSignal, stopReason?: string): boolean {
+  if (signal?.aborted || stopReason === "aborted") return true;
+  const lower = (message ?? "").toLowerCase();
+  return lower.includes("abort") || lower.includes("cancelled") || lower.includes("canceled");
+}
+
 function classifyFailure(
   status: number | undefined,
   headers: Record<string, string>,
@@ -182,6 +188,10 @@ export class RouterRuntime {
     this.state.pruneAccountIds(this.accounts.list().map((account) => account.id));
   }
 
+  renameAccount(id: string, label: string) {
+    this.accounts.rename(id, label);
+  }
+
   setEnabled(id: string, enabled: boolean) {
     this.accounts.setEnabled(id, enabled);
     if (enabled) this.state.clearHealth(id);
@@ -191,6 +201,38 @@ export class RouterRuntime {
     this.accounts.setWeight(id, weight);
   }
 
+  clearAccountHealth(id: string) {
+    this.state.clearHealth(id);
+  }
+
+  getUsageSummaries() {
+    this.reloadConfig();
+    return this.accounts.list().map((account) => this.state.getUsageSummary(account.id));
+  }
+
+  getUsageSummary(id: string) {
+    this.reloadConfig();
+    if (!this.accounts.get(id)) throw new Error(`Unknown account: ${id}`);
+    return this.state.getUsageSummary(id);
+  }
+
+  async refreshUsageSnapshot(id: string) {
+    this.reloadConfig();
+    const account = this.accounts.get(id);
+    if (!account) throw new Error(`Unknown account: ${id}`);
+    const upstream = this.getUpstream(account.upstreamId);
+    if (!upstream) throw new Error(`Unknown upstream for account ${id}: ${account.upstreamId}`);
+    const snapshot = await refreshProviderUsageSnapshot(account, upstream);
+    this.state.setProviderUsage(id, snapshot);
+    return snapshot;
+  }
+
+  resetUsage(id: string) {
+    this.reloadConfig();
+    if (!this.accounts.get(id)) throw new Error(`Unknown account: ${id}`);
+    this.state.resetUsage(id);
+  }
+
   setPolicy(policy: RoutingPolicyName) {
     this.state.setPolicy(policy);
   }
@@ -372,7 +414,17 @@ export class RouterRuntime {
 
     for await (const event of inner) {
       if (event.type === "error") {
-        const failure = classifyFailure(responseStatus, responseHeaders, event.error.errorMessage || "Upstream request failed", this.config);
+        const message = event.error.errorMessage || "Upstream request failed";
+        if (isAbortLike(message, options?.signal, event.error.stopReason)) {
+          outerStream.push({
+            ...event,
+            reason: "aborted",
+            error: { ...event.error, stopReason: "aborted", errorMessage: message },
+          });
+          return { completed: true, emittedMeaningfulOutput };
+        }
+
+        const failure = classifyFailure(responseStatus, responseHeaders, message, this.config);
         this.markFailure(selection.account.id, failure);
 
         if (!emittedMeaningfulOutput) {
@@ -400,6 +452,7 @@ export class RouterRuntime {
           for (const pending of buffered) outerStream.push(pending);
           buffered.length = 0;
         }
+        this.state.recordUsage(selection.account.id, selection.modelConfig.id, event.message.usage, responseStatus ?? 200);
         this.state.markSuccess(selection.account.id, responseStatus ?? 200);
         return { completed: true, emittedMeaningfulOutput };
       }
@@ -418,6 +471,7 @@ export class RouterRuntime {
 
   stream(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream {
     this.reloadConfig();
+    this.state.clearAbortHealth(this.accounts.list().map((account) => account.id));
     const outer = createAssistantMessageEventStream();
 
     (async () => {
@@ -427,6 +481,12 @@ export class RouterRuntime {
 
       try {
         while (true) {
+          if (options?.signal?.aborted) {
+            outer.push({ type: "error", reason: "aborted", error: createErrorMessage({ model, message: "Request was aborted", stopReason: "aborted" }) });
+            outer.end();
+            return;
+          }
+
           const eligible = this.getEligibleAccounts(model.id, tried);
           const policy = this.getPolicy();
           const cursor = this.state.getCursor(policy);
@@ -450,6 +510,11 @@ export class RouterRuntime {
             selection = await this.prepareSelection(picked.selected, model, options);
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
+            if (isAbortLike(message, options?.signal)) {
+              outer.push({ type: "error", reason: "aborted", error: createErrorMessage({ model, message, stopReason: "aborted" }) });
+              outer.end();
+              return;
+            }
             lastFailure = { kind: "auth", status: 401, message };
             this.markFailure(picked.selected.account.id, lastFailure);
             continue;
@@ -471,7 +536,8 @@ export class RouterRuntime {
         }
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        outer.push({ type: "error", reason: "error", error: createErrorMessage({ model, message }) });
+        const aborted = isAbortLike(message, options?.signal);
+        outer.push({ type: "error", reason: aborted ? "aborted" : "error", error: createErrorMessage({ model, message, stopReason: aborted ? "aborted" : "error" }) });
         outer.end();
       }
     })();

package/.pi/extensions/oauth-router/scripts/vibe-verify.py

@@ -20,10 +20,6 @@ REQUIRED = [
     ROOT / "config.ts",
     ROOT / "types.ts",
     ROOT / "README.md",
-    ROOT / "docs" / "Project_Requirements.md",
-    ROOT / "docs" / "Coding_Guidelines.md",
-    ROOT / "docs" / "Builder_Prompt.md",
-    ROOT / "docs" / "issues" / "FR-001.md",
 ]
 EXPECTED_MODELS = ["oauth-router", "gpt-4o", "gpt-4.1", "o4-mini", "gpt-5.4"]
 PI_CANDIDATES = [