open-multi-agent-kit 0.78.7 → 0.79.1

package/dist/runtime/router-v2-scoring.js

@@ -1,156 +0,0 @@
-/**
- * Router V2 Scoring Engine — Bayesian-smoothed evidence calibration (Algorithm 6).
- *
- * Composite formula (omk.weights.v1 routerV2Composite vector, normalize:true):
- *   ŵ_E*E + ŵ_conf*conf + ŵ_cap*cap + ŵ_mat*mat + ŵ_lat*lat + ŵ_cost*cost
- *   - p̂_fail*pen - p̂_blast*blast
- *
- * Historical raw weights (0.25/0.15/0.20/0.15/0.10/0.10 − 0.15/0.10) had a
- * positive Σ = 0.95; normalization divides weights AND penalties by the same
- * factor (1/0.95), a pure uniform scaling. The composite is ranking-only
- * (no absolute threshold compares it), so rankings are identical.
- */
-import { computeBlastRadiusPenalty } from "./blast-radius.js";
-import { intentCapabilityWeights, routerV2CompositeEffective } from "./weights-config.js";
-const ALPHA_0 = 1;
-const BETA_0 = 1;
-/**
- * Intent → capability emphasis vectors, sourced verbatim from the
- * omk.weights.v1 intentCapability vector family (normalize:false — sub-unit
- * sums are intentional feature-fit emphasis templates).
- */
-const INTENT_CAPABILITY_WEIGHTS = intentCapabilityWeights();
-/** Effective (normalized) composite weights/penalties — raw values ÷ 0.95. */
-const COMPOSITE_EFFECTIVE = routerV2CompositeEffective();
-function runtimeCapabilityEnabled(capabilities, capability) {
-    if (capability === "toolCalling") {
-        return capabilities.toolCalling === true || capabilities.supportsToolCalling === true;
-    }
-    if (capability === "streaming") {
-        return capabilities.streaming === true || capabilities.supportsStreaming === true;
-    }
-    return capabilities[capability] === true;
-}
-function computeCapabilityFit(runtime, intent) {
-    const caps = runtime.capabilities;
-    if (!caps)
-        return 0;
-    let score = 0;
-    for (const [capability, weight] of INTENT_CAPABILITY_WEIGHTS[intent]) {
-        if (runtimeCapabilityEnabled(caps, capability))
-            score += weight;
-    }
-    if (caps.maxTokens != null && caps.maxTokens > 0) {
-        score += Math.min(0.1, caps.maxTokens / 1_000_000);
-    }
-    if (caps.maxContextTokens != null && caps.maxContextTokens > 0) {
-        score += Math.min(0.1, caps.maxContextTokens / 1_000_000);
-    }
-    return score;
-}
-function computeMaturityScore(runtime) {
-    const caps = runtime.capabilities;
-    if (!caps)
-        return 0.5;
-    const capabilityCount = [
-        caps.read,
-        caps.write,
-        caps.shell,
-        caps.patch,
-        caps.review,
-        caps.merge,
-        caps.vision,
-        caps.mcp,
-        caps.toolCalling,
-        caps.supportsToolCalling,
-    ].filter(Boolean).length;
-    const breadthScore = Math.min(1, capabilityCount / 8);
-    const priorityScore = Math.max(0, Math.min(1, runtime.priority / 100));
-    return 0.6 * breadthScore + 0.4 * priorityScore;
-}
-function computeLatencyScore(runtime) {
-    return runtime.capabilities?.supportsStreaming === true || runtime.capabilities?.streaming === true
-        ? 0.85
-        : 0.70;
-}
-function computeCostScore(runtime) {
-    return runtime.priority > 50 ? 0.75 : 0.90;
-}
-export function createRouterV2ScoringEngine(options = {}, blastRadiusFn = computeBlastRadiusPenalty) {
-    const { enableBlastRadius = false, blastRadiusParams = { downstreamNodeCount: 0, affectedFileCount: 0, hasGlobalSideEffects: false }, } = options;
-    function score(runtime, intent, history) {
-        const runtimeHistory = history.filter((e) => e.runtime === runtime.id);
-        const totalAttempts = runtimeHistory.length;
-        const passedAttempts = runtimeHistory.filter((e) => e.passed).length;
-        // Bayesian smoothing with α₀=1, β₀=1
-        const bayesianEvidenceScore = (ALPHA_0 + passedAttempts) / (ALPHA_0 + BETA_0 + totalAttempts);
-        // Confidence increases with sample size (asymptotic toward 1)
-        const confidence = Math.min(1, totalAttempts / 10 + 0.1);
-        const recentFailures = runtimeHistory
-            .filter((e) => !e.passed)
-            .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
-            .slice(0, 5);
-        const recentFailurePenalty = Math.min(0.3, recentFailures.length * 0.06);
-        const capabilityFit = computeCapabilityFit(runtime, intent);
-        const maturityScore = computeMaturityScore(runtime);
-        const latencyScore = computeLatencyScore(runtime);
-        const costScore = computeCostScore(runtime);
-        const blastRadiusPenalty = enableBlastRadius ? blastRadiusFn(blastRadiusParams) : 0;
-        const cw = COMPOSITE_EFFECTIVE.weights;
-        const cp = COMPOSITE_EFFECTIVE.penalties;
-        const composite = cw.bayesianEvidence * bayesianEvidenceScore +
-            cw.confidence * confidence +
-            cw.capabilityFit * capabilityFit +
-            cw.maturity * maturityScore +
-            cw.latency * latencyScore +
-            cw.cost * costScore -
-            cp.recentFailure * recentFailurePenalty -
-            cp.blastRadius * blastRadiusPenalty;
-        return {
-            runtimeId: runtime.id,
-            bayesianEvidenceScore,
-            confidence,
-            capabilityFit,
-            maturityScore,
-            latencyScore,
-            costScore,
-            recentFailurePenalty,
-            blastRadiusPenalty,
-            composite,
-        };
-    }
-    function select(candidates, intent, history) {
-        const scored = candidates.map((runtime) => ({
-            runtime,
-            score: score(runtime, intent, history),
-        }));
-        scored.sort((a, b) => b.score.composite - a.score.composite);
-        const primary = scored[0].runtime;
-        const fallbacks = scored.slice(1).map((s) => s.runtime);
-        const bestScore = scored[0].score;
-        const reason = [
-            `intent=${intent}`,
-            `bayesianE=${bestScore.bayesianEvidenceScore.toFixed(2)}`,
-            `confidence=${bestScore.confidence.toFixed(2)}`,
-            `capability=${bestScore.capabilityFit.toFixed(2)}`,
-            `maturity=${bestScore.maturityScore.toFixed(2)}`,
-            `latency=${bestScore.latencyScore.toFixed(2)}`,
-            `cost=${bestScore.costScore.toFixed(2)}`,
-            `penalty=${bestScore.recentFailurePenalty.toFixed(2)}`,
-            `blast=${bestScore.blastRadiusPenalty.toFixed(2)}`,
-            `composite=${bestScore.composite.toFixed(3)}`,
-        ].join("; ");
-        return {
-            runtime: primary,
-            reason,
-            fallbacks,
-            intent,
-            scores: scored.map((s) => s.score),
-        };
-    }
-    return { score, select };
-}
-export function scoreRuntimes(candidates, intent, history, options = {}) {
-    const engine = createRouterV2ScoringEngine(options);
-    return candidates.map((runtime) => engine.score(runtime, intent, history));
-}

