pi-harness-runtime 0.10.7 → 0.10.11

package/packages/providers/src/deepagents-adapter.ts

@@ -1,458 +0,0 @@
-/**
- * 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/src/glm-usage.ts

@@ -1,248 +0,0 @@
-/**
- * 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);
- * });
- * ```
- */

package/packages/providers/src/index.ts

@@ -1,11 +0,0 @@
-/**
- * Provider Adapters (RFC-0027)
- *
- * Multi-provider adapter system.
- */
-
-export * from "./adapters.js";
-export * from "./deepagents-adapter.js";
-export * from "./glm-usage.js";
-export * from "./openai-usage.js";
-export * from "./provider-id.js";