@oh-my-pi/pi-ai 18.4.0 → 18.4.2

package/src/stream.ts

@@ -175,6 +175,9 @@ const PROVIDER_INFLIGHT_HEARTBEAT_MS = 5_000;
 const PROVIDER_INFLIGHT_SIGNAL_FALLBACK_MS = 250;
 const PROVIDER_INFLIGHT_HEARTBEAT_FLUSH_TIMEOUT_MS = 1_000;
 const PROVIDER_INFLIGHT_RELEASE_TIMEOUT_MS = 5_000;
+const PROVIDER_INFLIGHT_LOCK_RETRY_INITIAL_MS = 25;
+const PROVIDER_INFLIGHT_LOCK_RETRY_MAX_MS = 250;
+const PROVIDER_INFLIGHT_LOCK_RETRY_BUDGET_MS = 3_000;
 
 let configuredProviderMaxInFlightRequests: Record<string, number> = {};
 let providerInFlightRootOverride: string | undefined;
@@ -187,6 +190,9 @@ let providerInFlightLeaseRemoverOverride: ((leasePath: string) => Promise<void>)
 let providerInFlightWaitObserverOverride: ((provider: string) => void) | undefined;
 let providerInFlightLockCreatedObserverOverride: ((lockDir: string) => Promise<void>) | undefined;
 let providerInFlightLockIdentifiedObserverOverride: ((lockDir: string) => Promise<void>) | undefined;
+let providerInFlightLockMkdirOverride: ((lockDir: string) => Promise<void>) | undefined;
+let providerInFlightLockPlatformOverride: NodeJS.Platform | undefined;
+let providerInFlightLockRetryTimings: { budgetMs?: number; initialDelayMs?: number; maxDelayMs?: number } | undefined;
 
 export function configureProviderMaxInFlightRequests(limits: Record<string, number> | undefined): void {
 	configuredProviderMaxInFlightRequests = limits ?? {};
@@ -351,6 +357,42 @@ async function releaseProviderInFlightLockDirIfSame(
 	} catch {}
 }
 
