pi-claude-billing-router 0.1.0 → 0.1.2

package/README.md

@@ -67,7 +67,10 @@ and re-shaped on every request.
 
 Percentages are **used** capacity. Colors: green < 70%, yellow 70–89%, red 90%+.
 Error states (`login needed`, `⚠ HTTP 400`, `(stale)`, `usage n/a`) are
-inherited from the upstream connector. `⚠ extra usage` only appears when a
+inherited from the upstream connector. A failed usage read (Anthropic's usage
+endpoint intermittently answers 429) is retried automatically with backoff
+(10s → 20s → 40s → 60s, or `Retry-After` when sent) instead of waiting for the
+next model response. `⚠ extra usage` only appears when a
 request billed extra usage **while the router intended the plan** — i.e. the
 Claude Code shaping is broken, not when credits were chosen on purpose.
 

package/lib/subscription-guard.ts

@@ -1347,6 +1347,54 @@ function stripAliasStubs(payload: Record<string, unknown>): Record<string, unkno
 	return { ...payload, tools: kept };
 }
 
+// Project request-local transcript state BEFORE providers serialize/cache/seal it.
+// In particular pi-background-tasks protects both cache positions and lineage;
+// changing the serialized tool list in before_provider_request is too late.
+function transformTranscript(messages: unknown[], plan: boolean, disableFilter: boolean): unknown[] {
+	const active = new Map<string, Record<string, unknown>>();
+	let previous = new Map<string, Record<string, unknown>>();
+	return messages.map((message) => {
+		if (!isPlainObject(message)) return message;
+		if (message.role !== "system") {
+			if (!plan || message.role !== "assistant" || !Array.isArray(message.content)) return message;
+			const content = remapBlockNames(message.content, "toolCall", (name) => {
+				const alias = FLAT_TO_MCP.get(lower(name));
+				return alias && registeredMcpAliases.has(lower(alias)) ? alias : undefined;
+			});
+			return content === message.content ? message : { ...message, content };
+		}
+		if (Array.isArray(message.toolsRemoved)) {
+			for (const tool of message.toolsRemoved) {
+				if (isPlainObject(tool) && typeof tool.name === "string") active.delete(lower(tool.name));
+			}
+		}
+		if (Array.isArray(message.toolsAdded)) {
+			for (const tool of message.toolsAdded) {
+				if (isPlainObject(tool) && typeof tool.name === "string") active.set(lower(tool.name), tool);
+			}
+		}
+		const tools = [...active.values()];
+		const projected = plan
+			? filterAndRemapTools(tools, disableFilter)!
+			: (stripAliasStubs({ tools }).tools as unknown[]);
+		const next = collectToolsByName(projected);
+		const toolsRemoved = [...previous.keys()].filter((name) => !next.has(name))
+			.map((name) => ({ name: previous.get(name)!.name }));
+		const toolsAdded = [...next.entries()].filter(([name, tool]) =>
+			JSON.stringify(previous.get(name)) !== JSON.stringify(tool)).map(([, tool]) => tool);
+		previous = next;
+		const result: Record<string, unknown> = { ...message, toolsAdded, toolsRemoved };
+		if (plan) {
+			result.content = rewriteSystemField(message.content);
+			if (isPlainObject(message.sections)) {
+				result.sections = Object.fromEntries(Object.entries(message.sections).map(([key, value]) =>
+					[key, typeof value === "string" ? rewritePromptText(value) : value]));
+			}
+		}
+		return result;
+	});
+}
+
 // ============================================================================
 // Extension entry point
 // ============================================================================
@@ -1377,6 +1425,18 @@ export default async function piClaudeCodeUse(pi: ExtensionAPI): Promise<void> {
 		return { message: rewritten as typeof event.message };
 	});
 
