open-multi-agent-kit 0.80.2 → 0.80.4

package/dist/runtime/local-llm-runtime.js

@@ -1,222 +0,0 @@
-/**
- * LocalLlmRuntime — local LLM via OpenAI-compatible chat completions API.
- *
- * Connects to llama.cpp server, llama-server, vllm, or any
- * local OpenAI-compatible endpoint (/v1/chat/completions).
- * Supports SSE streaming and reasoning_content.
- */
-import { capsuleToTask } from "./context-broker-converter.js";
-import { sanitizeUserVisibleOutput } from "../util/user-visible-output.js";
-import { probeOpenAiCompatibleModels } from "./runtime-health-probes.js";
-export class LocalLlmRuntime {
-    id = "local-llm";
-    providerId = "local-llm";
-    advisory = true;
-    runtimeMode = "api";
-    kind = "api";
-    priority = 35;
-    capabilities = {
-        read: true,
-        write: false,
-        shell: false,
-        mcp: false,
-        patch: false,
-        review: true,
-        merge: false,
-        vision: false,
-        supportsStreaming: true,
-        supportsStructuredOutput: false,
-        supportsToolCalling: false,
-    };
-    apiKey;
-    model;
-    baseUrl;
-    constructor(options = {}) {
-        this.apiKey = options.apiKey ?? process.env.LOCAL_LLM_API_KEY ?? "not-needed";
-        this.model = options.model ?? process.env.LOCAL_LLM_MODEL ?? "qwen3-coder-30b-a3b";
-        this.baseUrl = (options.baseUrl ?? process.env.LOCAL_LLM_BASE_URL ?? "http://localhost:8080/v1").replace(/\/+$/, "");
-    }
-    supports(capsule) {
-        const requiredCapabilities = capsule.node.routing?.assignedProviderCapabilities ?? [];
-        if (requiredCapabilities.some((capability) => ["write", "patch", "shell", "mcp", "merge", "vision"].includes(capability)))
-            return false;
-        if (capsule.node.routing?.requiresToolCalling)
-            return false;
-        return true;
-    }
-    async health(input = { probeKind: "static", highRisk: false }) {
-        return probeOpenAiCompatibleModels({
-            runtimeId: this.id,
-            baseUrl: this.baseUrl,
-            apiKey: this.apiKey,
-            apiKeyName: "LOCAL_LLM_API_KEY",
-            model: this.model,
-            providerName: "Local LLM",
-            probeKind: input.probeKind === "static" ? "static" : input.probeKind,
-        });
-    }
-    async runNode(capsule, signal) {
-        try {
-            const task = await capsuleToTask(capsule, signal);
-            const result = await this.execute(task);
-            return {
-                success: result.exitCode === 0,
-                exitCode: result.exitCode,
-                stdout: result.output,
-                stderr: "",
-                metadata: {
-                    runtime: this.id,
-                    ...(result.thinking && { thinking: result.thinking }),
-                    ...(result.tokenUsage && { tokenUsage: result.tokenUsage }),
-                },
-            };
-        }
-        catch (err) {
-            const errorMsg = String(err);
-            return {
-                success: false,
-                exitCode: 1,
-                stdout: "",
-                stderr: errorMsg,
-                metadata: { runtime: this.id, error: errorMsg },
-            };
-        }
-    }
-    async execute(task) {
-        if (task.capabilities.write ||
-            task.capabilities.patch ||
-            task.capabilities.shell ||
-            task.capabilities.mcp ||
-            task.capabilities.merge ||
-            task.capabilities.toolCalling) {
-            return {
-                output: "",
-                exitCode: 1,
-                thinking: "",
-                metadata: {
-                    error: "local-llm is advisory/read-only and does not receive write, shell, MCP, merge, patch, or tool-calling authority",
-                    authorityMode: "advisory",
-                },
-            };
-        }
-        const messages = [];
-        if (task.context.system) {
-            messages.push({ role: "system", content: task.context.system });
-        }
-        messages.push({ role: "user", content: task.prompt });
-        const body = {
-            model: task.context.providerModel ?? task.context.env?.OMK_PROVIDER_MODEL ?? this.model,
-            messages,
-            stream: true,
-        };
-        if (task.capabilities.maxTokens) {
-            body.max_tokens = task.capabilities.maxTokens;
-        }
-        try {
-            const timeoutMs = Number(process.env.OMK_PROVIDER_TIMEOUT_MS ?? "300000");
-            const timeoutSignal = AbortSignal.timeout(timeoutMs);
-            const signal = task.context.abortSignal
-                ? AbortSignal.any([task.context.abortSignal, timeoutSignal])
-                : timeoutSignal;
-            const response = await fetch(`${this.baseUrl}/chat/completions`, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${this.apiKey}`,
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify(body),
-                signal,
-            });
-            if (!response.ok) {
-                const errorText = await response.text().catch(() => "Unknown error");
-                return {
-                    output: "",
-                    exitCode: 1,
-                    thinking: "",
-                    metadata: { error: `Local LLM API error ${response.status}: ${errorText}` },
-                };
-            }
-            return this.parseStreamResponse(response, task.context.onOutput);
-        }
-        catch (err) {
-            if (err instanceof Error && err.name === "AbortError") {
-                return {
-                    output: "",
-                    exitCode: 130,
-                    thinking: "",
-                    metadata: { error: "Request aborted" },
-                };
-            }
-            return {
-                output: "",
-                exitCode: 1,
-                thinking: "",
-                metadata: { error: String(err) },
-            };
-        }
-    }
-    async parseStreamResponse(response, onOutput) {
-        const reader = response.body?.getReader();
-        if (!reader) {
-            return {
-                output: "",
-                exitCode: 1,
-                thinking: "",
-                metadata: { error: "No response body for stream" },
-            };
-        }
-        const decoder = new TextDecoder();
-        let output = "";
-        let reasoning = "";
-        let inputTokens = 0;
-        let outputTokens = 0;
-        let totalTokens = 0;
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                const chunk = decoder.decode(value, { stream: true });
-                for (const line of chunk.split("\n")) {
-                    const trimmed = line.trim();
-                    if (!trimmed || trimmed === "data: [DONE]")
-                        continue;
-                    if (!trimmed.startsWith("data: "))
-                        continue;
-                    const jsonStr = trimmed.slice(6);
-                    let parsed;
-                    try {
-                        parsed = JSON.parse(jsonStr);
-                    }
-                    catch {
-                        continue;
-                    }
-                    const delta = parsed.choices?.[0]?.delta;
-                    if (delta?.content) {
-                        output += delta.content;
-                        onOutput?.(sanitizeUserVisibleOutput(delta.content));
-                    }
-                    if (delta?.reasoning_content) {
-                        reasoning += delta.reasoning_content;
-                    }
-                    if (parsed.usage) {
-                        inputTokens = parsed.usage.prompt_tokens;
-                        outputTokens = parsed.usage.completion_tokens;
-                        totalTokens = parsed.usage.total_tokens;
-                    }
-                }
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-        return {
-            output,
-            exitCode: 0,
-            thinking: reasoning || undefined,
-            tokenUsage: totalTokens > 0
-                ? { inputTokens, outputTokens, totalTokens }
-                : undefined,
-        };
-    }
-}

package/dist/runtime/mimo-api-runtime.d.ts

@@ -1,13 +0,0 @@
-/**
- * MimoApiRuntime — Xiaomi MiMo API runtime adapter.
- * Calls https://api.xiaomimimo.com/v1/chat/completions directly.
- * Extends KimiApiRuntime with MiMo-specific defaults.
- */
-import type { AgentRuntime } from "./agent-runtime.js";
-export interface MimoApiRuntimeOptions {
-    apiKey?: string;
-    model?: string;
-    baseUrl?: string;
-    env?: NodeJS.ProcessEnv;
-}
-export declare function createMimoApiRuntime(options?: MimoApiRuntimeOptions): AgentRuntime;

package/dist/runtime/mimo-api-runtime.js

@@ -1,24 +0,0 @@
-/**
- * MimoApiRuntime — Xiaomi MiMo API runtime adapter.
- * Calls https://api.xiaomimimo.com/v1/chat/completions directly.
- * Extends KimiApiRuntime with MiMo-specific defaults.
- */
-import { KimiApiRuntime } from "./kimi-api-runtime.js";
-export function createMimoApiRuntime(options = {}) {
-    const env = options.env ?? process.env;
-    return new MimoApiRuntime({
-        apiKey: options.apiKey ?? env.MIMO_API_KEY,
-        model: options.model ?? env.MIMO_MODEL,
-        baseUrl: options.baseUrl ?? env.MIMO_BASE_URL,
-    });
-}
-class MimoApiRuntime extends KimiApiRuntime {
-    constructor(options = {}) {
-        super({
-            ...options,
-            id: "mimo-api",
-            priority: 95,
-            baseUrl: options.baseUrl ?? "https://api.xiaomimimo.com/v1",
-        });
-    }
-}

package/dist/runtime/nlg-renderer.d.ts

@@ -1,38 +0,0 @@
-/**
- * NLG Renderer — consent-aware Natural Language Generation.
- *
- * Produces human-readable reasoning summaries and consent eligibility reports.
- * Uses i18n for bilingual (KO/EN) support.
- * Integrates with ThemePalette for styled output.
- *
- * Key principle: "사용자에게는 theme/NLG만"
- */
-import type { ThemePalette } from "../cli/theme/theme-registry.js";
-import type { ReasoningTrace, TraceSummary, ConsentAwareNlgOutput } from "./contracts/reasoning-trace.js";
-export interface NlgRendererOptions {
-    /** Theme palette for styled output */
-    palette?: ThemePalette;
-    /** Language override (defaults to i18n system language) */
-    language?: "ko" | "en";
-    /** Include file change details */
-    includeFiles?: boolean;
-    /** Include command execution details */
-    includeCommands?: boolean;
-    /** Consent level for redaction */
-    consentLevel?: "l0" | "l1" | "l2" | "l3";
-    /** Write function for output (defaults to process.stdout.write) */
-    write?: (text: string) => void;
-}
-export interface NlgRenderer {
-    /** Render a reasoning trace to human-readable summary */
-    renderTrace(trace: ReasoningTrace): string;
-    /** Render a trace summary (compact one-liner) */
-    renderSummary(summary: TraceSummary): string;
-    /** Generate consent-aware report */
-    renderConsentReport(trace: ReasoningTrace, consentLevel: "l0" | "l1" | "l2" | "l3"): ConsentAwareNlgOutput;
-    /** Render turn result with reasoning context */
-    renderTurnResult(trace: ReasoningTrace): string;
-    /** Flush buffered output */
-    flush(): string;
-}
-export declare function createNlgRenderer(options?: NlgRendererOptions): NlgRenderer;

package/dist/runtime/nlg-renderer.js

@@ -1,132 +0,0 @@
-/**
- * NLG Renderer — consent-aware Natural Language Generation.
- *
- * Produces human-readable reasoning summaries and consent eligibility reports.
- * Uses i18n for bilingual (KO/EN) support.
- * Integrates with ThemePalette for styled output.
- *
- * Key principle: "사용자에게는 theme/NLG만"
- */
-import { summarizeTrace, generateConsentReport } from "./reasoning-trace.js";
-import { t } from "../util/i18n.js";
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-function themed(p, token, text) {
-    if (!p || !p.supportsColor)
-        return text;
-    return p.render(token, text);
-}
-function outcomeIcon(outcome) {
-    switch (outcome) {
-        case "success": return "✓";
-        case "partial": return "◐";
-        case "failed": return "✗";
-        case "blocked": return "⊘";
-        default: return "·";
-    }
-}
-function formatDuration(ms) {
-    if (ms >= 60_000)
-        return `${(ms / 60_000).toFixed(1)}m`;
-    if (ms >= 1000)
-        return `${(ms / 1000).toFixed(1)}s`;
-    return `${ms}ms`;
-}
-// ─── NLG Renderer Factory ────────────────────────────────────────────────────
-export function createNlgRenderer(options) {
-    const palette = options?.palette;
-    const lines = [];
-    function write(text) {
-        if (options?.write) {
-            options.write(text + "\n");
-        }
-        else {
-            lines.push(text);
-        }
-    }
-    return {
-        renderTrace(trace) {
-            const summary = summarizeTrace(trace);
-            const out = [];
-            // Header
-            out.push(themed(palette, "header", t("nlg.traceHeader")));
-            out.push("");
-            // Intent + confidence
-            out.push(`${themed(palette, "labelKey", t("nlg.intent"))} ${themed(palette, "info", summary.intent)} ${themed(palette, "dim", `(${Math.round(summary.confidence * 100)}%)`)}`);
-            // Plan
-            out.push(`${themed(palette, "labelKey", t("nlg.plan"))} ${summary.planSummary}`);
-            // Tools used
-            if (summary.toolsUsed.length > 0) {
-                out.push(`${themed(palette, "labelKey", t("nlg.tools"))} ${summary.toolsUsed.map(tool => themed(palette, "tool", tool)).join(", ")}`);
-            }
-            // Test result
-            if (summary.testResult) {
-                out.push(`${themed(palette, "labelKey", t("nlg.tests"))} ${summary.testResult}`);
-            }
-            // Outcome
-            const icon = outcomeIcon(summary.outcome);
-            const outcomeToken = summary.outcome === "success" ? "success" : summary.outcome === "failed" ? "error" : "warning";
-            out.push(`${themed(palette, "labelKey", t("nlg.outcome"))} ${themed(palette, outcomeToken, `${icon} ${summary.outcome}`)}`);
-            // Duration
-            out.push(`${themed(palette, "labelKey", t("nlg.duration"))} ${formatDuration(trace.execution.durationMs)}`);
-            // Failure reason
-            if (trace.result.failureReason) {
-                out.push(`${themed(palette, "labelKey", t("nlg.failure"))} ${themed(palette, "error", trace.result.failureReason)}`);
-            }
-            // Decision records
-            if (trace.execution.decisionRecords.length > 0) {
-                out.push("");
-                out.push(themed(palette, "subheader", t("nlg.decisions")));
-                for (const d of trace.execution.decisionRecords) {
-                    out.push(`  ${themed(palette, "bullet", "•")} ${themed(palette, "labelKey", d.point)} → ${themed(palette, "info", d.chosen)} ${themed(palette, "dim", `(${d.reason})`)}`);
-                }
-            }
-            const result = out.join("\n");
-            write(result);
-            return result;
-        },
-        renderSummary(summary) {
-            const icon = outcomeIcon(summary.outcome);
-            const outcomeToken = summary.outcome === "success" ? "success" : summary.outcome === "failed" ? "error" : "warning";
-            const line = `${themed(palette, outcomeToken, icon)} ${themed(palette, "info", summary.intent)} → ${themed(palette, outcomeToken, summary.outcome)} ${themed(palette, "dim", `(${summary.duration})`)}`;
-            write(line);
-            return line;
-        },
-        renderConsentReport(trace, consentLevel) {
-            const language = options?.language ?? "en";
-            const report = generateConsentReport({
-                trace,
-                consentLevel,
-                includeFiles: options?.includeFiles ?? false,
-                includeCommands: options?.includeCommands ?? false,
-                language,
-            });
-            write(report.report);
-            return report;
-        },
-        renderTurnResult(trace) {
-            const summary = summarizeTrace(trace);
-            const out = [];
-            // Compact result line
-            const icon = outcomeIcon(summary.outcome);
-            const outcomeToken = summary.outcome === "success" ? "success" : summary.outcome === "failed" ? "error" : "warning";
-            out.push(`${themed(palette, outcomeToken, icon)} ${themed(palette, "info", summary.intent)} → ${themed(palette, outcomeToken, summary.outcome)} ${themed(palette, "dim", `(${summary.duration})`)}`);
-            out.push(`  ${themed(palette, "dim", summary.planSummary)}`);
-            // Tools used (compact)
-            if (summary.toolsUsed.length > 0) {
-                out.push(`  ${themed(palette, "dim", summary.toolsUsed.join(", "))}`);
-            }
-            // Failure reason
-            if (trace.result.failureReason) {
-                out.push(`  ${themed(palette, "error", trace.result.failureReason)}`);
-            }
-            const result = out.join("\n");
-            write(result);
-            return result;
-        },
-        flush() {
-            const output = lines.join("\n");
-            lines.length = 0;
-            return output;
-        },
-    };
-}

package/dist/runtime/ouroboros-policy.d.ts

@@ -1,57 +0,0 @@
-/**
- * Ouroboros routing policy for OMK.
- *
- * Resolves whether to prefer the embedded Ouroboros spec-first flow
- * for goal/spec/orchestration intents.  Detection is non-fatal and
- * never triggers network access or implicit installs.
- */
-export type OuroborosMode = "always" | "auto" | "off";
-/**
- * Read the OMK_OUROBOROS env var and normalise it into a mode.
- *
- * - unset / anything other than the known tokens  → "always" (default)
- * - "auto"                                        → "auto"
- * - "off" / "0" / "false" (case-insensitive)      → "off"
- */
-export declare function resolveOuroborosMode(env?: NodeJS.ProcessEnv): OuroborosMode;
-export interface OuroborosAvailability {
-    available: boolean;
-    via: "mcp" | "binary" | "none";
-    detail: string;
-}
-interface DetectOpts {
-    env?: NodeJS.ProcessEnv;
-    mcpConfigPath?: string;
-    which?: (cmd: string) => Promise<string | null>;
-}
-/**
- * Check whether Ouroboros is reachable without network or installs.
- *
- * Strategy (non-fatal):
- *   1. Look for an `ouroboros` key in ~/.omk/agent/mcp.json  (global)
- *      and/or .omk/mcp.json  (project-scoped).
- *   2. Optionally check for an `ouroboros` binary via an injectable which().
- *
- * Any I/O error silently yields `{ available: false, via: "none" }`.
- */
-export declare function detectOuroborosAvailable(opts?: DetectOpts): Promise<OuroborosAvailability>;
-export interface OuroborosDecision {
-    use: boolean;
-    mode: OuroborosMode;
-    availability: OuroborosAvailability;
-    reason: string;
-}
-interface DecisionInput {
-    intent: string;
-    env?: NodeJS.ProcessEnv;
-    detect?: () => Promise<OuroborosAvailability>;
-}
-/**
- * Decide whether the current run should route through Ouroboros.
- *
- * - use=true only when mode≠off AND available AND intent matches.
- * - When mode=always but unavailable → use=false with fallback reason.
- * - Never throws.
- */
-export declare function resolveOuroborosDecision(input: DecisionInput): Promise<OuroborosDecision>;
-export {};

package/dist/runtime/ouroboros-policy.js

@@ -1,134 +0,0 @@
-/**
- * Ouroboros routing policy for OMK.
- *
- * Resolves whether to prefer the embedded Ouroboros spec-first flow
- * for goal/spec/orchestration intents.  Detection is non-fatal and
- * never triggers network access or implicit installs.
- */
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { homedir } from "node:os";
-/**
- * Read the OMK_OUROBOROS env var and normalise it into a mode.
- *
- * - unset / anything other than the known tokens  → "always" (default)
- * - "auto"                                        → "auto"
- * - "off" / "0" / "false" (case-insensitive)      → "off"
- */
-export function resolveOuroborosMode(env = process.env) {
-    const raw = (env.OMK_OUROBOROS ?? "").trim().toLowerCase();
-    if (raw === "off" || raw === "0" || raw === "false")
-        return "off";
-    if (raw === "auto")
-        return "auto";
-    return "always";
-}
-/**
- * Check whether Ouroboros is reachable without network or installs.
- *
- * Strategy (non-fatal):
- *   1. Look for an `ouroboros` key in ~/.omk/agent/mcp.json  (global)
- *      and/or .omk/mcp.json  (project-scoped).
- *   2. Optionally check for an `ouroboros` binary via an injectable which().
- *
- * Any I/O error silently yields `{ available: false, via: "none" }`.
- */
-export async function detectOuroborosAvailable(opts) {
-    // --- binary check (fast, optional) ---
-    if (opts?.which) {
-        try {
-            const bin = await opts.which("ouroboros");
-            if (bin) {
-                return { available: true, via: "binary", detail: `found binary: ${bin}` };
-            }
-        }
-        catch {
-            // swallow
-        }
-    }
-    // --- MCP config check (non-fatal) ---
-    const home = homedir();
-    const candidates = [
-        opts?.mcpConfigPath ?? join(home, ".omk", "agent", "mcp.json"),
-        join(process.cwd(), ".omk", "mcp.json"),
-    ];
-    for (const configPath of candidates) {
-        try {
-            const raw = await readFile(configPath, "utf-8");
-            const parsed = JSON.parse(raw);
-            if (isRecord(parsed) && isRecord(parsed.mcpServers)) {
-                if ("ouroboros" in parsed.mcpServers) {
-                    return {
-                        available: true,
-                        via: "mcp",
-                        detail: `ouroboros server found in ${configPath}`,
-                    };
-                }
-            }
-        }
-        catch {
-            // file missing or malformed → continue
-        }
-    }
-    return { available: false, via: "none", detail: "ouroboros not detected" };
-}
-/**
- * Intent tokens (lowercased) that qualify for Ouroboros routing.
- */
-const OUROBOROS_INTENT_KEYWORDS = [
-    "goal",
-    "plan",
-    "spec",
-    "seed",
-    "interview",
-    "orchestrate",
-    "feature",
-    "build",
-    "implement",
-    // Korean equivalents
-    "계획",
-    "스펙",
-    "구현",
-    "기획",
-];
-/**
- * Decide whether the current run should route through Ouroboros.
- *
- * - use=true only when mode≠off AND available AND intent matches.
- * - When mode=always but unavailable → use=false with fallback reason.
- * - Never throws.
- */
-export async function resolveOuroborosDecision(input) {
-    const mode = resolveOuroborosMode(input.env);
-    const detect = input.detect ?? (() => detectOuroborosAvailable({ env: input.env }));
-    let availability;
-    try {
-        availability = await detect();
-    }
-    catch {
-        availability = { available: false, via: "none", detail: "detection threw" };
-    }
-    if (mode === "off") {
-        return { use: false, mode, availability, reason: "ouroboros-mode-off" };
-    }
-    if (!availability.available) {
-        return {
-            use: false,
-            mode,
-            availability,
-            reason: "ouroboros-unavailable-fallback-native",
-        };
-    }
-    if (!isGoalLikeIntent(input.intent)) {
-        return { use: false, mode, availability, reason: "intent-not-goal-like" };
-    }
-    return { use: true, mode, availability, reason: "ouroboros-routing-active" };
-}
-// ── Helpers ─────────────────────────────────────────────────────────
-function isGoalLikeIntent(intent) {
-    const lowered = intent.toLocaleLowerCase();
-    return OUROBOROS_INTENT_KEYWORDS.some((kw) => lowered.includes(kw));
-}
-function isRecord(v) {
-    return typeof v === "object" && v !== null && !Array.isArray(v);
-}

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

@@ -1,20 +0,0 @@
-/**
- * OutputRouter — routes OmkEvent to the appropriate renderer based on OutputProfile.stdoutMode.
- *
- * Invariant I-004: provider stdout MUST NOT bypass the router.
- * Raw provider stdout is never emitted directly; all output flows through a Renderer.
- */
-import type { OmkEvent, OutputProfile } from "./contracts/command-envelope.js";
-import type { ThemeRenderer, NlpRenderer, JsonRenderer } from "./renderers.js";
-import type { ReasoningTrace } from "./contracts/reasoning-trace.js";
-export type Renderer = ThemeRenderer | NlpRenderer | JsonRenderer;
-export interface OutputRouter {
-    route(event: OmkEvent): void;
-    /** Route a reasoning trace through the NLG renderer */
-    routeTrace(trace: ReasoningTrace): void;
-    /** Render opencode-style status bar at bottom */
-    renderStatusBar(provider: string, model: string, intent: string): void;
-    flush(): void;
-    getRenderer(): Renderer;
-}
-export declare function createOutputRouter(profile: OutputProfile): OutputRouter;