@oh-my-pi/pi-ai 18.2.0 → 18.2.2

package/src/registry/oauth/perplexity.ts

@@ -1,15 +1,6 @@
 /**
- * Perplexity login and token refresh.
- *
- * Login paths (in priority order):
- * 1. macOS native app: reads JWT from NSUserDefaults (`defaults read ai.perplexity.mac authToken`)
- * 2. HTTP email OTP: `GET /api/auth/csrf` → `POST /api/auth/signin-email` → `POST /api/auth/signin-otp`
- *
- * No browser or manual cookie paste required.
- * Refresh: Socket.IO `refreshJWT` RPC over authenticated WebSocket connection.
- *
- * Protocol: Engine.IO v4 + Socket.IO v4 over WebSocket (bypasses Cloudflare managed challenge).
- * Architecture reverse-engineered from Perplexity macOS app (ai.perplexity.mac).
+ * Perplexity login via legacy macOS session borrowing, host-managed browser SSO,
+ * or HTTP email OTP (including authenticator challenges).
  */
 import * as os from "node:os";
 import { $env } from "@oh-my-pi/pi-utils";
@@ -80,10 +71,7 @@ function jwtToCredentials(jwt: string, email?: string): OAuthCredentials {
 // Desktop app extraction
 // ---------------------------------------------------------------------------
 
-/**
- * Read the Perplexity JWT from the native macOS Catalyst app's UserDefaults.
- * Tokens are stored in NSUserDefaults (not Keychain), readable by any same-UID process.
- */
+/** Read the legacy ai.perplexity.mac app's session; newer Mac apps use a restricted Keychain. */
 async function extractFromNativeApp(): Promise<string | null> {
 	if (os.platform() !== "darwin") return null;
 
@@ -99,7 +87,7 @@ async function extractFromNativeApp(): Promise<string | null> {
 }
 
 // ---------------------------------------------------------------------------
-// Socket.IO email OTP login
+// HTTP email OTP login
 // ---------------------------------------------------------------------------
 
 /**
@@ -274,32 +262,110 @@ async function httpEmailLogin(ctrl: OAuthController): Promise<OAuthCredentials>
 	return jwtToCredentials(token, trimmedEmail);
 }
 
+// ---------------------------------------------------------------------------
+// Browser SSO login
+// ---------------------------------------------------------------------------
+
+const SESSION_COOKIE_NAME = "__Secure-next-auth.session-token";
+const PERPLEXITY_BASE_URL = "https://www.perplexity.ai";
+
+async function browserSsoLogin(ctrl: OAuthController): Promise<OAuthCredentials> {
+	if (!ctrl.onBrowserSession) {
+		throw new AIError.OAuthError("Browser SSO is unavailable in this client", {
+			kind: "validation",
+			provider: "perplexity",
+		});
+	}
+	ctrl.onProgress?.("Complete Perplexity sign-in in the browser window. Choose SSO for your organization.");
+	const token = (
+		await ctrl.onBrowserSession(
+			{
+				url: `${PERPLEXITY_BASE_URL}/auth/signin`,
+				cookieNames: [SESSION_COOKIE_NAME, "next-auth.session-token"],
+			},
+			ctrl.signal,
+		)
+	).trim();
+	if (ctrl.signal?.aborted) throw new AIError.LoginCancelledError();
+	if (!token || /[\s;]/.test(token)) {
+		throw new AIError.OAuthError("Perplexity SSO captured an invalid session cookie", {
+			kind: "validation",
+			provider: "perplexity",
+		});
+	}
+
+	ctrl.onProgress?.("Validating Perplexity session...");
+	const response = await (ctrl.fetch ?? fetch)(`${PERPLEXITY_BASE_URL}/api/auth/session`, {
+		headers: {
+			Cookie: `${SESSION_COOKIE_NAME}=${token}`,
+			"User-Agent": APP_USER_AGENT,
+			"X-App-ApiVersion": API_VERSION,
+		},
+		redirect: "error",
+		signal: ctrl.signal,
+	});
+	if (!response.ok) {
+		throw new AIError.ProviderHttpError(`Perplexity session validation failed (${response.status})`, response.status);
+	}
+	let email: unknown;
+	try {
+		const session = (await response.json()) as { user?: { email?: unknown } } | null;
+		email = session?.user?.email;
+	} catch (error) {
+		if (ctrl.signal?.aborted) throw new AIError.LoginCancelledError();
+		if (!(error instanceof SyntaxError)) throw error;
+		throw new AIError.OAuthError("Perplexity returned an invalid session response", {
+			kind: "validation",
+			provider: "perplexity",
+		});
+	}
+	if (ctrl.signal?.aborted) throw new AIError.LoginCancelledError();
+	if (typeof email !== "string" || !email.trim()) {
+		throw new AIError.OAuthError("Perplexity session is invalid or expired. Sign in again.", {
+			kind: "validation",
+			provider: "perplexity",
+		});
+	}
+	return jwtToCredentials(token, email.trim());
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
 
-/**
- * Login to Perplexity.
- *
- * Tries auto-extraction from the desktop app, then runs HTTP email OTP login.
- *
- * No browser/manual token paste fallback is used.
- */
+/** Prefer legacy app borrowing, then offer browser SSO when the host supports it. */
 export async function loginPerplexity(ctrl: OAuthController): Promise<OAuthCredentials> {
-	if (!ctrl.onPrompt) {
-		throw new AIError.OnPromptRequiredError("Perplexity");
-	}
+	if (!ctrl.onPrompt) throw new AIError.OnPromptRequiredError("Perplexity");
+	if (ctrl.signal?.aborted) throw new AIError.LoginCancelledError();
 
-	// Path 1: Native macOS app JWT (skip if PI_AUTH_NO_BORROW=1)
 	if (!$env.PI_AUTH_NO_BORROW) {
 		ctrl.onProgress?.("Checking for Perplexity desktop app...");
 		const nativeJwt = await extractFromNativeApp();
+		if (ctrl.signal?.aborted) throw new AIError.LoginCancelledError();
 		if (nativeJwt) {
 			ctrl.onProgress?.("Found Perplexity JWT from native app");
 			return jwtToCredentials(nativeJwt);
 		}
 	}
 
-	// Path 2: HTTP email OTP
+	if (ctrl.onBrowserSession) {
+		const method = (
+			await ctrl.onPrompt({
+				message: "Login method: sso (browser) or email; blank for sso",
+				placeholder: "sso / email",
+				allowEmpty: true,
+			})
+		)
+			.trim()
+			.toLowerCase();
+		if (ctrl.signal?.aborted) throw new AIError.LoginCancelledError();
+		if (!method || method === "sso") return browserSsoLogin(ctrl);
+		if (method !== "email") {
+			throw new AIError.OAuthError("Choose sso or email for Perplexity login", {
+				kind: "validation",
+				provider: "perplexity",
+			});
+		}
+	}
 	return httpEmailLogin(ctrl);
 }

package/src/registry/oauth/types.ts

@@ -70,12 +70,21 @@ export interface OAuthProviderInfo {
 	storeCredentialsAs?: string;
 }
 
+/** Sign-in URL and accepted cookies for an isolated, host-owned browser. */
+export type OAuthBrowserSessionRequest = {
+	url: string;
+	/** Cookie names in preference order; return the first non-empty matching value. */
+	cookieNames: readonly string[];
+};
+
 export interface OAuthController {
 	onAuth?(info: OAuthAuthInfo): void;
 	onProgress?(message: string): void;
 	/** Request pasted callback input; stop any visible prompt when `signal` aborts. */
 	onManualCodeInput?(signal?: AbortSignal): Promise<string>;
 	onPrompt?(prompt: OAuthPrompt): Promise<string>;
+	/** Complete browser login and return one matching cookie value privately. Reject on cancellation or failure. */
+	onBrowserSession?(request: OAuthBrowserSessionRequest, signal?: AbortSignal): Promise<string>;
 	signal?: AbortSignal;
 	fetch?: FetchImpl;
 }

package/src/stream.ts

@@ -193,6 +193,8 @@ let providerInFlightHeartbeatWriterOverride:
 	| undefined;
 let providerInFlightLeaseRemoverOverride: ((leasePath: string) => Promise<void>) | undefined;
 let providerInFlightWaitObserverOverride: ((provider: string) => void) | undefined;
+let providerInFlightLockCreatedObserverOverride: ((lockDir: string) => Promise<void>) | undefined;
+let providerInFlightLockIdentifiedObserverOverride: ((lockDir: string) => Promise<void>) | undefined;
 
 export function configureProviderMaxInFlightRequests(limits: Record<string, number> | undefined): void {
 	configuredProviderMaxInFlightRequests = limits ?? {};
@@ -365,12 +367,21 @@ async function acquireProviderInFlightLock(provider: string, signal?: AbortSigna
 		if (signal?.aborted) throw signal.reason ?? new AIError.AbortError("Provider request aborted before dispatch");
 		try {
 			await fs.mkdir(lockDir);
-			const lockIdentity = await readProviderInFlightLockIdentity(lockDir);
+			await providerInFlightLockCreatedObserverOverride?.(lockDir);
+			let lockIdentity: ProviderInFlightLockIdentity;
+			try {
+				lockIdentity = await readProviderInFlightLockIdentity(lockDir);
+			} catch (error) {
+				if (isEnoent(error)) continue;
+				throw error;
+			}
 			const token = crypto.randomUUID();
 			try {
+				await providerInFlightLockIdentifiedObserverOverride?.(lockDir);
 				await writeProviderInFlightInfo(lockDir, token);
 			} catch (error) {
 				await releaseProviderInFlightLockDirIfSame(lockDir, lockIdentity);
+				if (isEnoent(error)) continue;
 				throw error;
 			}
 			return async () => {
@@ -623,6 +634,12 @@ export const __providerInFlightForTesting = {
 	setWaitObserver(observer: ((provider: string) => void) | undefined): void {
 		providerInFlightWaitObserverOverride = observer;
 	},
+	setLockCreatedObserver(observer: ((lockDir: string) => Promise<void>) | undefined): void {
+		providerInFlightLockCreatedObserverOverride = observer;
+	},
+	setLockIdentifiedObserver(observer: ((lockDir: string) => Promise<void>) | undefined): void {
+		providerInFlightLockIdentifiedObserverOverride = observer;
+	},
 	providerDir(provider: string): string {
 		return providerInFlightDir(provider);
 	},
@@ -1061,7 +1078,11 @@ async function resolveWithThinkingLoopRetries(
 	onAttempt?: (message: AssistantMessage) => void,
 ): Promise<AssistantMessage> {
 	const dispatchAttempt = async (): Promise<AssistantMessage> => {
-		const message = await dispatch().result();
+		const response = dispatch();
+		for await (const _event of response) {
+			// Completion callers do not consume deltas; drain them as they arrive to avoid retaining the response history.
+		}
+		const message = await response.result();
 		onAttempt?.(message);
 		return message;
 	};

package/src/types.ts

@@ -1055,6 +1055,8 @@ export interface AssistantMessage {
 	errorMessage?: string;
 	/** Stable recovery-classification text when errorMessage includes display-only diagnostics. */
 	errorClassificationMessage?: string;
+	/** True only when an exact request-body-read timeout failed on a full Responses replay, not a previous-response delta. */
+	requestBodyReadTimeoutFullReplay?: boolean;
 	/** Per-tool abort messages used when an aborted assistant turn needs different placeholder results per tool call. */
 	toolCallAbortMessages?: Record<string, string>;
 	/** HTTP status surfaced by the provider when the request failed. Populated by every provider's catch block alongside `errorMessage` so consumers (auth retry, telemetry, UI) can branch without regex-scraping the message. */
@@ -1187,6 +1189,7 @@ export type CursorTodoSyncHandler = (
 	snapshot: CursorTodoSnapshot | null,
 	toolCallId: string,
 	error: string | null,
+	origin?: "read" | "update",
 ) => ToolResultMessage;
 
 export interface CursorShellStreamCallbacks {

package/src/usage/claude.ts

@@ -22,6 +22,8 @@ import { HOUR_MS, parseIsoTimestamp, WEEK_MS } from "./shared";
 const DEFAULT_ENDPOINT = "https://api.anthropic.com/api/oauth";
 const MAX_ATTEMPTS = 3;
 const BASE_RETRY_DELAY_MS = 500;
+/** Shared windows that gate every Claude request, whatever the model. */
+const CLAUDE_SHARED_GATE_WINDOW_IDS = ["5h", "7d"] as const;
 
 const CLAUDE_HEADERS = {
 	accept: "application/json, text/plain, */*",
@@ -921,5 +923,36 @@ export const claudeRankingStrategy: CredentialRankingStrategy = {
 		const kind = getClaudeModelKind(context);
 		return kind === "fable" || kind === "mythos" ? `tier:${kind}` : undefined;
 	},
+	/**
+	 * A reactive Fable/Mythos block carries the reset the 429 reported, but
+	 * Anthropic can restore the tier earlier (plan change, corrected counter),
+	 * and the block then idles a usable account for days. Judge each tier scope
+	 * against the limits that actually gate a request of that kind — its own
+	 * weekly row plus the shared umbrella windows — so a healthy report lifts
+	 * the block while a spent shared 5-hour wall keeps it.
+	 *
+	 * Only Fable/Mythos appear: {@link blockScope} scopes reactive blocks for
+	 * those tiers alone, so no other scope can exist to heal.
+	 */
+	healableBlockScopes(report) {
+		const sharedLimits = report.limits.filter(limit => limit.scope.shared === true);
+		// The endpoint returns a report as soon as one window parses, and a tier
+		// 429 can be caused by a shared wall. A payload missing a shared gate
+		// leaves the block's cause unknown, so vouch for nothing rather than
+		// clear a block that still holds.
+		const everySharedGateReported = CLAUDE_SHARED_GATE_WINDOW_IDS.every(windowId =>
+			sharedLimits.some(limit => limit.scope.windowId === windowId || limit.window?.id === windowId),
+		);
+		if (!everySharedGateReported) return [];
+		const tiers = new Set<string>();
+		for (const limit of report.limits) {
+			const tier = limit.scope.tier;
+			if (tier === "fable" || tier === "mythos") tiers.add(tier);
+		}
+		return [...tiers].map(tier => ({
+			blockScope: `tier:${tier}`,
+			limits: [...sharedLimits, ...report.limits.filter(limit => limit.scope.tier === tier)],
+		}));
+	},
 	windowDefaults: { primaryMs: 5 * 60 * 60 * 1000, secondaryMs: 7 * 24 * 60 * 60 * 1000 },
 };

package/src/usage/google-antigravity.ts

@@ -355,18 +355,24 @@ function buildQuotaSummaryReport(
 		);
 		const amount = buildQuotaSummaryAmount(bucket);
 		const counterKeys = getQuotaSummaryCounterKeys(group, bucket);
+		const sharedGroup =
+			counterKeys.length > 1
+				? `${bucket.bucketId ?? group?.displayName ?? "third-party"}:${window?.id ?? bucket.window ?? "default"}`
+				: undefined;
 		for (const counterKey of counterKeys) {
 			const counterName = getQuotaSummaryCounterName(counterKey);
 			const windowId = window?.id ?? bucket.window ?? bucket.bucketId ?? "default";
+			const label =
+				sharedGroup !== undefined ? "Claude & GPT (shared)" : counterKey === "google" ? "Gemini" : counterName;
 			limits.push({
 				id: `${params.provider}:${counterKey}:default:${bucket.bucketId ?? windowId}`,
-				label: counterName ? `Usage (${counterName})` : (group?.displayName ?? bucket.displayName ?? "Usage"),
+				label: label ?? group?.displayName ?? bucket.displayName ?? "Usage",
 				scope: {
 					provider: params.provider,
 					accountId: params.credential.accountId,
 					projectId: params.credential.projectId,
 					windowId,
-					...(counterKeys.length > 1 ? { shared: true } : {}),
+					...(sharedGroup !== undefined ? { shared: true, sharedGroup } : {}),
 				},
 				window,
 				amount,

package/src/usage/openai-codex.ts

@@ -43,10 +43,23 @@ interface CodexUsageAdditionalRateLimitPayload {
 	rate_limit?: CodexUsageRateLimitPayload | null;
 }
 
+interface CodexUsageCreditsPayload {
+	has_credits?: boolean;
+	unlimited?: boolean;
+	overage_limit_reached?: boolean;
+	balance?: string | number;
+}
+
+interface CodexUsageSpendControlPayload {
+	reached?: boolean;
+}
+
 interface CodexUsagePayload {
 	plan_type?: string;
 	rate_limit?: CodexUsageRateLimitPayload | null;
 	additional_rate_limits?: CodexUsageAdditionalRateLimitPayload[] | null;
+	credits?: CodexUsageCreditsPayload | null;
+	spend_control?: CodexUsageSpendControlPayload | null;
 }
 
 interface ParsedUsageWindow {
@@ -72,6 +85,13 @@ interface ParsedUsage {
 	primary?: ParsedUsageWindow;
 	secondary?: ParsedUsageWindow;
 	additional: ParsedAdditionalUsage[];
+	/**
+	 * True when the account can still serve requests on credits after its plan
+	 * windows report `limit_reached`. `/wham/usage` only describes the *plan*
+	 * allowance, so without this a credit-funded account looks permanently
+	 * exhausted until the weekly reset while `/responses` keeps accepting it.
+	 */
+	creditOverage: boolean;
 	raw: CodexUsagePayload;
 }
 
@@ -161,6 +181,28 @@ function parseAdditionalRateLimit(payload: unknown): ParsedAdditionalUsage | nul
 	return { limitName, meteredFeature, allowed, limitReached, primary, secondary };
 }
 
+/**
+ * True when paid credits can still fund plan-window overage. Codex CLI never
+ * gates on `/wham/usage`, so once the plan allowance is spent it keeps working
+ * off this balance; omp must mirror that or it parks a perfectly usable account
+ * until the weekly reset.
+ *
+ * Scoped to the plan verdict on purpose. `credits` describes the account's
+ * overage funding for the plan windows, and nothing in the payload says a
+ * balance covers a separate metered feature (Spark, reserve). A denial that is
+ * not plan exhaustion is left alone for the same reason: credits answer
+ * "allowance spent", not "request refused".
+ */
+function hasPlanCreditOverage(payload: Record<string, unknown>, planLimitReached: boolean | undefined): boolean {
+	if (planLimitReached !== true) return false;
+	const credits = isRecord(payload.credits) ? payload.credits : undefined;
+	if (!credits) return false;
+	if (credits.unlimited !== true && credits.has_credits !== true) return false;
+	if (credits.overage_limit_reached === true) return false;
+	const spendControl = isRecord(payload.spend_control) ? payload.spend_control : undefined;
+	return spendControl?.reached !== true;
+}
+
 function parseUsagePayload(payload: unknown): ParsedUsage | null {
 	if (!isRecord(payload)) return null;
 	const planType = typeof payload.plan_type === "string" ? payload.plan_type : undefined;
@@ -170,13 +212,15 @@ function parseUsagePayload(payload: unknown): ParsedUsage | null {
 		.map(parseAdditionalRateLimit)
 		.filter((value): value is ParsedAdditionalUsage => value !== null);
 	if (!rateLimit && additional.length === 0) return null;
+	const planLimitReached = rateLimit ? toBoolean(rateLimit.limit_reached) : undefined;
 	const parsed: ParsedUsage = {
 		planType,
 		allowed: rateLimit ? toBoolean(rateLimit.allowed) : undefined,
-		limitReached: rateLimit ? toBoolean(rateLimit.limit_reached) : undefined,
+		limitReached: planLimitReached,
 		primary: rateLimit ? parseUsageWindow(rateLimit.primary_window) : undefined,
 		secondary: rateLimit ? parseUsageWindow(rateLimit.secondary_window) : undefined,
 		additional,
+		creditOverage: hasPlanCreditOverage(payload, planLimitReached),
 		raw: payload as CodexUsagePayload,
 	};
 	if (
@@ -273,6 +317,17 @@ function buildUsageStatus(args: { usedFraction?: number; explicitlyAllowed: bool
 	return "ok";
 }
 
+/**
+ * Whether Codex will still serve this meter: an explicit positive verdict, or
+ * credits covering overage of a spent plan window. The credit override needs
+ * `limitReached === true`; a refusal for any other reason is not something a
+ * balance can pay for.
+ */
+function isCodexRequestAllowed(args: { allowed?: boolean; limitReached?: boolean; creditOverage?: boolean }): boolean {
+	if (args.creditOverage === true && args.limitReached === true) return true;
+	return args.allowed === true && args.limitReached === false;
+}
+
 function buildUsageLimit(args: {
 	key: "primary" | "secondary";
 	window: ParsedUsageWindow;
@@ -280,6 +335,7 @@ function buildUsageLimit(args: {
 	planType?: string;
 	allowed?: boolean;
 	limitReached?: boolean;
+	creditOverage?: boolean;
 	nowMs: number;
 }): UsageLimit {
 	const usageWindow = buildUsageWindow(args.window, args.key, args.nowMs);
@@ -296,11 +352,12 @@ function buildUsageLimit(args: {
 		amount,
 		// The shared account-level rejection flag cannot identify which window
 		// is binding, but an explicit positive verdict applies to both windows.
-		// Preserve 100% as a warning when Codex still allows requests; live
-		// usage_limit_reached responses remain authoritative for blocking.
+		// Preserve 100% as a warning when Codex still allows requests — either
+		// explicitly, or because credits fund overage past the plan window.
+		// Live usage_limit_reached responses remain authoritative for blocking.
 		status: buildUsageStatus({
 			usedFraction: amount.usedFraction,
-			explicitlyAllowed: args.allowed === true && args.limitReached === false,
+			explicitlyAllowed: isCodexRequestAllowed(args),
 		}),
 	};
 }
@@ -354,9 +411,11 @@ function buildAdditionalUsageLimit(args: {
 		amount,
 		// A positive meter verdict is authoritative even when the advisory
 		// percentage rounds to 100; negative shared verdicts remain window-local.
+		// Plan credits are deliberately not passed here: this meter is a separate
+		// allowance, and nothing in the payload says a balance funds its overage.
 		status: buildUsageStatus({
 			usedFraction: amount.usedFraction,
-			explicitlyAllowed: args.allowed === true && args.limitReached === false,
+			explicitlyAllowed: isCodexRequestAllowed(args),
 		}),
 	};
 }
@@ -367,7 +426,11 @@ function buildAdditionalUsageLimit(args: {
  * ingesting them lets credential selection block an exhausted account before
  * the next request burns a wire 429.
  */
-export function parseCodexRateLimitHeaders(headers: Record<string, string>, now = Date.now()): UsageReport | null {
+export function parseCodexRateLimitHeaders(
+	headers: Record<string, string>,
+	now = Date.now(),
+	context?: { responseStatus?: number },
+): UsageReport | null {
 	const parseWindow = (key: "primary" | "secondary"): ParsedUsageWindow | undefined => {
 		const usedPercent = toNumber(headers[`x-codex-${key}-used-percent`]);
 		if (usedPercent === undefined) return undefined;
@@ -383,8 +446,11 @@ export function parseCodexRateLimitHeaders(headers: Record<string, string>, now
 	const secondary = parseWindow("secondary");
 	if (!primary && !secondary) return null;
 	const limits: UsageLimit[] = [];
-	if (primary) limits.push(buildUsageLimit({ key: "primary", window: primary, nowMs: now }));
-	if (secondary) limits.push(buildUsageLimit({ key: "secondary", window: secondary, nowMs: now }));
+	const requestSucceeded =
+		context?.responseStatus !== undefined && context.responseStatus >= 200 && context.responseStatus < 300;
+	const verdict = requestSucceeded ? { allowed: true, limitReached: false } : {};
+	if (primary) limits.push(buildUsageLimit({ key: "primary", window: primary, ...verdict, nowMs: now }));
+	if (secondary) limits.push(buildUsageLimit({ key: "secondary", window: secondary, ...verdict, nowMs: now }));
 	return {
 		provider: "openai-codex",
 		fetchedAt: now,
@@ -393,6 +459,21 @@ export function parseCodexRateLimitHeaders(headers: Record<string, string>, now
 	};
 }
 
+/**
+ * Plan meter verdict as credential selection should see it. Credits funding
+ * overage flip a plan-level rejection back to serving, which is what lets a
+ * stale usage-limit block self-heal instead of parking the account until reset.
+ * Only the plan meter takes this override — {@link hasPlanCreditOverage}.
+ */
+function buildPlanMeterState(
+	allowed: boolean | undefined,
+	limitReached: boolean | undefined,
+	creditOverage: boolean,
+): { allowed?: boolean; limitReached?: boolean } {
+	if (!creditOverage) return { allowed, limitReached };
+	return { allowed: true, limitReached: false };
+}
+
 export const openaiCodexUsageProvider: UsageProvider = {
 	id: "openai-codex",
 	supports(params: UsageFetchParams): boolean {
@@ -444,9 +525,10 @@ export const openaiCodexUsageProvider: UsageProvider = {
 			parsed?.planType ??
 			(isRecord(payload) && typeof payload.plan_type === "string" ? payload.plan_type : undefined);
 
+		const creditOverage = parsed?.creditOverage === true;
 		const limits: UsageLimit[] = [];
 		const meterStates: Record<string, { allowed?: boolean; limitReached?: boolean }> = {
-			chat: { allowed: parsed?.allowed, limitReached: parsed?.limitReached },
+			chat: buildPlanMeterState(parsed?.allowed, parsed?.limitReached, creditOverage),
 		};
 		if (parsed?.primary) {
 			limits.push(
@@ -457,6 +539,7 @@ export const openaiCodexUsageProvider: UsageProvider = {
 					planType,
 					allowed: parsed.allowed,
 					limitReached: parsed.limitReached,
+					creditOverage,
 					nowMs,
 				}),
 			);
@@ -470,6 +553,7 @@ export const openaiCodexUsageProvider: UsageProvider = {
 					planType,
 					allowed: parsed.allowed,
 					limitReached: parsed.limitReached,
+					creditOverage,
 					nowMs,
 				}),
 			);
@@ -548,8 +632,7 @@ export const openaiCodexUsageProvider: UsageProvider = {
 			...(resetCredits ? { resetCredits } : {}),
 			metadata: {
 				planType,
-				allowed: parsed?.allowed,
-				limitReached: parsed?.limitReached,
+				...buildPlanMeterState(parsed?.allowed, parsed?.limitReached, creditOverage),
 				email,
 				accountId,
 				meterStates,

package/src/usage.ts

@@ -54,6 +54,8 @@ export interface UsageScope {
 	tier?: string;
 	windowId?: string;
 	shared?: boolean;
+	/** Stable identity shared by routing-specific copies of one upstream quota. */
+	sharedGroup?: string;
 }
 
 /** Normalized limit entry for a single window or quota bucket. */
@@ -271,6 +273,7 @@ export const usageScopeSchema = type({
 	"tier?": "string",
 	"windowId?": "string",
 	"shared?": "boolean",
+	"sharedGroup?": "string",
 });
 
 export const usageLimitSchema = type({
@@ -353,7 +356,11 @@ export interface UsageProvider {
 	id: Provider;
 	fetchUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null>;
 	/** Parse provider rate-limit response headers (lowercased keys) into a usage report, if supported. */
-	parseRateLimitHeaders?(headers: Record<string, string>, now?: number): UsageReport | null;
+	parseRateLimitHeaders?(
+		headers: Record<string, string>,
+		now?: number,
+		context?: { responseStatus?: number },
+	): UsageReport | null;
 	supports?(params: UsageFetchParams): boolean;
 	/** True when fetchUsage contacts upstream and can authenticate the credential for health checks. */
 	validatesCredentials?: boolean;

package/src/utils/block-symbols.ts

@@ -141,3 +141,60 @@ export type SyntheticUserCarrier = object & { [kSyntheticUser]?: boolean };
 export function isSyntheticUser(message: SyntheticUserCarrier | null | undefined): boolean {
 	return message?.[kSyntheticUser] === true;
 }
+
+/**
+ * Marks a message synthesized by a per-call context transform rather than
+ * loaded from persisted conversation history.
+ *
+ * Prompt-cache boundaries must skip these messages: their content is rebuilt
+ * for each request and cannot anchor a prefix reused by the next turn.
+ * Symbol-keyed so the marker never persists or reaches the provider wire.
+ */
+export const kPerCallContextMessage = Symbol("agent.message.perCallContext");
+
+/** Carries per-call context provenance without exposing a string-keyed property. */
+export type PerCallContextMessageCarrier = object & { [kPerCallContextMessage]?: true };
+
+/** Marks a message as synthesized for the current provider call. */
+export function markPerCallContextMessage(message: PerCallContextMessageCarrier): void {
+	message[kPerCallContextMessage] = true;
+}
+
+/** Copies per-call context provenance to a converted or projected message. */
+export function copyPerCallContextMessage(
+	target: PerCallContextMessageCarrier,
+	source: PerCallContextMessageCarrier,
+): void {
+	if (source[kPerCallContextMessage] === true) target[kPerCallContextMessage] = true;
+}
+
+/** True when a message was synthesized for the current provider call. */
+export function isPerCallContextMessage(message: PerCallContextMessageCarrier | null | undefined): boolean {
+	return message?.[kPerCallContextMessage] === true;
+}
+
+/**
+ * Original history position carried by a context message clone.
+ *
+ * Object-spread transforms retain this symbol, allowing the extension runner
+ * to distinguish byte-identical historical copies from inserted messages.
+ */
+export const kContextHistoryIndex = Symbol("agent.message.contextHistoryIndex");
+
+/** Carries a context message's original history position. */
+export type ContextHistoryIndexCarrier = object & { [kContextHistoryIndex]?: number };
+
+/** Reads a context message's original history position. */
+export function getContextHistoryIndex(message: ContextHistoryIndexCarrier | null | undefined): number | undefined {
+	return message?.[kContextHistoryIndex];
+}
+
+/** Records a context message's original history position. */
+export function setContextHistoryIndex(message: ContextHistoryIndexCarrier, index: number): void {
+	message[kContextHistoryIndex] = index;
+}
+
+/** Removes context-history tracking before provider conversion. */
+export function clearContextHistoryIndex(message: ContextHistoryIndexCarrier): void {
+	delete message[kContextHistoryIndex];
+}

package/src/utils/http-inspector.ts

@@ -165,10 +165,30 @@ export function rewriteClinePassError(errorMessage: string, provider: string): s
 function sanitizeDump(dump: RawHttpRequestDump): RawHttpRequestDump {
 	return {
 		...dump,
+		url: redactUrlQuery(dump.url),
 		headers: redactHeaders(dump.headers),
 	};
 }
 
+/**
+ * Strips a persisted dump's query string entirely rather than picking sensitive
+ * params by name: a configurable `baseUrl` (e.g. Bedrock's gateway routing) can
+ * carry an arbitrary query-based credential the way `SENSITIVE_HEADER_PATTERN`
+ * matches arbitrary header names, and dumps exist to diagnose the request body,
+ * not the query.
+ */
+function redactUrlQuery(url: string | undefined): string | undefined {
+	if (!url) return url;
+	try {
+		const parsed = new URL(url);
+		if (!parsed.search) return url;
+		parsed.search = "";
+		return `${parsed.toString()}[redacted-query]`;
+	} catch {
+		return url;
+	}
+}
+
 function redactHeaders(headers: Record<string, string> | undefined): Record<string, string> | undefined {
 	if (!headers) {
 		return undefined;