+	pi.on("context_with_system", (event, ctx) => {
+		const model = ctx.model;
+		if (model?.provider !== "anthropic" || !ctx.modelRegistry.isUsingOAuth(model)) return;
+		// Refresh before serialization, including tools registered after our
+		// before_agent_start handler. Keep the existing best-effort semantics.
+		try {
+			registerMcpAliases(pi, { cwd: typeof ctx.cwd === "string" ? ctx.cwd : undefined });
+		} catch { /* The existing aliases remain usable. */ }
+		return { messages: transformTranscript(event.messages, useSubscription(),
+			process.env.PI_CLAUDE_CODE_USE_DISABLE_TOOL_FILTER === "1") as typeof event.messages };
+	});
+
 	pi.on("before_provider_request", (event, ctx) => {
 		const model = ctx.model;
 		if (model?.provider !== "anthropic" || !ctx.modelRegistry.isUsingOAuth(model)) {
@@ -1452,6 +1512,8 @@ export const _test = {
 	},
 	syncAliasActivation,
 	transformPayload,
+	transformTranscript,
+	stripAliasStubs,
 	unaliasDisplayedProse,
 	unaliasToolCalls,
 };

package/lib/usage-status.ts

@@ -34,6 +34,10 @@ export const USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
 export const OPENAI_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 export const POLL_MIN_INTERVAL_MS = 30_000;
 export const IDLE_REFRESH_MS = 5 * 60_000;
+// Anthropic's usage endpoint intermittently answers 429; retry quickly with
+// backoff instead of showing "usage n/a" until the idle timer fires.
+export const RETRY_BASE_MS = 10_000;
+export const RETRY_MAX_MS = 60_000;
 export const OVERAGE_HEADER = "anthropic-ratelimit-unified-overage-in-use";
 const CONFLICT_PACKAGE = "@benvargas/pi-claude-code-use";
 // PCBR: the package this one was forked from must not run alongside it either.
@@ -214,6 +218,13 @@ export function shouldPoll(lastPollMs: number | undefined, nowMs: number, minInt
 	return lastPollMs === undefined || nowMs - lastPollMs >= minIntervalMs;
 }
 
+/** Delay before retrying a failed usage fetch: honors Retry-After, else exponential backoff. */
+export function retryDelayMs(attempt: number, retryAfterHeader?: string | null): number {
+	const retryAfter = retryAfterHeader ? Number(retryAfterHeader) : Number.NaN;
+	if (Number.isFinite(retryAfter) && retryAfter > 0) return Math.min(retryAfter * 1000, RETRY_MAX_MS);
+	return Math.min(RETRY_BASE_MS * 2 ** Math.max(0, attempt), RETRY_MAX_MS);
+}
+
 /** True when a settings `packages` array references the conflicting upstream package. */
 export function hasConflictingPackage(settings: unknown): boolean {
 	if (!isRecord(settings) || !Array.isArray(settings.packages)) return false;
@@ -249,6 +260,8 @@ type UsageProvider = "anthropic" | "openai-codex" | "openai";
 interface ProviderState extends StatusSnapshot {
 	lastPollMs: number | undefined;
 	inFlight: boolean;
+	retryAttempt: number;
+	retryTimer: ReturnType<typeof setTimeout> | undefined;
 }
 
 export default function usageStatus(pi: ExtensionAPI) {
@@ -267,6 +280,8 @@ export default function usageStatus(pi: ExtensionAPI) {
 				providerErrorStatus: undefined,
 				lastPollMs: undefined,
 				inFlight: false,
+				retryAttempt: 0,
+				retryTimer: undefined,
 			};
 			states.set(provider, state);
 		}
@@ -276,6 +291,23 @@ export default function usageStatus(pi: ExtensionAPI) {
 	const paint = (ui: StatusUi, color: string, text: string): string =>
 		ui.theme ? ui.theme.fg(color, text) : text;
 
+	function clearRetry(state: ProviderState): void {
+		if (state.retryTimer) clearTimeout(state.retryTimer);
+		state.retryTimer = undefined;
+		state.retryAttempt = 0;
+	}
+
+	function scheduleRetry(state: ProviderState, retryAfter?: string | null): void {
+		if (state.retryTimer) return;
+		const delay = retryDelayMs(state.retryAttempt, retryAfter);
+		state.retryAttempt += 1;
+		state.retryTimer = setTimeout(() => {
+			state.retryTimer = undefined;
+			if (currentCtx) void refresh(currentCtx, true);
+		}, delay);
+		state.retryTimer.unref?.();
+	}
+
 	function usageProvider(ctx: StatusCtx): UsageProvider | undefined {
 		const model = ctx.model;
 		if (!model) return undefined;
@@ -328,10 +360,12 @@ export default function usageStatus(pi: ExtensionAPI) {
 			if (response.status === 401 || response.status === 403) {
 				state.loginNeeded = true;
 				state.fetchFailed = false;
+				clearRetry(state);
 				return;
 			}
 			if (!response.ok) {
 				state.fetchFailed = true; // shown as "(stale)" / "usage n/a"
+				scheduleRetry(state, response.headers.get("retry-after"));
 				return;
 			}
 			const json: unknown = await response.json();
@@ -341,9 +375,12 @@ export default function usageStatus(pi: ExtensionAPI) {
 			state.loginNeeded = false;
 			// An unrecognized/empty payload counts as a failed read too.
 			state.fetchFailed = parsed.length === 0;
+			if (state.fetchFailed) scheduleRetry(state);
+			else clearRetry(state);
 		} catch {
 			// Keep last known data, but surface the failure in the status line.
 			state.fetchFailed = true;
+			scheduleRetry(state);
 		} finally {
 			state.inFlight = false;
 			// A different model may have been selected while the fetch was running.
@@ -471,6 +508,7 @@ export default function usageStatus(pi: ExtensionAPI) {
 	pi.on("session_shutdown", async () => {
 		if (idleTimer) clearInterval(idleTimer);
 		idleTimer = undefined;
+		for (const state of states.values()) clearRetry(state);
 		currentCtx = undefined;
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-claude-billing-router",
-	"version": "0.1.0",
+	"version": "0.1.2",
 	"description": "Route Claude Pro/Max OAuth requests in pi between your plan and extra-usage credits: plan first, automatic fallback to credits when the 5h window is exhausted, /billing override, live usage in the footer.",
 	"keywords": [
 		"pi-package",