package/dist/runtime/runtime-backed-task-runner.d.ts

@@ -1,20 +0,0 @@
-/**
- * RuntimeBackedTaskRunner — pure runtime-registry + runtime-router task runner.
- *
- * Replaces the provider-backed wrapper with a provider-neutral runtime pipeline:
- * 1. Build ContextCapsule via ContextBroker
- * 2. Route to best AgentRuntime via RuntimeRouter
- * 3. Convert AgentRunResult -> TaskResult
- */
-import type { TaskRunner } from "../contracts/orchestration.js";
-export interface RuntimeBackedTaskRunnerOptions {
-    cwd: string;
-    runtimePolicy?: string;
-    defaultRuntime?: string;
-    fallbackChain?: string[];
-    env?: Record<string, string>;
-    runId?: string;
-    goal?: string;
-    onOutput?: (text: string) => void;
-}
-export declare function createRuntimeBackedTaskRunner(options: RuntimeBackedTaskRunnerOptions): Promise<TaskRunner>;

package/dist/runtime/runtime-backed-task-runner.js

@@ -1,174 +0,0 @@
-/**
- * RuntimeBackedTaskRunner — pure runtime-registry + runtime-router task runner.
- *
- * Replaces the provider-backed wrapper with a provider-neutral runtime pipeline:
- * 1. Build ContextCapsule via ContextBroker
- * 2. Route to best AgentRuntime via RuntimeRouter
- * 3. Convert AgentRunResult -> TaskResult
- */
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { toTaskResult } from "./agent-runtime.js";
-import { capsuleToTask } from "./context-broker-converter.js";
-import { applyTaskRunContextToAgentTask, envFromWorkerManifest } from "./worker-manifest.js";
-import { createRuntimeRegistry } from "./runtime-registry.js";
-import { createRuntimeRouter } from "./runtime-router.js";
-import { createContextBroker } from "./context-broker.js";
-import { maybeCompactWithHeadroom } from "./headroom-policy.js";
-import { DeepSeekRuntime } from "./deepseek-runtime.js";
-import { CodexRuntime } from "./codex-runtime.js";
-import { createOpencodeCliAdapter } from "../adapters/opencode/opencode-cli-adapter.js";
-import { createCommandcodeCliAdapter } from "../adapters/commandcode/commandcode-cli-adapter.js";
-import { createChatAdvisoryRuntime } from "./chat-advisory-runtime.js";
-import { LocalLlmRuntime } from "./local-llm-runtime.js";
-import { checkCommand } from "../util/shell.js";
-import { createMimoApiRuntime } from "./mimo-api-runtime.js";
-import { createKimiApiRuntime } from "./kimi-api-runtime.js";
-import { getUserHome } from "../util/fs.js";
-async function createDefaultRuntimeRegistry(options) {
-    const registry = createRuntimeRegistry();
-    // ── MiMo API runtime (Xiaomi MiMo — OpenAI-compatible, highest priority) ──
-    let mimoApiKey = options.env?.MIMO_API_KEY ?? process.env.MIMO_API_KEY;
-    if (!mimoApiKey) {
-        mimoApiKey = readConfiguredProviderApiKey("mimo");
-    }
-    if (mimoApiKey) {
-        registry.register(createMimoApiRuntime({ apiKey: mimoApiKey }));
-    }
-    // ── Kimi API runtime (Moonshot HTTP direct — no binary needed) ──
-    let kimiApiKey = options.env?.KIMI_API_KEY ?? process.env.KIMI_API_KEY;
-    if (!kimiApiKey) {
-        kimiApiKey = readConfiguredProviderApiKey("kimi");
-    }
-    if (kimiApiKey) {
-        registry.register(createKimiApiRuntime({ apiKey: kimiApiKey }));
-    }
-    // ── codex-cli ──
-    const codexBin = options.env?.CODEX_BIN ?? process.env.CODEX_BIN ?? "codex";
-    if (await checkCommand(codexBin).catch(() => false)) {
-        registry.register(new CodexRuntime({ bin: codexBin, cwd: options.cwd }));
-    }
-    // ── local-llm (OpenAI-compatible local endpoint) ──
-    const localBaseUrl = options.env?.LOCAL_LLM_BASE_URL ?? process.env.LOCAL_LLM_BASE_URL;
-    if (localBaseUrl) {
-        registry.register(new LocalLlmRuntime({
-            baseUrl: localBaseUrl,
-            model: options.env?.LOCAL_LLM_MODEL ?? process.env.LOCAL_LLM_MODEL,
-            apiKey: options.env?.LOCAL_LLM_API_KEY ?? process.env.LOCAL_LLM_API_KEY,
-        }));
-    }
-    // ── deepseek-api ──
-    const deepseekKey = options.env?.DEEPSEEK_API_KEY ?? process.env.DEEPSEEK_API_KEY;
-    if (deepseekKey) {
-        registry.register(new DeepSeekRuntime({ apiKey: deepseekKey }));
-    }
-    // ── opencode-cli ──
-    const opencodeBin = options.env?.OPENCODE_BIN ?? process.env.OPENCODE_BIN ?? "opencode";
-    if (await checkCommand(opencodeBin).catch(() => false)) {
-        registry.register(createOpencodeCliAdapter({ bin: opencodeBin, cwd: options.cwd, env: options.env }));
-    }
-    // ── commandcode-cli ──
-    const configuredCommandcodeBin = options.env?.COMMANDCODE_BIN ?? process.env.COMMANDCODE_BIN;
-    let commandcodeBin = null;
-    if (configuredCommandcodeBin) {
-        commandcodeBin = await checkCommand(configuredCommandcodeBin).catch(() => false)
-            ? configuredCommandcodeBin
-            : null;
-    }
-    else if (await checkCommand("commandcode").catch(() => false)) {
-        commandcodeBin = "commandcode";
-    }
-    if (commandcodeBin) {
-        registry.register(createCommandcodeCliAdapter({ bin: commandcodeBin, cwd: options.cwd, env: options.env }));
-    }
-    // ── chat advisory fallback ──
-    if (registry.list().length === 0) {
-        registry.register(createChatAdvisoryRuntime());
-    }
-    return registry;
-}
-function readConfiguredProviderApiKey(providerId) {
-    const configContent = readProviderConfig(".omk");
-    if (!configContent)
-        return undefined;
-    const match = configContent.match(new RegExp(`\\[providers\\.${escapeRegExp(providerId)}\\][\\s\\S]*?api_key\\s*=\\s*"([^"]+)"`));
-    return match?.[1];
-}
-function readProviderConfig(configDir) {
-    try {
-        return readFileSync(join(getUserHome(), configDir, "config.toml"), "utf-8");
-    }
-    catch {
-        return undefined;
-    }
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-export async function createRuntimeBackedTaskRunner(options) {
-    const registry = await createDefaultRuntimeRegistry(options);
-    const runtimes = registry.list();
-    const runtimeRouter = createRuntimeRouter({
-        runtimes,
-        fallbackChain: options.fallbackChain,
-    });
-    registry.onChange((nextRuntimes) => {
-        runtimeRouter.setRuntimes(nextRuntimes);
-    });
-    const contextBroker = createContextBroker({
-        projectRoot: options.cwd,
-    });
-    const runner = {
-        async run(node, env, signal, runContext) {
-            const runState = options.runId
-                ? {
-                    schemaVersion: 1,
-                    runId: options.runId,
-                    goalId: options.goal,
-                    nodes: [node],
-                    startedAt: new Date().toISOString(),
-                }
-                : undefined;
-            const { capsule, headroomDecision } = await contextBroker.buildCapsule(node, runState);
-            // CTX guard: compact via headroom before the context window crosses the threshold (~90%).
-            if (headroomDecision?.shouldCompact) {
-                await maybeCompactWithHeadroom({
-                    decision: headroomDecision,
-                    text: JSON.stringify(capsule),
-                }).catch(() => undefined);
-            }
-            const routing = capsule.node.routing;
-            const providerFallbackChain = options.fallbackChain
-                ?? (routing?.fallbackProvider ? [routing.fallbackProvider] : []);
-            const abortSignal = signal ?? new AbortController().signal;
-            const taskEnv = {
-                ...(options.env ?? {}),
-                ...(env ?? {}),
-                ...(runContext ? envFromWorkerManifest(runContext.worker) : {}),
-            };
-            const baseTask = applyTaskRunContextToAgentTask(await capsuleToTask(capsule, {
-                signal: abortSignal,
-                cwd: options.cwd,
-                env: taskEnv,
-                fallbackChain: providerFallbackChain,
-            }), runContext);
-            const task = options.onOutput
-                ? { ...baseTask, context: { ...baseTask.context, onOutput: options.onOutput } }
-                : baseTask;
-            const agentResult = await runtimeRouter.executeTask(task, capsule, abortSignal);
-            const taskResult = toTaskResult(agentResult);
-            // Ensure routing metadata is present even if the router failed to attach it
-            taskResult.metadata = {
-                ...(taskResult.metadata ?? {}),
-                fallbackChain: task.providerPolicy.fallbackChain,
-                ...(runContext && { workerOwner: runContext.worker.owner }),
-            };
-            return taskResult;
-        },
-    };
-    // Attach introspection handles for executor debugging
-    runner._runtimeRouter = runtimeRouter;
-    runner._contextBroker = contextBroker;
-    runner._registry = registry;
-    return runner;
-}

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

@@ -1,21 +0,0 @@
-export type RuntimeSessionMode = "interactive-tty" | "one-shot-cli" | "api-turn" | "advisory-only";
-export interface RuntimeBootstrap {
-    ok: boolean;
-    provider: string;
-    providerPolicy: string;
-    selectedProvider: string;
-    selectedRuntimeId?: string;
-    selectedModel?: string;
-    sessionMode: RuntimeSessionMode;
-    authOk: boolean;
-    modelOk: boolean;
-    runtimeOk: boolean;
-    reason?: string;
-    setupHints: string[];
-}
-export declare function resolveRuntimeBootstrap(options: {
-    provider: string;
-    model?: string;
-    cwd?: string;
-    env?: Record<string, string | undefined>;
-}): Promise<RuntimeBootstrap>;

package/dist/runtime/runtime-bootstrap.js

@@ -1,208 +0,0 @@
-import { checkCommand } from "../util/shell.js";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-function detectProvider(provider, env) {
-    switch (provider) {
-        case "kimi":
-            return {
-                envKey: "KIMI_API_KEY",
-                sessionMode: "api-turn",
-                installHint: "Set KIMI_API_KEY env var or configure [providers.kimi] in ~/.omk/config.toml",
-                authHint: "Set KIMI_API_KEY env var",
-                modelHint: env.KIMI_MODEL ?? "kimi-k2.6",
-            };
-        case "mimo":
-            return {
-                envKey: "MIMO_API_KEY",
-                sessionMode: "api-turn",
-                installHint: "Set MIMO_API_KEY env var or configure [providers.mimo] in ~/.omk/config.toml",
-                authHint: "Set MIMO_API_KEY env var",
-                modelHint: env.MIMO_MODEL ?? "mimo-v2.5-pro",
-            };
-        case "codex":
-            return {
-                bin: env.CODEX_BIN ?? "codex",
-                sessionMode: "one-shot-cli",
-                installHint: "npm install -g @openai/codex",
-                authHint: "codex login",
-                modelHint: "codex-cli default",
-            };
-        case "deepseek":
-            return {
-                envKey: "DEEPSEEK_API_KEY",
-                sessionMode: "api-turn",
-                installHint: "export DEEPSEEK_API_KEY=sk-...",
-                authHint: "Set DEEPSEEK_API_KEY env var",
-                modelHint: env.DEEPSEEK_MODEL ?? "deepseek-chat",
-            };
-        case "local":
-        case "llama":
-        case "local-llm":
-            return {
-                sessionMode: "api-turn",
-                installHint: "LOCAL_LLM_BASE_URL=http://localhost:8080/v1 LOCAL_LLM_MODEL=qwen3-coder-30b-a3b",
-                authHint: "Start llama-server or llama.cpp with --port 8080",
-                modelHint: env.LOCAL_LLM_MODEL ?? "qwen3-coder-30b-a3b",
-            };
-        case "commandcode":
-            return {
-                bin: env.COMMANDCODE_BIN ?? "commandcode",
-                sessionMode: "one-shot-cli",
-                installHint: "npm install -g commandcode",
-                authHint: "commandcode login",
-                modelHint: "commandcode default",
-            };
-        case "opencode":
-            return {
-                bin: env.OPENCODE_BIN ?? "opencode",
-                sessionMode: "one-shot-cli",
-                installHint: "cargo install opencode",
-                authHint: "opencode login",
-                modelHint: "opencode default",
-            };
-        default:
-            return {
-                sessionMode: "advisory-only",
-                installHint: "omk auth",
-                authHint: "omk auth",
-                modelHint: "auto-detect",
-            };
-    }
-}
-async function resolveAutoProvider(env) {
-    // 1. Check OMK config.toml for explicit default_model (highest priority)
-    const configContent = readHomeProviderConfig(env, ".omk");
-    if (configContent) {
-        const defaultModelMatch = configContent.match(/default_model\s*=\s*"([^"]+)"/);
-        if (defaultModelMatch) {
-            const defaultModel = defaultModelMatch[1];
-            if (defaultModel.startsWith("mimo") && (env.MIMO_API_KEY || providerConfigHasApiKey(configContent, "mimo")))
-                return { provider: "mimo", runtimeId: "mimo-api" };
-            if ((defaultModel.startsWith("kimi") || defaultModel.startsWith("moonshot")) && (env.KIMI_API_KEY || providerConfigHasApiKey(configContent, "kimi")))
-                return { provider: "kimi", runtimeId: "kimi-api" };
-            if (defaultModel.startsWith("deepseek") && env.DEEPSEEK_API_KEY)
-                return { provider: "deepseek", runtimeId: "deepseek-api" };
-        }
-        if (providerConfigHasApiKey(configContent, "mimo"))
-            return { provider: "mimo", runtimeId: "mimo-api" };
-        if (providerConfigHasApiKey(configContent, "kimi"))
-            return { provider: "kimi", runtimeId: "kimi-api" };
-    }
-    // 2. Check for API keys in env
-    if (env.MIMO_API_KEY)
-        return { provider: "mimo", runtimeId: "mimo-api" };
-    if (env.KIMI_API_KEY)
-        return { provider: "kimi", runtimeId: "kimi-api" };
-    if (env.DEEPSEEK_API_KEY)
-        return { provider: "deepseek", runtimeId: "deepseek-api" };
-    if (env.LOCAL_LLM_BASE_URL)
-        return { provider: "local-llm", runtimeId: "local-llm" };
-    // 3. CLI binary detection (lowest priority)
-    const codexBin = env.CODEX_BIN ?? "codex";
-    if (await checkCommand(codexBin).catch(() => false))
-        return { provider: "codex", runtimeId: "codex-cli" };
-    let commandcodeBin;
-    if (env.COMMANDCODE_BIN) {
-        commandcodeBin = await checkCommand(env.COMMANDCODE_BIN).catch(() => false) ? env.COMMANDCODE_BIN : undefined;
-    }
-    else if (await checkCommand("commandcode").catch(() => false)) {
-        commandcodeBin = "commandcode";
-    }
-    if (commandcodeBin)
-        return { provider: "commandcode", runtimeId: "commandcode-cli" };
-    const opencodeBin = env.OPENCODE_BIN ?? "opencode";
-    if (await checkCommand(opencodeBin).catch(() => false))
-        return { provider: "opencode", runtimeId: "opencode-cli" };
-    return undefined;
-}
-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 autoSelection = effectiveProviderPolicy === "auto" ? await resolveAutoProvider(env) : undefined;
-    const selectedProvider = autoSelection?.provider ?? effectiveProviderPolicy;
-    const info = detectProvider(selectedProvider, env);
-    const hints = [];
-    let runtimeOk = false;
-    let authOk = false;
-    let modelOk = false;
-    const reasons = [];
-    if (effectiveProviderPolicy === "auto" && !autoSelection) {
-        reasons.push("no runnable runtime detected for auto provider policy");
-        hints.push("Configure a provider: mimo, deepseek, codex, commandcode, opencode, or local-llm");
-        hints.push("Use an explicit provider, e.g. omk chat --provider mimo --mcp-scope none");
-    }
-    else if (info.bin) {
-        runtimeOk = await checkCommand(info.bin).catch(() => false);
-        if (!runtimeOk) {
-            reasons.push(`${info.bin} CLI not found`);
-            hints.push(info.installHint);
-        }
-        else {
-            authOk = true;
-        }
-    }
-    else if (info.envKey) {
-        runtimeOk = Boolean(env[info.envKey]);
-        if (!runtimeOk && (selectedProvider === "mimo" || selectedProvider === "kimi")) {
-            const configContent = readHomeProviderConfig(env, ".omk");
-            runtimeOk = configContent ? providerConfigHasApiKey(configContent, selectedProvider) : false;
-        }
-        if (!runtimeOk) {
-            reasons.push(`${info.envKey} is not set`);
-            hints.push(info.installHint);
-        }
-        else {
-            authOk = true;
-        }
-    }
-    if (runtimeOk)
-        modelOk = true;
-    if (!runtimeOk && effectiveProviderPolicy !== "auto") {
-        hints.push(info.authHint);
-        hints.push(`omk chat --provider ${selectedProvider} --model ${info.modelHint}`);
-    }
-    const ok = runtimeOk && authOk && modelOk;
-    return {
-        ok,
-        provider: selectedProvider,
-        providerPolicy,
-        selectedProvider,
-        selectedRuntimeId: autoSelection?.runtimeId ?? info.bin ?? info.envKey ?? "auto",
-        selectedModel: options.model ?? info.modelHint,
-        sessionMode: info.sessionMode,
-        authOk,
-        modelOk,
-        runtimeOk,
-        reason: reasons.length > 0 ? reasons.join("; ") : undefined,
-        setupHints: hints,
-    };
-}
-function readHomeProviderConfig(env, configDir) {
-    try {
-        const home = env.HOME ?? env.USERPROFILE;
-        if (!home)
-            return undefined;
-        return readFileSync(join(home, configDir, "config.toml"), "utf-8");
-    }
-    catch {
-        return undefined;
-    }
-}
-function providerConfigHasApiKey(configContent, provider) {
-    return new RegExp(`\\[providers\\.${escapeRegExp(provider)}\\][\\s\\S]*?api_key\\s*=\\s*"[^"]+"`).test(configContent);
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function resolveAuthorityProviderPolicy(providerPolicy, env) {
-    if (providerPolicy !== "authority" && providerPolicy !== "primary" && providerPolicy !== "omk")
-        return undefined;
-    const configured = env.OMK_AUTHORITY_PROVIDER?.trim().toLowerCase()
-        || env.OMK_DEFAULT_PROVIDER?.trim().toLowerCase()
-        || "mimo";
-    if (configured === "authority" || configured === "primary" || configured === "omk")
-        return "mimo";
-    return configured || "mimo";
-}

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

@@ -1,23 +0,0 @@
-import type { AgentRuntime, RuntimeHealth } from "./agent-runtime.js";
-export interface RuntimeRegistryEntry {
-    runtime: AgentRuntime;
-    registeredAt: string;
-    enabled: boolean;
-}
-export type RuntimeRegistryListener = (runtimes: AgentRuntime[]) => void;
-export declare function createRuntimeRegistry(): {
-    register: (runtime: AgentRuntime) => void;
-    unregister: (runtimeId: string) => boolean;
-    get: (runtimeId: string) => AgentRuntime | undefined;
-    list: () => AgentRuntime[];
-    disable: (runtimeId: string) => void;
-    enable: (runtimeId: string) => void;
-    onChange: (listener: RuntimeRegistryListener) => () => void;
-    healthCheck: () => Promise<RuntimeHealth[]>;
-    findCompatible: (capsule: {
-        nodeId?: string;
-        role?: string;
-        taskType?: string;
-    }, requiredAuthority?: string[]) => AgentRuntime[];
-};
-export type RuntimeRegistry = ReturnType<typeof createRuntimeRegistry>;