pi-harness-runtime 0.10.13 → 0.10.15

package/packages/performance-optimizer/src/optimizer.js

@@ -0,0 +1,304 @@
+/**
+ * Performance Optimizer (RFC-0056)
+ *
+ * Analyzes runtime metrics and produces advisory optimization decisions.
+ */
+/**
+ * Detect bottlenecks from metrics
+ */
+function detectBottlenecks(metrics) {
+    const bottlenecks = [];
+    const { currentContextTokens, contextWindow, retryCount, successCount, failureCount, } = metrics;
+    // Context usage bottleneck
+    const contextUsagePercent = (currentContextTokens / contextWindow) * 100;
+    if (contextUsagePercent > 80) {
+        bottlenecks.push("high_context_usage");
+    }
+    // Retry bottleneck
+    const totalCalls = successCount + failureCount;
+    if (totalCalls > 0 && retryCount / totalCalls > 0.3) {
+        bottlenecks.push("high_retry_rate");
+    }
+    // Provider performance
+    const avgLatency = metrics.avgLatencyMs;
+    if (avgLatency > 30000) {
+        bottlenecks.push("high_latency");
+    }
+    return bottlenecks;
+}
+/**
+ * Normalize provider metrics
+ */
+function normalizeProviderStats(providerMetrics) {
+    const normalized = {};
+    for (const [providerId, stats] of Object.entries(providerMetrics)) {
+        const total = stats.callCount;
+        if (total > 0) {
+            normalized[providerId] = {
+                successRate: stats.successCount / total,
+                failureRate: stats.failureCount / total,
+            };
+        }
+    }
+    return normalized;
+}
+/**
+ * Generate context reduction recommendation
+ */
+function suggestContextReduction(metrics, policy) {
+    const { currentContextTokens, contextWindow } = metrics;
+    const usagePercent = (currentContextTokens / contextWindow) * 100;
+    if (usagePercent < 50) {
+        return null; // No reduction needed
+    }
+    // Calculate target (reduce to 60% of current)
+    const targetTokens = Math.floor(currentContextTokens * 0.6);
+    const reductionPercent = ((currentContextTokens - targetTokens) / currentContextTokens) * 100;
+    if (reductionPercent < policy.minContextReductionPercent) {
+        return null;
+    }
+    return {
+        type: "reduce_context",
+        targetTokens,
+        reason: `Context usage at ${usagePercent.toFixed(1)}% (${currentContextTokens}/${contextWindow} tokens). Reduce to ~60% to improve performance.`,
+    };
+}
+/**
+ * Generate provider change recommendation
+ */
+function suggestProviderChange(metrics, providerStates, policy) {
+    if (!policy.allowProviderSwitch) {
+        return null;
+    }
+    const providerStats = normalizeProviderStats(metrics.providerMetrics);
+    // Find worst performing provider
+    let worstProvider = null;
+    let worstFailureRate = 0;
+    for (const [providerId, stats] of Object.entries(providerStats)) {
+        if (stats.failureRate > worstFailureRate && stats.failureRate > 0.1) {
+            worstProvider = providerId;
+            worstFailureRate = stats.failureRate;
+        }
+    }
+    if (!worstProvider) {
+        return null;
+    }
+    // Check if there's a better available provider
+    const availableProviders = providerStates.filter((p) => p.state === "available" && p.providerId !== worstProvider);
+    if (availableProviders.length === 0) {
+        return null; // No alternative available
+    }
+    return {
+        type: "change_provider",
+        provider: availableProviders[0].providerId,
+        reason: `Provider '${worstProvider}' has ${(worstFailureRate * 100).toFixed(1)}% failure rate. Switch to '${availableProviders[0].providerId}' for better reliability.`,
+    };
+}
+/**
+ * Generate parallelism recommendations
+ */
+function suggestParallelismChanges(metrics, providerStates, policy, taskGraph) {
+    const recommendations = [];
+    // Check for blocked tasks that could be parallel
+    if (taskGraph) {
+        const runningTasks = taskGraph.nodes.filter((n) => n.status === "running");
+        const readyTasks = taskGraph.nodes.filter((n) => n.status === "ready");
+        // If we have many ready tasks and few running, suggest increasing parallelism
+        if (readyTasks.length > 5 && runningTasks.length < 3) {
+            const suggestedLimit = Math.min(runningTasks.length + 2, policy.maxParallelism);
+            if (suggestedLimit > runningTasks.length) {
+                recommendations.push({
+                    type: "increase_parallelism",
+                    limit: suggestedLimit,
+                    reason: `${readyTasks.length} tasks waiting. Increase parallelism to ${suggestedLimit} for faster completion.`,
+                });
+            }
+        }
+        // If too many tasks are hitting resource limits, suggest decreasing
+        const limitedProviders = providerStates.filter((p) => p.state === "limited");
+        if (limitedProviders.length > 0 && runningTasks.length > 5) {
+            recommendations.push({
+                type: "decrease_parallelism",
+                limit: Math.max(2, runningTasks.length - 2),
+                reason: `Provider quota limited. Reduce parallelism to ${Math.max(2, runningTasks.length - 2)} to avoid quota exhaustion.`,
+            });
+        }
+    }
+    return recommendations;
+}
+/**
+ * Resolve conflicting recommendations
+ */
+function resolveConflicts(recommendations, policy) {
+    // Sort by type priority (reductions first, then parallelism, then provider)
+    const priority = {
+        reduce_context: 1,
+        decrease_parallelism: 2,
+        increase_parallelism: 3,
+        change_provider: 4,
+        reuse_checkpoint: 5,
+        skip_redundant_step: 6,
+    };
+    // Remove duplicates and conflicting recommendations
+    const seen = new Set();
+    const resolved = [];
+    for (const rec of recommendations.sort((a, b) => priority[a.type] - priority[b.type])) {
+        const key = rec.type;
+        // Check for conflicts
+        if (key === "increase_parallelism" &&
+            resolved.some((r) => r.type === "decrease_parallelism")) {
+            continue; // Skip increase if decrease already added
+        }
+        if (key === "decrease_parallelism" &&
+            resolved.some((r) => r.type === "increase_parallelism")) {
+            // Remove increase and add decrease
+            const idx = resolved.findIndex((r) => r.type === "increase_parallelism");
+            if (idx !== -1)
+                resolved.splice(idx, 1);
+        }
+        if (!seen.has(key)) {
+            seen.add(key);
+            resolved.push(rec);
+        }
+    }
+    return resolved;
+}
+/**
+ * Calculate expected impact
+ */
+function calculateImpact(metrics, recommendations) {
+    let tokenReduction = 0;
+    let latencyReduction = 0;
+    let retryReduction = 0;
+    for (const rec of recommendations) {
+        switch (rec.type) {
+            case "reduce_context":
+                // Estimate 15-30% latency improvement from context reduction
+                latencyReduction += 20;
+                break;
+            case "change_provider":
+                // Estimate 10-25% latency improvement from better provider
+                latencyReduction += 15;
+                break;
+            case "decrease_parallelism":
+                // Reduce contention
+                latencyReduction += 10;
+                retryReduction += 15;
+                break;
+            case "skip_redundant_step":
+                tokenReduction += 10;
+                break;
+        }
+    }
+    return {
+        tokenReductionPercent: tokenReduction > 0 ? Math.min(tokenReduction, 50) : undefined,
+        latencyReductionPercent: latencyReduction > 0 ? Math.min(latencyReduction, 40) : undefined,
+        retryReductionPercent: retryReduction > 0 ? Math.min(retryReduction, 30) : undefined,
+    };
+}
+export class PerformanceOptimizer {
+    policy;
+    constructor(policy = {}) {
+        this.policy = {
+            minContextReductionPercent: 10,
+            maxParallelism: 10,
+            minImprovementPercent: 5,
+            allowProviderSwitch: true,
+            mandatoryStages: [],
+            ...policy,
+        };
+    }
+    /**
+     * Analyze metrics and produce optimization recommendations
+     */
+    analyze(request) {
+        const { jobId, metrics, providerStates } = request;
+        // Emit start event
+        this.emit({ type: "performance.analysis.started", jobId });
+        try {
+            // 1. Detect bottlenecks
+            const bottlenecks = detectBottlenecks(metrics);
+            // 2. Generate recommendations
+            const recommendations = [];
+            // Context reduction
+            const contextRec = suggestContextReduction(metrics, this.policy);
+            if (contextRec) {
+                recommendations.push(contextRec);
+                this.emit({
+                    type: "performance.recommendation.created",
+                    jobId,
+                    recommendation: contextRec,
+                });
+            }
+            // Provider change
+            const providerRec = suggestProviderChange(metrics, providerStates, this.policy);
+            if (providerRec) {
+                recommendations.push(providerRec);
+                this.emit({
+                    type: "performance.recommendation.created",
+                    jobId,
+                    recommendation: providerRec,
+                });
+            }
+            // Parallelism changes
+            const parallelismRecs = suggestParallelismChanges(metrics, providerStates, this.policy, request.taskGraph);
+            for (const rec of parallelismRecs) {
+                recommendations.push(rec);
+                this.emit({
+                    type: "performance.recommendation.created",
+                    jobId,
+                    recommendation: rec,
+                });
+            }
+            // 3. Resolve conflicts
+            const resolved = resolveConflicts(recommendations, this.policy);
+            // 4. Calculate impact
+            const expectedImpact = calculateImpact(metrics, resolved);
+            this.emit({ type: "performance.analysis.completed", jobId });
+            return {
+                jobId,
+                recommendations: resolved,
+                expectedImpact,
+                generatedAt: new Date().toISOString(),
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.emit({
+                type: "performance.analysis.failed",
+                jobId,
+                error: errorMessage,
+            });
+            return {
+                jobId,
+                recommendations: [],
+                expectedImpact: {},
+                generatedAt: new Date().toISOString(),
+            };
+        }
+    }
+    eventListeners = [];
+    /**
+     * Subscribe to optimizer events
+     */
+    onEvent(listener) {
+        this.eventListeners.push(listener);
+        return () => {
+            this.eventListeners = this.eventListeners.filter((l) => l !== listener);
+        };
+    }
+    emit(event) {
+        for (const listener of this.eventListeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // Best effort
+            }
+        }
+    }
+}
+// --- Factory ---------------------------------------------------------------
+export function createPerformanceOptimizer(policy) {
+    return new PerformanceOptimizer(policy);
+}

