pi-harness-runtime 0.10.11 → 0.10.12

package/packages/types/src/agent-worker-types.ts

@@ -0,0 +1,264 @@
+/**
+ * Agent Worker Interface — RFC-0030
+ *
+ * Common interface for all agent workers (Codex, MiniMax, GLM, GPT, DeepAgents).
+ * Runtime remains the orchestrator; agents are pluggable workers.
+ */
+
+import type { RuntimeTask } from "./runtime-types.js";
+
+// --- Agent Worker Types -----------------------------------------------
+
+export type AgentStatus =
+	| "idle"
+	| "initializing"
+	| "running"
+	| "paused"
+	| "stopped"
+	| "error";
+
+export type TaskResultStatus = "success" | "failure" | "partial" | "cancelled";
+
+export interface AgentWorkerConfig {
+	/** Unique identifier for this worker instance */
+	readonly id: string;
+	/** Provider name (e.g., "codex", "minimax", "glm", "gpt", "deepagents") */
+	readonly provider: string;
+	/** API endpoint or connection string */
+	readonly endpoint?: string;
+	/** Authentication token */
+	readonly apiKey?: string;
+	/** Default model to use */
+	readonly defaultModel?: string;
+	/** Supported models */
+	readonly supportedModels?: string[];
+	/** Request timeout in ms */
+	readonly timeoutMs?: number;
+	/** Maximum concurrent tasks */
+	readonly maxConcurrency?: number;
+}
+
+export interface TaskRequest {
+	/** Task to execute */
+	task: RuntimeTask;
+	/** Working directory for the task */
+	workingDir: string;
+	/** Context/memory from previous tasks */
+	context?: string;
+	/** Additional configuration */
+	config?: {
+		model?: string;
+		temperature?: number;
+		maxTokens?: number;
+	};
+}
+
+export interface TaskResult {
+	/** Task ID */
+	taskId: string;
+	/** Result status */
+	status: TaskResultStatus;
+	/** Summary of what was done */
+	summary: string;
+	/** Files that were changed */
+	filesChanged?: string[];
+	/** Output from the task */
+	output?: string;
+	/** Error message if failed */
+	error?: string;
+	/** Tokens used */
+	usage?: {
+		input: number;
+		output: number;
+		cost?: number;
+	};
+	/** Time taken in ms */
+	durationMs: number;
+	/** Timestamp */
+	completedAt: string;
+}
+
+export interface HealthStatus {
+	/** Whether the agent is healthy */
+	healthy: boolean;
+	/** Current status */
+	status: AgentStatus;
+	/** Current load (0-1) */
+	load: number;
+	/** Active task count */
+	activeTasks: number;
+	/** Queue depth */
+	queueDepth: number;
+	/** Last health check */
+	checkedAt: string;
+	/** Error message if unhealthy */
+	error?: string;
+}
+
+// --- Agent Worker Events ----------------------------------------------
+
+export interface AgentWorkerEvents {
+	/** Fired when task progress is made */
+	onProgress: (taskId: string, progress: TaskProgress) => void;
+	/** Fired when a task completes */
+	onTaskComplete: (result: TaskResult) => void;
+	/** Fired when an error occurs */
+	onError: (taskId: string, error: Error) => void;
+	/** Fired when agent status changes */
+	onStatusChange: (status: AgentStatus) => void;
+	/** Fired on health check changes */
+	onHealthChange: (health: HealthStatus) => void;
+}
+
+export interface TaskProgress {
+	taskId: string;
+	phase: "planning" | "executing" | "reviewing" | "finalizing";
+	message: string;
+	percentComplete: number;
+	timestamp: string;
+}
+
+// --- Agent Worker Interface -------------------------------------------
+
+export interface AgentWorker {
+	/** Unique identifier */
+	readonly id: string;
+	/** Provider name */
+	readonly provider: string;
+
+	/**
+	 * Initialize the agent worker
+	 * @param config Worker configuration
+	 */
+	initialize(config: AgentWorkerConfig): Promise<void>;
+
+	/**
+	 * Execute a task
+	 * @param request Task request
+	 * @param events Event handlers
+	 * @returns Task result
+	 */
+	execute(
+		request: TaskRequest,
+		events?: Partial<AgentWorkerEvents>,
+	): Promise<TaskResult>;
+
+	/**
+	 * Check agent health
+	 * @returns Health status
+	 */
+	health(): Promise<HealthStatus>;
+
+	/**
+	 * Get current status
+	 * @returns Agent status
+	 */
+	status(): AgentStatus;
+
+	/**
+	 * Pause the agent (stop accepting new tasks)
+	 */
+	pause(): Promise<void>;
+
+	/**
+	 * Resume the agent
+	 */
+	resume(): Promise<void>;
+
+	/**
+	 * Stop the agent and cleanup
+	 */
+	stop(): Promise<void>;
+
+	/**
+	 * Check if a model is supported
+	 * @param model Model identifier
+	 * @returns Whether the model is supported
+	 */
+	supportsModel(model: string): boolean;
+
+	/**
+	 * Get supported models
+	 * @returns List of supported model identifiers
+	 */
+	getSupportedModels(): string[];
+}
+
+// --- DeepAgents Specific Types ---------------------------------------
+
+export interface DeepAgentsConfig extends AgentWorkerConfig {
+	provider: "deepagents";
+	/** DeepAgents server URL */
+	endpoint: string;
+	/** Project path to work in */
+	projectPath?: string;
+	/** Additional DeepAgents options */
+	options?: {
+		streaming?: boolean;
+		autoRetry?: boolean;
+		maxRetries?: number;
+	};
+}
+
+export interface DeepAgentsTaskRequest extends TaskRequest {
+	config?: TaskRequest["config"] & {
+		/** Task priority */
+		priority?: "low" | "normal" | "high";
+		/** Whether to use sandbox */
+		sandbox?: boolean;
+		/** Environment variables */
+		env?: Record<string, string>;
+	};
+}
+
+export interface DeepAgentsResult extends TaskResult {
+	/** DeepAgents-specific metadata */
+	metadata?: {
+		agentId?: string;
+		workerId?: string;
+		sandboxUrl?: string;
+	};
+}
+
+// --- Factory Function -------------------------------------------------
+
+export type AgentWorkerFactory = (config: AgentWorkerConfig) => AgentWorker;
+
+/**
+ * Registry of agent worker factories
+ */
+export class AgentWorkerRegistry {
+	private factories: Map<string, AgentWorkerFactory> = new Map();
+
+	/**
+	 * Register a worker factory
+	 */
+	register(provider: string, factory: AgentWorkerFactory): void {
+		this.factories.set(provider.toLowerCase(), factory);
+	}
+
+	/**
+	 * Create a worker for a provider
+	 */
+	create(config: AgentWorkerConfig): AgentWorker | undefined {
+		const factory = this.factories.get(config.provider.toLowerCase());
+		if (!factory) {
+			return undefined;
+		}
+		return factory(config);
+	}
+
+	/**
+	 * Check if a provider is supported
+	 */
+	supports(provider: string): boolean {
+		return this.factories.has(provider.toLowerCase());
+	}
+
+	/**
+	 * List all supported providers
+	 */
+	listProviders(): string[] {
+		return Array.from(this.factories.keys());
+	}
+}

