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

package/packages/providers/deepagents-adapter.ts

@@ -0,0 +1,458 @@
+/**
+ * DeepAgents Adapter — RFC-0029
+ *
+ * Implements the AgentWorker interface for DeepAgents.
+ * DeepAgents is an optional Agent Worker; Runtime remains the orchestrator.
+ *
+ * @module deepagents-adapter
+ */
+
+import type {
+	AgentWorker,
+	AgentWorkerConfig,
+	AgentStatus,
+	TaskRequest,
+	TaskResult,
+	TaskResultStatus,
+	HealthStatus,
+	AgentWorkerEvents,
+	TaskProgress,
+	DeepAgentsConfig,
+	DeepAgentsTaskRequest,
+	DeepAgentsResult,
+} from "../../packages/types/src/agent-worker-types.js";
+import type { RuntimeTask } from "../../packages/types/src/runtime-types.js";
+
+/**
+ * DeepAgents Adapter
+ *
+ * Connects the harness runtime to a DeepAgents worker.
+ * Runtime orchestrates; DeepAgents executes tasks.
+ */
+export class DeepAgentsAdapter implements AgentWorker {
+	readonly id: string;
+	readonly provider = "deepagents" as const;
+
+	private config: DeepAgentsConfig | null = null;
+	private _status: AgentStatus = "idle";
+	private abortController: AbortController | null = null;
+	private currentTaskId: string | null = null;
+
+	constructor(id: string) {
+		this.id = id;
+	}
+
+	/**
+	 * Initialize the DeepAgents adapter
+	 */
+	async initialize(config: AgentWorkerConfig): Promise<void> {
+		if (config.provider !== "deepagents") {
+			throw new Error(
+				`Invalid provider: ${config.provider}. Expected "deepagents".`,
+			);
+		}
+
+		this.config = config as DeepAgentsConfig;
+		this._status = "initializing";
+
+		// Validate configuration
+		if (!this.config.endpoint) {
+			throw new Error("DeepAgents endpoint is required");
+		}
+
+		// Test connection to DeepAgents server
+		try {
+			await this.health();
+		} catch (error) {
+			this._status = "error";
+			throw new Error(
+				`Failed to connect to DeepAgents at ${this.config.endpoint}: ${
+					error instanceof Error ? error.message : String(error)
+				}`,
+			);
+		}
+
+		this._status = "idle";
+	}
+
+	/**
+	 * Execute a task using DeepAgents
+	 */
+	async execute(
+		request: TaskRequest,
+		events?: Partial<AgentWorkerEvents>,
+	): Promise<TaskResult> {
+		if (!this.config) {
+			throw new Error("Agent not initialized. Call initialize() first.");
+		}
+
+		if (this._status === "stopped") {
+			throw new Error("Agent has been stopped");
+		}
+
+		const startTime = Date.now();
+		this._status = "running";
+		this.currentTaskId = request.task.id;
+		this.abortController = new AbortController();
+
+		// Emit status change
+		events?.onStatusChange?.("running");
+
+		try {
+			// Report planning phase
+			const planningProgress: TaskProgress = {
+				taskId: request.task.id,
+				phase: "planning",
+				message: `Planning task: ${request.task.title}`,
+				percentComplete: 10,
+				timestamp: new Date().toISOString(),
+			};
+			events?.onProgress?.(request.task.id, planningProgress);
+
+			// Build DeepAgents request
+			const deepAgentsRequest = this.buildDeepAgentsRequest(request);
+
+			// Report executing phase
+			const executingProgress: TaskProgress = {
+				taskId: request.task.id,
+				phase: "executing",
+				message: `Executing task: ${request.task.title}`,
+				percentComplete: 30,
+				timestamp: new Date().toISOString(),
+			};
+			events?.onProgress?.(request.task.id, executingProgress);
+
+			// Execute via DeepAgents
+			const response = await this.callDeepAgents(deepAgentsRequest);
+
+			// Report reviewing phase
+			const reviewingProgress: TaskProgress = {
+				taskId: request.task.id,
+				phase: "reviewing",
+				message: "Reviewing results",
+				percentComplete: 80,
+				timestamp: new Date().toISOString(),
+			};
+			events?.onProgress?.(request.task.id, reviewingProgress);
+
+			// Parse response and build result
+			const result = this.parseDeepAgentsResponse(
+				request.task,
+				response,
+				startTime,
+			);
+
+			// Report finalizing phase
+			const finalizingProgress: TaskProgress = {
+				taskId: request.task.id,
+				phase: "finalizing",
+				message: "Finalizing task",
+				percentComplete: 100,
+				timestamp: new Date().toISOString(),
+			};
+			events?.onProgress?.(request.task.id, finalizingProgress);
+
+			// Emit completion
+			events?.onTaskComplete?.(result);
+
+			this._status = "idle";
+			this.currentTaskId = null;
+			events?.onStatusChange?.("idle");
+
+			return result;
+		} catch (error) {
+			this._status = "error";
+			this.currentTaskId = null;
+			events?.onStatusChange?.("error");
+
+			const taskError =
+				error instanceof Error ? error : new Error(String(error));
+			events?.onError?.(request.task.id, taskError);
+
+			// Return failure result
+			return {
+				taskId: request.task.id,
+				status: "failure",
+				summary: `Task failed: ${taskError.message}`,
+				error: taskError.message,
+				durationMs: Date.now() - startTime,
+				completedAt: new Date().toISOString(),
+			};
+		}
+	}
+
+	/**
+	 * Check health of DeepAgents connection
+	 */
+	async health(): Promise<HealthStatus> {
+		if (!this.config) {
+			return {
+				healthy: false,
+				status: this._status,
+				load: 0,
+				activeTasks: 0,
+				queueDepth: 0,
+				checkedAt: new Date().toISOString(),
+				error: "Not initialized",
+			};
+		}
+
+		try {
+			const controller = new AbortController();
+			const timeout = setTimeout(() => controller.abort(), 5000);
+
+			const response = await fetch(`${this.config.endpoint}/health`, {
+				method: "GET",
+				headers: {
+					"Content-Type": "application/json",
+					...(this.config.apiKey && {
+						Authorization: `Bearer ${this.config.apiKey}`,
+					}),
+				},
+				signal: controller.signal,
+			});
+
+			clearTimeout(timeout);
+
+			if (!response.ok) {
+				return {
+					healthy: false,
+					status: this._status,
+					load: this.currentTaskId ? 1 : 0,
+					activeTasks: this.currentTaskId ? 1 : 0,
+					queueDepth: 0,
+					checkedAt: new Date().toISOString(),
+					error: `Health check failed: ${response.status}`,
+				};
+			}
+
+			const data = (await response.json()) as {
+				status?: string;
+				load?: number;
+				activeTasks?: number;
+				queueDepth?: number;
+			};
+
+			return {
+				healthy: true,
+				status: this._status,
+				load: data.load ?? 0,
+				activeTasks: data.activeTasks ?? (this.currentTaskId ? 1 : 0),
+				queueDepth: data.queueDepth ?? 0,
+				checkedAt: new Date().toISOString(),
+			};
+		} catch (error) {
+			return {
+				healthy: false,
+				status: this._status,
+				load: this.currentTaskId ? 1 : 0,
+				activeTasks: this.currentTaskId ? 1 : 0,
+				queueDepth: 0,
+				checkedAt: new Date().toISOString(),
+				error: error instanceof Error ? error.message : "Health check failed",
+			};
+		}
+	}
+
+	/**
+	 * Get current status
+	 */
+	status(): AgentStatus {
+		return this._status;
+	}
+
+	/**
+	 * Pause the agent
+	 */
+	async pause(): Promise<void> {
+		if (this._status === "running" && this.abortController) {
+			this.abortController.abort();
+		}
+		this._status = "paused";
+	}
+
+	/**
+	 * Resume the agent
+	 */
+	async resume(): Promise<void> {
+		if (this._status === "paused") {
+			this._status = "idle";
+		}
+	}
+
+	/**
+	 * Stop the agent
+	 */
+	async stop(): Promise<void> {
+		if (this.abortController) {
+			this.abortController.abort();
+		}
+		this._status = "stopped";
+		this.currentTaskId = null;
+	}
+
+	/**
+	 * Check if a model is supported
+	 */
+	supportsModel(model: string): boolean {
+		const supported = this.config?.supportedModels ?? ["deepagents/default"];
+		return supported.some(
+			(m) => m.toLowerCase() === model.toLowerCase() || m === "*",
+		);
+	}
+
+	/**
+	 * Get supported models
+	 */
+	getSupportedModels(): string[] {
+		return this.config?.supportedModels ?? ["deepagents/default"];
+	}
+
+	// ─── Private Methods ────────────────────────────────────────────────
+
+	/**
+	 * Build a DeepAgents API request from a task request
+	 */
+	private buildDeepAgentsRequest(request: TaskRequest): {
+		task: {
+			id: string;
+			title: string;
+			description: string;
+			acceptanceCriteria?: string[];
+		};
+		workingDir: string;
+		context?: string;
+		config?: DeepAgentsTaskRequest["config"];
+	} {
+		const deepRequest = {
+			task: {
+				id: request.task.id,
+				title: request.task.title,
+				description: request.task.description,
+				acceptanceCriteria: request.task.acceptanceCriteria,
+			},
+			workingDir: request.workingDir,
+			context: request.context,
+			config: (request as DeepAgentsTaskRequest).config,
+		};
+
+		return deepRequest;
+	}
+
+	/**
+	 * Call the DeepAgents API
+	 */
+	private async callDeepAgents(
+		request: ReturnType<DeepAgentsAdapter["buildDeepAgentsRequest"]>,
+	): Promise<{
+		taskId: string;
+		status: "success" | "failure" | "partial";
+		summary: string;
+		filesChanged?: string[];
+		output?: string;
+		error?: string;
+		usage?: {
+			input: number;
+			output: number;
+			cost?: number;
+		};
+		metadata?: {
+			agentId?: string;
+			workerId?: string;
+			sandboxUrl?: string;
+		};
+	}> {
+		if (!this.config) {
+			throw new Error("Not initialized");
+		}
+
+		const controller = this.abortController ?? new AbortController();
+		const timeout = setTimeout(
+			() => controller.abort(),
+			this.config.timeoutMs ?? 300000, // 5 min default
+		);
+
+		try {
+			const response = await fetch(`${this.config.endpoint}/tasks/execute`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					...(this.config.apiKey && {
+						Authorization: `Bearer ${this.config.apiKey}`,
+					}),
+				},
+				body: JSON.stringify(request),
+				signal: controller.signal,
+			});
+
+			clearTimeout(timeout);
+
+			if (!response.ok) {
+				const errorBody = await response.text().catch(() => "");
+				throw new Error(
+					`DeepAgents API error: ${response.status} ${response.statusText} - ${errorBody}`,
+				);
+			}
+
+			const result = (await response.json()) as Awaited<
+				ReturnType<typeof fetch>
+			> extends {
+				json: () => Promise<infer T>;
+			}
+				? T
+				: unknown;
+
+			return result as typeof response extends { json: () => Promise<infer T> }
+				? T
+				: never;
+		} catch (error) {
+			clearTimeout(timeout);
+
+			if (error instanceof Error && error.name === "AbortError") {
+				throw new Error("Task was cancelled");
+			}
+
+			throw error;
+		}
+	}
+
+	/**
+	 * Parse DeepAgents response into TaskResult
+	 */
+	private parseDeepAgentsResponse(
+		task: RuntimeTask,
+		response: Awaited<ReturnType<DeepAgentsAdapter["callDeepAgents"]>>,
+		startTime: number,
+	): DeepAgentsResult {
+		const status: TaskResultStatus = response.status;
+		const durationMs = Date.now() - startTime;
+
+		const result: DeepAgentsResult = {
+			taskId: task.id,
+			status,
+			summary: response.summary,
+			filesChanged: response.filesChanged,
+			output: response.output,
+			error: response.error,
+			usage: response.usage,
+			durationMs,
+			completedAt: new Date().toISOString(),
+			metadata: response.metadata,
+		};
+
+		return result;
+	}
+}
+
+/**
+ * Factory function to create a DeepAgentsAdapter
+ * Matches AgentWorkerFactory signature from RFC-0030
+ */
+export function createDeepAgentsAdapter(
+	config: AgentWorkerConfig,
+): AgentWorker {
+	const adapter = new DeepAgentsAdapter(
+		config.id ?? `deepagents-${Date.now()}`,
+	);
+	return adapter;
+}

