open-multi-agent-kit 0.78.0

package/dist/runtime/deepseek-runtime.js

@@ -0,0 +1,270 @@
+/**
+ * DeepSeekRuntime — DeepSeek API runtime adapter.
+ *
+ * Calls https://api.deepseek.com/chat/completions directly.
+ * Supports SSE streaming, tool calling, and reasoning_content.
+ */
+import { capsuleToTask } from "./context-broker-converter.js";
+import { buildProviderToolPayload } from "./provider-tool-contracts.js";
+export class DeepSeekRuntime {
+    id = "deepseek-api";
+    kind = "api";
+    priority = 40;
+    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.DEEPSEEK_API_KEY;
+        this.model = options.model ?? process.env.DEEPSEEK_MODEL ?? "deepseek-chat";
+        this.baseUrl = (options.baseUrl ?? "https://api.deepseek.com").replace(/\/+$/, "");
+    }
+    supports(capsule) {
+        if (!this.apiKey)
+            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 available = Boolean(this.apiKey);
+        return {
+            runtimeId: this.id,
+            available,
+            reason: available ? undefined : "DEEPSEEK_API_KEY is not set",
+            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 (!this.apiKey) {
+            return {
+                output: "",
+                exitCode: 1,
+                thinking: "",
+                metadata: { error: "DEEPSEEK_API_KEY is not set" },
+            };
+        }
+        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: "DeepSeek 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 providerTools = buildProviderToolPayload([]);
+        const tools = providerTools.tools;
+        const body = {
+            model: task.context.providerModel ?? task.context.env?.OMK_PROVIDER_MODEL ?? this.model,
+            messages,
+            stream: task.capabilities.streaming === true,
+        };
+        if (tools.length > 0) {
+            body.tools = tools;
+        }
+        if (task.capabilities.maxTokens) {
+            body.max_tokens = task.capabilities.maxTokens;
+        }
+        try {
+            const timeoutMs = Number(process.env.OMK_PROVIDER_TIMEOUT_MS ?? "120000");
+            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: `DeepSeek API error ${response.status}: ${errorText}`,
+                        toolPlaneHash: providerTools.toolPlaneHash,
+                        toolContracts: providerTools.contracts,
+                    },
+                };
+            }
+            if (task.capabilities.streaming === true) {
+                return this.parseStreamResponse(response, {
+                    toolPlaneHash: providerTools.toolPlaneHash,
+                    toolContracts: providerTools.contracts,
+                });
+            }
+            const contentType = response.headers.get("content-type") ?? "";
+            if (contentType.includes("text/event-stream")) {
+                return this.parseStreamResponse(response, {
+                    toolPlaneHash: providerTools.toolPlaneHash,
+                    toolContracts: providerTools.contracts,
+                });
+            }
+            const payload = (await response.json());
+            const choice = payload.choices?.[0];
+            const content = choice?.message?.content ?? "";
+            const reasoning = choice?.message?.reasoning_content ?? "";
+            const usage = payload.usage;
+            return {
+                output: content,
+                exitCode: 0,
+                thinking: reasoning || undefined,
+                tokenUsage: usage
+                    ? {
+                        inputTokens: usage.prompt_tokens,
+                        outputTokens: usage.completion_tokens,
+                        totalTokens: usage.total_tokens,
+                    }
+                    : undefined,
+                metadata: {
+                    model: payload.model,
+                    finishReason: choice?.finish_reason ?? null,
+                    toolPlaneHash: providerTools.toolPlaneHash,
+                    toolContracts: providerTools.contracts,
+                },
+            };
+        }
+        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, metadata) {
+        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;
+                    }
+                    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,
+            metadata,
+        };
+    }
+}

