pi-harness-runtime 0.5.0 → 0.6.3-beta.13

package/packages/providers/index.ts

@@ -0,0 +1,85 @@
+/**
+ * Providers Package
+ *
+ * Provider adapters, agent workers, and usage fetchers.
+ */
+
+// Provider Adapters (RFC-0002)
+export {
+	AdapterRegistry,
+	MiniMaxAdapter,
+	OpenAIAdapter,
+	ClaudeAdapter,
+} from "./adapters.js";
+export type {
+	AdapterConfig,
+	AdapterResult,
+	ProviderAdapter,
+	QuotaSignal,
+} from "./adapters.js";
+
+// Agent Workers (RFC-0029, RFC-0030)
+import {
+	DeepAgentsAdapter,
+	createDeepAgentsAdapter,
+} from "./deepagents-adapter.js";
+import {
+	AgentWorkerRegistry,
+	type AgentWorker,
+	type AgentWorkerConfig,
+	type AgentStatus,
+	type TaskRequest,
+	type TaskResult,
+	type TaskResultStatus,
+	type HealthStatus,
+	type AgentWorkerEvents,
+	type TaskProgress,
+	type DeepAgentsConfig,
+	type DeepAgentsTaskRequest,
+	type DeepAgentsResult,
+	type AgentWorkerFactory,
+} from "../../packages/types/src/agent-worker-types.js";
+
+// Re-export for consumers
+export { DeepAgentsAdapter, createDeepAgentsAdapter, AgentWorkerRegistry };
+export type {
+	AgentWorker,
+	AgentWorkerConfig,
+	AgentStatus,
+	TaskRequest,
+	TaskResult,
+	TaskResultStatus,
+	HealthStatus,
+	AgentWorkerEvents,
+	TaskProgress,
+	DeepAgentsConfig,
+	DeepAgentsTaskRequest,
+	DeepAgentsResult,
+	AgentWorkerFactory,
+};
+
+// OpenAI Usage (TUI Message Parsing)
+export { OpenAIUsageProvider } from "./openai-usage.js";
+export type {
+	OpenAIUsageData,
+	OpenAIUsageConfig,
+} from "./openai-usage.js";
+
+// GLM Usage (TUI Message Parsing)
+export { GLMUsageProvider } from "./glm-usage.js";
+export type {
+	GLMUsageData,
+	GLMUsageConfig,
+} from "./glm-usage.js";
+
+/**
+ * Create a default agent worker registry with all built-in workers
+ */
+export function createDefaultAgentWorkerRegistry(): AgentWorkerRegistry {
+	const registry = new AgentWorkerRegistry();
+
+	// Register DeepAgents adapter
+	registry.register("deepagents", createDeepAgentsAdapter);
+
+	return registry;
+}

package/packages/providers/openai-usage.ts

