opencode-ultra 0.8.2 → 0.9.0

package/dist/shared/concurrency.d.ts

@@ -0,0 +1,109 @@
+export interface BackoffOptions {
+    /** Base delay in ms (default: 200) */
+    baseDelayMs?: number;
+    /** Max delay in ms (default: 10_000) */
+    maxDelayMs?: number;
+}
+export type BackoffJitterMode = "full" | "none";
+export interface ExponentialBackoffOptions extends BackoffOptions {
+    /** Jitter strategy (default: full) */
+    jitter?: BackoffJitterMode;
+    /** Random generator in [0, 1) (default: Math.random) */
+    rng?: () => number;
+}
+export declare function computeExponentialBackoffDelayMs(attempt: number, opts?: ExponentialBackoffOptions): number;
+export interface CircuitBreakerOptions {
+    /** Open circuit after this many consecutive retryable failures (default: 3) */
+    failureThreshold?: number;
+    /** How long the circuit stays open before allowing a single trial (default: 10_000) */
+    cooldownMs?: number;
+}
+type CircuitState = "closed" | "open" | "half_open";
+export declare class CircuitBreakerOpenError extends Error {
+    readonly provider: string;
+    readonly waitMs: number;
+    constructor(provider: string, waitMs: number);
+}
+export declare class CircuitBreaker {
+    private state;
+    private consecutiveFailures;
+    private openUntil;
+    private halfOpenInFlight;
+    private failureThreshold;
+    private cooldownMs;
+    constructor(opts?: CircuitBreakerOptions);
+    snapshot(now: number): {
+        state: CircuitState;
+        consecutiveFailures: number;
+        openForMs: number;
+    };
+    /**
+     * Gate a request. If open, returns not allowed with waitMs.
+     * If half-open, only allows a single in-flight probe.
+     */
+    enter(now: number): {
+        allowed: boolean;
+        waitMs?: number;
+    };
+    onSuccess(): void;
+    onFailure(now: number): void;
+}
+export interface RetryBudgetOptions {
+    /** Max retries per provider per interval (default: 20) */
+    maxRetries?: number;
+    /** Interval for budget reset (default: 60_000) */
+    intervalMs?: number;
+}
+export declare class RetryBudgetExceededError extends Error {
+    readonly provider: string;
+    constructor(provider: string);
+}
+export declare class RetryBudget {
+    private maxRetries;
+    private intervalMs;
+    private state;
+    constructor(opts?: RetryBudgetOptions);
+    trySpend(provider: string, cost?: number): boolean;
+}
+export interface RetryDecision {
+    retryable: boolean;
+    /** HTTP status code when available */
+    status?: number;
+    /** Retry-After when available */
+    retryAfterMs?: number;
+}
+export declare function parseRetryAfterMs(value: string, now: number): number | undefined;
+export declare function classifyRetryableError(err: unknown, now?: number): RetryDecision;
+export interface AdaptiveRetryOptions {
+    /** Max total attempts including the first attempt (default: 4) */
+    maxAttempts?: number;
+    /** Backoff options (default: base 200, max 10_000) */
+    backoff?: ExponentialBackoffOptions;
+    /** Cap any retry-after delays to this max (default: 30_000) */
+    maxRetryAfterMs?: number;
+    /** Treat this classifier result as authoritative (default: classifyRetryableError) */
+    classify?: (err: unknown, now: number) => RetryDecision;
+    /** Sleep function used for delays (default: setTimeout) */
+    sleep?: (ms: number) => Promise<void>;
+    /** Time source (default: Date.now) */
+    now?: () => number;
+}
+export declare function adaptiveRetry<T>(provider: string, fn: () => Promise<T>, breaker: CircuitBreaker, budget: RetryBudget, opts?: AdaptiveRetryOptions): Promise<T>;
+export interface ProviderResilienceOptions {
+    breaker?: CircuitBreakerOptions;
+    retryBudget?: RetryBudgetOptions;
+    retry?: AdaptiveRetryOptions;
+}
+export declare class ProviderResilience {
+    private breakers;
+    private budgets;
+    private opts;
+    constructor(opts?: ProviderResilienceOptions);
+    private getBreaker;
+    private getBudget;
+    run<T>(provider: string, fn: () => Promise<T>, retryOverrides?: AdaptiveRetryOptions): Promise<T>;
+    snapshot(provider: string, now?: number): {
+        breaker: ReturnType<CircuitBreaker["snapshot"]>;
+    };
+}
+export {};

package/dist/shared/index.d.ts

@@ -3,3 +3,5 @@ export { parseJsonc } from "./jsonc";
 export { log } from "./log";
 export type { ExtendedClient, ModelRef, ToastOptions, SystemTransformInput } from "./types";
 export { TtlMap } from "./ttl-map";