package/dist/runtime/external-cli-adapter.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ExternalCliAdapter — generic factory for AgentRuntime implementations
+ * that delegate to an external CLI tool.
+ */
+import type { AgentRuntime, AgentRunResult, RuntimeCapabilities } from "./agent-runtime.js";
+import type { ContextCapsule } from "./context-capsule.js";
+import { type ShellResult } from "../util/shell.js";
+export type ExternalCliPromptTransport = "argv" | "stdin" | "tempfile";
+export interface ExternalCliPromptContext {
+    readonly promptFile?: string;
+    readonly promptEnvName: string;
+}
+export interface ExternalCliAdapterOptions {
+    id: string;
+    displayName: string;
+    bin: string;
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    priority: number;
+    capabilities: RuntimeCapabilities;
+    promptTransport?: ExternalCliPromptTransport;
+    promptFileEnvName?: string;
+    buildArgs: (capsule: ContextCapsule, promptContext: ExternalCliPromptContext) => string[];
+    buildInput?: (capsule: ContextCapsule) => string | undefined;
+    buildEnv?: (capsule: ContextCapsule) => Record<string, string>;
+    parseResult?: (shellResult: ShellResult, capsule: ContextCapsule) => AgentRunResult;
+}
+export declare function createExternalCliAdapter(options: ExternalCliAdapterOptions): AgentRuntime;

package/dist/runtime/external-cli-adapter.js