package/packages/performance-optimizer/src/types.js

@@ -0,0 +1,6 @@
+/**
+ * Performance Optimizer Types (RFC-0056)
+ *
+ * Interfaces for performance analysis and recommendations.
+ */
+export {};

package/packages/projection-engine/src/types.js

@@ -0,0 +1,5 @@
+/**
+ * Projection Engine — Types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/packages/providers/src/provider-id.js

@@ -0,0 +1,112 @@
+/**
+ * Provider ID — single source of truth for "which provider does this model id belong to".
+ *
+ * Used by:
+ *   - `index.ts` to gate fetcher calls (replaces the old `isMiniMaxModel` check)
+ *   - `mirror.ts` to key per-provider records
+ *   - the footer renderer to label lines correctly
+ *   - the cookie sanitizer and quota manager
+ *
+ * Provider boundaries (model-id prefix → provider id):
+ *
+ * | Model id prefix | Provider       | Notes                                |
+ * |-----------------|----------------|--------------------------------------|
+ * | `minimax/`      | minimax        | Playwright scrape path                |
+ * | `openai/`       | openai         | TUI signal path                       |
+ * | `openai-codex/` | openai-codex   | OAuth (different auth shape)          |
+ * | `zai/`          | glm            | Z.ai / Zhipu                         |
+ * | `zhipu/`        | glm            | alt alias                            |
+ * | `anthropic/`    | anthropic      | TUI signal path                       |
+ * | `openrouter/`   | openrouter     | TUI signal path                       |
+ * | other           | null           | unknown — caller decides default     |
+ *
+ * Match is case-insensitive on the prefix portion.
+ *
+ * The set is intentionally small and explicit. To add a provider: add
+ * a row to MODEL_PREFIXES and to the sanitization doc in
+ * wiki/bugs/multi-provider-usage-status.md.
+ */
+/** True if the given string is a known, canonical provider id. */
+export function isKnownAiProvider(value) {
+    return (value === "minimax" ||
+        value === "openai" ||
+        value === "openai-codex" ||
+        value === "glm" ||
+        value === "anthropic" ||
+        value === "openrouter");
+}
+const MODEL_PREFIXES = [
+    { prefix: "minimax/", provider: "minimax" },
+    { prefix: "openai-codex/", provider: "openai-codex" },
+    { prefix: "openai/", provider: "openai" },
+    { prefix: "anthropic/", provider: "anthropic" },
+    { prefix: "openrouter/", provider: "openrouter" },
+    { prefix: "zai/", provider: "glm" },
+    { prefix: "zhipu/", provider: "glm" },
+];
+/** Return the provider id for a model id, or null if unknown. */
+export function providerFromModelId(modelId) {
+    if (!modelId || typeof modelId !== "string")
+        return null;
+    const lower = modelId.toLowerCase();
+    for (const { prefix, provider } of MODEL_PREFIXES) {
+        if (lower.startsWith(prefix))
+            return provider;
+    }
+    // Some model ids may be just the provider name (no `/` separator) —
+    // common when the user picks via a friendly picker.
+    if (lower.startsWith("minimax"))
+        return "minimax";
+    if (lower.startsWith("openai-codex"))
+        return "openai-codex";
+    if (lower.startsWith("openai"))
+        return "openai";
+    if (lower.startsWith("anthropic") || lower.startsWith("claude"))
+        return "anthropic";
+    if (lower.startsWith("openrouter"))
+        return "openrouter";
+    if (lower.startsWith("zai") ||
+        lower.startsWith("zhipu") ||
+        lower.startsWith("glm"))
+        return "glm";
+    // Fallback for bare model names (no provider prefix)
+    if (lower.startsWith("gpt"))
+        return "openai"; // e.g., "gpt-5.4" → openai
+    return null;
+}
+/** Display name for the provider (used in the footer label). */
+export function providerDisplayName(provider) {
+    switch (provider) {
+        case "minimax":
+            return "MiniMax";
+        case "openai":
+            return "OpenAI";
+        case "openai-codex":
+            return "OpenAI Codex";
+        case "glm":
+            return "GLM";
+        case "anthropic":
+            return "Anthropic";
+        case "openrouter":
+            return "OpenRouter";
+        default:
+            return provider;
+    }
+}
+/** True if this provider has a continuous scrape path today (only MiniMax). */
+/**
+ * Providers with continuous quota scraping via browser/API.
+ * - minimax: has both 5h and weekly windows
+ * - openai: has weekly-only window (no 5h limit since 2026)
+ */
+export function providerHasContinuousScrape(provider) {
+    return provider === "minimax" || provider === "openai";
+}
+/** True if this provider has a TUI-driven signal path today. */
+export function providerHasTUISignal(provider) {
+    return (provider === "openai" ||
+        provider === "openai-codex" ||
+        provider === "glm" ||
+        provider === "anthropic" ||
+        provider === "openrouter");
+}

