@zgltyq/pi-provider-claude 1.1.0 → 1.2.0

package/README.md

@@ -78,6 +78,19 @@ fail over between them: when the active account hits its rate / usage cap (429/5
 it's put on cooldown and the next turn transparently continues on the other account.
 Subscription billing is preserved (Pi detects the OAuth path from the token shape).
 
+**Priority:** array order in `claude-pool.json` IS the priority. `accounts[0]` is the
+primary — failover is non-sticky, so as soon as the primary's cooldown expires the
+pool returns to it automatically. Put your preferred account first.
+
+**Detection (v1.2.0):** pi-ai's anthropic transport only emits
+`after_provider_response` for *successful* requests — the Anthropic SDK throws on
+429/529 before that callback runs, so header-based detection alone never fires.
+Since v1.2.0 the primary detector pattern-matches the provider error that lands on
+the assistant message (`stopReason: "error"`) via `message_end`, including Claude's
+`"usage limit reached|<epoch>"` reset timestamps for accurate cooldowns. When a cap
+is hit, the turn errors once, the pool flips (with a UI notification), and you just
+resend your message to continue on the other account.
+
 It is **inert** unless `<agentDir>/claude-pool.json` exists with ≥2 accounts and
 `"enabled" !== false`.
 

package/index.ts

@@ -336,7 +336,10 @@ function persistPool(): void {
 
 function poolSelectActive(): void {
 	const now = Date.now();
-	if (poolCooldownUntil[poolActive] <= now) return; // active still usable
+	// Priority = array order: always prefer the LOWEST-index account that is
+	// not cooling down (accounts[0] is the primary, e.g. "work"). This makes
+	// failover non-sticky: as soon as the primary's cooldown expires, we
+	// return to it instead of staying on the fallback account.
 	let pick = -1;
 	for (let i = 0; i < poolAccounts.length; i++) {
 		if (poolCooldownUntil[i] <= now) {
@@ -391,6 +394,10 @@ function poolMarkRateLimited(headers?: Record<string, string>): void {
 		const n = Number(ra);
 		if (Number.isFinite(n)) until = n > 1e9 ? n * 1000 : now + n * 1000; // epoch-seconds vs delta-seconds
 	}
+	poolMarkRateLimitedUntil(until);
+}
+
+function poolMarkRateLimitedUntil(until: number): void {
 	poolCooldownUntil[poolActive] = until;
 	poolLog(
 		`rate-limited ${poolAccounts[poolActive].label} until ${new Date(until).toISOString()}`,
@@ -398,6 +405,34 @@ function poolMarkRateLimited(headers?: Record<string, string>): void {
 	poolSelectActive();
 }
 
+// Rate/usage-cap detection from ERROR MESSAGES.
+//
+// pi-ai's anthropic provider only invokes onResponse (→ after_provider_response)
+// for SUCCESSFUL requests — on a 429/529 the Anthropic SDK throws before that
+// callback, so the header-based hook above never sees rate limits in practice.
+// The thrown error instead lands on the assistant message as stopReason:"error"
+// + errorMessage, which flows through message_end. We pattern-match it there.
+const POOL_LIMIT_RE =
+	/\b429\b|\b529\b|rate[ _-]?limit|usage[ _-]?limit|overloaded_error|quota/i;
+
+// Claude subscription cap messages often carry a reset epoch after a pipe,
+// e.g. "Claude AI usage limit reached|1750000000".
+function poolParseResetEpoch(message: string): number | undefined {
+	const m = message.match(/\|(\d{9,13})\b/);
+	if (!m) return undefined;
+	const n = Number(m[1]);
+	return n > 1e12 ? n : n * 1000;
+}
+
+// Returns true if the error was a rate/usage cap and the pool reacted.
+function poolHandleErrorMessage(errorMessage: string): boolean {
+	if (!POOL_LIMIT_RE.test(errorMessage)) return false;
+	const until =
+		poolParseResetEpoch(errorMessage) ?? Date.now() + POOL_DEFAULT_COOLDOWN_MS;
+	poolMarkRateLimitedUntil(until);
+	return true;
+}
+
 // Read the current single-slot anthropic OAuth creds from auth.json.
 function readAnthropicAuth():
 	| { refresh: string; access: string; expires: number }
@@ -518,7 +553,51 @@ function setupPool(pi: ExtensionAPI): void {
 		await prep();
 	});
 
-	// Observe rate/usage-cap responses → cooldown the active account + flip.
+	// PRIMARY rate/usage-cap detector: provider errors surface on the assistant
+	// message (stopReason "error"), not via after_provider_response (the SDK
+	// throws on 429/529 before pi-ai's onResponse callback runs).
+	pi.on("message_end", async (event, ctx) => {
+		try {
+			const model = ctx.model;
+			if (
+				!model ||
+				model.provider !== "anthropic" ||
+				!ctx.modelRegistry.isUsingOAuth(model)
+			)
+				return undefined;
+			const msg = event.message as {
+				role?: string;
+				stopReason?: string;
+				errorMessage?: string;
+			};
+			if (
+				msg.role !== "assistant" ||
+				msg.stopReason !== "error" ||
+				typeof msg.errorMessage !== "string"
+			)
+				return undefined;
+			const prev = poolAccounts[poolActive]?.label;
+			if (!poolHandleErrorMessage(msg.errorMessage)) return undefined;
+			const next = poolAccounts[poolActive]?.label;
+			if (next !== prev) {
+				await poolEnsureFresh(poolActive);
+				ctx.ui.notify(
+					`Claude account "${prev}" hit its limit → switched to "${next}". Resend your message to continue.`,
+					"warning",
+				);
+			} else {
+				ctx.ui.notify(
+					`Claude account "${prev}" hit its limit and all pooled accounts are cooling down — retrying on the one that frees up soonest.`,
+					"warning",
+				);
+			}
+		} catch {
+			/* detection must never break the message path */
+		}
+		return undefined;
+	});
+
+	// Secondary detector (kept for transports that DO surface response headers).
 	pi.on("after_provider_response", (event: unknown) => {
 		try {
 			const e = event as {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgltyq/pi-provider-claude",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Claude (Anthropic OAuth/subscription) compatibility layer for pi-coding-agent — keeps ALL extension tools usable under the Claude subscription by mapping unknown flat tool names to mcp__pi__<name> on the wire instead of dropping them, plus optional multi-account failover. Self-contained fork of the tool half of @benvargas/pi-claude-code-use.",
   "author": "Leechael",
   "license": "MIT",