psyclaw 0.24.0 → 0.25.2

package/dist/src/integrations/mcp.js

@@ -1,826 +0,0 @@
-import { spawn as nodeSpawn } from "node:child_process";
-import { createInterface } from "node:readline";
-import { sha256Text } from "../core/hash.js";
-import { PSYCLAW_VERSION } from "../branding.js";
-import { denyByDefault } from "./contracts.js";
-/**
- * The secure default: argv (never a shell) and an explicit env. The child
- * inherits nothing from `process.env`, so a provider secret in the parent
- * cannot leak into a tool subprocess unless the caller names it explicitly.
- */
-const defaultSpawn = (command, args, options) => {
-    const child = nodeSpawn(command, args, {
-        env: options.env ?? {},
-        stdio: ["pipe", "pipe", "pipe"],
-        shell: false,
-        windowsHide: true,
-    });
-    return {
-        stdout: child.stdout,
-        stderr: child.stderr,
-        stdin: { write: (chunk) => child.stdin.write(chunk), end: () => child.stdin.end() },
-        kill: () => child.kill(),
-        onClose: (handler) => child.on("close", handler),
-    };
-};
-/** Line-delimited JSON-RPC transport over a spawned child. */
-export class StdioMcpTransport {
-    child;
-    handlers = [];
-    closeHandlers = [];
-    closed = false;
-    constructor(config, spawn = defaultSpawn) {
-        this.child = spawn(config.command, config.args, { env: config.env ?? {} });
-        createInterface({ input: this.child.stdout, crlfDelay: Infinity }).on("line", (line) => {
-            const trimmed = line.trim();
-            if (trimmed.length === 0)
-                return;
-            let parsed;
-            try {
-                parsed = JSON.parse(trimmed);
-            }
-            catch {
-                // Malformed server output is ignored. The request will fail by timeout
-                // and the timeout path terminates this transport.
-                return;
-            }
-            for (const handler of this.handlers)
-                handler(parsed);
-        });
-        // stderr is drained for diagnostics but never logged verbatim; a server
-        // must not be able to inject log text that the host then persists.
-        createInterface({ input: this.child.stderr, crlfDelay: Infinity }).on("line", () => undefined);
-        this.child.onClose(() => this.markClosed());
-    }
-    send(message) {
-        if (this.closed)
-            throw new McpTransportClosedError();
-        this.child.stdin.write(`${JSON.stringify(message)}\n`);
-    }
-    onMessage(handler) {
-        this.handlers.push(handler);
-    }
-    onClose(handler) {
-        if (this.closed) {
-            handler();
-            return;
-        }
-        this.closeHandlers.push(handler);
-    }
-    close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        try {
-            this.child.stdin.end();
-        }
-        catch {
-            // The child may have already closed its pipe.
-        }
-        try {
-            this.child.kill();
-        }
-        catch {
-            // A failed kill is still represented as a closed transport.
-        }
-        this.notifyClosed();
-    }
-    markClosed() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        this.notifyClosed();
-    }
-    notifyClosed() {
-        const handlers = this.closeHandlers.splice(0);
-        for (const handler of handlers)
-            handler();
-    }
-}
-export class McpTimeoutError extends Error {
-    method;
-    code = "mcp.timeout";
-    constructor(method) {
-        super("MCP request timed out");
-        this.method = method;
-        this.name = "McpTimeoutError";
-    }
-}
-export class McpTransportClosedError extends Error {
-    code = "mcp.transport-closed";
-    constructor() {
-        super("MCP transport closed");
-        this.name = "McpTransportClosedError";
-    }
-}
-class McpRemoteError extends Error {
-    code = "mcp.remote-error";
-    constructor() {
-        // Never copy the server's error text. It can contain credentials or data.
-        super("MCP server returned an error");
-        this.name = "McpRemoteError";
-    }
-}
-/** Minimal JSON-RPC client for the MCP initialize/list/call sequence. */
-export class McpClient {
-    transport;
-    nextId = 1;
-    pending = new Map();
-    closed = false;
-    constructor(transport) {
-        this.transport = transport;
-        transport.onMessage((message) => this.handle(message));
-        transport.onClose?.(() => {
-            this.closed = true;
-            this.rejectPending(new McpTransportClosedError());
-        });
-    }
-    initialize(clientInfo, timeoutMs = 10000) {
-        return this.request("initialize", {
-            protocolVersion: "2024-11-05",
-            capabilities: {},
-            clientInfo,
-        }, timeoutMs);
-    }
-    initialized() {
-        this.transport.send({ jsonrpc: "2.0", method: "notifications/initialized" });
-    }
-    listTools(timeoutMs = 10000) {
-        return this.request("tools/list", undefined, timeoutMs).then((result) => {
-            const tools = result?.tools;
-            if (!Array.isArray(tools))
-                return [];
-            // A malformed descriptor makes the discovery set ambiguous. Do not
-            // silently drop it and expose a partially trusted server.
-            if (tools.some((tool) => !isMcpTool(tool)))
-                throw new Error("invalid MCP tool descriptor");
-            return tools;
-        });
-    }
-    callTool(name, args, timeoutMs = 30000) {
-        return this.request("tools/call", { name, arguments: args }, timeoutMs);
-    }
-    close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        try {
-            this.transport.close();
-        }
-        catch {
-            // Treat an already-dead transport as closed.
-        }
-        this.rejectPending(new McpTransportClosedError());
-    }
-    request(method, params, timeoutMs) {
-        if (this.closed)
-            return Promise.reject(new McpTransportClosedError());
-        const timeout = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.floor(timeoutMs) : 10000;
-        const id = this.nextId;
-        this.nextId += 1;
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                const entry = this.pending.get(id);
-                if (!entry)
-                    return;
-                this.pending.delete(id);
-                clearTimeout(entry.timer);
-                // A timed-out side effect is indeterminate. Closing the transport is
-                // mandatory so a late response/child cannot be mistaken for a retry.
-                try {
-                    this.transport.close();
-                }
-                catch {
-                    // The request is still rejected below; a broken close implementation
-                    // must not leave the caller hanging.
-                }
-                reject(new McpTimeoutError(method));
-            }, timeout);
-            this.pending.set(id, { resolve, reject, timer });
-            try {
-                this.transport.send({
-                    jsonrpc: "2.0",
-                    id,
-                    method,
-                    ...(params === undefined ? {} : { params }),
-                });
-            }
-            catch {
-                const entry = this.pending.get(id);
-                if (entry) {
-                    this.pending.delete(id);
-                    clearTimeout(entry.timer);
-                }
-                reject(new McpTransportClosedError());
-            }
-        });
-    }
-    rejectPending(error) {
-        const entries = [...this.pending.values()];
-        this.pending.clear();
-        for (const entry of entries) {
-            clearTimeout(entry.timer);
-            entry.reject(error);
-        }
-    }
-    handle(message) {
-        if (!isRecord(message))
-            return;
-        const id = message.id;
-        if (typeof id !== "number" || !this.pending.has(id))
-            return;
-        const entry = this.pending.get(id);
-        if (!entry)
-            return;
-        this.pending.delete(id);
-        clearTimeout(entry.timer);
-        if (message.error !== undefined && message.error !== null) {
-            entry.reject(new McpRemoteError());
-            return;
-        }
-        entry.resolve(message.result);
-    }
-}
-/** A real stdio MCP integration behind the shared `Integration` contract. */
-export class StdioMcpIntegration {
-    config;
-    spawn;
-    transport;
-    client;
-    initialized = false;
-    discoveryAttempted = false;
-    discovered = new Map();
-    /** Reservations survive a failed/timeout call to prevent blind replay. */
-    idempotency = new Map();
-    defaultEffect;
-    constructor(config, spawn = defaultSpawn) {
-        this.config = config;
-        this.spawn = spawn;
-        // Omitted host policy is read-only. A caller must opt into network/write
-        // effects in the host config and still provide approval/idempotency.
-        this.defaultEffect = isEffect(config.effect) ? config.effect : "read";
-    }
-    async list() {
-        if (!this.config.enabled || !this.config.trusted)
-            return [];
-        if (this.discoveryAttempted)
-            return this.descriptorSnapshot();
-        try {
-            const client = await this.connectAndInitialize();
-            const tools = await client.listTools(this.timeoutFor("list"));
-            const seen = new Set();
-            const next = new Map();
-            for (const tool of tools) {
-                if (!isSafeToolName(tool.name) || seen.has(tool.name)) {
-                    // Duplicate/invalid names make the discovery set ambiguous. Do not
-                    // expose a partially trusted set.
-                    this.resetConnection(true);
-                    return [];
-                }
-                seen.add(tool.name);
-                const policy = resolvePolicy(this.config, tool.name, this.defaultEffect);
-                const effect = policy?.effect ?? this.defaultEffect;
-                const allowed = policy !== undefined && policy.enabled && effectAllowed(this.config, effect);
-                const resolved = policy === undefined
-                    ? undefined
-                    : {
-                        // Keep explicit host enablement separate from the effect
-                        // ceiling. Invocation can then report the precise blocked
-                        // reason instead of conflating it with an unknown tool.
-                        enabled: policy.enabled,
-                        effect,
-                        ...(policy.inputSchema !== undefined ? { inputSchema: policy.inputSchema } : {}),
-                        approvalRequired: policy.approvalRequired === true,
-                    };
-                const descriptor = {
-                    id: `${this.config.id}.${tool.name}`,
-                    description: typeof tool.description === "string" ? tool.description.slice(0, 1000) : "",
-                    // This effect is always host-assigned. Any server-provided effect
-                    // field is intentionally not represented in McpTool.
-                    effect,
-                    source: this.config.id,
-                    trust: "approved",
-                    enabled: allowed,
-                };
-                next.set(tool.name, {
-                    name: tool.name,
-                    schema: tool.inputSchema,
-                    ...(resolved === undefined ? {} : { policy: resolved }),
-                    descriptor,
-                });
-            }
-            this.discovered.clear();
-            for (const [name, cached] of next)
-                this.discovered.set(name, cached);
-            this.discoveryAttempted = true;
-            return this.descriptorSnapshot();
-        }
-        catch {
-            this.resetConnection(true);
-            return [];
-        }
-    }
-    async health() {
-        if (!this.config.enabled)
-            return { ok: false, reason: "server disabled" };
-        if (!this.config.trusted)
-            return { ok: false, reason: "server not trusted" };
-        try {
-            await this.connectAndInitialize();
-            return { ok: true };
-        }
-        catch (error) {
-            this.resetConnection(true);
-            return { ok: false, reason: failureCode(error) };
-        }
-    }
-    async invoke(call, approval) {
-        const fallback = this.defaultEffect;
-        const safeCall = sanitizeCall(call);
-        if (!isValidCallEnvelope(call)) {
-            return denyByDefault(safeCall, fallback, "mcp.invalid-call", "mcp.invalid-call");
-        }
-        if (!this.config.enabled || !this.config.trusted) {
-            return denyByDefault(safeCall, fallback, "mcp.untrusted", "mcp.untrusted");
-        }
-        if (!isValidApproval(approval)) {
-            return denyByDefault(safeCall, fallback, "mcp.invalid-approval", "mcp.invalid-approval");
-        }
-        if (!this.discoveryAttempted) {
-            return denyByDefault(safeCall, fallback, "mcp.tool-not-discovered", "mcp.tool-not-discovered");
-        }
-        const parsed = parseToolId(call.tool, this.config.id);
-        if (parsed === undefined) {
-            return denyByDefault(safeCall, fallback, "mcp.source-mismatch", "mcp.source-mismatch");
-        }
-        const cached = this.discovered.get(parsed);
-        if (cached === undefined) {
-            return denyByDefault(safeCall, fallback, "mcp.tool-not-discovered", "mcp.tool-not-discovered");
-        }
-        const policy = cached.policy;
-        if (policy === undefined || !policy.enabled || cached.descriptor.source !== this.config.id) {
-            return denyByDefault(safeCall, cached.descriptor.effect, "mcp.tool-not-enabled", "mcp.tool-not-enabled");
-        }
-        const requested = call.effect;
-        if (requested !== undefined && requested !== policy.effect) {
-            return denyByDefault(safeCall, policy.effect, "mcp.effect-mismatch", "mcp.effect-mismatch");
-        }
-        const requestedSource = call.source;
-        if (requestedSource !== undefined && requestedSource !== this.config.id) {
-            return denyByDefault(safeCall, policy.effect, "mcp.source-mismatch", "mcp.source-mismatch");
-        }
-        if (!effectAllowed(this.config, policy.effect)) {
-            return denyByDefault(safeCall, policy.effect, "mcp.effect-not-allowed", "mcp.effect-not-allowed");
-        }
-        if (approval.decision === "denied") {
-            return denyByDefault(safeCall, policy.effect, "mcp.approval-required", "mcp.approval-required");
-        }
-        if ((policy.effect !== "read" || policy.approvalRequired) && approval.decision !== "approved") {
-            return denyByDefault(safeCall, policy.effect, "mcp.approval-required", "mcp.approval-required");
-        }
-        const schema = policy.inputSchema ?? cached.schema;
-        if (!validateToolInput(schema, call.input)) {
-            return denyByDefault(safeCall, policy.effect, "mcp.invalid-input", "mcp.invalid-input");
-        }
-        const suppliedIdempotencyKey = validIdempotencyKey(call.idempotencyKey) ? call.idempotencyKey : undefined;
-        let idempotencyKey = suppliedIdempotencyKey;
-        if (policy.effect !== "read") {
-            if (idempotencyKey === undefined) {
-                return denyByDefault(safeCall, policy.effect, "mcp.idempotency-required", "mcp.idempotency-required");
-            }
-            let inputCanonical;
-            try {
-                inputCanonical = canonicalJson(call.input);
-            }
-            catch {
-                inputCanonical = undefined;
-            }
-            if (inputCanonical === undefined) {
-                return denyByDefault(safeCall, policy.effect, "mcp.invalid-input", "mcp.invalid-input");
-            }
-            const fingerprint = sha256Text(`${call.tool}\n${policy.effect}\n${inputCanonical}`);
-            const previous = this.idempotency.get(idempotencyKey);
-            if (previous !== undefined) {
-                return denyByDefault(safeCall, policy.effect, previous === fingerprint ? "mcp.duplicate-idempotency" : "mcp.idempotency-conflict", previous === fingerprint ? "mcp.duplicate-idempotency" : "mcp.idempotency-conflict");
-            }
-            // Reserve before crossing the transport boundary. The reservation is
-            // intentionally retained after errors and timeouts.
-            this.idempotency.set(idempotencyKey, fingerprint);
-        }
-        try {
-            const client = await this.connectAndInitialize();
-            const result = await client.callTool(parsed, call.input, this.timeoutFor("call"));
-            const now = new Date().toISOString();
-            const resultText = canonicalJson(result) ?? "<invalid-result>";
-            return {
-                schemaVersion: "psyclaw/tool-receipt/v1",
-                runId: safeCall.runId,
-                taskId: safeCall.taskId,
-                tool: safeCall.tool,
-                effect: policy.effect,
-                approval: approval.decision,
-                ...(idempotencyKey === undefined ? {} : { idempotencyKey }),
-                ok: true,
-                resultHash: sha256Text(resultText),
-                startedAt: now,
-                finishedAt: now,
-            };
-        }
-        catch (error) {
-            // A disconnect/timeout/error invalidates the discovery session. Never
-            // retry automatically: a side effect may have happened remotely.
-            this.resetConnection(true);
-            return denyByDefault(safeCall, policy.effect, failureCode(error), failureCode(error));
-        }
-    }
-    close() {
-        this.resetConnection(true);
-    }
-    descriptorSnapshot() {
-        return [...this.discovered.values()].map((entry) => ({ ...entry.descriptor }));
-    }
-    timeoutFor(kind) {
-        const configured = this.config.requestTimeoutMs;
-        if (Number.isFinite(configured) && configured !== undefined && configured > 0)
-            return Math.floor(configured);
-        return kind === "list" ? 10000 : 30000;
-    }
-    async connectAndInitialize() {
-        if (this.client === undefined) {
-            this.transport = new StdioMcpTransport(this.config, this.spawn);
-            this.client = new McpClient(this.transport);
-            this.initialized = false;
-        }
-        if (!this.initialized) {
-            await this.client.initialize({ name: "psyclaw", version: PSYCLAW_VERSION }, this.timeoutFor("list"));
-            this.client.initialized();
-            this.initialized = true;
-        }
-        return this.client;
-    }
-    resetConnection(invalidateDiscovery) {
-        try {
-            this.client?.close();
-        }
-        catch {
-            // The boundary remains invalidated even if a custom transport throws.
-        }
-        this.client = undefined;
-        this.transport = undefined;
-        this.initialized = false;
-        if (invalidateDiscovery) {
-            this.discoveryAttempted = false;
-            this.discovered.clear();
-        }
-    }
-}
-/**
- * Deliberately lazy MCP boundary retained for M1/M2 compatibility. Discovery
- * is data-only; invocation is denied until `StdioMcpIntegration` is approved.
- */
-export class LazyMcpIntegration {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    async list() {
-        if (!this.config.enabled || !this.config.trusted)
-            return [];
-        return [];
-    }
-    async health() {
-        if (!this.config.enabled)
-            return { ok: false, reason: "server disabled" };
-        if (!this.config.trusted)
-            return { ok: false, reason: "server not trusted" };
-        return { ok: false, reason: "stdio adapter not enabled in M1" };
-    }
-    async invoke(call, approval) {
-        const approved = approval.decision === "approved";
-        return denyByDefault(sanitizeCall(call), "network", approved ? "mcp.transport-disabled" : "mcp.approval-required", approved ? "mcp.transport-disabled" : "mcp.approval-required");
-    }
-}
-const EFFECTS = ["read", "write", "network", "destructive"];
-function isEffect(value) {
-    return typeof value === "string" && EFFECTS.includes(value);
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isMcpTool(value) {
-    if (!isRecord(value) || typeof value.name !== "string")
-        return false;
-    if (value.description !== undefined && typeof value.description !== "string")
-        return false;
-    return true;
-}
-function isSafeToolName(value) {
-    return value.length > 0 && value.length <= 256 && !/[\u0000-\u001f\u007f]/.test(value);
-}
-function parseToolId(tool, serverId) {
-    if (!isSafeToolName(tool))
-        return undefined;
-    const prefix = `${serverId}.`;
-    if (!tool.startsWith(prefix))
-        return undefined;
-    const name = tool.slice(prefix.length);
-    return isSafeToolName(name) ? name : undefined;
-}
-function validIdempotencyKey(value) {
-    return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/.test(value);
-}
-function isValidApproval(value) {
-    if (!isRecord(value))
-        return false;
-    const decision = value.decision;
-    const actor = value.actor;
-    const reason = value.reason;
-    return (decision === "not-needed" || decision === "approved" || decision === "denied") &&
-        (actor === "policy" || actor === "researcher") &&
-        typeof reason === "string" && reason.length <= 2000;
-}
-function isValidCallEnvelope(value) {
-    return isRecord(value) &&
-        typeof value.runId === "string" && value.runId.length > 0 && value.runId.length <= 256 &&
-        typeof value.taskId === "string" && value.taskId.length > 0 && value.taskId.length <= 256 &&
-        typeof value.tool === "string";
-}
-function sanitizeCall(call) {
-    const record = isRecord(call) ? call : {};
-    const rawTool = typeof record.tool === "string" ? record.tool : "";
-    const tool = isSafeToolName(rawTool) ? rawTool : "mcp.invalid-tool";
-    const idempotencyKey = validIdempotencyKey(record.idempotencyKey) ? record.idempotencyKey : undefined;
-    return {
-        runId: typeof record.runId === "string" && record.runId.length <= 256 ? record.runId : "mcp.invalid-run",
-        taskId: typeof record.taskId === "string" && record.taskId.length <= 256 ? record.taskId : "mcp.invalid-task",
-        tool,
-        input: record.input,
-        ...(idempotencyKey === undefined ? {} : { idempotencyKey }),
-    };
-}
-function resolvePolicy(config, name, defaultEffect) {
-    const canonical = `${config.id}.${name}`;
-    const maps = [
-        config.toolPolicies,
-        config.toolPolicy,
-        isPolicyMap(config.tools) ? config.tools : undefined,
-        isPolicyMap(config.allowlist) ? config.allowlist : undefined,
-    ];
-    for (const map of maps) {
-        if (map === undefined)
-            continue;
-        const entry = map[name] ?? map[canonical];
-        if (entry === undefined)
-            continue;
-        if (typeof entry === "boolean") {
-            return { enabled: entry, effect: defaultEffect, approvalRequired: false };
-        }
-        if (!isRecord(entry))
-            return undefined;
-        const enabled = entry.enabled === true;
-        const effect = isEffect(entry.effect) ? entry.effect : defaultEffect;
-        const inputSchema = Object.prototype.hasOwnProperty.call(entry, "inputSchema") ? entry.inputSchema : undefined;
-        return {
-            enabled,
-            effect,
-            ...(inputSchema === undefined ? {} : { inputSchema }),
-            approvalRequired: entry.approvalRequired === true,
-        };
-    }
-    const explicitLists = [
-        config.enabledTools,
-        config.toolAllowlist,
-        config.allowedTools,
-        Array.isArray(config.tools) ? config.tools : undefined,
-        Array.isArray(config.allowlist) ? config.allowlist : undefined,
-    ];
-    const hasList = explicitLists.some((list) => list !== undefined);
-    if (hasList) {
-        const enabled = explicitLists.some((list) => list?.some((entry) => entry === name || entry === canonical));
-        return enabled ? { enabled: true, effect: defaultEffect, approvalRequired: false } : undefined;
-    }
-    if (config.allowAllDiscoveredTools === true && defaultEffect === "read" && effectAllowed(config, "read")) {
-        return { enabled: true, effect: defaultEffect, approvalRequired: false };
-    }
-    return undefined;
-}
-function isPolicyMap(value) {
-    return isRecord(value);
-}
-function effectAllowed(config, effect) {
-    if (!isEffect(effect))
-        return false;
-    if (config.allowedEffects !== undefined) {
-        const configured = config.allowedEffects instanceof Set
-            ? [...config.allowedEffects]
-            : config.allowedEffects;
-        if (!Array.isArray(configured) || configured.some((item) => !isEffect(item)))
-            return false;
-        return configured.includes(effect);
-    }
-    if (config.effectCeiling !== undefined) {
-        const ceiling = config.effectCeiling;
-        if (Array.isArray(ceiling)) {
-            return ceiling.length > 0 && ceiling.every((item) => isEffect(item)) && ceiling.includes(effect);
-        }
-        if (!isEffect(ceiling))
-            return false;
-        const allowed = ceiling === "read"
-            ? ["read"]
-            : ceiling === "write"
-                ? ["read", "write"]
-                : ceiling === "network"
-                    ? ["read", "network"]
-                    : EFFECTS;
-        return allowed.includes(effect);
-    }
-    return true;
-}
-function failureCode(error) {
-    if (error instanceof McpTimeoutError)
-        return error.code;
-    if (error instanceof McpTransportClosedError)
-        return error.code;
-    if (error instanceof McpRemoteError)
-        return error.code;
-    return "mcp.call-failed";
-}
-function canonicalJson(value, seen = new Set(), depth = 0) {
-    if (depth > 40)
-        return undefined;
-    if (value === null)
-        return "null";
-    if (typeof value === "string")
-        return JSON.stringify(value);
-    if (typeof value === "boolean")
-        return value ? "true" : "false";
-    if (typeof value === "number")
-        return Number.isFinite(value) ? JSON.stringify(value) : undefined;
-    if (typeof value !== "object")
-        return undefined;
-    if (seen.has(value))
-        return undefined;
-    seen.add(value);
-    let result;
-    if (Array.isArray(value)) {
-        const parts = [];
-        for (const item of value) {
-            const encoded = canonicalJson(item, seen, depth + 1);
-            if (encoded === undefined)
-                return undefined;
-            parts.push(encoded);
-        }
-        result = `[${parts.join(",")}]`;
-    }
-    else {
-        const record = value;
-        const parts = [];
-        for (const key of Object.keys(record).sort()) {
-            const encoded = canonicalJson(record[key], seen, depth + 1);
-            if (encoded === undefined)
-                return undefined;
-            parts.push(`${JSON.stringify(key)}:${encoded}`);
-        }
-        result = `{${parts.join(",")}}`;
-    }
-    seen.delete(value);
-    return result;
-}
-function validateToolInput(schema, input) {
-    try {
-        if (canonicalJson(input) === undefined)
-            return false;
-        const schemaText = canonicalJson(schema);
-        if (schemaText === undefined || schemaText.length > 65_536)
-            return false;
-        return validateSchema(schema, input, 0, new Set());
-    }
-    catch {
-        // Accessors/proxies and cyclic values are untrusted caller input.
-        return false;
-    }
-}
-/** A bounded JSON-Schema subset sufficient for MCP tool arguments. */
-function validateSchema(schema, value, depth, seen) {
-    if (!isRecord(schema) || depth > 32)
-        return false;
-    if (seen.has(schema))
-        return false;
-    seen.add(schema);
-    try {
-        for (const keyword of ["allOf", "anyOf", "oneOf"]) {
-            if (schema[keyword] !== undefined) {
-                if (!Array.isArray(schema[keyword]) || schema[keyword].some((item) => !isRecord(item)))
-                    return false;
-                const matches = schema[keyword].filter((item) => validateSchema(item, value, depth + 1, seen)).length;
-                if (keyword === "allOf" && matches !== schema[keyword].length)
-                    return false;
-                if (keyword === "anyOf" && matches < 1)
-                    return false;
-                if (keyword === "oneOf" && matches !== 1)
-                    return false;
-            }
-        }
-        if (schema.enum !== undefined) {
-            if (!Array.isArray(schema.enum) || !schema.enum.some((entry) => canonicalJson(entry) === canonicalJson(value)))
-                return false;
-        }
-        if (Object.prototype.hasOwnProperty.call(schema, "const") && canonicalJson(schema.const) !== canonicalJson(value))
-            return false;
-        if (schema.type !== undefined) {
-            const types = Array.isArray(schema.type) ? schema.type : [schema.type];
-            if (!types.every((item) => typeof item === "string"))
-                return false;
-            if (!types.some((type) => typeMatches(type, value)))
-                return false;
-        }
-        if (typeof value === "string") {
-            if (schema.minLength !== undefined && (!isFiniteInteger(schema.minLength) || value.length < schema.minLength))
-                return false;
-            if (schema.maxLength !== undefined && (!isFiniteInteger(schema.maxLength) || value.length > schema.maxLength))
-                return false;
-            if (schema.pattern !== undefined) {
-                if (typeof schema.pattern !== "string")
-                    return false;
-                if (schema.pattern.length > 512)
-                    return false;
-                try {
-                    if (!new RegExp(schema.pattern).test(value))
-                        return false;
-                }
-                catch {
-                    return false;
-                }
-            }
-        }
-        if (typeof value === "number") {
-            if (schema.minimum !== undefined && (typeof schema.minimum !== "number" || value < schema.minimum))
-                return false;
-            if (schema.maximum !== undefined && (typeof schema.maximum !== "number" || value > schema.maximum))
-                return false;
-        }
-        if (Array.isArray(value)) {
-            if (schema.minItems !== undefined && (!isFiniteInteger(schema.minItems) || value.length < schema.minItems))
-                return false;
-            if (schema.maxItems !== undefined && (!isFiniteInteger(schema.maxItems) || value.length > schema.maxItems))
-                return false;
-            if (schema.items !== undefined) {
-                if (!isRecord(schema.items) || !value.every((item) => validateSchema(schema.items, item, depth + 1, seen)))
-                    return false;
-            }
-        }
-        if (isRecord(value)) {
-            if (schema.required !== undefined) {
-                if (!Array.isArray(schema.required) || schema.required.some((item) => typeof item !== "string"))
-                    return false;
-                if (schema.required.some((key) => !Object.prototype.hasOwnProperty.call(value, key)))
-                    return false;
-            }
-            let properties = {};
-            if (schema.properties !== undefined) {
-                if (!isRecord(schema.properties))
-                    return false;
-                if (Object.keys(schema.properties).length > 256)
-                    return false;
-                properties = schema.properties;
-                for (const [key, child] of Object.entries(properties)) {
-                    if (Object.prototype.hasOwnProperty.call(value, key) && !validateSchema(child, value[key], depth + 1, seen))
-                        return false;
-                }
-            }
-            if (schema.additionalProperties === false) {
-                if (Object.keys(value).some((key) => !Object.prototype.hasOwnProperty.call(properties, key)))
-                    return false;
-            }
-            else if (isRecord(schema.additionalProperties)) {
-                for (const key of Object.keys(value)) {
-                    if (!Object.prototype.hasOwnProperty.call(properties, key) && !validateSchema(schema.additionalProperties, value[key], depth + 1, seen))
-                        return false;
-                }
-            }
-            else if (schema.additionalProperties !== undefined && schema.additionalProperties !== true) {
-                return false;
-            }
-        }
-        return true;
-    }
-    finally {
-        seen.delete(schema);
-    }
-}
-function typeMatches(type, value) {
-    switch (type) {
-        case "null": return value === null;
-        case "boolean": return typeof value === "boolean";
-        case "object": return isRecord(value);
-        case "array": return Array.isArray(value);
-        case "string": return typeof value === "string";
-        case "number": return typeof value === "number" && Number.isFinite(value);
-        case "integer": return typeof value === "number" && Number.isInteger(value);
-        default: return false;
-    }
-}
-function isFiniteInteger(value) {
-    return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 1_000_000;
-}
-//# sourceMappingURL=mcp.js.map