pi-harness-runtime 0.10.11 → 0.10.12

package/packages/provider-router/dist/types/src/runtime-types.d.ts

@@ -0,0 +1,412 @@
+export type JobStatus = "created" | "planning" | "queued" | "running" | "testing" | "e2e_testing" | "reviewing" | "repairing" | "paused_quota" | "waiting_human" | "blocked" | "ready_for_client" | "archived" | "cancelled";
+export type TaskStatus = "pending" | "ready" | "running" | "testing" | "reviewing" | "done" | "failed" | "blocked";
+export type ProviderState = "available" | "limited" | "exhausted" | "disabled" | "unknown";
+export interface RuntimeTask {
+    id: string;
+    title: string;
+    description: string;
+    status: TaskStatus;
+    assignedProvider?: string;
+    worktreePath?: string;
+    acceptanceCriteria?: string[];
+    /** Task instructions (used by LoopRuntime for compactable message content) */
+    instructions?: string;
+    /** Tools available for this task */
+    tools?: Array<{
+        name: string;
+        description?: string;
+        input_schema?: Record<string, unknown>;
+    }>;
+}
+export interface RuntimeCheckpoint {
+    version: number;
+    jobId: string;
+    status: JobStatus;
+    requirement: string;
+    currentTaskId?: string;
+    provider?: string;
+    resumeAt?: string;
+    lastError?: string;
+    createdAt: string;
+    updatedAt: string;
+    /** Loop iteration at checkpoint (used by LoopRuntime for resume) */
+    iteration?: number;
+    /** Task ID being executed at checkpoint */
+    taskId?: string;
+}
+export interface RuntimeEvent {
+    ts: string;
+    jobId: string;
+    type: string;
+    message: string;
+    data?: Record<string, unknown>;
+}
+export interface RuntimeContext {
+    jobId: string;
+    requirement: string;
+    tasks: RuntimeTask[];
+    providerStates: Record<string, ProviderState>;
+}
+export interface ProviderSelection {
+    providerId: string;
+    reason: string;
+}
+export interface TaskNode {
+    id: string;
+    title: string;
+    description: string;
+    status: TaskStatus;
+    dependencies: string[];
+    dependents: string[];
+    assignedAgent?: string;
+    worktreePath?: string;
+    acceptanceCriteria?: string[];
+    retryCount?: number;
+    maxRetries?: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface TaskGraph {
+    jobId: string;
+    nodes: Record<string, TaskNode>;
+    topologicalOrder: string[];
+}
+export interface BlackboardRecord {
+    jobId: string;
+    status: JobStatus;
+    nextAction?: NextAction;
+    tasks: TaskGraph;
+    agentRegistry: AgentRegistry;
+    reports: Record<string, AgentReport>;
+    locks: Record<string, LockInfo>;
+    updatedAt: string;
+}
+export interface NextAction {
+    taskId?: string;
+    agentId?: string;
+    instruction: string;
+    priority: "high" | "normal" | "low";
+    createdAt: string;
+    expiresAt?: string;
+}
+export interface AgentRegistry {
+    agents: Record<string, AgentInfo>;
+}
+export interface AgentInfo {
+    id: string;
+    name: string;
+    provider: string;
+    model?: string;
+    status: "idle" | "working" | "waiting" | "failed";
+    currentTaskId?: string;
+    startedAt?: string;
+    lastHeartbeat?: string;
+}
+export interface AgentReport {
+    agentId: string;
+    taskId: string;
+    status: "success" | "failure" | "partial";
+    summary: string;
+    filesChanged?: string[];
+    testsRun?: number;
+    testsPassed?: number;
+    testsFailed?: number;
+    createdAt: string;
+}
+export interface LockInfo {
+    taskId: string;
+    agentId: string;
+    acquiredAt: string;
+    expiresAt?: string;
+}
+export interface ContextWindowUpdate {
+    provider: string;
+    model: string;
+    maxTokens: number;
+    usedTokens: number;
+}
+export interface ContextWindowStats {
+    provider: string;
+    model: string;
+    maxTokens: number;
+    usedTokens: number;
+    availableTokens: number;
+    utilizationPct: number;
+}
+export interface ContextWindowConfig {
+    warningThreshold: number;
+    criticalThreshold: number;
+    strategy: "truncate" | "summarize" | "split";
+}
+export interface QuotaSignal {
+    provider: string;
+    windowType: "5h" | "daily" | "weekly" | "monthly";
+    usedPct: number;
+    remainingPct: number;
+    resetsAt?: string;
+    exhausted: boolean;
+    source: "api_response" | "provider_status" | "playwright" | "local_estimate" | "tui_message";
+    capturedAt: string;
+    retryAfterMs?: number;
+}
+export interface QuotaState {
+    provider: string;
+    available: boolean;
+    limited: boolean;
+    exhausted: boolean;
+    signals: QuotaSignal[];
+    nextAvailableAt?: string;
+}
+export interface ProviderConfig {
+    id: string;
+    name: string;
+    apiKey?: string;
+    baseUrl?: string;
+    models: string[];
+    capabilities: ProviderCapability[];
+    rateLimits: RateLimitConfig;
+}
+export type ProviderCapability = "code" | "review" | "plan" | "test" | "e2e" | "refactor" | "analysis" | "debug";
+export interface RateLimitConfig {
+    requestsPerMinute?: number;
+    tokensPerMinute?: number;
+    tokensPerDay?: number;
+    concurrentRequests?: number;
+}
+export interface ProviderResponse {
+    content: string;
+    usage?: {
+        input: number;
+        output: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+        cost?: number;
+    };
+    model?: string;
+    finishReason?: "stop" | "length" | "content_filter" | "error";
+    error?: string;
+}
+export interface ProviderRequest {
+    model: string;
+    messages: ProviderMessage[];
+    temperature?: number;
+    maxTokens?: number;
+    stop?: string[];
+}
+export interface ProviderMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+export interface HandoffContext {
+    jobId: string;
+    taskId: string;
+    fromAgent: string;
+    toAgent: string;
+    sharedFiles: string[];
+    taskHistory: HandoffEvent[];
+    summary: string;
+}
+export interface HandoffEvent {
+    ts: string;
+    agentId: string;
+    action: string;
+    result?: string;
+}
+export type ProjectType = "frappe_erpnext" | "frappe_spa" | "nextjs" | "react_vite" | "django" | "laravel" | "generic_web" | "unknown";
+export interface ProjectDetection {
+    projectType: ProjectType;
+    confidence: number;
+    signals: string[];
+    recommendedSeedStrategy: SeedStrategy;
+    recommendedE2EStrategy: E2EStrategy;
+    framework?: string;
+    version?: string;
+}
+export type SeedStrategy = "frappe_doc_insert" | "frappe_site_seed" | "nextjs_factory" | "react_factory" | "django_fixture" | "laravel_factory" | "generic_sql";
+export type E2EStrategy = "bench_site_browser_flow" | "next_dev_server_flow" | "vite_dev_server_flow" | "django_test_client_flow" | "laravel_dusk_flow" | "generic_playwright_flow";
+export interface E2EScenario {
+    id: string;
+    name: string;
+    description: string;
+    steps: E2EStep[];
+    required: boolean;
+    tags?: string[];
+}
+export interface E2EStep {
+    action: "navigate" | "click" | "type" | "wait" | "screenshot" | "assert" | "hover" | "select" | "upload";
+    selector?: string;
+    value?: string;
+    timeout?: number;
+    assertCondition?: string;
+}
+export interface E2EResult {
+    scenarioId: string;
+    status: "passed" | "failed" | "skipped" | "error";
+    duration: number;
+    stepsExecuted: number;
+    stepsPassed: number;
+    stepsFailed: number;
+    screenshotPath?: string;
+    tracePath?: string;
+    videoPath?: string;
+    errorMessage?: string;
+    failedStep?: number;
+    executedAt: string;
+}
+export interface E2EReport {
+    jobId: string;
+    scenarios: E2EScenario[];
+    results: E2EResult[];
+    summary: {
+        total: number;
+        passed: number;
+        failed: number;
+        skipped: number;
+        duration: number;
+    };
+    createdAt: string;
+}
+export interface RepairTask {
+    id: string;
+    originalTaskId: string;
+    failureType: FailureType;
+    description: string;
+    attemptedFixes: AttemptedFix[];
+    status: "pending" | "in_progress" | "resolved" | "escalated";
+    retryPolicy: RetryPolicy;
+    createdAt: string;
+    resolvedAt?: string;
+}
+export type FailureType = "test_failure" | "e2e_failure" | "build_error" | "runtime_error" | "lint_error" | "type_error" | "quota_exhausted" | "provider_error" | "unknown";
+export interface AttemptedFix {
+    attempt: number;
+    description: string;
+    success: boolean;
+    output?: string;
+    timestamp: string;
+}
+export interface RetryPolicy {
+    maxRetries: number;
+    backoffMs: number;
+    backoffMultiplier: number;
+    escalationAfter?: number;
+}
+export interface WorktreeInfo {
+    name: string;
+    path: string;
+    branch: string;
+    jobId?: string;
+    taskId?: string;
+    createdAt: string;
+    status: "active" | "merged" | "abandoned";
+}
+export interface LoopConfig {
+    jobId: string;
+    requirement: string;
+    providerPolicy?: {
+        plannerProvider: string;
+        codeProviders: string[];
+        reviewProvider: string;
+        fallbackProviders: string[];
+    };
+    maxIterations?: number;
+    checkpointInterval?: number;
+    autoCheckpoint?: boolean;
+    pauseOnQuota?: boolean;
+    maxRepairAttempts?: number;
+}
+export interface LoopState {
+    jobId: string;
+    iteration: number;
+    currentTaskId?: string | null;
+    status: JobStatus;
+    lastActivity?: string;
+    lastCheckpoint?: RuntimeCheckpoint | null;
+}
+/** Why a compact was triggered */
+export type CompactTriggerReason = "token_threshold" | "manual" | "output_limit" | "quota_exceeded" | "error";
+/** A single tool-call result that can be microcompacted */
+export interface CompactableToolResult {
+    id: string;
+    name: string;
+    timestamp: number;
+    tokens: number;
+    content: string;
+}
+/**
+ * A message in the compactable conversation history.
+ * System-role messages are used as compact boundaries.
+ */
+export interface CompactableMessage {
+    role: "user" | "assistant" | "system";
+    content: string;
+    timestamp: number;
+    toolResults?: CompactableToolResult[];
+    /** Arbitrary per-message metadata (e.g. model, usage stats) */
+    metadata?: Record<string, unknown>;
+}
+/** Return type of every LLM invocation */
+export interface InvokeResult {
+    success: boolean;
+    output?: string;
+    error?: string;
+    finishReason?: "stop" | "length" | "content_filter";
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    /** The model that generated this result (used for cost tracking) */
+    model?: string;
+}
+/**
+ * Options passed when invoking the LLM through CompactOrchestrator.
+ * The orchestrator injects microcompact / full compact around this call.
+ */
+export interface InvokeWithCompactOptions {
+    messages: CompactableMessage[];
+    model: string;
+    systemPrompt?: string;
+    maxOutputTokens: number;
+    tools?: Array<{
+        name: string;
+        description?: string;
+        input_schema?: Record<string, unknown>;
+    }>;
+    /**
+     * The actual LLM invoke function.
+     * When provided in opts, the orchestrator uses it directly.
+     * Otherwise the orchestrator falls back to callbacks.invokeAgent.
+     */
+    invokeAgent?: (opts: InvokeWithCompactOptions) => Promise<InvokeResult>;
+}
+/** What the orchestrator emits after a full compact */
+export interface CompactResult {
+    trigger: CompactTriggerReason;
+    beforeTokens: number;
+    afterTokens: number;
+    messagesCompacted: number;
+    summary?: string;
+}
+/** What the orchestrator emits as its final return value */
+export interface OrchestratedInvokeResult extends InvokeResult {
+    compactResult?: CompactResult;
+    continueMessage?: string;
+}
+/** Callbacks the harness provides to CompactOrchestrator */
+export interface CompactOrchestratorCallbacks {
+    /** Called after every successful compaction with the result */
+    onCheckpoint?: (result: CompactResult) => void;
+    /** Called when a quota event occurs */
+    onQuotaEvent?: (event: "paused" | "resumed" | "exhausted", provider?: string) => void;
+    /**
+     * Summarize messages via a forked agent.
+     * Used by runFullCompact() instead of the main conversation.
+     * Until RFC-0028 is fully wired, falls back to heuristic truncation.
+     */
+    summarizeViaForkedAgent?: (messages: CompactableMessage[], reason: CompactTriggerReason) => Promise<{
+        summary: string;
+        droppedCount: number;
+    }>;
+}
+//# sourceMappingURL=runtime-types.d.ts.map

package/packages/provider-router/dist/types/src/runtime-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=runtime-types.js.map

package/packages/provider-router/src/index.ts

@@ -0,0 +1,49 @@
+/**
+ * Provider Router Package (RFC-0054)
+ *
+ * Enhanced provider routing with capability, cost, and quota awareness.
+ *
+ * @example
+ * ```typescript
+ * import { createProviderRouter, DEFAULT_ROUTING_POLICY } from "@pi-harness/provider-router";
+ *
+ * const router = createProviderRouter();
+ *
+ * const decision = await router.selectProvider(task, context, {
+ *   preferCheapest: true,
+ *   requiredCapabilities: ["code_generation"],
+ * });
+ * ```
+ */
+
+// Types
+export type {
+	RoutingStrategy,
+	RoutingPolicy,
+	QuotaState,
+	RoutingContext,
+	RoutingOptions,
+	ProviderCandidate,
+	RoutingDecision,
+	ProviderRouter,
+	ProviderRouterEvent,
+	Latency,
+} from "./types.js";
+
+export { LATENCY_RANK } from "./types.js";
+
+// Router
+export {
+	EnhancedProviderRouter,
+	createProviderRouter,
+} from "./provider-router.js";
+
+// Policy
+export { DEFAULT_ROUTING_POLICY, createRoutingPolicy } from "./policy.js";
+
+// Strategies
+export {
+	applyStrategy,
+	calculateWeightedScore,
+	createDecision,
+} from "./strategies.js";

package/packages/provider-router/src/policy.ts

@@ -0,0 +1,50 @@
+/**
+ * Default Routing Policy (RFC-0054)
+ */
+
+import type { RoutingPolicy } from "./types.js";
+
+export const DEFAULT_ROUTING_POLICY: RoutingPolicy = {
+	defaultStrategy: "balanced",
+	costWeight: 30,
+	qualityWeight: 40,
+	latencyWeight: 20,
+	quotaWeight: 10,
+	fallbackProviders: ["anthropic", "openai"],
+	taskTypeOverrides: {
+		planning: "best_quality",
+		code_generation: "balanced",
+		code_review: "best_quality",
+		test_generation: "fastest",
+		e2e_testing: "quota_aware",
+		analysis: "best_quality",
+		refactoring: "balanced",
+		debugging: "fastest",
+		documentation: "cheapest",
+	},
+	providerPreferences: {
+		minimax: 20, // prefer cheaper options
+		openai: 0,
+		anthropic: 10,
+	},
+};
+
+/**
+ * Create a custom routing policy
+ */
+export function createRoutingPolicy(
+	overrides: Partial<RoutingPolicy>,
+): RoutingPolicy {
+	return {
+		...DEFAULT_ROUTING_POLICY,
+		...overrides,
+		taskTypeOverrides: {
+			...DEFAULT_ROUTING_POLICY.taskTypeOverrides,
+			...overrides.taskTypeOverrides,
+		},
+		providerPreferences: {
+			...DEFAULT_ROUTING_POLICY.providerPreferences,
+			...overrides.providerPreferences,
+		},
+	};
+}