+// On Windows, mkdir on a lock directory another process is concurrently deleting
+// (delete-pending while a watcher, antivirus, or indexer still holds it) fails
+// with ERROR_ACCESS_DENIED — mapped to EPERM/EACCES — instead of EEXIST, so
+// ordinary contention looks like a permission error. On win32 only, back off and
+// retry briefly; if the failure persists past the budget, rethrow the original
+// error so a real permission problem still surfaces. Every other outcome
+// (success, EEXIST, any other code) exits immediately, keeping non-win32 and
+// non-transient behavior unchanged.
+function isTransientProviderInFlightLockMkdirError(error: NodeJS.ErrnoException): boolean {
+	if ((providerInFlightLockPlatformOverride ?? process.platform) !== "win32") return false;
+	return error.code === "EPERM" || error.code === "EACCES";
+}
+
+async function mkdirProviderInFlightLockDir(lockDir: string, signal?: AbortSignal): Promise<void> {
+	const mkdir = providerInFlightLockMkdirOverride ?? ((dir: string) => fs.mkdir(dir));
+	let failures = 0;
+	let since = Date.now();
+	while (true) {
+		try {
+			await mkdir(lockDir);
+			return;
+		} catch (error) {
+			if (!isTransientProviderInFlightLockMkdirError(error as NodeJS.ErrnoException)) throw error;
+			const now = Date.now();
+			if (failures === 0) since = now;
+			const budgetMs = providerInFlightLockRetryTimings?.budgetMs ?? PROVIDER_INFLIGHT_LOCK_RETRY_BUDGET_MS;
+			if (now - since >= budgetMs) throw error;
+			const initialMs = providerInFlightLockRetryTimings?.initialDelayMs ?? PROVIDER_INFLIGHT_LOCK_RETRY_INITIAL_MS;
+			const maxMs = providerInFlightLockRetryTimings?.maxDelayMs ?? PROVIDER_INFLIGHT_LOCK_RETRY_MAX_MS;
+			const delayMs = Math.min(maxMs, initialMs * 2 ** failures);
+			failures++;
+			await untilAborted(signal, Bun.sleep(delayMs));
+		}
+	}
+}
+
 async function acquireProviderInFlightLock(provider: string, signal?: AbortSignal): Promise<() => Promise<void>> {
 	const lockDir = providerInFlightLockDir(provider);
 	await fs.mkdir(path.dirname(lockDir), { recursive: true });
@@ -358,7 +400,7 @@ async function acquireProviderInFlightLock(provider: string, signal?: AbortSigna
 	while (true) {
 		if (signal?.aborted) throw signal.reason ?? new AIError.AbortError("Provider request aborted before dispatch");
 		try {
-			await fs.mkdir(lockDir);
+			await mkdirProviderInFlightLockDir(lockDir, signal);
 			await providerInFlightLockCreatedObserverOverride?.(lockDir);
 			let lockIdentity: ProviderInFlightLockIdentity;
 			try {
@@ -632,6 +674,15 @@ export const __providerInFlightForTesting = {
 	setLockIdentifiedObserver(observer: ((lockDir: string) => Promise<void>) | undefined): void {
 		providerInFlightLockIdentifiedObserverOverride = observer;
 	},
+	setLockMkdirOverride(mkdir: ((lockDir: string) => Promise<void>) | undefined): void {
+		providerInFlightLockMkdirOverride = mkdir;
+	},
+	setLockPlatformOverride(platform: NodeJS.Platform | undefined): void {
+		providerInFlightLockPlatformOverride = platform;
+	},
+	setLockRetryTimings(timings: { budgetMs?: number; initialDelayMs?: number; maxDelayMs?: number } | undefined): void {
+		providerInFlightLockRetryTimings = timings;
+	},
 	providerDir(provider: string): string {
 		return providerInFlightDir(provider);
 	},
@@ -1881,29 +1932,39 @@ function mapOptionsForApi<TApi extends Api>(
 			}
 
 			if (ANTHROPIC_USE_INTERLEAVED_THINKING) {
-				return castApi<"anthropic-messages">({
-					...base,
-					maxTokens: maxTokensWithThinking,
-					requestModelId: resolveWireModelId(model, reasoning),
-					thinkingEnabled: true,
-					thinkingBudgetTokens: thinkingBudget,
-					effort,
-					toolChoice: mapAnthropicToolChoice(options?.toolChoice),
-					thinkingDisplay: options?.hideThinkingSummary ? "omitted" : undefined,
-					serviceTier: options?.serviceTier,
-				});
+				if (
+					model.maxTokens !== null &&
+					model.maxTokens !== undefined &&
+					model.maxTokens < thinkingBudget + OUTPUT_FALLBACK_BUFFER
+				) {
+					thinkingBudget = model.maxTokens - OUTPUT_FALLBACK_BUFFER;
+				}
+				if (thinkingBudget >= ANTHROPIC_THINKING.minimal) {
+					return castApi<"anthropic-messages">({
+						...base,
+						maxTokens: maxTokensWithThinking,
+						requestModelId: resolveWireModelId(model, reasoning),
+						thinkingEnabled: true,
+						thinkingBudgetTokens: thinkingBudget,
+						effort,
+						toolChoice: mapAnthropicToolChoice(options?.toolChoice),
+						thinkingDisplay: options?.hideThinkingSummary ? "omitted" : undefined,
+						serviceTier: options?.serviceTier,
+					});
+				}
 			}
 
 			// Caller's maxTokens is desired output, so add thinking budget on top. With no caller/model cap, use a finite total fallback.
 			const maxTokens = maxTokensWithThinkingBudget(base.maxTokens, model.maxTokens, thinkingBudget);
 
-			// If not enough room for thinking + output, reduce thinking budget
-			if (maxTokens <= thinkingBudget) {
-				thinkingBudget = maxTokens - MIN_OUTPUT_TOKENS;
+			// Keep the provider's output buffer after thinking, reducing the
+			// budget before its wire-level clamp could fall below the API minimum.
+			if (maxTokens < thinkingBudget + OUTPUT_FALLBACK_BUFFER) {
+				thinkingBudget = maxTokens - OUTPUT_FALLBACK_BUFFER;
 			}
 
 			// If thinking budget is too low, disable thinking
-			if (thinkingBudget <= 0) {
+			if (thinkingBudget < ANTHROPIC_THINKING.minimal) {
 				return castApi<"anthropic-messages">({
 					...base,
 					requestModelId: resolveWireModelId(model, undefined),

package/src/usage/claude.ts

@@ -702,6 +702,11 @@ async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext
 		const { orgId, baseUrl: _baseUrl, report: _report, ...resetCredits } = resetCreditList;
 		result.resetCredits = resetCredits;
 		if (orgId) result.metadata = { ...result.metadata, orgId };
+	} else if (ctx.previousReport?.resetCredits) {
+		// `null` means the reset probe failed (timeout, 429, malformed body), not
+		// that the account has no saved resets. Keep the block this credential
+		// last reported instead of dropping banked resets from the report.
+		result.resetCredits = ctx.previousReport.resetCredits;
 	}
 	result.metadata = {
 		...result.metadata,

package/src/usage/cursor.ts

@@ -1,6 +1,9 @@
+import { quotaTierFor } from "@oh-my-pi/pi-catalog/compat/behavior";
 import { toNumber } from "@oh-my-pi/pi-catalog/utils";
 import { extractCursorAccessTokenUserId } from "../registry/oauth/cursor";
 import type {
+	CredentialRankingContext,
+	CredentialRankingStrategy,
 	UsageAmount,
 	UsageFetchContext,
 	UsageFetchParams,
@@ -10,7 +13,7 @@ import type {
 	UsageWindow,
 } from "../usage";
 import { isRecord } from "../utils";
-import { parseIsoTimestamp, usageStatus } from "./shared";
+import { DAY_MS, parseIsoTimestamp, usageStatus } from "./shared";
 
 function parseTimestamp(value: unknown): number | undefined {
 	const numeric = toNumber(value);
@@ -352,6 +355,45 @@ export function parseCursorUsage(payload: unknown, fetchedAt = Date.now()): Usag
 	};
 }
 
+const CURSOR_MODELS_LIMIT_ID = "cursor:usd:individual-auto";
+const OTHER_MODELS_LIMIT_ID = "cursor:usd:individual-api";
+
+function scopeCursorLimitsForModel(report: UsageReport, context: CredentialRankingContext | undefined): UsageLimit[] {
+	const splitLimits = report.limits.filter(
+		limit => limit.id === CURSOR_MODELS_LIMIT_ID || limit.id === OTHER_MODELS_LIMIT_ID,
+	);
+	if (splitLimits.length > 0) {
+		const modelId = context?.modelId;
+		if (!modelId) return [];
+		const tier = quotaTierFor("cursor", modelId);
+		const limitId = tier === "auto" ? CURSOR_MODELS_LIMIT_ID : tier === "api" ? OTHER_MODELS_LIMIT_ID : undefined;
+		return limitId ? splitLimits.filter(limit => limit.id === limitId) : [];
+	}
+
+	const combinedLimits = report.limits.filter(
+		limit => limit.id === "cursor:usd:individual-plan" || limit.id === "cursor:usd:individual-overall",
+	);
+	return combinedLimits.length > 0 ? combinedLimits : report.limits;
+}
+
+/** Routes Cursor credential ranking and reserve checks through the requested model's billing pool. */
+export const cursorRankingStrategy: CredentialRankingStrategy = {
+	findWindowLimits(report, context) {
+		return { secondary: scopeCursorLimitsForModel(report, context)[0] };
+	},
+	scopeLimits: scopeCursorLimitsForModel,
+	scopeLimitsForReserve: scopeCursorLimitsForModel,
+	// Back off per billing pool so an exhausted Other Models pool does not
+	// block Grok/Composer on the same account (and vice versa).
+	blockScope(context) {
+		return context?.modelId ? `pool:${quotaTierFor("cursor", context.modelId)}` : undefined;
+	},
+	windowDefaults: {
+		primaryMs: 30 * DAY_MS,
+		secondaryMs: 30 * DAY_MS,
+	},
+};
+
 export const cursorUsageProvider: UsageProvider = {
 	id: "cursor",
 	supports(params: UsageFetchParams): boolean {

package/src/usage/devin.ts

@@ -21,7 +21,7 @@ import {
 	type Timestamp,
 } from "@oh-my-pi/pi-catalog/discovery/devin-proto";
 import { create, toBinary } from "@oh-my-pi/pi-catalog/discovery/protobuf";
-import { DEVIN_DEFAULT_BASE_URL, devinCliMetadata, normalizeDevinSessionToken } from "@oh-my-pi/pi-catalog/wire/devin";
+import { DEVIN_DEFAULT_BASE_URL, devinCliMetadata, devinWireMetadata } from "@oh-my-pi/pi-catalog/wire/devin";
 import { decodeDevinUnaryMessage } from "@oh-my-pi/pi-catalog/wire/devin-proto";
 import type {
 	UsageAmount,
@@ -48,11 +48,11 @@ function timestampMs(timestamp: Timestamp): number {
 	return Number(timestamp.seconds) * 1_000 + timestamp.nanos / 1_000_000;
 }
 
-/** Session token as the CLI sends it: the wire format carries the scheme prefix. */
-function devinSessionToken(credential: UsageCredential): string | undefined {
+/** Credential bytes exactly as their storage kind requires on the Cascade wire. */
+function devinCredential(credential: UsageCredential): string | undefined {
 	const raw = credential.type === "oauth" ? credential.accessToken : credential.apiKey;
 	const token = raw?.trim();
-	return token ? normalizeDevinSessionToken(token) : undefined;
+	return token || undefined;
 }
 
 /** `TEAMS_TIER_DEVIN_PRO` → `Devin Pro`, for plans that ship no `plan_name`. */
@@ -261,13 +261,14 @@ function buildDevinReport(response: GetUserStatusResponse): UsageReport | null {
 
 async function fetchDevinUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
 	if (params.provider !== PROVIDER) return null;
-	const token = devinSessionToken(params.credential);
+	const token = devinCredential(params.credential);
 	if (!token) return null;
 	const baseUrl = (params.baseUrl ?? DEVIN_DEFAULT_BASE_URL).replace(/\/+$/, "");
 
+	const metadata = params.credential.type === "oauth" ? devinCliMetadata(token) : devinWireMetadata(token);
 	try {
 		const request = create(GetUserStatusRequestSchema, {
-			metadata: create(MetadataSchema, devinCliMetadata(token)),
+			metadata: create(MetadataSchema, metadata),
 		});
 		const response = await ctx.fetch(`${baseUrl}${GET_USER_STATUS_PATH}`, {
 			method: "POST",
@@ -305,6 +306,6 @@ async function fetchDevinUsage(params: UsageFetchParams, ctx: UsageFetchContext)
 export const devinUsageProvider: UsageProvider = {
 	id: PROVIDER,
 	fetchUsage: fetchDevinUsage,
-	supports: params => params.provider === PROVIDER && devinSessionToken(params.credential) !== undefined,
+	supports: params => params.provider === PROVIDER && devinCredential(params.credential) !== undefined,
 	validatesCredentials: true,
 };

package/src/usage/registry.ts

@@ -4,7 +4,7 @@ import { alibabaTokenPlanRankingStrategy, alibabaTokenPlanUsageProvider } from "
 import { charmHyperUsageProvider } from "./charm-hyper";
 import { claudeRankingStrategy, claudeUsageProvider } from "./claude";
 import { clinePassUsageProvider } from "./cline-pass";
-import { cursorUsageProvider } from "./cursor";
+import { cursorRankingStrategy, cursorUsageProvider } from "./cursor";
 import { devinUsageProvider } from "./devin";
 import { googleGeminiCliUsageProvider } from "./gemini";
 import { githubCopilotUsageProvider } from "./github-copilot";
@@ -60,6 +60,7 @@ const DEFAULT_RANKING_STRATEGIES = new Map<Provider, CredentialRankingStrategy>(
 	["alibaba-token-plan", alibabaTokenPlanRankingStrategy],
 	["openai-codex", codexRankingStrategy],
 	["anthropic", claudeRankingStrategy],
+	["cursor", cursorRankingStrategy],
 	["google-antigravity", antigravityRankingStrategy],
 	["kimi-code", kimiRankingStrategy],
 	["zai", zaiRankingStrategy],

package/src/usage/zai.ts

@@ -390,6 +390,7 @@ async function fetchZaiUsage(params: UsageFetchParams, ctx: UsageFetchContext):
 	return report;
 }
 
+/** Fetches the account-wide quota windows for ZAI credentials. */
 export const zaiUsageProvider: UsageProvider = {
 	id: "zai",
 	cacheVersion: 2,
@@ -399,7 +400,10 @@ export const zaiUsageProvider: UsageProvider = {
 		(params.credential.type === "oauth" ? Boolean(params.credential.accessToken) : Boolean(params.credential.apiKey)),
 };
 
+/** Ranks ZAI credentials and identifies quota blocks a live report can heal. */
 export const zaiRankingStrategy: CredentialRankingStrategy = {
+	// Pre-scoping ZAI quota blocks are unscoped; let the usage preflight probe them.
+	healsGlobalBlocks: true,
 	findWindowLimits(report) {
 		const ranked = rankZaiRequestLimits(report);
 		return { primary: ranked[0], secondary: ranked[1] };
@@ -408,6 +412,22 @@ export const zaiRankingStrategy: CredentialRankingStrategy = {
 		const limits = getZaiCredentialLimits(report);
 		return limits;
 	},
+	// All GLM requests share the account's quota pool; keep reactive blocks
+	// separate from provider-wide failures that a usage report cannot heal.
+	blockScope() {
+		return "credits";
+	},
+	healableBlockScopes(report) {
+		const limits = getZaiCredentialLimits(report);
+		// A feature-only report cannot prove the shared credit/token pool recovered.
+		if (!limits.some(limit => limit.id.startsWith("zai:credits:") || limit.id.startsWith("zai:tokens:"))) {
+			return [];
+		}
+		return [
+			{ blockScope: "credits", limits },
+			{ blockScope: "", limits },
+		];
+	},
 	windowDefaults: {
 		primaryMs: 5 * HOUR_MS,
 		secondaryMs: WEEK_MS,

package/src/usage.ts

@@ -396,6 +396,12 @@ export interface UsageFetchContext {
 	fetch: FetchImpl;
 	logger?: UsageLogger;
 	retryWait?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
+	/**
+	 * Last report cached for this exact credential cache key, when one exists.
+	 * Lets a fetcher keep a field it could not re-read this time (a failed
+	 * secondary probe) instead of reporting it as absent.
+	 */
+	previousReport?: UsageReport;
 }
 
 /** Provider implementation for fetching usage information. */