package/packages/types/src/ai-providers.d.ts

@@ -0,0 +1,36 @@
+/**
+ * AI Provider Registry
+ *
+ * Centralized, canonical list of known AI/LLM providers used as keys across
+ * mirror.json, quota tracking, TUI signal parsing, and footer display.
+ *
+ * Adding a new provider = add ONE entry here + update the places that
+ * need per-provider behaviour (scraper, TUI parser, footer, etc.).
+ *
+ * Provider ids are lowercase internal keys.
+ * Labels are human-readable display strings.
+ */
+export declare const KNOWN_AI_PROVIDERS: readonly ["minimax", "openai", "anthropic", "glm", "openrouter", "openai-codex", "deepseek", "gemini", "kimi"];
+export type KnownAiProvider = (typeof KNOWN_AI_PROVIDERS)[number];
+/** Human-readable display labels (used in footer, notifications). */
+export declare const PROVIDER_LABELS: Record<string, string>;
+/**
+ * Providers that support continuous quota scraping via cookie/browser automation.
+ * Only MiniMax is currently supported here.
+ */
+export declare const SCRAPEABLE_PROVIDERS: KnownAiProvider[];
+/**
+ * Providers that report quota via TUI signal capture (one-shot on limit hit).
+ * These do NOT have a continuous scraping path.
+ */
+export declare const TUI_SIGNAL_PROVIDERS: KnownAiProvider[];
+/**
+ * Check if a provider id is a known AI provider.
+ */
+export declare function isKnownAiProvider(id: string): id is KnownAiProvider;
+/**
+ * Get the display label for a provider id.
+ * Falls back to the id itself if unknown.
+ */
+export declare function getProviderLabel(id: string): string;
+//# sourceMappingURL=ai-providers.d.ts.map

package/packages/types/src/ai-providers.js