@@ -0,0 +1,263 @@
+/**
+ * OpenAI Usage Parser — TUI Message Parsing
+ *
+ * OpenAI (GPT) reports quota exhaustion via TUI in pi.dev.
+ * When tokens run out or context window is full, pi shows:
+ * - Exact reset time
+ * - Which limit was hit
+ *
+ * This module hooks into TUI messages to capture quota signals.
+ * No API key needed - uses the same method as GLM.
+ */
+
+import { EventEmitter } from "node:events";
+
+export interface OpenAIUsageData {
+	provider: "openai";
+	timestamp: string;
+	/** Usage percentage (0-100), if available */
+	usedPct?: number;
+	/** Remaining percentage (0-100) */
+	remainingPct: number;
+	/** If exhausted */
+	exhausted: boolean;
+	/** Reset time */
+	resetsAt: string;
+	/** Which limit was hit */
+	limitType: "tokens" | "context_window" | "rate_limit" | "unknown";
+	/** Original message from TUI */
+	originalMessage: string;
+}
+
+export interface OpenAIUsageConfig {
+	/** Called when OpenAI quota signal is detected from TUI */
+	onQuotaSignal?: (data: OpenAIUsageData) => void;
+}
+
+/**
+ * OpenAI quota message patterns from TUI
+ * These patterns match the messages pi displays when OpenAI hits limits
+ */
+const OPENAI_QUOTA_PATTERNS = [
+	// Context window full
+	{
+		pattern: /OpenAI|GPT|context.*(?:window|length).*(?:full|exceeded|limit)/i,
+		limitType: "context_window" as const,
+	},
+	// Tokens exhausted
+	{
+		pattern: /openai.*(?:quota|limit|exhausted|tokens?.*(?:ran out|exceeded))/i,
+		limitType: "tokens" as const,
+	},
+	// Rate limit
+	{
+		pattern: /openai.*rate.?limit|429/i,
+		limitType: "rate_limit" as const,
+	},
+	// Reset time patterns
+	{
+		pattern: /openai.*reset.*(?:at|in).*(\d{1,2}):(\d{2})/i,
+		limitType: "unknown" as const,
+	},
+	// Error codes
+	{
+		pattern: /insufficient_quota|context_length_exceeded/i,
+		limitType: "tokens" as const,
+	},
+];
+
+const RESET_TIME_PATTERNS = [
+	/reset(?:s)?\s+(?:at|in)\s+(\d{1,2}):(\d{2})/i,
+	/(?:at|in)\s+(\d{1,2}):(\d{2})/i,
+	/retry\s+after\s+(\d{1,2}):(\d{2})/i,
+	/(\d{1,2}):(\d{2})\s*(?:am|pm)/i,
+];
+
+export class OpenAIUsageProvider extends EventEmitter {
+	private lastUsageData: OpenAIUsageData | null = null;
+	private onQuotaSignal?: (data: OpenAIUsageData) => void;
+
+	constructor(config: OpenAIUsageConfig = {}) {
+		super();
+		this.onQuotaSignal = config.onQuotaSignal;
+	}
+
+	/**
+	 * Check if auto-fetch is possible via TUI
+	 * OpenAI reports quota via TUI, so this is always true when hooked
+	 */
+	supportsAutoFetch(): boolean {
+		return true; // TUI integration is always available
+	}
+
+	/**
+	 * Process a TUI message and extract OpenAI quota data
+	 * Call this when receiving error/status messages from pi
+	 */
+	processTUIMessage(message: string): OpenAIUsageData | null {
+		// Check if this is an OpenAI quota message
+		for (const { pattern, limitType } of OPENAI_QUOTA_PATTERNS) {
+			if (pattern.test(message)) {
+				const usageData = this.parseOpenAIQuotaMessage(message, limitType);
+
+				if (usageData) {
+					this.lastUsageData = usageData;
+
+					// Emit event
+					this.emit("quota", usageData);
+
+					// Call callback if set
+					this.onQuotaSignal?.(usageData);
+
+					return usageData;
+				}
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * Parse reset time from message
+	 */
+	private parseResetTime(message: string): string | undefined {
+		for (const pattern of RESET_TIME_PATTERNS) {
+			const match = message.match(pattern);
+			if (match) {
+				let hour = parseInt(match[1], 10);
+				const minute = parseInt(match[2], 10);
+
+				// Handle AM/PM
+				const isPM = /pm/i.test(
+					message.slice(match.index ?? 0, (match.index ?? 0) + 10),
+				);
+				const isAM = /am/i.test(
+					message.slice(match.index ?? 0, (match.index ?? 0) + 10),
+				);
+
+				if (isPM && hour < 12) hour += 12;
+				if (isAM && hour === 12) hour = 0;
+
+				// Convert to ISO string for today or tomorrow
+				const now = new Date();
+				const resetTime = new Date(now);
+				resetTime.setHours(hour, minute, 0, 0);
+
+				// If time has passed today, assume tomorrow
+				if (resetTime <= now) {
+					resetTime.setDate(resetTime.getDate() + 1);
+				}
+
+				return resetTime.toISOString();
+			}
+		}
+
+		return undefined;
+	}
+
+	/**
+	 * Parse the OpenAI quota message
+	 */
+	private parseOpenAIQuotaMessage(
+		message: string,
+		limitType: OpenAIUsageData["limitType"],
+	): OpenAIUsageData {
+		const resetsAt =
+			this.parseResetTime(message) ??
+			new Date(Date.now() + 60 * 60 * 1000).toISOString();
+
+		// Try to extract percentage if present
+		let usedPct: number | undefined;
+		const pctMatch = message.match(/(\d+)%/);
+		if (pctMatch) {
+			usedPct = parseInt(pctMatch[1], 10);
+		}
+
+		return {
+			provider: "openai",
+			timestamp: new Date().toISOString(),
+			usedPct,
+			remainingPct: usedPct !== undefined ? 100 - usedPct : 0,
+			exhausted: true,
+			resetsAt,
+			limitType,
+			originalMessage: message,
+		};
+	}
+
+	/**
+	 * Get the last captured usage data
+	 */
+	getLastUsage(): OpenAIUsageData | null {
+		return this.lastUsageData;
+	}
+
+	/**
+	 * Clear stored usage data
+	 */
+	clear(): void {
+		this.lastUsageData = null;
+	}
+
+	/**
+	 * For QuotaManager integration
+	 * Returns current state (from last TUI message)
+	 */
+	async getUsage(): Promise<OpenAIUsageData> {
+		if (!this.lastUsageData) {
+			return {
+				provider: "openai",
+				timestamp: new Date().toISOString(),
+				remainingPct: 100,
+				exhausted: false,
+				resetsAt: "",
+				limitType: "unknown",
+				originalMessage: "",
+			};
+		}
+		return this.lastUsageData;
+	}
+
+	/**
+	 * Get usage as percentage
+	 */
+	async getUsagePercent(): Promise<number> {
+		const usage = await this.getUsage();
+		return usage.usedPct ?? 100 - usage.remainingPct;
+	}
+
+	/**
+	 * Check if quota is exhausted
+	 */
+	async isExhausted(): Promise<boolean> {
+		const usage = await this.getUsage();
+		return usage.exhausted;
+	}
+}
+
+/**
+ * Integration helper: Hook OpenAI usage provider into pi extension
+ *
+ * Usage:
+ * ```typescript
+ * const openaiUsage = new OpenAIUsageProvider({
+ *   onQuotaSignal: (data) => {
+ *     quotaManager.recordSignal({
+ *       provider: "openai",
+ *       source: "tui_message",
+ *       windowType: data.limitType === "context_window" ? "daily" : "5h",
+ *       exhausted: data.exhausted,
+ *       resetsAt: data.resetsAt,
+ *     });
+ *   }
+ * });
+ *
+ * pi.on("error", (event) => {
+ *   openaiUsage.processTUIMessage(event.message);
+ * });
+ *
+ * pi.on("message", (event) => {
+ *   openaiUsage.processTUIMessage(event.message);
+ * });
+ * ```
+ */

package/packages/quota-manager/examples/tui-usage-integration.ts

@@ -0,0 +1,72 @@
+/**
+ * TUI Usage Integration Example
+ *
+ * Shows how to integrate TUIUsageMonitor with the pi extension.
+ *
+ * Usage:
+ * ```typescript
+ * import { QuotaManager, TUIUsageMonitor } from "@pi-harness/quota-manager";
+ *
+ * // In your extension setup:
+ * const quotaManager = new QuotaManager();
+ *
+ * const monitor = new TUIUsageMonitor({
+ *   quotaManager,
+ *   debug: true,
+ * });
+ *
+ * // Hook into pi events
+ * pi.on("error", (event) => {
+ *   monitor.processMessage(event.message);
+ * });
+ *
+ * pi.on("message", (event) => {
+ *   monitor.processMessage(event.message);
+ * });
+ *
+ * // Now QuotaManager automatically receives signals from all providers
+ * // Check provider availability:
+ * if (!quotaManager.isAvailable("openai")) {
+ *   console.log("OpenAI exhausted, waiting for:", quotaManager.getWaitTime("openai"));
+ * }
+ * ```
+ */
+
+// Example standalone usage
+/*
+import { QuotaManager, TUIUsageMonitor } from "./index.js";
+
+// Create quota manager
+const quotaManager = new QuotaManager();
+
+// Create TUI monitor
+const monitor = new TUIUsageMonitor({
+	quotaManager,
+	debug: true,
+});
+
+// Process some example messages
+const messages = [
+	"OpenAI: Quota exhausted. Reset at 14:30",
+	"GLM context window full. Retry in 30 minutes",
+	"Anthropic Claude rate limit hit. 429 error",
+	"OpenRouter tokens running out",
+];
+
+for (const msg of messages) {
+	const signal = monitor.processMessage(msg);
+	if (signal) {
+		console.log(`Detected: ${signal.provider} - ${signal.limitType}`);
+		console.log(`  Exhausted: ${signal.exhausted}`);
+		console.log(`  Resets at: ${signal.resetsAt}`);
+		console.log("");
+	}
+}
+
+// Check quota state
+console.log("=== Quota State ===");
+for (const provider of ["openai", "glm", "anthropic", "openrouter"]) {
+	const state = quotaManager.getProviderState(provider);
+	console.log(`${provider}: ${state.exhausted ? "EXHAUSTED" : state.limited ? "LIMITED" : "AVAILABLE"}`);
+}
+*/

package/packages/quota-manager/index.ts

@@ -0,0 +1,28 @@
+/**
+ * Quota Manager Package
+ *
+ * Collects quota signals from multiple sources:
+ * - API responses
+ * - Provider status
+ * - Playwright scraping
+ * - TUI messages
+ * - Local estimates
+ */
+
+// Core Quota Manager
+export {
+	QuotaManager,
+	parseMiniMaxError,
+	parseOpenAIError,
+} from "./quota-manager.js";
+export type { QuotaSignalInput } from "./quota-manager.js";
+
+// TUI Usage Monitor (unified message parser)
+export {
+	TUIUsageMonitor,
+	createTUIUsageMonitor,
+} from "./tui-usage-monitor.js";
+export type {
+	TUIUsageSignal,
+	TUIUsageMonitorConfig,
+} from "./tui-usage-monitor.js";

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

@@ -8,11 +8,16 @@
 import type {
 	QuotaSignal,
 	QuotaState,
-} from "../../packages/types/src/runtime-types.ts";
+} from "../../packages/types/src/runtime-types.js";
 
 export interface QuotaSignalInput {
 	provider: string;
-	source: "api_response" | "provider_status" | "playwright" | "local_estimate";
+	source:
+		| "api_response"
+		| "provider_status"
+		| "playwright"
+		| "local_estimate"
+		| "tui_message";
 	windowType: "5h" | "daily" | "weekly" | "monthly";
 	usedPct?: number;
 	exhausted?: boolean;
@@ -70,10 +75,12 @@ export class QuotaManager {
 		let latest: QuotaSignal | null = null;
 		let latestTs = 0;
 
-		for (const [k, sigs] of this.signals.entries()) {
+		for (const entry of Array.from(this.signals.entries())) {
+			const [k, sigs] = entry;
 			if (k.startsWith(`${provider}:`)) {
 				const mostRecent = sigs.sort(
-					(a, b) => Date.parse(b.capturedAt) - Date.parse(a.capturedAt),
+					(a: QuotaSignal, b: QuotaSignal) =>
+						Date.parse(b.capturedAt) - Date.parse(a.capturedAt),
 				)[0];
 				if (mostRecent) {
 					const ts = Date.parse(mostRecent.capturedAt);
@@ -130,7 +137,8 @@ export class QuotaManager {
 		const result: QuotaSignal[] = [];
 		const cutoff = Date.now() - this.staleThresholdMs;
 
-		for (const [key, sigs] of this.signals.entries()) {
+		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) {
@@ -194,8 +202,11 @@ export class QuotaManager {
 	clearStale(): void {
 		const cutoff = Date.now() - this.staleThresholdMs;
 
-		for (const [key, sigs] of this.signals.entries()) {
-			const fresh = sigs.filter((s) => Date.parse(s.capturedAt) >= cutoff);
+		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 {