open-multi-agent-kit 0.78.0

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

@@ -0,0 +1,166 @@
+/**
+ * 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 { 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 } = await contextBroker.buildCapsule(node, runState);
+            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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,208 @@
+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

@@ -0,0 +1,23 @@
+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>;

package/dist/runtime/runtime-registry.js

@@ -0,0 +1,95 @@
+export function createRuntimeRegistry() {
+    const adapters = new Map();
+    const listeners = new Set();
+    function notify() {
+        const runtimes = list();
+        for (const listener of listeners)
+            listener(runtimes);
+    }
+    function register(runtime) {
+        adapters.set(runtime.id, {
+            runtime,
+            registeredAt: new Date().toISOString(),
+            enabled: true,
+        });
+        notify();
+    }
+    function unregister(runtimeId) {
+        const removed = adapters.delete(runtimeId);
+        if (removed)
+            notify();
+        return removed;
+    }
+    function get(runtimeId) {
+        return adapters.get(runtimeId)?.runtime;
+    }
+    function list() {
+        return [...adapters.values()]
+            .filter((e) => e.enabled)
+            .map((e) => e.runtime)
+            .sort((a, b) => b.priority - a.priority);
+    }
+    function disable(runtimeId) {
+        const entry = adapters.get(runtimeId);
+        if (entry) {
+            entry.enabled = false;
+            notify();
+        }
+    }
+    function enable(runtimeId) {
+        const entry = adapters.get(runtimeId);
+        if (entry) {
+            entry.enabled = true;
+            notify();
+        }
+    }
+    function onChange(listener) {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+    }
+    async function healthCheck() {
+        const results = [];
+        for (const entry of adapters.values()) {
+            if (entry.runtime.health) {
+                results.push(await entry.runtime.health());
+            }
+            else {
+                results.push({
+                    runtimeId: entry.runtime.id,
+                    available: true,
+                    checkedAt: new Date().toISOString(),
+                    reason: "no health check available",
+                });
+            }
+        }
+        return results;
+    }
+    function findCompatible(capsule, requiredAuthority) {
+        return list().filter((r) => {
+            if (!r.capabilities)
+                return true;
+            if (requiredAuthority) {
+                return requiredAuthority.every((auth) => {
+                    const key = auth;
+                    return r.capabilities[key] === true;
+                });
+            }
+            if (capsule.role) {
+                const roleKey = capsule.role;
+                return r.capabilities[roleKey] === true;
+            }
+            return true;
+        });
+    }
+    return {
+        register,
+        unregister,
+        get,
+        list,
+        disable,
+        enable,
+        onChange,
+        healthCheck,
+        findCompatible,
+    };
+}

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

@@ -0,0 +1,51 @@
+/**
+ * RuntimeRouter — intent-aware runtime selection with evidence pass history.
+ *
+ * Routes capsules based on:
+ * 1. NodeIntent (research, planning, coding, debugging, etc.)
+ * 2. RuntimeScore (quality, cost, latency, evidence pass rate)
+ * 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 { ContextCapsule } from "./context-capsule.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 evidencePassRate: number;
+    readonly recentFailurePenalty: number;
+}
+export interface RuntimeRouterOptions {
+    readonly runtimes?: AgentRuntime[];
+    readonly fallbackChain?: string[];
+    readonly memoryPath?: string;
+}
+export interface RuntimeRouteDecision {
+    readonly runtime: AgentRuntime;
+    readonly reason: string;
+    readonly fallbacks: AgentRuntime[];
+    readonly intent: NodeIntent;
+    readonly scores: RuntimeScore[];
+}
+interface EvidenceHistoryEntry {
+    readonly runtime: string;
+    readonly intent: string;
+    readonly passed: boolean;
+    readonly timestamp: string;
+    readonly nodeId: string;
+}
+export declare function createRuntimeRouter(options?: RuntimeRouterOptions): {
+    select: (capsule: ContextCapsule) => RuntimeRouteDecision;
+    selectByIntent: (capsule: ContextCapsule, history: EvidenceHistoryEntry[]) => RuntimeRouteDecision;
+    runNode: (capsule: ContextCapsule, signal: AbortSignal) => Promise<AgentRunResult>;
+    execute: (task: AgentTask, signal?: AbortSignal) => Promise<AgentRunResult>;
+    executeTask: (task: AgentTask, capsule: ContextCapsule, signal: AbortSignal) => Promise<AgentRunResult>;
+    classifyIntent: (capsule: ContextCapsule) => NodeIntent;
+    listRuntimes(): AgentRuntime[];
+    setRuntimes(nextRuntimes: AgentRuntime[]): void;
+    invalidateCache: () => void;
+};
+export {};