package/packages/providers/glm-usage.ts

@@ -0,0 +1,248 @@
+/**
+ * GLM (Zhipu AI) Usage Fetcher — TUI Integration
+ *
+ * GLM reports quota exhaustion directly 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.
+ */
+
+import { EventEmitter } from "node:events";
+
+export interface GLMUsageData {
+	provider: "glm";
+	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 GLMUsageConfig {
+	/** Called when GLM quota signal is detected from TUI */
+	onQuotaSignal?: (data: GLMUsageData) => void;
+}
+
+/**
+ * GLM quota message patterns from TUI
+ * These patterns match the messages pi displays when GLM hits limits
+ */
+const GLM_QUOTA_PATTERNS = [
+	// Context window full
+	{
+		pattern: /GLM.*context.*(?:window|length).*(?:full|exceeded|limit)/i,
+		limitType: "context_window" as const,
+	},
+	{
+		pattern: /tokens.*(?:exhausted|limit|ran out|remaining).*(\d+)h?\s*(\d+)m/i,
+		limitType: "tokens" as const,
+	},
+	// Reset time patterns
+	{
+		pattern: /GLM.*reset.*(?:at|in).*(\d{1,2}):(\d{2})/i,
+		limitType: "unknown" as const,
+	},
+	{
+		pattern: /GLM.*(?:quota|limit|exhausted|rate.?limit)/i,
+		limitType: "tokens" as const,
+	},
+	// OpenRouter GLM via OpenRouter
+	{
+		pattern: /ZhipuAI|GLM.*(?:exhausted|limit|quota)/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,
+];
+
+export class GLMUsageProvider extends EventEmitter {
+	private lastUsageData: GLMUsageData | null = null;
+	private onQuotaSignal?: (data: GLMUsageData) => void;
+
+	constructor(config: GLMUsageConfig = {}) {
+		super();
+		this.onQuotaSignal = config.onQuotaSignal;
+	}
+
+	/**
+	 * Check if auto-fetch is possible via TUI
+	 * GLM 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 GLM quota data
+	 * Call this when receiving error/status messages from pi
+	 */
+	processTUIMessage(message: string): GLMUsageData | null {
+		// Check if this is a GLM quota message
+		for (const { pattern, limitType } of GLM_QUOTA_PATTERNS) {
+			if (pattern.test(message)) {
+				const usageData = this.parseGLMQuotaMessage(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) {
+				const hour = parseInt(match[1], 10);
+				const minute = parseInt(match[2], 10);
+
+				// 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 GLM quota message
+	 */
+	private parseGLMQuotaMessage(
+		message: string,
+		limitType: GLMUsageData["limitType"],
+	): GLMUsageData {
+		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: "glm",
+			timestamp: new Date().toISOString(),
+			usedPct,
+			remainingPct: usedPct !== undefined ? 100 - usedPct : 0,
+			exhausted: true,
+			resetsAt,
+			limitType,
+			originalMessage: message,
+		};
+	}
+
+	/**
+	 * Get the last captured usage data
+	 */
+	getLastUsage(): GLMUsageData | 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<GLMUsageData> {
+		if (!this.lastUsageData) {
+			return {
+				provider: "glm",
+				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 GLM usage provider into pi extension
+ *
+ * Usage:
+ * ```typescript
+ * const glmUsage = new GLMUsageProvider({
+ *   onQuotaSignal: (data) => {
+ *     quotaManager.recordSignal({
+ *       provider: "glm",
+ *       source: "tui_message",
+ *       windowType: data.limitType === "context_window" ? "daily" : "5h",
+ *       exhausted: data.exhausted,
+ *       resetsAt: data.resetsAt,
+ *     });
+ *   }
+ * });
+ *
+ * pi.on("error", (event) => {
+ *   glmUsage.processTUIMessage(event.message);
+ * });
+ *
+ * pi.on("message", (event) => {
+ *   glmUsage.processTUIMessage(event.message);
+ * });
+ * ```
+ */