pi-harness-runtime 0.10.11 → 0.10.12

package/packages/providers/dist/src/deepagents-adapter.js

@@ -0,0 +1,323 @@
+/**
+ * DeepAgents Adapter — RFC-0029
+ *
+ * Implements the AgentWorker interface for DeepAgents.
+ * DeepAgents is an optional Agent Worker; Runtime remains the orchestrator.
+ *
+ * @module deepagents-adapter
+ */
+/**
+ * DeepAgents Adapter
+ *
+ * Connects the harness runtime to a DeepAgents worker.
+ * Runtime orchestrates; DeepAgents executes tasks.
+ */
+export class DeepAgentsAdapter {
+    id;
+    provider = "deepagents";
+    config = null;
+    _status = "idle";
+    abortController = null;
+    currentTaskId = null;
+    constructor(id) {
+        this.id = id;
+    }
+    /**
+     * Initialize the DeepAgents adapter
+     */
+    async initialize(config) {
+        if (config.provider !== "deepagents") {
+            throw new Error(`Invalid provider: ${config.provider}. Expected "deepagents".`);
+        }
+        this.config = config;
+        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, events) {
+        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 = {
+                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 = {
+                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 = {
+                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 = {
+                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() {
+        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());
+            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() {
+        return this._status;
+    }
+    /**
+     * Pause the agent
+     */
+    async pause() {
+        if (this._status === "running" && this.abortController) {
+            this.abortController.abort();
+        }
+        this._status = "paused";
+    }
+    /**
+     * Resume the agent
+     */
+    async resume() {
+        if (this._status === "paused") {
+            this._status = "idle";
+        }
+    }
+    /**
+     * Stop the agent
+     */
+    async stop() {
+        if (this.abortController) {
+            this.abortController.abort();
+        }
+        this._status = "stopped";
+        this.currentTaskId = null;
+    }
+    /**
+     * Check if a model is supported
+     */
+    supportsModel(model) {
+        const supported = this.config?.supportedModels ?? ["deepagents/default"];
+        return supported.some((m) => m.toLowerCase() === model.toLowerCase() || m === "*");
+    }
+    /**
+     * Get supported models
+     */
+    getSupportedModels() {
+        return this.config?.supportedModels ?? ["deepagents/default"];
+    }
+    // --- Private Methods ------------------------------------------------
+    /**
+     * Build a DeepAgents API request from a task request
+     */
+    buildDeepAgentsRequest(request) {
+        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.config,
+        };
+        return deepRequest;
+    }
+    /**
+     * Call the DeepAgents API
+     */
+    async callDeepAgents(request) {
+        if (!this.config) {
+            throw new Error("Not initialized");
+        }
+        const controller = this.abortController ?? new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs ?? 300000);
+        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());
+            return result;
+        }
+        catch (error) {
+            clearTimeout(timeout);
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new Error("Task was cancelled");
+            }
+            throw error;
+        }
+    }
+    /**
+     * Parse DeepAgents response into TaskResult
+     */
+    parseDeepAgentsResponse(task, response, startTime) {
+        const status = response.status;
+        const durationMs = Date.now() - startTime;
+        const result = {
+            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) {
+    const adapter = new DeepAgentsAdapter(config.id ?? `deepagents-${Date.now()}`);
+    return adapter;
+}
+//# sourceMappingURL=deepagents-adapter.js.map

package/packages/providers/dist/src/glm-usage.d.ts

@@ -0,0 +1,102 @@
+/**
+ * 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;
+}
+export declare class GLMUsageProvider extends EventEmitter {
+    private lastUsageData;
+    private onQuotaSignal?;
+    constructor(config?: GLMUsageConfig);
+    /**
+     * Check if auto-fetch is possible via TUI
+     * GLM reports quota via TUI, so this is always true when hooked
+     */
+    supportsAutoFetch(): boolean;
+    /**
+     * Process a TUI message and extract GLM quota data
+     * Call this when receiving error/status messages from pi
+     */
+    processTUIMessage(message: string): GLMUsageData | null;
+    /**
+     * Parse reset time from message
+     */
+    private parseResetTime;
+    /**
+     * Parse the GLM quota message
+     */
+    private parseGLMQuotaMessage;
+    /**
+     * Get the last captured usage data
+     */
+    getLastUsage(): GLMUsageData | null;
+    /**
+     * Clear stored usage data
+     */
+    clear(): void;
+    /**
+     * For QuotaManager integration
+     * Returns current state (from last TUI message)
+     */
+    getUsage(): Promise<GLMUsageData>;
+    /**
+     * Get usage as percentage
+     */
+    getUsagePercent(): Promise<number>;
+    /**
+     * Check if quota is exhausted
+     */
+    isExhausted(): Promise<boolean>;
+}
+/**
+ * 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);
+ * });
+ * ```
+ */
+//# sourceMappingURL=glm-usage.d.ts.map

package/packages/providers/dist/src/glm-usage.js

@@ -0,0 +1,197 @@
+/**
+ * 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";
+/**
+ * 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",
+    },
+    {
+        pattern: /tokens.*(?:exhausted|limit|ran out|remaining).*(\d+)h?\s*(\d+)m/i,
+        limitType: "tokens",
+    },
+    // Reset time patterns
+    {
+        pattern: /GLM.*reset.*(?:at|in).*(\d{1,2}):(\d{2})/i,
+        limitType: "unknown",
+    },
+    {
+        pattern: /GLM.*(?:quota|limit|exhausted|rate.?limit)/i,
+        limitType: "tokens",
+    },
+    // OpenRouter GLM via OpenRouter
+    {
+        pattern: /ZhipuAI|GLM.*(?:exhausted|limit|quota)/i,
+        limitType: "tokens",
+    },
+];
+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 {
+    lastUsageData = null;
+    onQuotaSignal;
+    constructor(config = {}) {
+        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() {
+        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) {
+        // 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
+     */
+    parseResetTime(message) {
+        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
+     */
+    parseGLMQuotaMessage(message, limitType) {
+        const resetsAt = this.parseResetTime(message) ??
+            new Date(Date.now() + 60 * 60 * 1000).toISOString();
+        // Try to extract percentage if present
+        let usedPct;
+        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() {
+        return this.lastUsageData;
+    }
+    /**
+     * Clear stored usage data
+     */
+    clear() {
+        this.lastUsageData = null;
+    }
+    /**
+     * For QuotaManager integration
+     * Returns current state (from last TUI message)
+     */
+    async getUsage() {
+        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() {
+        const usage = await this.getUsage();
+        return usage.usedPct ?? 100 - usage.remainingPct;
+    }
+    /**
+     * Check if quota is exhausted
+     */
+    async isExhausted() {
+        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);
+ * });
+ * ```
+ */
+//# sourceMappingURL=glm-usage.js.map

package/packages/providers/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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";
+//# sourceMappingURL=index.d.ts.map

package/packages/providers/dist/src/index.js

@@ -0,0 +1,11 @@
+/**
+ * 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";
+//# sourceMappingURL=index.js.map