pi-harness-runtime 0.10.43 → 1.1.1

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/providers/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@pi-harness/providers",
+  "version": "0.10.30",
+  "description": "pi-harness-runtime — providers",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test"
+  },
+  "dependencies": {}
+}

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/quota-manager/README.md

@@ -0,0 +1,3 @@
+# packages/quota-manager
+
+Quota detection, reset-time handling, and pause/resume logic will live here.

package/packages/quota-manager/{dist/examples/tui-usage-integration.js → examples/tui-usage-integration.ts}

@@ -31,7 +31,7 @@
  * }
  * ```
  */
-export {};
+
 // Example standalone usage
 /*
 import { QuotaManager, TUIUsageMonitor } from "./index.js";
@@ -41,33 +41,32 @@ const quotaManager = new QuotaManager();
 
 // Create TUI monitor
 const monitor = new TUIUsageMonitor({
-    quotaManager,
-    debug: true,
+	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",
+	"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("");
-    }
+	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"}`);
+	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/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/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@pi-harness/quota-manager",
+  "version": "0.10.30",
+  "description": "pi-harness-runtime — quota-manager",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test"
+  },
+  "dependencies": {}
+}