open-multi-agent-kit 0.78.0

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

@@ -0,0 +1,231 @@
+/**
+ * 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";
+export class LocalLlmRuntime {
+    id = "local-llm";
+    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() {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 5000);
+            const resp = await fetch(`${this.baseUrl}/models`, {
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            return {
+                runtimeId: this.id,
+                available: resp.ok,
+                reason: resp.ok ? undefined : `Local LLM returned ${resp.status}`,
+                checkedAt: new Date().toISOString(),
+            };
+        }
+        catch (err) {
+            return {
+                runtimeId: this.id,
+                available: false,
+                reason: `Local LLM not reachable: ${err instanceof Error ? err.message : String(err)}`,
+                checkedAt: new Date().toISOString(),
+            };
+        }
+    }
+    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

@@ -0,0 +1,13 @@
+/**
+ * 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

@@ -0,0 +1,24 @@
+/**
+ * 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

@@ -0,0 +1,38 @@
+/**
+ * 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

@@ -0,0 +1,132 @@
+/**
+ * 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/output-router.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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;

package/dist/runtime/output-router.js

@@ -0,0 +1,171 @@
+/**
+ * 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 { createThemeRenderer, createNlpRenderer, createJsonRenderer, } from "./renderers.js";
+import { getBuiltinTheme } from "../cli/theme/theme-registry.js";
+import { resolveTheme } from "../cli/theme/theme-resolver.js";
+import { createNlgRenderer } from "./nlg-renderer.js";
+// ─── Implementation ──────────────────────────────────────────────────────────
+class OutputRouterImpl {
+    renderer;
+    stdoutMode;
+    themeRenderer;
+    nlpRenderer;
+    jsonRenderer;
+    nlgRenderer;
+    constructor(profile) {
+        this.stdoutMode = profile.stdoutMode;
+        // Resolve ThemePalette from the theme system (flag → env → config → terminal)
+        const palette = (() => {
+            try {
+                const resolved = resolveTheme({ cwd: process.cwd() });
+                return getBuiltinTheme(resolved.name);
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        // Initialize NLG renderer with the resolved palette
+        this.nlgRenderer = createNlgRenderer({ palette, write: process.stdout.write.bind(process.stdout) });
+        switch (profile.stdoutMode) {
+            case "theme":
+            case "human": {
+                const useColor = profile.color === "always" || (profile.color === "auto" && process.stdout.isTTY === true);
+                const r = createThemeRenderer(useColor
+                    ? process.stdout.write.bind(process.stdout)
+                    : stripColorWriter, useColor ? palette : undefined);
+                this.themeRenderer = r;
+                this.renderer = r;
+                break;
+            }
+            case "nlp": {
+                const r = createNlpRenderer();
+                this.nlpRenderer = r;
+                this.renderer = r;
+                break;
+            }
+            case "json":
+            case "machine": {
+                const r = createJsonRenderer();
+                this.jsonRenderer = r;
+                this.renderer = r;
+                break;
+            }
+            case "raw": {
+                // "raw" is an escape hatch that still routes through the NLP renderer
+                // to enforce I-004: provider stdout never bypasses the router.
+                const r = createNlpRenderer();
+                this.nlpRenderer = r;
+                this.renderer = r;
+                break;
+            }
+            default: {
+                const _exhaustive = profile.stdoutMode;
+                void _exhaustive;
+                const r = createNlpRenderer();
+                this.nlpRenderer = r;
+                this.renderer = r;
+            }
+        }
+    }
+    route(event) {
+        if (this.themeRenderer) {
+            routeToTheme(this.themeRenderer, event);
+        }
+        else if (this.nlpRenderer) {
+            this.nlpRenderer.render(event);
+        }
+        else if (this.jsonRenderer) {
+            this.jsonRenderer.render(event);
+        }
+    }
+    routeTrace(trace) {
+        if (this.nlgRenderer) {
+            this.nlgRenderer.renderTurnResult(trace);
+        }
+        else if (this.themeRenderer) {
+            // Fallback: use trace summary as progress
+            const summary = trace.result.summary;
+            this.themeRenderer.renderProgress(summary);
+        }
+        else if (this.jsonRenderer) {
+            this.jsonRenderer.render({
+                type: "result",
+                timestamp: new Date().toISOString(),
+                data: { kind: "result", content: JSON.stringify(trace), format: "json" },
+            });
+        }
+    }
+    renderStatusBar(provider, model, intent) {
+        if (this.themeRenderer) {
+            this.themeRenderer.renderStatusBar(provider, model, intent);
+        }
+    }
+    flush() {
+        if (this.themeRenderer) {
+            this.themeRenderer.flush();
+        }
+        else if (this.nlpRenderer) {
+            const text = this.nlpRenderer.flush();
+            if (text.length > 0) {
+                process.stdout.write(text + "\n");
+            }
+        }
+        else if (this.jsonRenderer) {
+            const records = this.jsonRenderer.flush();
+            if (records.length > 0) {
+                process.stdout.write(JSON.stringify(records, null, 2) + "\n");
+            }
+        }
+    }
+    getRenderer() {
+        return this.renderer;
+    }
+}
+// ─── Factory ─────────────────────────────────────────────────────────────────
+export function createOutputRouter(profile) {
+    return new OutputRouterImpl(profile);
+}
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+/**
+ * Route an OmkEvent to the ThemeRenderer's typed methods.
+ */
+function routeToTheme(renderer, event) {
+    if (!event.data) {
+        return;
+    }
+    switch (event.data.kind) {
+        case "turn_started":
+            renderer.renderTurnStarted(event.data.intent, event.data.provider);
+            break;
+        case "progress":
+            renderer.renderProgress(event.data.message, event.data.percent);
+            break;
+        case "mcp_status":
+            renderer.renderMcpStatus(event.data.server, event.data.status);
+            break;
+        case "warning":
+            renderer.renderWarning(event.data.message);
+            break;
+        case "result":
+            renderer.renderResult(event.data.content);
+            break;
+        case "error":
+            renderer.renderError(event.data.message, event.data.recoverable);
+            break;
+        case "turn_finished":
+            renderer.renderTurnFinished(event.data.durationMs);
+            break;
+    }
+}
+/**
+ * Writer that strips ANSI escape codes — used when profile.color is false.
+ */
+function stripColorWriter(text) {
+    const stripped = text.replace(/\x1b\[[0-9;]*m/g, "");
+    process.stdout.write(stripped);
+    return true;
+}

package/dist/runtime/process-session.d.ts

@@ -0,0 +1,27 @@
+import { type ShellResult, type StreamingShellIo } from "../util/shell.js";
+import { type ChildEnvSource } from "./child-env.js";
+export type ProcessSessionIo = StreamingShellIo;
+export interface ProcessSessionOptions {
+    readonly command: string;
+    readonly args?: readonly string[];
+    readonly cwd?: string;
+    readonly env?: ChildEnvSource;
+    readonly parentEnv?: ChildEnvSource;
+    readonly inheritParentEnv?: boolean;
+    readonly allowedParentEnvNames?: readonly string[];
+    readonly allowedSecretEnvNames?: readonly string[];
+    readonly allowSecretPassthrough?: boolean;
+    readonly timeoutMs?: number;
+    readonly maxBuffer?: number;
+    readonly stdio?: "pipe" | "inherit";
+    readonly logPath?: string;
+    readonly input?: string;
+    readonly signal?: AbortSignal;
+    readonly onStdout?: (chunk: string, io?: ProcessSessionIo) => void;
+    readonly onStderr?: (chunk: string, io?: ProcessSessionIo) => void;
+}
+export interface ProcessSessionResult extends ShellResult {
+    readonly aborted: boolean;
+    readonly durationMs: number;
+}
+export declare function runProcessSession(options: ProcessSessionOptions): Promise<ProcessSessionResult>;