open-multi-agent-kit 0.78.0

package/dist/runtime/kimi-wire-protocol-runtime.js

@@ -0,0 +1,436 @@
+/**
+ * KimiWireProtocolRuntime — true wire-protocol runtime adapter.
+ *
+ * Communicates with Kimi CLI via `kimi --wire` using the JSON-RPC 2.0
+ * wire protocol (protocol version 1.7).
+ */
+import { KimiWireClient } from "../adapters/kimi/wire-client.js";
+import { checkCommand, resolveKimiBin } from "../util/shell.js";
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+function mapToolCallEventToRecord(tc) {
+    let input;
+    if (tc.function.arguments) {
+        try {
+            input = JSON.parse(tc.function.arguments);
+        }
+        catch {
+            input = tc.function.arguments;
+        }
+    }
+    return {
+        name: tc.function.name,
+        input,
+        output: undefined,
+        durationMs: 0,
+        success: false,
+    };
+}
+export class KimiWireProtocolRuntime {
+    id = "kimi-wire";
+    providerId = "kimi";
+    legacy = true;
+    runtimeMode = "wire";
+    kind = "cli";
+    priority = 85;
+    capabilities = {
+        read: true,
+        write: true,
+        shell: false,
+        mcp: false,
+        patch: true,
+        review: true,
+        merge: false,
+        vision: true,
+        supportsStreaming: true,
+        supportsStructuredOutput: false,
+        supportsToolCalling: true,
+    };
+    options;
+    kimiAvailable;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    supports(capsule) {
+        if (this.kimiAvailable === false)
+            return false;
+        const requiresVision = capsule.node?.routing?.assignedProviderCapabilities?.includes("vision");
+        if (requiresVision && !this.capabilities.vision)
+            return false;
+        const requiresToolCalling = capsule.node?.routing?.requiresToolCalling;
+        if (requiresToolCalling && !this.capabilities.supportsToolCalling)
+            return false;
+        return true;
+    }
+    async health() {
+        const kimiBin = resolveKimiBin();
+        const available = await checkCommand(kimiBin);
+        this.kimiAvailable = available;
+        return {
+            runtimeId: this.id,
+            available,
+            reason: available ? undefined : "`kimi` command not found in PATH",
+            checkedAt: new Date().toISOString(),
+        };
+    }
+    async runNode(capsule, signal) {
+        const client = new KimiWireClient({
+            cwd: this.options.cwd,
+            env: this.options.env,
+            agentFile: this.options.agentFile,
+            configFile: this.options.configFile,
+            mcpConfigFile: this.options.mcpConfigFile,
+            hooks: this.options.hooks,
+        });
+        try {
+            await client.start();
+            if (signal.aborted) {
+                return {
+                    success: false,
+                    exitCode: 130,
+                    stdout: "",
+                    stderr: "Aborted before execution",
+                    metadata: { runtime: this.id, aborted: true },
+                };
+            }
+            const prompt = [
+                capsule.system ? `<system>\n${capsule.system}\n</system>` : "",
+                capsule.task,
+            ]
+                .filter(Boolean)
+                .join("\n\n");
+            let output = "";
+            let thinking = "";
+            const toolCallRecords = [];
+            const toolResultMap = new Map();
+            const toolCallIdToIndex = new Map();
+            let errorMsg = "";
+            let tokenUsage = null;
+            let planMode = null;
+            const offEvent = client.onEvent((event) => {
+                switch (event.type) {
+                    case "ContentPart": {
+                        if (event.payload.type === "text") {
+                            output += event.payload.text;
+                        }
+                        else if (event.payload.type === "think") {
+                            thinking += event.payload.think;
+                        }
+                        break;
+                    }
+                    case "TurnEnd": {
+                        // Turn completed
+                        break;
+                    }
+                    case "ToolCall": {
+                        toolCallIdToIndex.set(event.payload.id, toolCallRecords.length);
+                        toolCallRecords.push(mapToolCallEventToRecord(event.payload));
+                        break;
+                    }
+                    case "ToolResult": {
+                        toolResultMap.set(event.payload.tool_call_id, event.payload);
+                        const idx = toolCallIdToIndex.get(event.payload.tool_call_id);
+                        if (idx !== undefined) {
+                            toolCallRecords[idx] = {
+                                ...toolCallRecords[idx],
+                                output: event.payload.return_value.output,
+                                success: !event.payload.return_value.is_error,
+                            };
+                        }
+                        break;
+                    }
+                    case "StatusUpdate": {
+                        if (event.payload.token_usage)
+                            tokenUsage = event.payload.token_usage;
+                        if (event.payload.plan_mode != null)
+                            planMode = event.payload.plan_mode;
+                        break;
+                    }
+                }
+            });
+            // Set up approval handler — auto-approve for now (configurable in future)
+            const offApproval = client.onApprovalRequest((req, respond) => {
+                respond({ request_id: req.id, response: "approve" });
+            });
+            const offToolCall = client.onToolCallRequest((req, respond) => {
+                let isError = false;
+                let toolOutput = "";
+                switch (req.name) {
+                    case "omk_claim_task":
+                        // no-op: DAG node assignment — not actionable in runtime
+                        break;
+                    case "omk_update_task":
+                        // no-op: task status updates handled by orchestrator
+                        break;
+                    case "omk_read_memory": {
+                        try {
+                            const args = req.arguments ? JSON.parse(req.arguments) : {};
+                            const filePath = join(process.cwd(), ".omk", "memory", args.path);
+                            toolOutput = readFileSync(filePath, "utf-8");
+                        }
+                        catch (e) {
+                            isError = true;
+                            toolOutput = String(e);
+                        }
+                        break;
+                    }
+                    case "omk_write_memory": {
+                        try {
+                            const args = req.arguments ? JSON.parse(req.arguments) : {};
+                            const filePath = join(process.cwd(), ".omk", "memory", args.path);
+                            mkdirSync(dirname(filePath), { recursive: true });
+                            writeFileSync(filePath, args.content, "utf-8");
+                        }
+                        catch (e) {
+                            isError = true;
+                            toolOutput = String(e);
+                        }
+                        break;
+                    }
+                    case "omk_emit_metric":
+                        console.log(`[omk_emit_metric] ${req.arguments}`);
+                        break;
+                    case "omk_report_blocker":
+                        console.log(`[omk_report_blocker] ${req.arguments}`);
+                        break;
+                    default:
+                        isError = true;
+                        toolOutput = `Unknown tool: ${req.name}`;
+                }
+                respond({
+                    tool_call_id: req.id,
+                    return_value: { is_error: isError, output: toolOutput, message: "", display: [] },
+                });
+            });
+            const offQuestion = client.onQuestionRequest((req, respond) => {
+                respond({ request_id: req.id, answers: {} });
+            });
+            const offHook = client.onHookRequest((req, respond) => {
+                respond({ request_id: req.id, action: "allow", reason: "" });
+            });
+            try {
+                const result = await client.prompt(prompt);
+                if (signal.aborted) {
+                    return {
+                        success: false,
+                        exitCode: 130,
+                        stdout: output,
+                        stderr: "Aborted during execution",
+                        metadata: { runtime: this.id, aborted: true },
+                    };
+                }
+                const success = result.status === "finished" || result.status === "max_steps_reached";
+                return {
+                    success,
+                    exitCode: success ? 0 : 1,
+                    stdout: output,
+                    stderr: errorMsg,
+                    metadata: {
+                        runtime: this.id,
+                        ...(result.steps && { steps: result.steps }),
+                        ...(thinking && { thinking }),
+                        ...(tokenUsage !== null ? { tokenUsage } : {}),
+                        ...(planMode !== null && { planMode }),
+                    },
+                    toolCalls: toolCallRecords.length > 0 ? toolCallRecords : undefined,
+                };
+            }
+            catch (err) {
+                errorMsg = String(err);
+                return {
+                    success: false,
+                    exitCode: 1,
+                    stdout: output,
+                    stderr: errorMsg,
+                    metadata: { runtime: this.id, error: errorMsg },
+                    toolCalls: toolCallRecords.length > 0 ? toolCallRecords : undefined,
+                };
+            }
+            finally {
+                offEvent();
+                offApproval();
+                offToolCall();
+                offQuestion();
+                offHook();
+            }
+        }
+        finally {
+            await client.stop();
+        }
+    }
+    async execute(task) {
+        const client = new KimiWireClient({
+            cwd: this.options.cwd ?? task.context.cwd,
+            env: {
+                ...this.options.env,
+                ...task.context.env,
+                ...(task.context.providerModel ? { OMK_PROVIDER_MODEL: task.context.providerModel } : {}),
+            },
+            agentFile: this.options.agentFile,
+            configFile: this.options.configFile,
+            mcpConfigFile: this.options.mcpConfigFile,
+            hooks: this.options.hooks,
+        });
+        try {
+            await client.start();
+            if (task.context.abortSignal?.aborted) {
+                return {
+                    output: "",
+                    exitCode: 130,
+                    metadata: { runtime: this.id, aborted: true },
+                };
+            }
+            let output = "";
+            let thinking = "";
+            const toolCallRecords = [];
+            const toolResultMap = new Map();
+            const toolCallIdToIndex = new Map();
+            let tokenUsage = null;
+            let planMode = null;
+            const offEvent = client.onEvent((event) => {
+                switch (event.type) {
+                    case "ContentPart": {
+                        if (event.payload.type === "text") {
+                            output += event.payload.text;
+                        }
+                        else if (event.payload.type === "think") {
+                            thinking += event.payload.think;
+                        }
+                        break;
+                    }
+                    case "TurnEnd": {
+                        break;
+                    }
+                    case "ToolCall": {
+                        toolCallIdToIndex.set(event.payload.id, toolCallRecords.length);
+                        toolCallRecords.push(mapToolCallEventToRecord(event.payload));
+                        break;
+                    }
+                    case "ToolResult": {
+                        toolResultMap.set(event.payload.tool_call_id, event.payload);
+                        const idx = toolCallIdToIndex.get(event.payload.tool_call_id);
+                        if (idx !== undefined) {
+                            toolCallRecords[idx] = {
+                                ...toolCallRecords[idx],
+                                output: event.payload.return_value.output,
+                                success: !event.payload.return_value.is_error,
+                            };
+                        }
+                        break;
+                    }
+                    case "StatusUpdate": {
+                        if (event.payload.token_usage)
+                            tokenUsage = event.payload.token_usage;
+                        if (event.payload.plan_mode != null)
+                            planMode = event.payload.plan_mode;
+                        break;
+                    }
+                }
+            });
+            const offApproval = client.onApprovalRequest((req, respond) => {
+                respond({ request_id: req.id, response: "approve" });
+            });
+            const offToolCall = client.onToolCallRequest((req, respond) => {
+                let isError = false;
+                let toolOutput = "";
+                switch (req.name) {
+                    case "omk_claim_task":
+                        // no-op: DAG node assignment — not actionable in runtime
+                        break;
+                    case "omk_update_task":
+                        // no-op: task status updates handled by orchestrator
+                        break;
+                    case "omk_read_memory": {
+                        try {
+                            const args = req.arguments ? JSON.parse(req.arguments) : {};
+                            const filePath = join(process.cwd(), ".omk", "memory", args.path);
+                            toolOutput = readFileSync(filePath, "utf-8");
+                        }
+                        catch (e) {
+                            isError = true;
+                            toolOutput = String(e);
+                        }
+                        break;
+                    }
+                    case "omk_write_memory": {
+                        try {
+                            const args = req.arguments ? JSON.parse(req.arguments) : {};
+                            const filePath = join(process.cwd(), ".omk", "memory", args.path);
+                            mkdirSync(dirname(filePath), { recursive: true });
+                            writeFileSync(filePath, args.content, "utf-8");
+                        }
+                        catch (e) {
+                            isError = true;
+                            toolOutput = String(e);
+                        }
+                        break;
+                    }
+                    case "omk_emit_metric":
+                        console.log(`[omk_emit_metric] ${req.arguments}`);
+                        break;
+                    case "omk_report_blocker":
+                        console.log(`[omk_report_blocker] ${req.arguments}`);
+                        break;
+                    default:
+                        isError = true;
+                        toolOutput = `Unknown tool: ${req.name}`;
+                }
+                respond({
+                    tool_call_id: req.id,
+                    return_value: { is_error: isError, output: toolOutput, message: "", display: [] },
+                });
+            });
+            const offQuestion = client.onQuestionRequest((req, respond) => {
+                respond({ request_id: req.id, answers: {} });
+            });
+            const offHook = client.onHookRequest((req, respond) => {
+                respond({ request_id: req.id, action: "allow", reason: "" });
+            });
+            try {
+                const result = await client.prompt(task.prompt);
+                if (task.context.abortSignal?.aborted) {
+                    return {
+                        output,
+                        exitCode: 130,
+                        metadata: { runtime: this.id, aborted: true },
+                    };
+                }
+                const success = result.status === "finished" || result.status === "max_steps_reached";
+                return {
+                    output,
+                    exitCode: success ? 0 : 1,
+                    thinking: thinking || undefined,
+                    metadata: {
+                        runtime: this.id,
+                        ...(result.steps && { steps: result.steps }),
+                        ...(tokenUsage !== null ? { tokenUsage } : {}),
+                        ...(planMode !== null && { planMode }),
+                    },
+                    toolCalls: toolCallRecords.length > 0 ? toolCallRecords : undefined,
+                };
+            }
+            catch (err) {
+                return {
+                    output,
+                    exitCode: 1,
+                    thinking: thinking || undefined,
+                    metadata: { runtime: this.id, error: String(err) },
+                    toolCalls: toolCallRecords.length > 0 ? toolCallRecords : undefined,
+                };
+            }
+            finally {
+                offEvent();
+                offApproval();
+                offToolCall();
+                offQuestion();
+                offHook();
+            }
+        }
+        finally {
+            await client.stop();
+        }
+    }
+}
+export function createKimiWireProtocolRuntime(options = {}) {
+    return new KimiWireProtocolRuntime(options);
+}

