kimi-plugin-cc 2.3.1 → 2.4.0

package/dist/mcp/launcher.js

@@ -0,0 +1,257 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { access, open, stat } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { RuntimeError } from "../errors.js";
+import { preferStableNodePath } from "../hooks/install-paths.js";
+import { JobStore } from "../job-store.js";
+import { markJobFailed } from "../jobs.js";
+import { resolveKimiHome } from "../kimi-home.js";
+import { ensurePluginPaths, resolvePluginPaths } from "../paths.js";
+import { readProcessIdentity, revalidateProcessIdentities, } from "../process-tree.js";
+import { assertMcpJobBinding, mcpCompanionIdentity } from "./binding.js";
+import { resolveMcpWorkspace } from "./workspace.js";
+const compiled = import.meta.url.endsWith(".js");
+const companionEntrypoint = fileURLToPath(new URL(compiled ? "../companion.js" : "../companion.ts", import.meta.url));
+const companionProjectRoot = path.resolve(path.dirname(companionEntrypoint), "..");
+export async function launchMcpOperation(invocation, env, options) {
+    const attachTimeoutMs = options?.attachTimeoutMs ?? 60_000;
+    const readIdentity = options?.identityReader ?? readProcessIdentity;
+    let preserveStartingTask = false;
+    const attachDeadline = Date.now() + attachTimeoutMs;
+    const paths = resolvePluginPaths(env);
+    await ensurePluginPaths(paths);
+    const workspace = await resolveMcpWorkspace(env, invocation.workspace);
+    const taskId = randomUUID();
+    const stdoutPath = path.join(paths.logsDir, `mcp-${taskId}.stdout.log`);
+    const stderrPath = path.join(paths.logsDir, `mcp-${taskId}.stderr.log`);
+    const store = new JobStore(paths);
+    let child;
+    let stdoutHandle;
+    let stderrHandle;
+    let exited;
+    let spawnError;
+    try {
+        const task = store.createMcpTask({
+            task_id: taskId,
+            operation_kind: invocation.operationKind,
+            repo_id: workspace.repo.repoId,
+            workspace_cwd: workspace.cwd,
+            stdout_path: stdoutPath,
+            stderr_path: stderrPath,
+        });
+        stdoutHandle = await open(stdoutPath, "wx", 0o600);
+        stderrHandle = await open(stderrPath, "wx", 0o600);
+        const nodeBinary = await resolveNodeBinary(env);
+        const args = compiled
+            ? [companionEntrypoint, "mcp-child", taskId, ...invocation.argv]
+            : ["--import", "tsx", companionEntrypoint, "mcp-child", taskId, ...invocation.argv];
+        const childEnv = sanitizedChildEnv(env, paths, workspace.cwd);
+        child = spawn(nodeBinary, args, {
+            cwd: companionProjectRoot,
+            detached: process.platform !== "win32",
+            stdio: ["ignore", stdoutHandle.fd, stderrHandle.fd],
+            env: childEnv,
+        });
+        child.once("error", (error) => { spawnError = error; });
+        child.once("close", (code, signal) => { exited = { code, signal }; });
+        if (child.pid !== undefined) {
+            const identity = await readIdentity(child.pid);
+            store.updateMcpTask(taskId, {
+                companion_pid: child.pid,
+                ...(identity ? { companion_identity: JSON.stringify(identity) } : {}),
+            });
+        }
+        await stdoutHandle.close();
+        await stderrHandle.close();
+        stdoutHandle = undefined;
+        stderrHandle = undefined;
+        for (;;) {
+            if (spawnError)
+                throw await markLaunchFailure(store, task, spawnError);
+            const job = store.getJob(taskId);
+            if (job && (job.status !== "running" || job.phase === "turn-running" || job.phase === "worker-running")) {
+                const currentTask = store.getMcpTask(taskId) ?? task;
+                await assertMcpJobBinding(currentTask, job);
+                let identity;
+                if (job.status === "running") {
+                    const expected = mcpCompanionIdentity(currentTask);
+                    if (expected) {
+                        const validation = await revalidateProcessIdentities([expected], {
+                            identityReader: options?.identityReader,
+                        });
+                        if (!validation.complete) {
+                            preserveStartingTask = true;
+                            throw new RuntimeError("MCP_PROCESS_IDENTITY_UNAVAILABLE", "The attachment identity probe was inconclusive; the launch record was preserved.", "mcp.launch", { details: { job_id: taskId, operation_kind: invocation.operationKind } });
+                        }
+                        if (validation.identities.length === 0) {
+                            preserveStartingTask = true;
+                            throw new RuntimeError("MCP_PROCESS_IDENTITY_MISMATCH", "The recorded companion process identity changed before attachment; no process was adopted and the launch record was preserved.", "mcp.launch", { details: { job_id: taskId, operation_kind: invocation.operationKind } });
+                        }
+                        identity = validation.identities[0];
+                    }
+                    else if (child.pid !== undefined) {
+                        identity = await readIdentity(child.pid);
+                    }
+                }
+                const attached = store.updateMcpTask(taskId, {
+                    launch_state: "attached",
+                    attached_at: new Date().toISOString(),
+                    ...(identity ? { companion_identity: JSON.stringify(identity) } : {}),
+                });
+                child.unref();
+                return { task: attached, job };
+            }
+            if (exited) {
+                const diagnostic = await readTail(stderrPath);
+                const error = new RuntimeError("MCP_CHILD_LAUNCH_FAILED", `The companion exited before creating its job (code ${exited.code ?? "unknown"}${exited.signal ? `, signal ${exited.signal}` : ""}).${diagnostic ? `\n${diagnostic}` : ""}`, "mcp.launch", { details: { job_id: taskId, operation_kind: invocation.operationKind, exit_code: exited.code, signal: exited.signal } });
+                throw await markLaunchFailure(store, task, error, diagnostic);
+            }
+            if (Date.now() >= attachDeadline) {
+                const aborted = await abortMcpLaunch(store, paths, task, job, attachTimeoutMs, options?.identityReader);
+                if ("result" in aborted) {
+                    child.unref();
+                    return aborted.result;
+                }
+                preserveStartingTask = aborted.preserveStarting;
+                throw aborted.error;
+            }
+            await sleep(25);
+        }
+    }
+    catch (error) {
+        if (!preserveStartingTask && store.getMcpTask(taskId)?.launch_state === "starting") {
+            store.updateMcpTask(taskId, {
+                launch_state: "exited",
+                launch_error: (error instanceof Error ? error.message : String(error)).slice(-8_000),
+            });
+        }
+        child?.unref();
+        throw error;
+    }
+    finally {
+        store.close();
+        await stdoutHandle?.close().catch(() => undefined);
+        await stderrHandle?.close().catch(() => undefined);
+    }
+}
+async function abortMcpLaunch(store, paths, task, job, timeoutMs, identityReader) {
+    let signalDelivered = false;
+    let preserveStarting = true;
+    try {
+        const current = store.getMcpTask(task.task_id) ?? task;
+        const identity = mcpCompanionIdentity(current);
+        if (identity) {
+            const validation = await revalidateProcessIdentities([identity], { identityReader });
+            if (!validation.complete) {
+                throw new RuntimeError("MCP_PROCESS_IDENTITY_UNAVAILABLE", "The companion identity probe was inconclusive; no signal was sent and the launch record was preserved.", "mcp.launch", { details: { job_id: task.task_id, operation_kind: task.operation_kind } });
+            }
+            if (validation.identities.length === 0) {
+                throw new RuntimeError("MCP_PROCESS_IDENTITY_MISMATCH", "The recorded companion process identity no longer matches; no signal was sent and the launch record was preserved.", "mcp.launch", { details: { job_id: task.task_id, operation_kind: task.operation_kind } });
+            }
+            signalVerifiedIdentity(identity, "SIGTERM");
+            signalDelivered = true;
+            await sleep(1_500);
+            const remaining = await revalidateProcessIdentities([identity], { identityReader });
+            if (!remaining.complete) {
+                const error = new RuntimeError("MCP_PROCESS_IDENTITY_UNAVAILABLE", "The post-signal companion identity probe was inconclusive; the launch record was preserved.", "mcp.launch", { details: { job_id: task.task_id, operation_kind: task.operation_kind } });
+                if (job) {
+                    await assertMcpJobBinding(current, job);
+                    return { result: { task: current, job } };
+                }
+                return { error, preserveStarting };
+            }
+            if (remaining.identities.length > 0) {
+                signalVerifiedIdentity(identity, "SIGKILL");
+            }
+            preserveStarting = false;
+        }
+        const error = new RuntimeError("MCP_LAUNCH_TIMEOUT", `The companion did not become cancellation-ready within ${timeoutMs}ms.${signalDelivered ? " The companion was signalled." : " No verified process identity was available, so no signal was sent."}`, "mcp.launch", { details: { job_id: task.task_id, operation_kind: task.operation_kind, timeout_ms: timeoutMs, signal_delivered: signalDelivered } });
+        if (signalDelivered) {
+            if (job) {
+                await markJobFailed(store, paths, job, error, "MCP launch timed out before cancellation was ready.", { phase: "failed" });
+            }
+            return { error: await markLaunchFailure(store, current, error), preserveStarting };
+        }
+        if (job) {
+            await assertMcpJobBinding(current, job);
+            return { result: { task: current, job } };
+        }
+        return { error, preserveStarting };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error : new Error(String(error)), preserveStarting };
+    }
+}
+function signalVerifiedIdentity(identity, signal) {
+    try {
+        process.kill(identity.processGroupId === identity.pid ? -identity.processGroupId : identity.pid, signal);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ESRCH")
+            throw error;
+    }
+}
+async function resolveNodeBinary(env) {
+    const override = env.KIMI_PLUGIN_CC_NODE_BIN;
+    const binary = override ? override : preferStableNodePath(process.execPath);
+    if (binary.includes("/") || binary.includes("\\")) {
+        try {
+            await access(binary, fsConstants.X_OK);
+        }
+        catch (error) {
+            throw new RuntimeError("MCP_NODE_BIN_INVALID", `Configured Node binary is not executable: ${binary}`, "mcp.launch", {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+    }
+    return binary;
+}
+function sanitizedChildEnv(env, paths, workspace) {
+    return {
+        ...env,
+        KIMI_PLUGIN_CC_WORKSPACE_CWD: workspace,
+        KIMI_PLUGIN_CC_MCP_WORKSPACE: workspace,
+        KIMI_PLUGIN_CC_DATA: path.resolve(paths.claudePluginData),
+        KIMI_CODE_HOME: resolveKimiHome(env, workspace),
+        KIMI_PLUGIN_CC_WORKSPACE_ROOT: undefined,
+        KIMI_PLUGIN_CC_CMD: undefined,
+        KIMI_PLUGIN_CC_OPERATION: undefined,
+        KIMI_PLUGIN_CC_SKIP_HOOK_CHECK: undefined,
+        KIMI_PLUGIN_CC_SKIP_VERSION_PROBE: undefined,
+        KIMI_CODE_TRUST_WORKSPACE: undefined,
+        KIMI_CODE_EXPERIMENTAL_FLAG: undefined,
+    };
+}
+async function markLaunchFailure(store, task, error, diagnostic) {
+    const failure = error instanceof Error ? error : new Error(String(error));
+    store.updateMcpTask(task.task_id, {
+        launch_state: "exited",
+        launch_error: (diagnostic || failure.message).slice(-8_000),
+    });
+    return failure;
+}
+async function readTail(filePath, maximum = 8_000) {
+    try {
+        const info = await stat(filePath);
+        const handle = await open(filePath, "r");
+        try {
+            const length = Math.min(maximum, info.size);
+            const buffer = Buffer.alloc(length);
+            await handle.read(buffer, 0, length, Math.max(0, info.size - length));
+            return buffer.toString("utf8").trim();
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return "";
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

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");
+}