@@ -0,0 +1,283 @@
+/**
+ * ExternalCliAdapter — generic factory for AgentRuntime implementations
+ * that delegate to an external CLI tool.
+ */
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { checkCommand, } from "../util/shell.js";
+import { runtimeMetadataEnv } from "./child-env.js";
+import { runProcessSession } from "./process-session.js";
+import { createRuntimeSandboxProfile } from "./sandbox-profile.js";
+export function createExternalCliAdapter(options) {
+    let pendingOnOutput;
+    return {
+        id: options.id,
+        displayName: options.displayName,
+        kind: "cli",
+        priority: options.priority,
+        capabilities: options.capabilities,
+        supports(capsule) {
+            return runtimeCapabilitiesSupportCapsule(options.capabilities, capsule);
+        },
+        async health() {
+            const available = await checkCommand(options.bin);
+            return {
+                runtimeId: options.id,
+                available,
+                reason: available ? undefined : `Command not found: ${options.bin}`,
+                checkedAt: new Date().toISOString(),
+            };
+        },
+        async execute(task) {
+            pendingOnOutput = task.context.onOutput;
+            const routing = routingFromTask(task);
+            const capsule = {
+                schemaVersion: 1,
+                runId: task.context.runId,
+                nodeId: task.context.nodeId,
+                goal: task.context.goal ?? task.prompt,
+                task: task.prompt,
+                system: task.context.system ?? "",
+                node: {
+                    id: task.context.nodeId,
+                    name: task.prompt,
+                    role: task.context.role ?? "worker",
+                    dependsOn: [],
+                    status: "running",
+                    retries: 0,
+                    maxRetries: 1,
+                    routing,
+                },
+                dependencySummaries: [],
+                relevantFiles: [],
+                graphMemory: [],
+                priorAttempts: [],
+                evidenceRequirements: [],
+                budget: {
+                    maxInputTokens: task.capabilities.maxTokens ?? 16000,
+                    compression: "normal",
+                },
+            };
+            const result = await this.runNode(capsule, task.context.abortSignal ?? new AbortController().signal);
+            return {
+                output: result.stdout,
+                exitCode: result.exitCode ?? (result.success ? 0 : 1),
+                metadata: result.metadata,
+                toolCalls: result.toolCalls,
+                tokenUsage: result.tokenUsage,
+            };
+        },
+        async runNode(capsule, signal) {
+            // Validate capsule task is not empty to prevent CLI errors
+            if (!capsule.task || capsule.task.trim().length === 0) {
+                const errorMsg = `Empty task for node ${capsule.nodeId}`;
+                process.stderr.write(`[omk] ${errorMsg}\n`);
+                return {
+                    success: false,
+                    exitCode: 1,
+                    stdout: `[ERROR] ${errorMsg}`,
+                    stderr: errorMsg,
+                    metadata: { ...externalCliMetadata(capsule, options.id, undefined, options.cwd), error: errorMsg },
+                };
+            }
+            const promptEnvName = options.promptFileEnvName ?? "OMK_PROMPT_FILE";
+            const promptTransport = options.promptTransport ?? "argv";
+            let promptTempDir;
+            let promptFile;
+            const env = {
+                ...runtimeMetadataEnv({
+                    runtimeId: options.id,
+                    runId: capsule.runId,
+                    nodeId: capsule.nodeId,
+                    role: capsule.node?.role,
+                }),
+                ...runtimeSafetyEnv(capsule),
+                ...(options.env ?? {}),
+                ...(options.buildEnv ? options.buildEnv(capsule) : {}),
+            };
+            const timeoutMs = resolveExternalCliTimeoutMs(options.timeoutMs, env.OMK_TURN_TIMEOUT_MS);
+            try {
+                if (promptTransport === "tempfile") {
+                    promptTempDir = await mkdtemp(join(tmpdir(), `omk-${sanitizeTempName(options.id)}-prompt-`));
+                    promptFile = join(promptTempDir, "prompt.txt");
+                    await writeFile(promptFile, capsule.task, { mode: 0o600 });
+                    env[promptEnvName] = promptFile;
+                }
+                const args = options.buildArgs(capsule, {
+                    promptFile,
+                    promptEnvName,
+                });
+                const input = promptTransport === "stdin"
+                    ? options.buildInput?.(capsule) ?? capsule.task
+                    : options.buildInput?.(capsule);
+                const shellResult = await runProcessSession({
+                    command: options.bin,
+                    args,
+                    env,
+                    cwd: options.cwd,
+                    timeoutMs,
+                    input,
+                    signal,
+                    onStdout: pendingOnOutput
+                        ? (chunk) => { pendingOnOutput?.(chunk); }
+                        : undefined,
+                });
+                pendingOnOutput = undefined;
+                if (signal.aborted) {
+                    return {
+                        success: false,
+                        exitCode: 130,
+                        stdout: shellResult.stdout,
+                        stderr: "Aborted by signal",
+                        metadata: { ...externalCliMetadata(capsule, options.id, shellResult.durationMs, options.cwd), aborted: true },
+                    };
+                }
+                if (options.parseResult) {
+                    const parsed = options.parseResult(shellResult, capsule);
+                    return {
+                        ...parsed,
+                        metadata: {
+                            ...externalCliMetadata(capsule, options.id, shellResult.durationMs, options.cwd),
+                            ...(parsed.metadata ?? {}),
+                        },
+                    };
+                }
+                return {
+                    success: !shellResult.failed,
+                    exitCode: shellResult.exitCode,
+                    stdout: shellResult.stdout,
+                    stderr: shellResult.stderr,
+                    metadata: externalCliMetadata(capsule, options.id, shellResult.durationMs, options.cwd),
+                };
+            }
+            catch (err) {
+                const errorMsg = String(err);
+                return {
+                    success: false,
+                    exitCode: 1,
+                    stdout: `[ERROR] ${errorMsg}`,
+                    stderr: errorMsg,
+                    metadata: { ...externalCliMetadata(capsule, options.id, undefined, options.cwd), error: errorMsg },
+                };
+            }
+            finally {
+                if (promptTempDir) {
+                    await rm(promptTempDir, { recursive: true, force: true }).catch(() => undefined);
+                }
+            }
+        },
+    };
+}
+function sanitizeTempName(value) {
+    return value.replace(/[^a-z0-9._-]+/giu, "_");
+}
+function routingFromTask(task) {
+    const toolNames = unique(task.tools.available.map((tool) => tool.name));
+    const mcpServers = unique(task.tools.mcpServers ?? []);
+    const skills = unique(task.tools.skills ?? []);
+    const hooks = unique(task.tools.hooks ?? []);
+    return {
+        risk: normalizeRisk(task.context.risk ?? task.context.env?.OMK_TASK_RISK),
+        approvalPolicy: task.context.approvalPolicy ?? task.context.env?.OMK_APPROVAL_POLICY,
+        sandboxMode: normalizeSandboxMode(task.context.sandboxMode ?? task.context.env?.OMK_SANDBOX_MODE),
+        providerModel: task.context.providerModel ?? task.context.env?.OMK_PROVIDER_MODEL,
+        assignedCapabilities: {
+            tools: toolNames,
+            mcpServers,
+            skills,
+            hooks,
+        },
+        tools: toolNames,
+        mcpServers,
+        skills,
+        hooks,
+    };
+}
+function runtimeSafetyEnv(capsule) {
+    const routing = capsule.node.routing;
+    const assigned = routing?.assignedCapabilities;
+    return {
+        OMK_TASK_RISK: routing?.risk,
+        OMK_APPROVAL_POLICY: routing?.approvalPolicy ?? routing?.executionPrompt,
+        OMK_SANDBOX_MODE: routing?.sandboxMode,
+        OMK_MCP_SERVERS: joinList(routing?.mcpServers ?? assigned?.mcpServers),
+        OMK_SKILLS: joinList(routing?.skills ?? assigned?.skills),
+        OMK_HOOKS: joinList(routing?.hooks ?? assigned?.hooks),
+        OMK_TOOLS: joinList(routing?.tools ?? assigned?.tools),
+        OMK_PROVIDER_MODEL: routing?.providerModel,
+    };
+}
+function externalCliMetadata(capsule, runtime, durationMs, cwd = process.cwd()) {
+    const routing = capsule.node.routing;
+    const sandboxMode = normalizeSandboxMode(routing?.sandboxMode) ?? "read-only";
+    return {
+        runtime,
+        durationMs,
+        risk: routing?.risk,
+        approvalPolicy: routing?.approvalPolicy ?? routing?.executionPrompt,
+        sandboxMode,
+        sandboxProfile: createRuntimeSandboxProfile({
+            cwd,
+            mode: sandboxMode,
+            enforcement: "env-only",
+            writableRoots: [],
+            readableRoots: [cwd],
+            network: "unspecified",
+            secretEnvPolicy: "drop-by-default",
+            notes: [
+                "External CLI env is sanitized.",
+                "OS-level sandboxing is future work.",
+            ],
+        }),
+        providerModel: routing?.providerModel,
+    };
+}
+function normalizeRisk(value) {
+    return value === "read" || value === "write" || value === "shell" || value === "merge" ? value : undefined;
+}
+function normalizeSandboxMode(value) {
+    return value === "read-only" || value === "workspace-write" ? value : undefined;
+}
+function joinList(values) {
+    const joined = unique(values ?? []).join(",");
+    return joined.length > 0 ? joined : undefined;
+}
+function unique(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function runtimeCapabilitiesSupportCapsule(capabilities, capsule) {
+    const routing = capsule.node.routing;
+    if (routing?.requiresMcp === true && capabilities.mcp !== true)
+        return false;
+    if (routing?.requiresToolCalling === true && capabilities.supportsToolCalling !== true)
+        return false;
+    const required = routing?.assignedProviderCapabilities ?? [];
+    for (const capability of required) {
+        if (capability === "read" && capabilities.read !== true)
+            return false;
+        if (capability === "write" && capabilities.write !== true)
+            return false;
+        if (capability === "shell" && capabilities.shell !== true)
+            return false;
+        if (capability === "mcp" && capabilities.mcp !== true)
+            return false;
+        if (capability === "patch" && capabilities.patch !== true)
+            return false;
+        if (capability === "review" && capabilities.review !== true)
+            return false;
+        if (capability === "merge" && capabilities.merge !== true)
+            return false;
+        if (capability === "vision" && capabilities.vision !== true)
+            return false;
+    }
+    return true;
+}
+function resolveExternalCliTimeoutMs(explicitTimeoutMs, envTimeoutMs) {
+    if (explicitTimeoutMs !== undefined)
+        return explicitTimeoutMs;
+    if (!envTimeoutMs)
+        return undefined;
+    const parsed = Number.parseInt(envTimeoutMs, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,8 @@
+export { type ContextCapsule, type ContextBudget, type FileSlice, type MemoryFact, type MemoryFactKind, type AttemptDigest, type EvidenceSpec, DEFAULT_CONTEXT_BUDGET, CONTEXT_BUDGET_PRESETS, estimateCapsuleTokens, } from "./context-capsule.js";
+export { type AgentRuntime, type AgentRunResult, type TokenUsage, type ToolCallRecord, toTaskResult as runtimeToTaskResult, } from "./agent-runtime.js";
+export { type ContextBrokerOptions, createContextBroker, } from "./context-broker.js";
+export { type RuntimeRouterOptions, type RuntimeRouteDecision, type NodeIntent, type RuntimeScore, createRuntimeRouter, } from './runtime-router.js';
+export { type ToolProxyOptions, type ToolResultCompression, createToolProxy, } from "./tool-proxy.js";
+export { type KimiWireRuntimeOptions, createKimiWireRuntime, } from "./kimi-wire-runtime.js";
+export { type KimiPrintRuntimeOptions, createKimiPrintRuntime, } from "./kimi-print-runtime.js";
+export { type ContextBudgetReport, type DroppedContextItem, type ContextTokenBreakdown, type ContextBudgetOptimizationResult, type ContextItemEvidenceStats, createContextBudgetOptimizer, estimateTokens, breakdownCapsuleTokens, } from "./context-budget-optimizer.js";

package/dist/runtime/index.js

@@ -0,0 +1,8 @@
+export { DEFAULT_CONTEXT_BUDGET, CONTEXT_BUDGET_PRESETS, estimateCapsuleTokens, } from "./context-capsule.js";
+export { toTaskResult as runtimeToTaskResult, } from "./agent-runtime.js";
+export { createContextBroker, } from "./context-broker.js";
+export { createRuntimeRouter, } from './runtime-router.js';
+export { createToolProxy, } from "./tool-proxy.js";
+export { createKimiWireRuntime, } from "./kimi-wire-runtime.js";
+export { createKimiPrintRuntime, } from "./kimi-print-runtime.js";
+export { createContextBudgetOptimizer, estimateTokens, breakdownCapsuleTokens, } from "./context-budget-optimizer.js";

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

@@ -0,0 +1,52 @@
+/**
+ * KimiApiRuntime — Moonshot API runtime adapter.
+ * Previously misnamed as KimiWireRuntime; this is an HTTP API adapter, not wire protocol.
+ *
+ * Calls https://api.moonshot.cn/v1/chat/completions directly.
+ */
+import type { AgentRuntime, AgentRunResult, AgentResult, AgentTask, RuntimeCapabilities, RuntimeHealth } from "./agent-runtime.js";
+import type { ContextCapsule } from "./context-capsule.js";
+export interface KimiApiRuntimeOptions {
+    id?: string;
+    priority?: number;
+    apiKey?: string;
+    model?: string;
+    baseUrl?: string;
+    /** @deprecated Wire-client option, ignored by HTTP adapter */
+    cwd?: string;
+    /** @deprecated Wire-client option, used only to read KIMI_API_KEY */
+    env?: NodeJS.ProcessEnv;
+    /** @deprecated Wire-client option, ignored by HTTP adapter */
+    agentFile?: string;
+    /** @deprecated Wire-client option, ignored by HTTP adapter */
+    configFile?: string;
+    /** @deprecated Wire-client option, ignored by HTTP adapter */
+    mcpConfigFile?: string;
+    /** @deprecated Wire-client option, ignored by HTTP adapter */
+    timeoutMs?: number;
+    /** @deprecated Wire-client option, ignored by HTTP adapter */
+    enabled?: boolean;
+}
+/** @deprecated Use KimiApiRuntimeOptions instead */
+export type KimiWireRuntimeOptions = KimiApiRuntimeOptions;
+export declare function createKimiApiRuntime(options?: KimiApiRuntimeOptions): AgentRuntime;
+/** @deprecated Use createKimiApiRuntime instead */
+export declare const createKimiWireRuntime: typeof createKimiApiRuntime;
+export declare class KimiApiRuntime implements AgentRuntime {
+    readonly id: string;
+    readonly providerId = "kimi";
+    readonly legacy = false;
+    readonly runtimeMode = "api";
+    readonly kind = "api";
+    readonly priority: number;
+    readonly capabilities: RuntimeCapabilities;
+    private readonly apiKey;
+    private readonly model;
+    private readonly baseUrl;
+    constructor(options?: KimiApiRuntimeOptions);
+    supports(capsule: ContextCapsule): boolean;
+    health(): Promise<RuntimeHealth>;
+    runNode(capsule: ContextCapsule, signal: AbortSignal): Promise<AgentRunResult>;
+    execute(task: AgentTask): Promise<AgentResult>;
+    private parseStreamResponse;
+}