+export { CircuitBreaker, CircuitBreakerOpenError, ProviderResilience, RetryBudget, RetryBudgetExceededError, adaptiveRetry, classifyRetryableError, computeExponentialBackoffDelayMs, parseRetryAfterMs, } from "./concurrency";
+export type { AdaptiveRetryOptions, BackoffJitterMode, BackoffOptions, CircuitBreakerOptions, ExponentialBackoffOptions, ProviderResilienceOptions, RetryBudgetOptions, RetryDecision, } from "./concurrency";

package/dist/tools/health-check.d.ts

@@ -0,0 +1,73 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
+import { type ActiveRalphLoopInfo } from "./ralph-loop";
+export declare const BUILTIN_HOOK_IDS: readonly ["keyword-detector", "rules-injector", "context-injector", "fragment-injector", "prompt-renderer", "todo-enforcer", "comment-checker", "token-truncation", "session-compaction"];
+export declare const BUILTIN_TOOL_IDS: readonly ["spawn_agent", "ralph_loop", "cancel_ralph", "batch_read", "ledger_save", "ledger_load", "ast_search", "evolve_apply", "evolve_scan", "evolve_score", "evolve_exe", "evolve_publish", "health_check"];
+export type BuiltinHookId = (typeof BUILTIN_HOOK_IDS)[number];
+export type BuiltinToolId = (typeof BUILTIN_TOOL_IDS)[number];
+export interface BinaryStatus {
+    found: boolean;
+    path?: string;
+    version?: string;
+    error?: string;
+}
+export interface HealthCheckResult {
+    ok: boolean;
+    generatedAt: string;
+    registry: {
+        tools: {
+            enabled: string[];
+            disabled: string[];
+            unknownDisabled: string[];
+        };
+        hooks: {
+            enabled: string[];
+            disabled: string[];
+            unknownDisabled: string[];
+        };
+        mcps: {
+            enabled: string[];
+            disabled: string[];
+            unknownDisabled: string[];
+        };
+    };
+    loops: {
+        ralph: {
+            activeCount: number;
+            active: ActiveRalphLoopInfo[];
+        };
+    };
+    sessions: {
+        internalSessionCount: number;
+    };
+    config: {
+        astSearch: {
+            enabled: boolean;
+            binaryFound: boolean;
+            binaryPath?: string;
+        };
+        mcp: {
+            context7: {
+                enabled: boolean;
+                npxFound: boolean;
+                npxPath?: string;
+            };
+        };
+    };
+    binaries: Record<string, BinaryStatus>;
+    warnings: string[];
+}
+export declare const BinaryStatusSchema: z.ZodType<BinaryStatus>;
+export declare const HealthCheckResultSchema: z.ZodType<HealthCheckResult>;
+export interface HealthCheckDeps {
+    toolNames: string[];
+    disabledTools?: string[];
+    disabledHooks?: string[];
+    disabledMcps?: string[];
+    internalSessions?: Set<string>;
+    astGrepBinary?: string | null;
+}
+export declare function findBinaryInPath(name: string): string | null;
+export declare function checkBinary(name: string, versionArgs?: string[], includeVersion?: boolean): BinaryStatus;
+export declare function createHealthCheckTool(ctx: PluginInput, deps: HealthCheckDeps): ReturnType<typeof tool>;

package/dist/tools/ralph-loop.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export interface ActiveRalphLoopInfo {
+    sessionID: string;
+    iteration: number;
+    maxIterations: number;
+    active: boolean;
+}
+export declare function getActiveRalphLoops(): ActiveRalphLoopInfo[];
+export interface RalphLoopDeps {
+    /** Per-iteration timeout in ms (default: 180000 = 3min) */
+    iterationTimeoutMs?: number;
+}
+export declare function createRalphLoopTools(ctx: PluginInput, internalSessions: Set<string>, deps?: RalphLoopDeps): {
+    ralph_loop: any;
+    cancel_ralph: any;
+};

package/dist/tools/spawn-agent.d.ts

@@ -0,0 +1,19 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import { tool } from "@opencode-ai/plugin";
+import { ProviderResilience } from "../shared";
+import { type ConcurrencyPool } from "../concurrency";
+import type { CategoryConfig } from "../categories";
+export interface SpawnAgentDeps {
+    pool?: ConcurrencyPool;
+    categories?: Record<string, CategoryConfig>;
+    resolveAgentModel?: (agent: string) => string | undefined;
+    /** Provider-level retry/backoff + circuit breaker */
+    resilience?: ProviderResilience;
+    /** Max total concurrent spawned sessions (default: 15) */
+    maxTotalSpawned?: number;
+    /** Per-agent timeout in ms (default: 180000 = 3min) */
+    agentTimeoutMs?: number;
+    /** Reference to internalSessions for spawn limit check */
+    internalSessions?: Set<string>;
+}
+export declare function createSpawnAgentTool(ctx: PluginInput, internalSessions: Set<string>, deps?: SpawnAgentDeps): ReturnType<typeof tool>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ultra",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "description": "Lightweight OpenCode 1.2.x plugin — ultrawork mode, multi-agent orchestration, rules injection",
   "keywords": [
     "opencode",