open-multi-agent-kit 0.79.3 → 0.80.0

package/dist/runtime/runtime-bootstrap.js

@@ -134,8 +134,25 @@ async function resolveAutoProvider(env) {
 export async function resolveRuntimeBootstrap(options) {
     const providerPolicy = options.provider.trim().toLowerCase() || "auto";
     const env = options.env ?? process.env;
-    const authorityProvider = resolveAuthorityProviderPolicy(providerPolicy, env);
-    const effectiveProviderPolicy = authorityProvider ?? providerPolicy;
+    const resolvedPolicy = await resolveProviderPolicy(providerPolicy, env);
+    if (!resolvedPolicy.ok) {
+        return {
+            ok: false,
+            provider: providerPolicy,
+            providerPolicy,
+            selectedProvider: providerPolicy,
+            selectedRuntimeId: "unresolved",
+            selectedModel: options.model,
+            sessionMode: "advisory-only",
+            authOk: false,
+            modelOk: false,
+            runtimeOk: false,
+            reason: resolvedPolicy.reason,
+            setupHints: resolvedPolicy.remediation,
+        };
+    }
+    const authorityProvider = resolvedPolicy.provider;
+    const effectiveProviderPolicy = authorityProvider;
     const autoSelection = effectiveProviderPolicy === "auto" ? await resolveAutoProvider(env) : undefined;
     const selectedProvider = autoSelection?.provider ?? effectiveProviderPolicy;
     const info = detectProvider(selectedProvider, env);
@@ -185,7 +202,7 @@ export async function resolveRuntimeBootstrap(options) {
         provider: selectedProvider,
         providerPolicy,
         selectedProvider,
-        selectedRuntimeId: autoSelection?.runtimeId ?? info.bin ?? info.envKey ?? "auto",
+        selectedRuntimeId: autoSelection?.runtimeId ?? resolvedPolicy.runtimeId ?? info.bin ?? info.envKey ?? "auto",
         selectedModel: options.model ?? info.modelHint,
         sessionMode: info.sessionMode,
         authOk,
@@ -212,6 +229,42 @@ function providerConfigHasApiKey(configContent, provider) {
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+export async function resolveProviderPolicy(providerPolicy, env) {
+    const normalized = providerPolicy.trim().toLowerCase() || "auto";
+    if (!["authority", "primary", "omk"].includes(normalized)) {
+        return { ok: true, provider: normalized };
+    }
+    const configured = env.OMK_AUTHORITY_PROVIDER?.trim().toLowerCase()
+        || env.OMK_DEFAULT_PROVIDER?.trim().toLowerCase();
+    if (configured && !["authority", "primary", "omk"].includes(configured)) {
+        return { ok: true, provider: configured, reason: `resolved from OMK_AUTHORITY_PROVIDER` };
+    }
+    // Default authority chain: mimo > kimi > auto
+    if (env.MIMO_API_KEY || (await hasProviderConfigApiKey(env, "mimo"))) {
+        return { ok: true, provider: "mimo", runtimeId: "mimo-api", reason: "default authority resolved to mimo" };
+    }
+    if (env.KIMI_API_KEY || (await hasProviderConfigApiKey(env, "kimi"))) {
+        return { ok: true, provider: "kimi", runtimeId: "kimi-api", reason: "default authority resolved to kimi" };
+    }
+    const auto = await resolveAutoProvider(env);
+    if (auto) {
+        return { ok: true, provider: auto.provider, runtimeId: auto.runtimeId, reason: "authority fell back to auto-selected provider" };
+    }
+    return {
+        ok: false,
+        provider: normalized,
+        reason: "no authority provider is configured or healthy",
+        remediation: [
+            "Set OMK_AUTHORITY_PROVIDER to a concrete provider (e.g. mimo, kimi, codex).",
+            "Set the provider API key env var (e.g. MIMO_API_KEY, KIMI_API_KEY).",
+            "Or configure [providers.<name>] api_key in ~/.omk/config.toml.",
+        ],
+    };
+}
+async function hasProviderConfigApiKey(env, provider) {
+    const configContent = readHomeProviderConfig(env, ".omk");
+    return configContent ? providerConfigHasApiKey(configContent, provider) : false;
+}
 function resolveAuthorityProviderPolicy(providerPolicy, env) {
     if (providerPolicy !== "authority" && providerPolicy !== "primary" && providerPolicy !== "omk")
         return undefined;

package/dist/runtime/runtime-failure-classifier.d.ts

@@ -0,0 +1,15 @@
+export type RuntimeFailureClass = "none" | "runtime" | "auth" | "model" | "quota" | "rate_limit" | "timeout" | "authority" | "abort" | "transient" | "unknown";
+export interface RuntimeFailureClassification {
+    readonly failureClass: RuntimeFailureClass;
+    readonly retryable: boolean;
+    readonly circuitBreaker: boolean;
+    readonly cooldownMs: number;
+    readonly reason: string;
+}
+export interface RuntimeFailureInput {
+    readonly exitCode?: number;
+    readonly stdout?: string;
+    readonly stderr?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export declare function classifyRuntimeFailure(input: RuntimeFailureInput): RuntimeFailureClassification;

package/dist/runtime/runtime-failure-classifier.js

@@ -0,0 +1,107 @@
+import { maskSensitiveText } from "../util/secret-mask.js";
+const DEFAULT_COOLDOWNS = {
+    runtime: 120_000,
+    auth: 300_000,
+    model: 300_000,
+    quota: 300_000,
+    rate_limit: 60_000,
+    timeout: 45_000,
+    authority: 120_000,
+    abort: 0,
+    transient: 30_000,
+    unknown: 0,
+};
+const RETRYABLE_FAILURES = new Set(["runtime", "rate_limit", "timeout", "transient"]);
+const CIRCUIT_BREAKER_FAILURES = new Set([
+    "runtime",
+    "auth",
+    "model",
+    "quota",
+    "rate_limit",
+    "timeout",
+    "authority",
+    "transient",
+]);
+export function classifyRuntimeFailure(input) {
+    const metadataClass = normalizeFailureClass(input.metadata?.failureClass ?? input.metadata?.failureKind ?? nestedFailureKind(input.metadata?.providerFallback));
+    const failureClass = metadataClass ?? classifyRuntimeFailureFromSignals(input);
+    if (failureClass === "none") {
+        return { failureClass, retryable: false, circuitBreaker: false, cooldownMs: 0, reason: "runtime result succeeded" };
+    }
+    return {
+        failureClass,
+        retryable: RETRYABLE_FAILURES.has(failureClass),
+        circuitBreaker: CIRCUIT_BREAKER_FAILURES.has(failureClass),
+        cooldownMs: DEFAULT_COOLDOWNS[failureClass],
+        reason: reasonForFailureClass(failureClass),
+    };
+}
+function classifyRuntimeFailureFromSignals(input) {
+    if (input.exitCode === 0)
+        return "none";
+    if (input.exitCode === 130)
+        return "abort";
+    if (input.exitCode === 78)
+        return "authority";
+    const text = maskSensitiveText(`${input.stderr ?? ""}\n${input.stdout ?? ""}`).toLowerCase();
+    if (/\b(unauthorized|forbidden|invalid api key|api key|authentication|auth failed|permission denied|401|403)\b/.test(text))
+        return "auth";
+    if (/\b(insufficient balance|quota|billing|payment required|402|credit exhausted)\b/.test(text))
+        return "quota";
+    if (/\b(rate[-\s_]*limit|too many requests|429)\b/.test(text))
+        return "rate_limit";
+    if (/\b(timeout|timed out|etimedout|deadline exceeded)\b/.test(text))
+        return "timeout";
+    if (/\b(model not found|unknown model|invalid model|model unavailable|404 model)\b/.test(text))
+        return "model";
+    if (/\b(command not found|enoent|spawn .* failed|runtime unavailable|binary missing|not installed)\b/.test(text))
+        return "runtime";
+    if (/\b(econnreset|econnrefused|network|temporarily unavailable|503|502|504|5\d\d)\b/.test(text))
+        return "transient";
+    return "unknown";
+}
+function normalizeFailureClass(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+    switch (normalized) {
+        case "none":
+        case "runtime":
+        case "auth":
+        case "model":
+        case "quota":
+        case "rate_limit":
+        case "timeout":
+        case "authority":
+        case "abort":
+        case "transient":
+        case "unknown":
+            return normalized;
+        case "availability":
+            return "runtime";
+        case "policy":
+            return "authority";
+        default:
+            return undefined;
+    }
+}
+function nestedFailureKind(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    return value.failureKind;
+}
+function reasonForFailureClass(failureClass) {
+    switch (failureClass) {
+        case "runtime": return "runtime unavailable or adapter launch failed";
+        case "auth": return "runtime authentication failed";
+        case "model": return "runtime model is unavailable or invalid";
+        case "quota": return "runtime quota or billing is exhausted";
+        case "rate_limit": return "runtime rate limit was reached";
+        case "timeout": return "runtime timed out";
+        case "authority": return "runtime authority or policy boundary blocked execution";
+        case "abort": return "runtime execution was aborted";
+        case "transient": return "transient runtime or network failure";
+        case "unknown": return "unclassified runtime failure";
+        case "none": return "runtime result succeeded";
+    }
+}

package/dist/runtime/runtime-health-probes.d.ts

@@ -0,0 +1,30 @@
+import type { RuntimeHealth, RuntimeHealthProbeKind } from "./contracts/shared.js";
+export interface RuntimeHealthProbeInput {
+    readonly probeKind?: RuntimeHealthProbeKind;
+    readonly timeoutMs?: number;
+    readonly highRisk?: boolean;
+}
+export interface StaticHealthInput {
+    readonly runtimeId: string;
+    readonly available: boolean;
+    readonly reason?: string;
+    readonly authOk?: boolean;
+    readonly modelOk?: boolean;
+    readonly runtimeOk?: boolean;
+    readonly quotaOk?: boolean;
+    readonly rateLimitOk?: boolean;
+    readonly probeKind?: RuntimeHealthProbeKind;
+    readonly ttlMs?: number;
+    readonly latencyMs?: number;
+}
+export declare function staticRuntimeHealth(input: StaticHealthInput): RuntimeHealth;
+export declare function probeOpenAiCompatibleModels(input: {
+    readonly runtimeId: string;
+    readonly baseUrl: string;
+    readonly apiKey?: string;
+    readonly apiKeyName: string;
+    readonly model: string;
+    readonly providerName: string;
+    readonly probeKind: RuntimeHealthProbeKind;
+    readonly timeoutMs?: number;
+}): Promise<RuntimeHealth>;

package/dist/runtime/runtime-health-probes.js

@@ -0,0 +1,102 @@
+import { maskSensitiveText } from "../util/secret-mask.js";
+export function staticRuntimeHealth(input) {
+    const now = new Date();
+    const runtimeOk = input.runtimeOk ?? input.available;
+    const authOk = input.authOk ?? input.available;
+    const modelOk = input.modelOk ?? input.available;
+    const quotaOk = input.quotaOk ?? true;
+    const rateLimitOk = input.rateLimitOk ?? true;
+    return {
+        runtimeId: input.runtimeId,
+        available: input.available,
+        reason: input.reason,
+        checkedAt: now.toISOString(),
+        vector: {
+            runtimeOk,
+            authOk,
+            modelOk,
+            quotaOk,
+            rateLimitOk,
+            runtime: runtimeOk ? "pass" : "fail",
+            auth: authOk ? "pass" : "fail",
+            model: modelOk ? "pass" : "fail",
+            quota: quotaOk ? "unknown" : "fail",
+            rateLimit: rateLimitOk ? "unknown" : "fail",
+            ...(input.latencyMs !== undefined && { latencyMs: input.latencyMs }),
+            lastProbeKind: input.probeKind ?? "static",
+            checkedAt: now.toISOString(),
+            expiresAt: new Date(now.getTime() + (input.ttlMs ?? 60_000)).toISOString(),
+        },
+    };
+}
+export async function probeOpenAiCompatibleModels(input) {
+    const staticAuthOk = Boolean(input.apiKey);
+    const staticModelOk = input.model.trim().length > 0 && input.model !== "default";
+    if (!staticAuthOk || !staticModelOk || input.probeKind === "static" || input.probeKind === "none") {
+        const reason = !staticAuthOk
+            ? `${input.apiKeyName} is not set`
+            : !staticModelOk
+                ? `${input.providerName} model is not configured`
+                : undefined;
+        return staticRuntimeHealth({
+            runtimeId: input.runtimeId,
+            available: staticAuthOk && staticModelOk,
+            reason,
+            authOk: staticAuthOk,
+            modelOk: staticModelOk,
+            runtimeOk: true,
+            probeKind: input.probeKind === "none" ? "static" : input.probeKind,
+        });
+    }
+    const started = Date.now();
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), input.timeoutMs ?? 5000);
+    try {
+        const response = await fetch(`${input.baseUrl.replace(/\/+$/, "")}/models`, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${input.apiKey}` },
+            signal: controller.signal,
+        });
+        const latencyMs = Date.now() - started;
+        const authOk = response.status !== 401 && response.status !== 403;
+        const rateLimitOk = response.status !== 429;
+        const quotaOk = response.status !== 402;
+        const modelOk = staticModelOk && response.status !== 404;
+        const runtimeOk = response.status < 500;
+        const available = response.ok && authOk && modelOk && quotaOk && rateLimitOk;
+        const reason = available ? undefined : `${input.providerName} health probe returned ${response.status}`;
+        return staticRuntimeHealth({
+            runtimeId: input.runtimeId,
+            available,
+            reason,
+            authOk,
+            modelOk,
+            runtimeOk,
+            quotaOk,
+            rateLimitOk,
+            latencyMs,
+            probeKind: input.probeKind,
+            ttlMs: 30_000,
+        });
+    }
+    catch (err) {
+        const latencyMs = Date.now() - started;
+        const reason = maskSensitiveText(err instanceof Error ? err.message : String(err));
+        return staticRuntimeHealth({
+            runtimeId: input.runtimeId,
+            available: false,
+            reason: `${input.providerName} health probe failed: ${reason}`,
+            authOk: staticAuthOk,
+            modelOk: staticModelOk,
+            runtimeOk: false,
+            quotaOk: true,
+            rateLimitOk: true,
+            latencyMs,
+            probeKind: input.probeKind,
+            ttlMs: 30_000,
+        });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/runtime/runtime-router.d.ts

@@ -7,16 +7,20 @@
  * 3. Historical evidence pass rates from graph-state memory
  * 4. Fallback chain with runtime.supports() check
  */
-import type { AgentRuntime, AgentRunResult, AgentTask } from "./agent-runtime.js";
+import type { AgentRuntime, AgentRunResult, AgentTask, RuntimeHealth } from "./agent-runtime.js";
 import type { ContextCapsule } from "./context-capsule.js";
+import type { RuntimeHealthProbeKind } from "./contracts/shared.js";
 export type NodeIntent = "research" | "planning" | "coding" | "debugging" | "refactor" | "review" | "test-generation" | "documentation" | "shell-operation";
 export interface RuntimeScore {
     readonly runtime: string;
     readonly qualityScore: number;
     readonly costScore: number;
     readonly latencyScore: number;
+    readonly healthScore: number;
     readonly evidencePassRate: number;
     readonly recentFailurePenalty: number;
+    readonly healthAvailable?: boolean;
+    readonly healthReason?: string;
 }
 export interface RuntimeRouterOptions {
     readonly runtimes?: AgentRuntime[];
@@ -39,7 +43,7 @@ interface EvidenceHistoryEntry {
 }
 export declare function createRuntimeRouter(options?: RuntimeRouterOptions): {
     select: (capsule: ContextCapsule) => RuntimeRouteDecision;
-    selectByIntent: (capsule: ContextCapsule, history: EvidenceHistoryEntry[]) => RuntimeRouteDecision;
+    selectByIntent: (capsule: ContextCapsule, history: EvidenceHistoryEntry[], healthMap?: ReadonlyMap<string, RuntimeHealth>, probeKind?: RuntimeHealthProbeKind) => RuntimeRouteDecision;
     runNode: (capsule: ContextCapsule, signal: AbortSignal) => Promise<AgentRunResult>;
     execute: (task: AgentTask, signal?: AbortSignal) => Promise<AgentRunResult>;
     executeTask: (task: AgentTask, capsule: ContextCapsule, signal: AbortSignal) => Promise<AgentRunResult>;