package/dist/runtime/kimi-wire-runtime.d.ts

@@ -0,0 +1,17 @@
+/**
+ * KimiWireRuntime — wraps KimiWireClient (kimi --wire JSON-RPC).
+ *
+ * Uses the wire protocol for structured tool-call interaction.
+ * Currently incomplete — wire-mode tool handling is not fully implemented.
+ */
+import type { AgentRuntime } from "./agent-runtime.js";
+export interface KimiWireRuntimeOptions {
+    readonly agentFile?: string;
+    readonly configFile?: string;
+    readonly mcpConfigFile?: string;
+    readonly cwd?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly timeoutMs?: number;
+    readonly enabled?: boolean;
+}
+export declare function createKimiWireRuntime(options?: KimiWireRuntimeOptions): AgentRuntime;

package/dist/runtime/kimi-wire-runtime.js

@@ -0,0 +1,112 @@
+/**
+ * KimiWireRuntime — wraps KimiWireClient (kimi --wire JSON-RPC).
+ *
+ * Uses the wire protocol for structured tool-call interaction.
+ * Currently incomplete — wire-mode tool handling is not fully implemented.
+ */
+import { KimiWireClient } from "../kimi/wire-client.js";
+import { CappedOutputBuffer } from "../util/output-buffer.js";
+import { getOmkResourceSettings } from "../util/resource-profile.js";
+export function createKimiWireRuntime(options = {}) {
+    const env = options.env ?? process.env;
+    const enabled = options.enabled === true || /^(1|true|yes)$/i.test(env.OMK_ENABLE_KIMI_WIRE ?? "");
+    return {
+        id: "kimi-wire",
+        providerId: "kimi",
+        legacy: true,
+        runtimeMode: "wire",
+        priority: 90,
+        supports(_capsule) {
+            return enabled;
+        },
+        async runNode(capsule, signal) {
+            const resources = await getOmkResourceSettings();
+            const client = new KimiWireClient({
+                agentFile: options.agentFile,
+                configFile: options.configFile,
+                mcpConfigFile: options.mcpConfigFile,
+                cwd: options.cwd,
+                env: options.env,
+            });
+            const stdout = new CappedOutputBuffer(resources.wireOutputBytes, "wire stdout");
+            const stderr = new CappedOutputBuffer(resources.wireOutputBytes, "wire stderr");
+            const startedAt = Date.now();
+            try {
+                await client.start();
+                const offEvent = client.onEvent((event) => {
+                    if (signal.aborted)
+                        return;
+                    if (event.type === "message") {
+                        stdout.append(`${event.content}\n`);
+                    }
+                    else if (event.type === "error") {
+                        stderr.append(`${event.message}\n`);
+                    }
+                    else if (event.type === "tool_result") {
+                        stdout.append(`${JSON.stringify(event.output)}\n`);
+                    }
+                });
+                const promptParts = [
+                    capsule.system,
+                    capsule.task,
+                ];
+                if (capsule.dependencySummaries.length > 0) {
+                    promptParts.push(`\nDependency outputs:\n${capsule.dependencySummaries.join("\n---\n")}`);
+                }
+                if (capsule.evidenceRequirements.length > 0) {
+                    promptParts.push(`\nEvidence required:\n${capsule.evidenceRequirements.map((e) => `- ${e.gate}: ${e.ref ?? "(any)"}`).join("\n")}`);
+                }
+                if (capsule.relevantFiles.length > 0) {
+                    const fileSection = capsule.relevantFiles
+                        .map((f) => `### ${f.path}${f.startLine > 0 ? ` (lines ${f.startLine}-${f.endLine})` : ""}\n${f.content}`)
+                        .join("\n\n");
+                    promptParts.push(`\nRelevant files:\n${fileSection}`);
+                }
+                if (capsule.graphMemory.length > 0) {
+                    const memorySection = capsule.graphMemory
+                        .map((m) => `- [${m.kind}] ${m.subject} ${m.predicate} ${m.object} (confidence: ${m.confidence})`)
+                        .join('\n');
+                    promptParts.push(`\nProject knowledge:\n${memorySection}`);
+                }
+                if (capsule.priorAttempts.length > 0) {
+                    const attemptSection = capsule.priorAttempts
+                        .slice(-3)
+                        .map((a) => `- attempt ${a.attempt} (${a.provider}): ${a.status}${a.failureSummary ? ` — ${a.failureSummary.slice(0, 200)}` : ""}`)
+                        .join("\n");
+                    promptParts.push(`\nPrior attempts:\n${attemptSection}`);
+                }
+                const prompt = promptParts.filter(Boolean).join("\n\n");
+                if (!prompt.trim()) {
+                    throw new Error("[omk] KimiWireRuntime refused to send an empty prompt to the wire client.");
+                }
+                const result = await client.prompt(prompt);
+                offEvent();
+                const durationMs = Date.now() - startedAt;
+                const success = result.status === "finished" && !signal.aborted;
+                return {
+                    success,
+                    stdout: stdout.toString(),
+                    stderr: stderr.toString(),
+                    metadata: {
+                        runtime: "kimi-wire",
+                        durationMs,
+                        capsuleTokens: capsule.budget.maxInputTokens,
+                    },
+                };
+            }
+            catch (err) {
+                stderr.append(`\n${String(err)}`);
+                return {
+                    success: false,
+                    exitCode: 1,
+                    stdout: stdout.toString(),
+                    stderr: stderr.toString(),
+                    metadata: { runtime: "kimi-wire", error: String(err) },
+                };
+            }
+            finally {
+                await client.stop();
+            }
+        },
+    };
+}