@@ -0,0 +1,66 @@
+/**
+ * AI Provider Registry
+ *
+ * Centralized, canonical list of known AI/LLM providers used as keys across
+ * mirror.json, quota tracking, TUI signal parsing, and footer display.
+ *
+ * Adding a new provider = add ONE entry here + update the places that
+ * need per-provider behaviour (scraper, TUI parser, footer, etc.).
+ *
+ * Provider ids are lowercase internal keys.
+ * Labels are human-readable display strings.
+ */
+export const KNOWN_AI_PROVIDERS = [
+    "minimax",
+    "openai",
+    "anthropic",
+    "glm",
+    "openrouter",
+    "openai-codex",
+    "deepseek",
+    "gemini",
+    "kimi",
+];
+/** Human-readable display labels (used in footer, notifications). */
+export const PROVIDER_LABELS = {
+    minimax: "MiniMax",
+    openai: "OpenAI",
+    anthropic: "Anthropic",
+    glm: "GLM",
+    openrouter: "OpenRouter",
+    "openai-codex": "OpenAI Codex",
+    deepseek: "DeepSeek",
+    gemini: "Gemini",
+    kimi: "Kimi",
+    unknown: "Unknown",
+};
+/**
+ * Providers that support continuous quota scraping via cookie/browser automation.
+ * Only MiniMax is currently supported here.
+ */
+export const SCRAPEABLE_PROVIDERS = ["minimax"];
+/**
+ * Providers that report quota via TUI signal capture (one-shot on limit hit).
+ * These do NOT have a continuous scraping path.
+ */
+export const TUI_SIGNAL_PROVIDERS = [
+    "openai",
+    "openai-codex",
+    "anthropic",
+    "glm",
+    "openrouter",
+];
+/**
+ * Check if a provider id is a known AI provider.
+ */
+export function isKnownAiProvider(id) {
+    return KNOWN_AI_PROVIDERS.includes(id);
+}
+/**
+ * Get the display label for a provider id.
+ * Falls back to the id itself if unknown.
+ */
+export function getProviderLabel(id) {
+    return PROVIDER_LABELS[id] ?? id;
+}
+//# sourceMappingURL=ai-providers.js.map

package/packages/types/src/ai-providers.ts

@@ -0,0 +1,73 @@
+/**
+ * AI Provider Registry
+ *
+ * Centralized, canonical list of known AI/LLM providers used as keys across
+ * mirror.json, quota tracking, TUI signal parsing, and footer display.
+ *
+ * Adding a new provider = add ONE entry here + update the places that
+ * need per-provider behaviour (scraper, TUI parser, footer, etc.).
+ *
+ * Provider ids are lowercase internal keys.
+ * Labels are human-readable display strings.
+ */
+
+export const KNOWN_AI_PROVIDERS = [
+	"minimax",
+	"openai",
+	"anthropic",
+	"glm",
+	"openrouter",
+	"openai-codex",
+	"deepseek",
+	"gemini",
+	"kimi",
+] as const;
+
+export type KnownAiProvider = (typeof KNOWN_AI_PROVIDERS)[number];
+
+/** Human-readable display labels (used in footer, notifications). */
+export const PROVIDER_LABELS: Record<string, string> = {
+	minimax: "MiniMax",
+	openai: "OpenAI",
+	anthropic: "Anthropic",
+	glm: "GLM",
+	openrouter: "OpenRouter",
+	"openai-codex": "OpenAI Codex",
+	deepseek: "DeepSeek",
+	gemini: "Gemini",
+	kimi: "Kimi",
+	unknown: "Unknown",
+};
+
+/**
+ * Providers that support continuous quota scraping via cookie/browser automation.
+ * Only MiniMax is currently supported here.
+ */
+export const SCRAPEABLE_PROVIDERS: KnownAiProvider[] = ["minimax"];
+
+/**
+ * Providers that report quota via TUI signal capture (one-shot on limit hit).
+ * These do NOT have a continuous scraping path.
+ */
+export const TUI_SIGNAL_PROVIDERS: KnownAiProvider[] = [
+	"openai",
+	"openai-codex",
+	"anthropic",
+	"glm",
+	"openrouter",
+];
+
+/**
+ * Check if a provider id is a known AI provider.
+ */
+export function isKnownAiProvider(id: string): id is KnownAiProvider {
+	return (KNOWN_AI_PROVIDERS as readonly string[]).includes(id);
+}
+
+/**
+ * Get the display label for a provider id.
+ * Falls back to the id itself if unknown.
+ */
+export function getProviderLabel(id: string): string {
+	return PROVIDER_LABELS[id] ?? id;
+}