pi-harness-runtime 0.9.4 → 0.9.6

package/packages/providers/src/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/providers/test/providers.test.ts

@@ -0,0 +1,225 @@
+/**
+ * Providers Tests
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+	MiniMaxAdapter,
+	OpenAIAdapter,
+	ClaudeAdapter,
+	AdapterRegistry,
+} from "../src/adapters.js";
+import type { ProviderConfig } from "../../../packages/types/src/runtime-types.js";
+
+const makeConfig = (id: string): ProviderConfig => ({
+	id,
+	name: id,
+	models: [`${id}/model-a`, `${id}/model-b`],
+	capabilities: ["code", "review"],
+	rateLimits: {},
+});
+
+describe("MiniMaxAdapter", () => {
+	const adapter = new MiniMaxAdapter(makeConfig("minimax"));
+
+	it("has correct id and name", () => {
+		expect(adapter.id).toBe("minimax");
+		expect(adapter.name).toBe("MiniMax");
+	});
+
+	it("supports its configured models", () => {
+		expect(adapter.supportsModel("minimax/model-a")).toBe(true);
+		expect(adapter.supportsModel("minimax/model-b")).toBe(true);
+	});
+
+	it("does not support other models", () => {
+		expect(adapter.supportsModel("openai/gpt-4")).toBe(false);
+	});
+
+	it("returns default model", () => {
+		expect(adapter.getDefaultModel()).toBe("minimax/model-a");
+	});
+
+	it("returns correct max tokens", () => {
+		expect(adapter.getMaxTokens("minimax/MiniMax-Text-01")).toBe(1000000);
+		expect(adapter.getMaxTokens("minimax/MiniMax-M3")).toBe(32768);
+	});
+
+	it("returns capabilities", () => {
+		const caps = adapter.getCapabilities();
+		expect(caps).toContain("code");
+		expect(caps).toContain("review");
+	});
+
+	it("parses MiniMax quota errors", () => {
+		const result = adapter.parseError({
+			message: "Error code: 2056 - Rate limit exceeded",
+		});
+		expect(result.quotaExceeded).toBe(true);
+		expect(result.rateLimited).toBe(true);
+	});
+
+	it("parses rate limit errors", () => {
+		const result = adapter.parseError({
+			message: "Rate limit exceeded, retry after 429",
+		});
+		expect(result.rateLimited).toBe(true);
+	});
+
+	it("parses timeout errors", () => {
+		const result = adapter.parseError({ message: "Request timed out" });
+		expect(result.timeout).toBe(true);
+	});
+
+	it("parses server errors", () => {
+		const result = adapter.parseError({ message: "Internal server error 500" });
+		expect(result.serverError).toBe(true);
+	});
+
+	it("parses client errors", () => {
+		const result = adapter.parseError({ message: "Bad request 400" });
+		expect(result.clientError).toBe(true);
+	});
+
+	it("invokes and returns mock result", async () => {
+		const result = await adapter.invoke({
+			model: "minimax/model-a",
+			messages: [],
+			maxTokens: 100,
+		});
+		expect(result.response.content).toBe("Mock response");
+		expect(result.retryable).toBe(false);
+	});
+});
+
+describe("OpenAIAdapter", () => {
+	const adapter = new OpenAIAdapter(makeConfig("openai"));
+
+	it("has correct id and name", () => {
+		expect(adapter.id).toBe("openai");
+		expect(adapter.name).toBe("OpenAI");
+	});
+
+	it("parses insufficient_quota error", () => {
+		const result = adapter.parseError({
+			code: "insufficient_quota",
+			message: "Quota exceeded",
+		});
+		expect(result.quotaExceeded).toBe(true);
+		expect(result.quotaSignal?.exhausted).toBe(true);
+	});
+
+	it("parses rate_limit_exceeded error", () => {
+		const result = adapter.parseError({
+			code: "rate_limit_exceeded",
+			message: "Rate limit",
+		});
+		expect(result.rateLimited).toBe(true);
+	});
+
+	it("returns correct max tokens", () => {
+		expect(adapter.getMaxTokens("openai/gpt-4o")).toBe(128000);
+	});
+});
+
+describe("ClaudeAdapter", () => {
+	const adapter = new ClaudeAdapter(makeConfig("anthropic"));
+
+	it("has correct id and name", () => {
+		expect(adapter.id).toBe("anthropic");
+		expect(adapter.name).toBe("Anthropic Claude");
+	});
+
+	it("returns Claude default model", () => {
+		expect(adapter.getDefaultModel()).toBe(
+			"anthropic/claude-3-5-sonnet-20240620",
+		);
+	});
+
+	it("returns large token limits for Claude models", () => {
+		expect(adapter.getMaxTokens("anthropic/claude-3-5-sonnet-20240620")).toBe(
+			200000,
+		);
+		expect(adapter.getMaxTokens("anthropic/claude-3-opus-20240229")).toBe(
+			200000,
+		);
+		expect(adapter.getMaxTokens("anthropic/claude-2")).toBe(100000);
+	});
+
+	it("parses rate_limit_error type", () => {
+		const result = adapter.parseError({
+			type: "rate_limit_error",
+			message: "Rate limited",
+		});
+		expect(result.rateLimited).toBe(true);
+	});
+
+	it("parses overloaded_error type", () => {
+		const result = adapter.parseError({
+			type: "overloaded_error",
+			message: "Overloaded",
+		});
+		expect(result.rateLimited).toBe(true);
+		expect(result.serverError).toBe(true);
+	});
+
+	it("parses quota_error type", () => {
+		const result = adapter.parseError({
+			type: "quota_error",
+			message: "Quota exceeded",
+		});
+		expect(result.quotaExceeded).toBe(true);
+		expect(result.quotaSignal?.exhausted).toBe(true);
+	});
+
+	it("parses authentication_error as client error", () => {
+		const result = adapter.parseError({
+			type: "authentication_error",
+			message: "Auth failed",
+		});
+		expect(result.clientError).toBe(true);
+	});
+});
+
+describe("AdapterRegistry", () => {
+	it("starts empty", () => {
+		const registry = new AdapterRegistry();
+		expect(registry.list()).toEqual([]);
+		expect(registry.get("minimax")).toBeUndefined();
+	});
+
+	it("registers and retrieves adapters", () => {
+		const registry = new AdapterRegistry();
+		const adapter = new MiniMaxAdapter(makeConfig("minimax"));
+		registry.register(adapter);
+
+		expect(registry.get("minimax")).toBe(adapter);
+		expect(registry.list()).toHaveLength(1);
+	});
+
+	it("creates default registry with all adapters", () => {
+		const registry = AdapterRegistry.createDefault();
+		const adapters = registry.list();
+
+		expect(adapters.some((a) => a.id === "minimax")).toBe(true);
+		expect(adapters.some((a) => a.id === "openai")).toBe(true);
+		expect(adapters.some((a) => a.id === "anthropic")).toBe(true);
+		expect(registry.get("minimax")).toBeDefined();
+		expect(registry.get("openai")).toBeDefined();
+		expect(registry.get("anthropic")).toBeDefined();
+	});
+
+	it("overwrites adapter with same id", () => {
+		const registry = new AdapterRegistry();
+		const a1 = new MiniMaxAdapter(makeConfig("minimax"));
+		const a2 = new MiniMaxAdapter({
+			...makeConfig("minimax"),
+			name: "New MinMax",
+		});
+		registry.register(a1);
+		registry.register(a2);
+
+		expect(registry.list()).toHaveLength(1);
+		expect(registry.get("minimax")).toBe(a2);
+	});
+});

package/packages/providers/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}

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

@@ -0,0 +1,35 @@
+/**
+ * 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"));
+ * }
+ * ```
+ */
+export {};
+//# sourceMappingURL=tui-usage-integration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tui-usage-integration.d.ts","sourceRoot":"","sources":["../../src/examples/tui-usage-integration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG"}

package/packages/quota-manager/dist/examples/tui-usage-integration.js

@@ -0,0 +1,73 @@
+/**
+ * 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"));
+ * }
+ * ```
+ */
+export {};
+// 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"}`);
+}
+*/
+//# sourceMappingURL=tui-usage-integration.js.map

package/packages/quota-manager/dist/examples/tui-usage-integration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui-usage-integration.js","sourceRoot":"","sources":["../../src/examples/tui-usage-integration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;;AAEH,2BAA2B;AAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCE"}

package/packages/quota-manager/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Quota Manager (RFC-0003)
+ *
+ * Multi-provider quota tracking and reset estimation.
+ */
+export * from "./quota-manager.js";
+export * from "./tui-usage-monitor.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/quota-manager/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC"}

package/packages/quota-manager/dist/index.js

@@ -0,0 +1,8 @@
+/**
+ * Quota Manager (RFC-0003)
+ *
+ * Multi-provider quota tracking and reset estimation.
+ */
+export * from "./quota-manager.js";
+export * from "./tui-usage-monitor.js";
+//# sourceMappingURL=index.js.map

package/packages/quota-manager/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC"}