kimi-plugin-cc 2.2.2 → 2.4.0

package/dist/mcp/operations.js

@@ -0,0 +1,301 @@
+import { RuntimeError } from "../errors.js";
+import { parseDurationMs, validateThinkingEffort } from "../parsing.js";
+const WORKSPACE_PROPERTY = {
+    type: "string",
+    description: "Absolute workspace directory. Required when the host does not configure a default; Codex normally supplies it explicitly.",
+};
+const MODEL_PROPERTY = {
+    type: "string",
+    description: "One configured Kimi model alias. Omit to preserve the normal session default; never guess an alias.",
+};
+const THINKING_PROPERTY = {
+    type: "string",
+    description: "Per-run thinking-effort request such as off, low, medium, or high. Provider/model support varies and is not observable by the plugin.",
+};
+const BUDGET_PROPERTY = {
+    type: "string",
+    description: "Finite duration such as 30m, 1h, or 90s; bare numbers mean minutes. Maximum 24h. Background operation does not extend it.",
+};
+const COMMON_PROPERTIES = {
+    workspace: WORKSPACE_PROPERTY,
+    model: MODEL_PROPERTY,
+    thinking: THINKING_PROPERTY,
+    budget: BUDGET_PROPERTY,
+};
+const RESUME_PROPERTIES = {
+    fresh: {
+        type: "boolean",
+        description: "Start a fresh Kimi session. Incompatible with resume and resume_latest.",
+    },
+    resume: {
+        type: "string",
+        description: "Resume this job ID or Kimi session ID with the standard continuation instruction. Do not also supply prompt.",
+    },
+    resume_latest: {
+        type: "boolean",
+        description: "Resume the latest matching session for this repository. May be combined with a new prompt.",
+    },
+};
+const PROMPT_PROPERTY = {
+    type: "string",
+    description: "The complete user request, preserved verbatim. Required except when resume or resume_latest supplies the continuation context.",
+};
+const OBJECTIVE_PROPERTY = {
+    type: "string",
+    description: "The complete objective, preserved verbatim.",
+};
+const FOCUS_PROPERTY = {
+    type: "string",
+    description: "Optional review focus or adversarial framing, preserved verbatim.",
+};
+const BASE_PROPERTY = {
+    type: "string",
+    description: "Optional Git base ref. The committed branch diff is authoritative; dirty current files are not treated as committed snapshots.",
+};
+const TURNS_PROPERTY = {
+    type: "integer",
+    minimum: 1,
+    description: "Soft turn-count hint included in the objective. The finite budget is the hard bound.",
+};
+const CAP_PROPERTY = {
+    type: "integer",
+    minimum: 1,
+    description: "Soft hint for total subagent count, not a hook-enforced limit.",
+};
+const MAX_CONCURRENCY_PROPERTY = {
+    type: "integer",
+    minimum: 1,
+    description: "Hard peak subagent concurrency on supported Kimi Code versions. Distinct from the soft total cap.",
+};
+const START_RESULT_GUIDANCE = "Task-capable clients receive an MCP task. Other clients receive a job ID immediately after launch; use kimi_job_status and kimi_job_result until terminal, and kimi_job_cancel to stop. Do not present a launch handle as the finished answer.";
+function schema(properties, required = []) {
+    return { type: "object", properties, required, additionalProperties: false };
+}
+const OPERATION_SPECS = {
+    kimi_ask: {
+        kind: "ask",
+        command: ["ask"],
+        write: false,
+        summary: "Start an independent read-only Kimi repository explanation.",
+        inputSchema: schema({ ...COMMON_PROPERTIES, prompt: PROMPT_PROPERTY, ...RESUME_PROPERTIES }),
+    },
+    kimi_review: {
+        kind: "review",
+        command: ["review"],
+        write: false,
+        summary: "Start an independent read-only Kimi review of working-tree changes, including untracked files, or a committed base diff.",
+        inputSchema: schema({ ...COMMON_PROPERTIES, base: BASE_PROPERTY, focus: FOCUS_PROPERTY }),
+    },
+    kimi_challenge: {
+        kind: "challenge",
+        command: ["task", "challenge"],
+        write: false,
+        summary: "Start a read-only Kimi challenge of assumptions, design choices, and tradeoffs rather than a defect-only review.",
+        inputSchema: schema({ ...COMMON_PROPERTIES, base: BASE_PROPERTY, focus: FOCUS_PROPERTY }),
+    },
+    kimi_rescue: {
+        kind: "rescue",
+        command: ["task", "rescue"],
+        write: true,
+        summary: "Start a bounded write-capable Kimi investigation or fix inside the validated workspace. Review the resulting changes; no commit is made.",
+        inputSchema: schema({ ...COMMON_PROPERTIES, prompt: PROMPT_PROPERTY, ...RESUME_PROPERTIES }),
+    },
+    kimi_pursue: {
+        kind: "pursue",
+        command: ["task", "pursue"],
+        write: true,
+        summary: "Start explicitly autonomous Kimi goal mode with a finite hard budget and workspace write limits. Use only for hands-off objectives, not a single bounded fix.",
+        inputSchema: schema({ ...COMMON_PROPERTIES, objective: OBJECTIVE_PROPERTY, turns: TURNS_PROPERTY }, ["objective"]),
+    },
+    kimi_swarm: {
+        kind: "swarm",
+        command: ["task", "swarm"],
+        write: false,
+        summary: "Start a read-only parallel Kimi fan-out across many independent review targets.",
+        inputSchema: schema({ ...COMMON_PROPERTIES, objective: OBJECTIVE_PROPERTY, cap: CAP_PROPERTY, max_concurrency: MAX_CONCURRENCY_PROPERTY }, ["objective"]),
+    },
+    kimi_swarm_write: {
+        kind: "swarm-write",
+        command: ["task", "swarm"],
+        write: true,
+        summary: "Start parallel Kimi implementation in a disposable worktree off HEAD. The real tree is not edited; the result is a patch to review and apply separately.",
+        inputSchema: schema({ ...COMMON_PROPERTIES, objective: OBJECTIVE_PROPERTY, cap: CAP_PROPERTY, max_concurrency: MAX_CONCURRENCY_PROPERTY }, ["objective"]),
+    },
+};
+const JOB_CONTROL_SCHEMA = schema({
+    workspace: WORKSPACE_PROPERTY,
+    job_id: { type: "string", description: "The UUID returned by an MCP-launched Kimi operation." },
+}, ["job_id"]);
+export const MCP_TOOL_DEFINITIONS = [
+    ...Object.entries(OPERATION_SPECS).map(([name, spec]) => ({
+        name: name,
+        description: `${spec.summary} ${START_RESULT_GUIDANCE}`,
+        inputSchema: spec.inputSchema,
+        annotations: {
+            title: name.replaceAll("_", " "),
+            readOnlyHint: !spec.write,
+            destructiveHint: spec.write,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    })),
+    {
+        name: "kimi_job_status",
+        description: "Read one MCP-launched job's durable state and phase in the same workspace. This is always an ordinary MCP result, never a task.",
+        inputSchema: JOB_CONTROL_SCHEMA,
+        annotations: { title: "kimi job status", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    {
+        name: "kimi_job_result",
+        description: "Read the terminal artifact for one MCP-launched job in the same workspace. Failed jobs return isError:true with their artifact; running jobs return JOB_NOT_TERMINAL without changing state.",
+        inputSchema: JOB_CONTROL_SCHEMA,
+        annotations: { title: "kimi job result", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    {
+        name: "kimi_job_cancel",
+        description: "Cooperatively cancel one running MCP-launched job in the same workspace. Terminal jobs are a no-op. Cancellation does not roll back edits, and write-swarm still captures its patch before cleanup.",
+        inputSchema: JOB_CONTROL_SCHEMA,
+        annotations: { title: "kimi job cancel", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    },
+];
+export function isMcpModelToolName(name) {
+    return Object.hasOwn(OPERATION_SPECS, name);
+}
+export function buildMcpOperationInvocation(name, input) {
+    const spec = OPERATION_SPECS[name];
+    const properties = spec.inputSchema.properties;
+    const args = readArguments(input, Object.keys(properties));
+    const workspace = optionalString(args, "workspace");
+    const argv = [...spec.command];
+    appendCommonOptions(argv, args, spec.kind === "pursue" || spec.kind === "swarm" || spec.kind === "swarm-write" ? "safety" : "response");
+    switch (spec.kind) {
+        case "ask":
+        case "rescue": {
+            const prompt = args.prompt === undefined ? undefined : requiredNonEmptyString(args, "prompt");
+            const fresh = optionalBoolean(args, "fresh") ?? false;
+            const resumeLatest = optionalBoolean(args, "resume_latest") ?? false;
+            const resume = args.resume === undefined ? undefined : requiredNonEmptyString(args, "resume");
+            if (fresh && (resumeLatest || resume !== undefined)) {
+                throw invalidArguments("fresh cannot be combined with resume or resume_latest.");
+            }
+            if (resumeLatest && resume !== undefined) {
+                throw invalidArguments("resume and resume_latest are alternatives; choose one.");
+            }
+            if (resume !== undefined && prompt !== undefined) {
+                throw invalidArguments("resume uses the standard continuation instruction and cannot include prompt. Use resume_latest with a new prompt instead.");
+            }
+            if (prompt === undefined && !resumeLatest && resume === undefined) {
+                throw invalidArguments(`${spec.kind} requires prompt unless resume or resume_latest is selected.`);
+            }
+            if (fresh)
+                argv.push("--fresh");
+            if (resumeLatest)
+                argv.push("-r");
+            if (resume !== undefined)
+                argv.push("--resume", resume);
+            if (prompt !== undefined)
+                argv.push("--", prompt);
+            break;
+        }
+        case "review":
+        case "challenge": {
+            const base = args.base === undefined ? undefined : requiredNonEmptyString(args, "base");
+            const focus = optionalString(args, "focus");
+            if (base !== undefined)
+                argv.push("--base", base);
+            if (focus !== undefined)
+                argv.push("--", focus);
+            break;
+        }
+        case "pursue": {
+            const turns = optionalPositiveInteger(args, "turns");
+            if (turns !== undefined)
+                argv.push("--turns", String(turns));
+            argv.push("--", requiredNonEmptyString(args, "objective"));
+            break;
+        }
+        case "swarm":
+        case "swarm-write": {
+            const cap = optionalPositiveInteger(args, "cap");
+            const maxConcurrency = optionalPositiveInteger(args, "max_concurrency");
+            if (cap !== undefined)
+                argv.push("--cap", String(cap));
+            if (maxConcurrency !== undefined)
+                argv.push("--max-concurrency", String(maxConcurrency));
+            if (spec.kind === "swarm-write")
+                argv.push("--write");
+            argv.push("--", requiredNonEmptyString(args, "objective"));
+            break;
+        }
+    }
+    return { operationKind: spec.kind, ...(workspace !== undefined ? { workspace } : {}), argv };
+}
+export function readJobControlArguments(input) {
+    const args = readArguments(input, ["workspace", "job_id"]);
+    return {
+        ...(optionalString(args, "workspace") !== undefined ? { workspace: optionalString(args, "workspace") } : {}),
+        jobId: requiredNonEmptyString(args, "job_id"),
+    };
+}
+function appendCommonOptions(argv, args, budgetKind) {
+    const budget = optionalString(args, "budget");
+    const model = optionalString(args, "model");
+    const thinking = optionalString(args, "thinking");
+    if (budget !== undefined) {
+        parseDurationMs(budget, "--budget", "mcp.args", budgetKind);
+        argv.push("--budget", budget);
+    }
+    if (model !== undefined)
+        argv.push("-m", requiredNonEmptyString(args, "model"));
+    if (thinking !== undefined) {
+        validateThinkingEffort(thinking, "mcp.args");
+        argv.push("--thinking", thinking);
+    }
+}
+function readArguments(input, allowedKeys) {
+    if (input === undefined)
+        return {};
+    if (input === null || typeof input !== "object" || Array.isArray(input)) {
+        throw invalidArguments("Tool arguments must be a JSON object.");
+    }
+    const args = input;
+    const allowed = new Set(allowedKeys);
+    for (const key of Object.keys(args)) {
+        if (!allowed.has(key))
+            throw invalidArguments(`Unknown argument ${key}. Allowed arguments: ${allowedKeys.join(", ")}.`);
+    }
+    return args;
+}
+function optionalString(args, key) {
+    const value = args[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string")
+        throw invalidArguments(`${key} must be a string.`);
+    return value;
+}
+function requiredNonEmptyString(args, key) {
+    const value = optionalString(args, key);
+    if (value === undefined || value.trim().length === 0)
+        throw invalidArguments(`${key} must be a non-empty string.`);
+    return value;
+}
+function optionalBoolean(args, key) {
+    const value = args[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "boolean")
+        throw invalidArguments(`${key} must be a boolean.`);
+    return value;
+}
+function optionalPositiveInteger(args, key) {
+    const value = args[key];
+    if (value === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(value) || value <= 0)
+        throw invalidArguments(`${key} must be a positive safe integer.`);
+    return value;
+}
+function invalidArguments(message) {
+    return new RuntimeError("MCP_INVALID_ARGUMENTS", message, "mcp.args");
+}

package/dist/mcp/protocol.js

@@ -0,0 +1,275 @@
+import { formatError, RuntimeError } from "../errors.js";
+import { KIMI_PLUGIN_CC_VERSION } from "../version.js";
+import { cancelMcpJob, getMcpJobResult, getMcpJobStatus, getMcpTaskView } from "./job-control.js";
+import { launchMcpOperation } from "./launcher.js";
+import { buildMcpOperationInvocation, isMcpModelToolName, MCP_TOOL_DEFINITIONS, } from "./operations.js";
+import { textResult } from "./tool-result.js";
+const MODERN_VERSION = "2026-07-28";
+const LEGACY_VERSIONS = new Set(["2024-11-05", "2025-03-26", "2025-06-18", "2025-11-25"]);
+const PROTOCOL_VERSION_META = "io.modelcontextprotocol/protocolVersion";
+const CLIENT_INFO_META = "io.modelcontextprotocol/clientInfo";
+const CLIENT_CAPABILITIES_META = "io.modelcontextprotocol/clientCapabilities";
+const TASKS_EXTENSION = "io.modelcontextprotocol/tasks";
+const SERVER_INFO_META = "io.modelcontextprotocol/serverInfo";
+export function createMcpMessageHandler(env) {
+    let mode;
+    return async (message) => {
+        let requestId = isRecord(message) && "id" in message &&
+            (typeof message.id === "string" || typeof message.id === "number" || message.id === null)
+            ? message.id
+            : null;
+        try {
+            const request = parseRequest(message);
+            if (!request)
+                return undefined;
+            requestId = request.id;
+            const { id, method, params } = request;
+            if (method === "server/discover") {
+                requireModernMetadata(params);
+                mode = "modern";
+                return response(id, {
+                    resultType: "complete",
+                    supportedVersions: [MODERN_VERSION],
+                    capabilities: { tools: {}, extensions: { [TASKS_EXTENSION]: {} } },
+                    _meta: { [SERVER_INFO_META]: { name: "kimi-plugin-cc", version: KIMI_PLUGIN_CC_VERSION } },
+                    ttlMs: 0,
+                    cacheScope: "private",
+                });
+            }
+            if (method === "initialize") {
+                const requested = params.protocolVersion;
+                if (typeof requested !== "string" || !LEGACY_VERSIONS.has(requested)) {
+                    throw rpcError(-32_602, "Unsupported protocol version", { supportedVersions: [...LEGACY_VERSIONS] });
+                }
+                mode = "legacy";
+                return response(id, {
+                    protocolVersion: requested,
+                    capabilities: { tools: {} },
+                    serverInfo: { name: "kimi-plugin-cc", version: KIMI_PLUGIN_CC_VERSION },
+                });
+            }
+            if (method === "notifications/initialized")
+                return undefined;
+            if (method.startsWith("notifications/"))
+                return undefined;
+            if (!mode && hasModernVersion(params))
+                mode = "modern";
+            if (!mode)
+                throw rpcError(-32_002, "Server is not initialized");
+            const modern = requireProtocolMode(mode, method);
+            const capabilities = modern ? requireModernMetadata(params) : undefined;
+            switch (method) {
+                case "ping":
+                    return response(id, modern ? { resultType: "complete" } : {});
+                case "tools/list":
+                    return response(id, modern
+                        ? { resultType: "complete", tools: MCP_TOOL_DEFINITIONS, ttlMs: 0, cacheScope: "private" }
+                        : { tools: MCP_TOOL_DEFINITIONS });
+                case "tools/call":
+                    return response(id, await callTool(env, params, modern, capabilities));
+                case "tasks/get": {
+                    requireModern(method, modern);
+                    requireTasksCapability(method, capabilities);
+                    const taskId = requiredTaskId(params);
+                    try {
+                        const view = await getMcpTaskView(env, { job_id: taskId });
+                        return response(id, { resultType: "complete", ...view });
+                    }
+                    catch (error) {
+                        if (error instanceof RuntimeError && error.code === "JOB_NOT_FOUND") {
+                            throw rpcError(-32_602, `Unknown task ID: ${taskId}`);
+                        }
+                        throw error;
+                    }
+                }
+                case "tasks/cancel": {
+                    requireModern(method, modern);
+                    requireTasksCapability(method, capabilities);
+                    const taskId = requiredTaskId(params);
+                    try {
+                        await cancelMcpJob(env, { job_id: taskId });
+                        return response(id, { resultType: "complete" });
+                    }
+                    catch (error) {
+                        if (error instanceof RuntimeError && error.code === "JOB_NOT_FOUND") {
+                            throw rpcError(-32_602, `Unknown task ID: ${taskId}`);
+                        }
+                        throw error;
+                    }
+                }
+                default:
+                    throw rpcError(-32_601, `Method not found: ${method}`);
+            }
+        }
+        catch (error) {
+            if (isRpcError(error))
+                return response(requestId, undefined, error);
+            if (error instanceof RuntimeError) {
+                return response(requestId, undefined, rpcError(-32_603, formatError(error), error.details));
+            }
+            return response(requestId, undefined, rpcError(-32_603, error instanceof Error ? error.message : String(error)));
+        }
+    };
+}
+async function callTool(env, params, modern, capabilities) {
+    const name = params.name;
+    if (typeof name !== "string")
+        throw rpcError(-32_602, "tools/call requires a tool name");
+    try {
+        let result;
+        if (isMcpModelToolName(name)) {
+            const launched = await launchMcpOperation(buildMcpOperationInvocation(name, params.arguments), env);
+            if (modern && hasTasksCapability(capabilities))
+                return taskHandle(launched);
+            result = launched.job.status === "running"
+                ? launchResult(launched)
+                : await getMcpJobResult(env, { job_id: launched.task.task_id });
+        }
+        else {
+            switch (name) {
+                case "kimi_job_status":
+                    result = await getMcpJobStatus(env, params.arguments);
+                    break;
+                case "kimi_job_result":
+                    result = await getMcpJobResult(env, params.arguments);
+                    break;
+                case "kimi_job_cancel":
+                    result = await cancelMcpJob(env, params.arguments);
+                    break;
+                default:
+                    throw rpcError(-32_602, `Unknown tool: ${name}`);
+            }
+        }
+        return modern ? { resultType: "complete", ...result } : result;
+    }
+    catch (error) {
+        if (isRpcError(error))
+            throw error;
+        if (error instanceof RuntimeError) {
+            const result = textResult(formatError(error), {
+                error: { code: error.code, stage: error.stage, details: error.details },
+            }, true);
+            return modern ? { resultType: "complete", ...result } : result;
+        }
+        throw error;
+    }
+}
+function launchResult(launched) {
+    const { task, job } = launched;
+    const metadata = {
+        job_id: task.task_id,
+        operation_kind: task.operation_kind,
+        workspace: task.workspace_cwd,
+        status: job.status,
+        phase: job.phase,
+        created_at: task.created_at,
+    };
+    return textResult(`Started ${task.operation_kind} job ${task.task_id}. This is a launch handle, not the finished answer. Use kimi_job_status and kimi_job_result with this job_id until the job is terminal; use kimi_job_cancel to stop it.`, metadata);
+}
+function taskHandle({ task, job }) {
+    return {
+        resultType: "task",
+        taskId: task.task_id,
+        status: job.status === "running" ? "working" : job.status === "cancelled" ? "cancelled" : "completed",
+        ...(job.status === "running" ? { statusMessage: `${task.operation_kind}: ${job.phase ?? "running"}` } : job.summary ? { statusMessage: job.summary } : {}),
+        createdAt: task.created_at,
+        lastUpdatedAt: job.updated_at,
+        ttlMs: null,
+        pollIntervalMs: 2_000,
+    };
+}
+function parseRequest(message) {
+    if (!isRecord(message))
+        throw new McpJsonRpcError(-32_600, "Invalid JSON-RPC request");
+    if (!("method" in message))
+        return undefined;
+    if (message.jsonrpc !== "2.0" || typeof message.method !== "string" || message.method.length === 0) {
+        throw new McpJsonRpcError(-32_600, "Invalid JSON-RPC request");
+    }
+    if (!("id" in message))
+        return undefined;
+    const id = message.id;
+    if (id !== null && typeof id !== "string" &&
+        (typeof id !== "number" || !Number.isFinite(id))) {
+        throw new McpJsonRpcError(-32_600, "Invalid JSON-RPC request ID");
+    }
+    const params = message.params === undefined ? {} : message.params;
+    if (!isRecord(params))
+        throw new McpJsonRpcError(-32_602, "Request params must be an object");
+    return { id, method: message.method, params };
+}
+function requireProtocolMode(mode, method) {
+    if (mode === "modern")
+        return true;
+    if (method === "tasks/get" || method === "tasks/cancel") {
+        throw new McpJsonRpcError(-32_601, `Method not found: ${method}`);
+    }
+    return false;
+}
+function requireModern(method, modern) {
+    if (!modern)
+        throw new McpJsonRpcError(-32_601, `Method not found: ${method}`);
+}
+function hasModernVersion(params) {
+    return isRecord(params._meta) && params._meta[PROTOCOL_VERSION_META] === MODERN_VERSION;
+}
+function requireModernMetadata(params) {
+    const meta = params._meta;
+    if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+        throw new McpJsonRpcError(-32_602, "Modern MCP requests require protocol metadata");
+    }
+    const record = meta;
+    if (record[PROTOCOL_VERSION_META] !== MODERN_VERSION) {
+        throw new McpJsonRpcError(-32_022, "Unsupported protocol version", {
+            supported: [MODERN_VERSION],
+            requested: record[PROTOCOL_VERSION_META],
+        });
+    }
+    if (record[CLIENT_INFO_META] !== undefined && !isRecord(record[CLIENT_INFO_META])) {
+        throw new McpJsonRpcError(-32_602, "clientInfo must be an object when supplied");
+    }
+    if (!isRecord(record[CLIENT_CAPABILITIES_META])) {
+        throw new McpJsonRpcError(-32_602, "Modern MCP requests require client capabilities");
+    }
+    return record[CLIENT_CAPABILITIES_META];
+}
+function hasTasksCapability(capabilities) {
+    if (!capabilities || !isRecord(capabilities.extensions))
+        return false;
+    return isRecord(capabilities.extensions[TASKS_EXTENSION]);
+}
+function requireTasksCapability(method, capabilities) {
+    if (!hasTasksCapability(capabilities)) {
+        throw new McpJsonRpcError(-32_021, "Missing required client capability", {
+            requiredCapabilities: { extensions: { [TASKS_EXTENSION]: {} } },
+        });
+    }
+}
+function requiredTaskId(params) {
+    if (typeof params.taskId !== "string" || params.taskId.length === 0 || params.taskId.length > 128 || !/^[\x21-\x7e]+$/.test(params.taskId)) {
+        throw new McpJsonRpcError(-32_602, "taskId must be 1-128 printable ASCII characters without spaces");
+    }
+    return params.taskId;
+}
+function response(id, result, error) {
+    return error ? { jsonrpc: "2.0", id, error: { code: error.code, message: error.message, ...(error.data !== undefined ? { data: error.data } : {}) } } : { jsonrpc: "2.0", id, result };
+}
+function rpcError(code, message, data) {
+    return new McpJsonRpcError(code, message, data);
+}
+class McpJsonRpcError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = "McpJsonRpcError";
+    }
+}
+function isRpcError(error) {
+    return error instanceof McpJsonRpcError || (error instanceof Error && "code" in error && typeof error.code === "number");
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/mcp/server.js

@@ -0,0 +1,8 @@
+import { ensurePluginPaths, resolvePluginPaths } from "../paths.js";
+import { createMcpMessageHandler } from "./protocol.js";
+import { serveMcpStdio } from "./stdio.js";
+export async function runMcpServer(context) {
+    const paths = resolvePluginPaths(context.env);
+    await ensurePluginPaths(paths);
+    await serveMcpStdio(process.stdin, process.stdout, createMcpMessageHandler(context.env));
+}

package/dist/mcp/stdio.js

@@ -0,0 +1,78 @@
+const MAX_MESSAGE_BYTES = 8 * 1024 * 1024;
+export async function serveMcpStdio(input, output, handle) {
+    let buffer = Buffer.alloc(0);
+    let writeTail = Promise.resolve();
+    let writeError;
+    const pending = new Set();
+    output.on("error", (error) => { writeError ??= error; });
+    const write = (message) => {
+        if (writeError)
+            return Promise.reject(writeError);
+        const frame = `${JSON.stringify(message)}\n`;
+        writeTail = writeTail.then(() => new Promise((resolve, reject) => {
+            try {
+                if (output.write(frame))
+                    resolve();
+                else
+                    output.once("drain", resolve);
+            }
+            catch (error) {
+                reject(error);
+            }
+        }));
+        return writeTail;
+    };
+    const track = (promise) => {
+        const tracked = promise.catch((error) => { writeError ??= error; }).finally(() => pending.delete(tracked));
+        pending.add(tracked);
+    };
+    try {
+        for await (const chunk of input) {
+            buffer = Buffer.concat([buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+            for (;;) {
+                const newline = buffer.indexOf(0x0a);
+                if (newline < 0)
+                    break;
+                const line = buffer.subarray(0, newline);
+                buffer = buffer.subarray(newline + 1);
+                if (line.length > MAX_MESSAGE_BYTES)
+                    throw new Error("MCP frame exceeds 8 MiB");
+                if (line.toString("utf8").trim().length === 0)
+                    continue;
+                let parsed;
+                try {
+                    parsed = JSON.parse(line.toString("utf8"));
+                }
+                catch {
+                    track(write({ jsonrpc: "2.0", id: null, error: { code: -32_700, message: "Parse error" } }));
+                    continue;
+                }
+                track((async () => {
+                    try {
+                        const response = await handle(parsed);
+                        if (response !== undefined)
+                            await write(response);
+                    }
+                    catch (error) {
+                        await write({
+                            jsonrpc: "2.0",
+                            id: null,
+                            error: { code: -32_603, message: error instanceof Error ? error.message : String(error) },
+                        });
+                    }
+                })());
+            }
+            if (buffer.length > MAX_MESSAGE_BYTES)
+                throw new Error("MCP frame exceeds 8 MiB");
+        }
+    }
+    catch (error) {
+        await write({ jsonrpc: "2.0", id: null, error: { code: -32_700, message: error instanceof Error ? error.message : String(error) } });
+    }
+    finally {
+        await Promise.all(pending);
+        await writeTail;
+        if (writeError)
+            throw writeError;
+    }
+}

package/dist/mcp/supervised-child.js

@@ -0,0 +1,15 @@
+import { RuntimeError } from "../errors.js";
+import { allocateJobId } from "../job-id.js";
+import { runModelCommand } from "../model-command.js";
+export async function runMcpChild(argv, context) {
+    const [jobId, ...command] = argv;
+    if (!jobId || command.length === 0) {
+        throw new RuntimeError("MCP_INVALID_CHILD", "mcp-child expects a job UUID followed by one model operation.", "mcp.child");
+    }
+    const mcpJobId = allocateJobId({ ...context, mcpJobId: jobId });
+    const result = await runModelCommand(command, { ...context, mcpJobId });
+    if (result === undefined) {
+        throw new RuntimeError("MCP_INVALID_CHILD", "mcp-child accepts only the public model operations.", "mcp.child");
+    }
+    return result;
+}