package/packages/quota-manager/src/quota-manager.js

@@ -0,0 +1,259 @@
+/**
+ * Quota Manager — RFC-0003
+ *
+ * Collects quota signals from API responses, provider status,
+ * Playwright, and local estimates. Produces provider availability state.
+ */
+export class QuotaManager {
+    signals = new Map();
+    staleThresholdMs;
+    constructor(staleThresholdMs = 30 * 60 * 1000) {
+        this.staleThresholdMs = staleThresholdMs;
+    }
+    /**
+     * Record a quota signal
+     */
+    recordSignal(input) {
+        const signal = {
+            provider: input.provider,
+            windowType: input.windowType,
+            usedPct: input.usedPct ?? 0,
+            remainingPct: 100 - (input.usedPct ?? 0),
+            exhausted: input.exhausted ?? false,
+            source: input.source,
+            capturedAt: new Date().toISOString(),
+            resetsAt: input.resetsAt,
+        };
+        const key = `${input.provider}:${input.windowType}`;
+        const existing = this.signals.get(key) ?? [];
+        this.signals.set(key, [...existing, signal]);
+    }
+    /**
+     * Get the latest signal for a provider
+     */
+    getLatestSignal(provider, windowType) {
+        const key = windowType ? `${provider}:${windowType}` : provider;
+        if (windowType) {
+            const signals = this.signals.get(key) ?? [];
+            return (signals.sort((a, b) => Date.parse(b.capturedAt) - Date.parse(a.capturedAt))[0] ?? null);
+        }
+        // Return most recent across all window types
+        let latest = null;
+        let latestTs = 0;
+        for (const entry of Array.from(this.signals.entries())) {
+            const [k, sigs] = entry;
+            if (k.startsWith(`${provider}:`)) {
+                const mostRecent = sigs.sort((a, b) => Date.parse(b.capturedAt) - Date.parse(a.capturedAt))[0];
+                if (mostRecent) {
+                    const ts = Date.parse(mostRecent.capturedAt);
+                    if (ts > latestTs) {
+                        latestTs = ts;
+                        latest = mostRecent;
+                    }
+                }
+            }
+        }
+        return latest;
+    }
+    /**
+     * Get quota state for a provider
+     */
+    getProviderState(provider) {
+        const signals = this.getSignals(provider);
+        const exhausted = signals.some((s) => s.exhausted || (s.usedPct !== undefined && s.usedPct >= 100));
+        const limited = signals.some((s) => s.usedPct !== undefined && s.usedPct >= 90);
+        // Find next reset time
+        let nextAvailableAt;
+        for (const signal of signals) {
+            if (signal.resetsAt) {
+                if (!nextAvailableAt ||
+                    Date.parse(signal.resetsAt) < Date.parse(nextAvailableAt)) {
+                    nextAvailableAt = signal.resetsAt;
+                }
+            }
+        }
+        return {
+            provider,
+            available: !exhausted && !limited,
+            limited,
+            exhausted,
+            signals,
+            nextAvailableAt,
+        };
+    }
+    /**
+     * Get signals for a provider
+     */
+    getSignals(provider) {
+        const result = [];
+        const cutoff = Date.now() - this.staleThresholdMs;
+        for (const entry of Array.from(this.signals.entries())) {
+            const [key, sigs] = entry;
+            if (key.startsWith(`${provider}:`)) {
+                for (const signal of sigs) {
+                    if (Date.parse(signal.capturedAt) >= cutoff) {
+                        result.push(signal);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Check if provider is available
+     */
+    isAvailable(provider) {
+        return this.getProviderState(provider).available;
+    }
+    /**
+     * Check if provider is exhausted
+     */
+    isExhausted(provider) {
+        return this.getProviderState(provider).exhausted;
+    }
+    /**
+     * Get time until provider is available again
+     */
+    getWaitTime(provider) {
+        const state = this.getProviderState(provider);
+        if (!state.nextAvailableAt)
+            return null;
+        const waitMs = Date.parse(state.nextAvailableAt) - Date.now();
+        return waitMs > 0 ? waitMs : null;
+    }
+    /**
+     * Get best available provider from a list
+     */
+    selectBestProvider(providers) {
+        const available = providers.filter((p) => this.isAvailable(p));
+        if (available.length === 0)
+            return null;
+        // Sort by remaining quota (prefer those with more remaining)
+        available.sort((a, b) => {
+            const signalA = this.getLatestSignal(a);
+            const signalB = this.getLatestSignal(b);
+            const remA = signalA?.remainingPct ?? 100;
+            const remB = signalB?.remainingPct ?? 100;
+            return remB - remA;
+        });
+        return available[0];
+    }
+    /**
+     * Clear stale signals
+     */
+    clearStale() {
+        const cutoff = Date.now() - this.staleThresholdMs;
+        for (const entry of Array.from(this.signals.entries())) {
+            const [key, sigs] = entry;
+            const fresh = sigs.filter((s) => Date.parse(s.capturedAt) >= cutoff);
+            if (fresh.length === 0) {
+                this.signals.delete(key);
+            }
+            else {
+                this.signals.set(key, fresh);
+            }
+        }
+    }
+    /**
+     * Generate quota report
+     */
+    generateReport(providers) {
+        const lines = ["Quota Status Report", "=".repeat(40), ""];
+        for (const provider of providers) {
+            const state = this.getProviderState(provider);
+            const latest = this.getLatestSignal(provider);
+            const status = state.exhausted
+                ? "EXHAUSTED"
+                : state.limited
+                    ? "LIMITED"
+                    : "AVAILABLE";
+            lines.push(`${provider}: ${status}`);
+            if (latest) {
+                lines.push(`  Latest: ${latest.usedPct ?? 0}% used`);
+                if (latest.resetsAt) {
+                    const wait = Date.parse(latest.resetsAt) - Date.now();
+                    if (wait > 0) {
+                        lines.push(`  Resets: in ${Math.ceil(wait / 60000)} minutes`);
+                    }
+                }
+                lines.push(`  Source: ${latest.source}`);
+            }
+            lines.push("");
+        }
+        return lines.join("\n");
+    }
+}
+/**
+ * Parse quota signal from MiniMax error
+ */
+export function parseMiniMaxError(error) {
+    const e = error;
+    const msg = String(e.message ?? e.error ?? "");
+    // MiniMax quota error: "Error code: 2056 - Rate limit exceeded. Retry after..."
+    if (msg.includes("2056") ||
+        msg.includes("quota") ||
+        msg.includes("rate limit")) {
+        // Try to extract retry time
+        const retryMatch = msg.match(/retry after (\d+) (seconds?|minutes?)/i);
+        let retryAfterMs;
+        if (retryMatch) {
+            const value = parseInt(retryMatch[1], 10);
+            const unit = retryMatch[2].toLowerCase();
+            retryAfterMs = unit.startsWith("minute")
+                ? value * 60 * 1000
+                : value * 1000;
+        }
+        return {
+            provider: "minimax",
+            windowType: "5h",
+            usedPct: 100,
+            remainingPct: 0,
+            exhausted: true,
+            source: "api_response",
+            capturedAt: new Date().toISOString(),
+            retryAfterMs,
+        };
+    }
+    return null;
+}
+/**
+ * Parse quota signal from OpenAI error
+ */
+export function parseOpenAIError(error) {
+    const e = error;
+    const code = String(e.code ?? "");
+    const msg = String(e.message ?? e.error ?? "");
+    if (code === "insufficient_quota" || code === "context_length_exceeded") {
+        return {
+            provider: "openai",
+            windowType: "daily",
+            usedPct: 100,
+            remainingPct: 0,
+            exhausted: true,
+            source: "api_response",
+            capturedAt: new Date().toISOString(),
+        };
+    }
+    if (msg.includes("429")) {
+        const retryMatch = msg.match(/retry after (\d+) (seconds?|minutes?)/i);
+        let retryAfterMs;
+        if (retryMatch) {
+            const value = parseInt(retryMatch[1], 10);
+            const unit = retryMatch[2].toLowerCase();
+            retryAfterMs = unit.startsWith("minute")
+                ? value * 60 * 1000
+                : value * 1000;
+        }
+        return {
+            provider: "openai",
+            windowType: "5h",
+            usedPct: 100,
+            remainingPct: 0,
+            exhausted: true,
+            source: "api_response",
+            capturedAt: new Date().toISOString(),
+            retryAfterMs,
+        };
+    }
+    return null;
+}