pi-harness-runtime 0.10.43 → 1.1.1

package/packages/quota-manager/quota-manager.ts

@@ -0,0 +1,339 @@
+/**
+ * Quota Manager — RFC-0003
+ *
+ * Collects quota signals from API responses, provider status,
+ * Playwright, and local estimates. Produces provider availability state.
+ */
+
+import type {
+	QuotaSignal,
+	QuotaState,
+} from "../../packages/types/src/runtime-types.js";
+
+export interface QuotaSignalInput {
+	provider: string;
+	source:
+		| "api_response"
+		| "provider_status"
+		| "playwright"
+		| "local_estimate"
+		| "tui_message";
+	windowType: "5h" | "daily" | "weekly" | "monthly";
+	usedPct?: number;
+	exhausted?: boolean;
+	resetsAt?: string;
+	retryAfterMs?: number;
+}
+
+export class QuotaManager {
+	private signals: Map<string, QuotaSignal[]> = new Map();
+	private readonly staleThresholdMs: number;
+
+	constructor(staleThresholdMs: number = 30 * 60 * 1000) {
+		this.staleThresholdMs = staleThresholdMs;
+	}
+
+	/**
+	 * Record a quota signal
+	 */
+	recordSignal(input: QuotaSignalInput): void {
+		const signal: QuotaSignal = {
+			provider: input.provider,
+			windowType: input.windowType,
+			usedPct: input.usedPct ?? 0,
+			remainingPct: 100 - (input.usedPct ?? 0),
+			exhausted: input.exhausted ?? false,
+			source: input.source,
+			capturedAt: new Date().toISOString(),
+			resetsAt: input.resetsAt,
+		};
+
+		const key = `${input.provider}:${input.windowType}`;
+		const existing = this.signals.get(key) ?? [];
+		this.signals.set(key, [...existing, signal]);
+	}
+
+	/**
+	 * Get the latest signal for a provider
+	 */
+	getLatestSignal(
+		provider: string,
+		windowType?: "5h" | "daily" | "weekly" | "monthly",
+	): QuotaSignal | null {
+		const key = windowType ? `${provider}:${windowType}` : provider;
+
+		if (windowType) {
+			const signals = this.signals.get(key) ?? [];
+			return (
+				signals.sort(
+					(a, b) => Date.parse(b.capturedAt) - Date.parse(a.capturedAt),
+				)[0] ?? null
+			);
+		}
+
+		// Return most recent across all window types
+		let latest: QuotaSignal | null = null;
+		let latestTs = 0;
+
+		for (const entry of Array.from(this.signals.entries())) {
+			const [k, sigs] = entry;
+			if (k.startsWith(`${provider}:`)) {
+				const mostRecent = sigs.sort(
+					(a: QuotaSignal, b: QuotaSignal) =>
+						Date.parse(b.capturedAt) - Date.parse(a.capturedAt),
+				)[0];
+				if (mostRecent) {
+					const ts = Date.parse(mostRecent.capturedAt);
+					if (ts > latestTs) {
+						latestTs = ts;
+						latest = mostRecent;
+					}
+				}
+			}
+		}
+
+		return latest;
+	}
+
+	/**
+	 * Get quota state for a provider
+	 */
+	getProviderState(provider: string): QuotaState {
+		const signals = this.getSignals(provider);
+		const exhausted = signals.some(
+			(s) => s.exhausted || (s.usedPct !== undefined && s.usedPct >= 100),
+		);
+		const limited = signals.some(
+			(s) => s.usedPct !== undefined && s.usedPct >= 90,
+		);
+
+		// Find next reset time
+		let nextAvailableAt: string | undefined;
+		for (const signal of signals) {
+			if (signal.resetsAt) {
+				if (
+					!nextAvailableAt ||
+					Date.parse(signal.resetsAt) < Date.parse(nextAvailableAt)
+				) {
+					nextAvailableAt = signal.resetsAt;
+				}
+			}
+		}
+
+		return {
+			provider,
+			available: !exhausted && !limited,
+			limited,
+			exhausted,
+			signals,
+			nextAvailableAt,
+		};
+	}
+
+	/**
+	 * Get signals for a provider
+	 */
+	getSignals(provider: string): QuotaSignal[] {
+		const result: QuotaSignal[] = [];
+		const cutoff = Date.now() - this.staleThresholdMs;
+
+		for (const entry of Array.from(this.signals.entries())) {
+			const [key, sigs] = entry;
+			if (key.startsWith(`${provider}:`)) {
+				for (const signal of sigs) {
+					if (Date.parse(signal.capturedAt) >= cutoff) {
+						result.push(signal);
+					}
+				}
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Check if provider is available
+	 */
+	isAvailable(provider: string): boolean {
+		return this.getProviderState(provider).available;
+	}
+
+	/**
+	 * Check if provider is exhausted
+	 */
+	isExhausted(provider: string): boolean {
+		return this.getProviderState(provider).exhausted;
+	}
+
+	/**
+	 * Get time until provider is available again
+	 */
+	getWaitTime(provider: string): number | null {
+		const state = this.getProviderState(provider);
+		if (!state.nextAvailableAt) return null;
+
+		const waitMs = Date.parse(state.nextAvailableAt) - Date.now();
+		return waitMs > 0 ? waitMs : null;
+	}
+
+	/**
+	 * Get best available provider from a list
+	 */
+	selectBestProvider(providers: string[]): string | null {
+		const available = providers.filter((p) => this.isAvailable(p));
+
+		if (available.length === 0) return null;
+
+		// Sort by remaining quota (prefer those with more remaining)
+		available.sort((a, b) => {
+			const signalA = this.getLatestSignal(a);
+			const signalB = this.getLatestSignal(b);
+			const remA = signalA?.remainingPct ?? 100;
+			const remB = signalB?.remainingPct ?? 100;
+			return remB - remA;
+		});
+
+		return available[0];
+	}
+
+	/**
+	 * Clear stale signals
+	 */
+	clearStale(): void {
+		const cutoff = Date.now() - this.staleThresholdMs;
+
+		for (const entry of Array.from(this.signals.entries())) {
+			const [key, sigs] = entry;
+			const fresh = sigs.filter(
+				(s: QuotaSignal) => Date.parse(s.capturedAt) >= cutoff,
+			);
+			if (fresh.length === 0) {
+				this.signals.delete(key);
+			} else {
+				this.signals.set(key, fresh);
+			}
+		}
+	}
+
+	/**
+	 * Generate quota report
+	 */
+	generateReport(providers: string[]): string {
+		const lines = ["Quota Status Report", "=".repeat(40), ""];
+
+		for (const provider of providers) {
+			const state = this.getProviderState(provider);
+			const latest = this.getLatestSignal(provider);
+
+			const status = state.exhausted
+				? "EXHAUSTED"
+				: state.limited
+					? "LIMITED"
+					: "AVAILABLE";
+
+			lines.push(`${provider}: ${status}`);
+
+			if (latest) {
+				lines.push(`  Latest: ${latest.usedPct ?? 0}% used`);
+				if (latest.resetsAt) {
+					const wait = Date.parse(latest.resetsAt) - Date.now();
+					if (wait > 0) {
+						lines.push(`  Resets: in ${Math.ceil(wait / 60000)} minutes`);
+					}
+				}
+				lines.push(`  Source: ${latest.source}`);
+			}
+
+			lines.push("");
+		}
+
+		return lines.join("\n");
+	}
+}
+
+/**
+ * Parse quota signal from MiniMax error
+ */
+export function parseMiniMaxError(error: unknown): QuotaSignal | null {
+	const e = error as Record<string, unknown>;
+	const msg = String(e.message ?? e.error ?? "");
+
+	// MiniMax quota error: "Error code: 2056 - Rate limit exceeded. Retry after..."
+	if (
+		msg.includes("2056") ||
+		msg.includes("quota") ||
+		msg.includes("rate limit")
+	) {
+		// Try to extract retry time
+		const retryMatch = msg.match(/retry after (\d+) (seconds?|minutes?)/i);
+		let retryAfterMs: number | undefined;
+
+		if (retryMatch) {
+			const value = parseInt(retryMatch[1], 10);
+			const unit = retryMatch[2].toLowerCase();
+			retryAfterMs = unit.startsWith("minute")
+				? value * 60 * 1000
+				: value * 1000;
+		}
+
+		return {
+			provider: "minimax",
+			windowType: "5h",
+			usedPct: 100,
+			remainingPct: 0,
+			exhausted: true,
+			source: "api_response",
+			capturedAt: new Date().toISOString(),
+			retryAfterMs,
+		};
+	}
+
+	return null;
+}
+
+/**
+ * Parse quota signal from OpenAI error
+ */
+export function parseOpenAIError(error: unknown): QuotaSignal | null {
+	const e = error as Record<string, unknown>;
+	const code = String(e.code ?? "");
+	const msg = String(e.message ?? e.error ?? "");
+
+	if (code === "insufficient_quota" || code === "context_length_exceeded") {
+		return {
+			provider: "openai",
+			windowType: "daily",
+			usedPct: 100,
+			remainingPct: 0,
+			exhausted: true,
+			source: "api_response",
+			capturedAt: new Date().toISOString(),
+		};
+	}
+
+	if (msg.includes("429")) {
+		const retryMatch = msg.match(/retry after (\d+) (seconds?|minutes?)/i);
+		let retryAfterMs: number | undefined;
+
+		if (retryMatch) {
+			const value = parseInt(retryMatch[1], 10);
+			const unit = retryMatch[2].toLowerCase();
+			retryAfterMs = unit.startsWith("minute")
+				? value * 60 * 1000
+				: value * 1000;
+		}
+
+		return {
+			provider: "openai",
+			windowType: "5h",
+			usedPct: 100,
+			remainingPct: 0,
+			exhausted: true,
+			source: "api_response",
+			capturedAt: new Date().toISOString(),
+			retryAfterMs,
+		};
+	}
+
+	return null;
+}