package/dist/runtime/legacy-bridge.d.ts

@@ -0,0 +1,14 @@
+import type { RuntimeId } from "./agent-runtime.js";
+export declare function providerToRuntimeId(provider: string): RuntimeId;
+export declare function runtimeIdToProvider(runtimeId: RuntimeId): string;
+export interface LegacyProviderDecision {
+    provider: string;
+    reason: string;
+    fallbackProvider?: string;
+    confidence: number;
+}
+export declare function legacyProviderToRuntimeIds(decision: LegacyProviderDecision): {
+    selectedRuntime: RuntimeId;
+    candidateRuntimes: RuntimeId[];
+    fallbackChain: RuntimeId[];
+};

package/dist/runtime/legacy-bridge.js

@@ -0,0 +1,27 @@
+const PROVIDER_TO_RUNTIME = {
+    kimi: "kimi-api",
+    deepseek: "deepseek-api",
+    codex: "codex-cli",
+    qwen: "qwen-api",
+    openrouter: "openrouter-api",
+    gemini: "gemini-cli",
+    claude: "claude-code",
+};
+export function providerToRuntimeId(provider) {
+    return PROVIDER_TO_RUNTIME[provider] ?? `${provider}-adapter`;
+}
+export function runtimeIdToProvider(runtimeId) {
+    const entry = Object.entries(PROVIDER_TO_RUNTIME).find(([, rid]) => rid === runtimeId);
+    return entry?.[0] ?? runtimeId.replace(/-adapter$/, "").replace(/-cli$/, "").replace(/-api$/, "");
+}
+export function legacyProviderToRuntimeIds(decision) {
+    const selectedRuntime = providerToRuntimeId(decision.provider);
+    const fallbackChain = decision.fallbackProvider
+        ? [providerToRuntimeId(decision.fallbackProvider)]
+        : [];
+    return {
+        selectedRuntime,
+        candidateRuntimes: [selectedRuntime, ...fallbackChain],
+        fallbackChain,
+    };
+}

package/dist/runtime/local-llm-runtime.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 type { AgentRuntime, AgentRunResult, AgentResult, AgentTask, RuntimeCapabilities, RuntimeHealth } from "./agent-runtime.js";
+import type { ContextCapsule } from "./context-capsule.js";
+export interface LocalLlmRuntimeOptions {
+    apiKey?: string;
+    model?: string;
+    baseUrl?: string;
+}
+export declare class LocalLlmRuntime implements AgentRuntime {
+    readonly id = "local-llm";
+    readonly kind = "api";
+    readonly priority = 35;
+    readonly capabilities: RuntimeCapabilities;
+    private readonly apiKey;
+    private readonly model;
+    private readonly baseUrl;
+    constructor(options?: LocalLlmRuntimeOptions);
+    supports(capsule: ContextCapsule): boolean;
+    health(): Promise<RuntimeHealth>;
+    runNode(capsule: ContextCapsule, signal: AbortSignal): Promise<AgentRunResult>;
+    execute(task: AgentTask): Promise<AgentResult>;
+    private parseStreamResponse;
+}