@kamilio/wire 0.1.9 → 0.1.10

package/node_modules/toolcraft/node_modules/tiny-mcp-client/dist/internal.js

@@ -1,2688 +0,0 @@
-import { spawn } from "node:child_process";
-import { PassThrough } from "node:stream";
-import { createOAuthClientProvider, OAuthError, } from "mcp-oauth";
-import { OAuthMetadataDiscovery, parseBearerWwwAuthenticateHeader, } from "./oauth-discovery.js";
-export { OAuthMetadataDiscovery, discoverOAuthMetadata, parseBearerWwwAuthenticateHeader, resolveAuthorizationServerMetadataUrl, resolveProtectedResourceMetadataUrl, } from "./oauth-discovery.js";
-export { createAuthStoreSessionStore, createDefaultOAuthClientProvider, } from "mcp-oauth";
-const MCP_PROTOCOL_VERSION = "2025-03-26";
-export class McpClient {
-    currentState = "disconnected";
-    currentServerCapabilities = null;
-    currentClientCapabilities = null;
-    currentServerInfo = null;
-    currentInstructions;
-    subscribedResourceUris = new Set();
-    activeProgressTokens = new Map();
-    options;
-    transport = null;
-    messageLayer = null;
-    constructor(options) {
-        this.options = options;
-    }
-    get state() {
-        return this.currentState;
-    }
-    get serverCapabilities() {
-        return this.currentServerCapabilities === null
-            ? null
-            : structuredClone(this.currentServerCapabilities);
-    }
-    get serverInfo() {
-        return this.currentServerInfo;
-    }
-    get instructions() {
-        return this.currentInstructions;
-    }
-    getMessageLayerOrThrow() {
-        if (this.currentState === "disconnected") {
-            throw new Error("MCP client is disconnected");
-        }
-        if (this.currentState === "closed") {
-            throw new Error("MCP client is closed");
-        }
-        if (this.messageLayer === null) {
-            throw new Error("MCP client is disconnected");
-        }
-        return this.messageLayer;
-    }
-    async connect(transport) {
-        if (this.currentState !== "disconnected" && this.currentState !== "closed") {
-            throw new Error("MCP client is already connected");
-        }
-        this.currentServerCapabilities = null;
-        this.currentClientCapabilities = null;
-        this.currentServerInfo = null;
-        this.currentInstructions = undefined;
-        this.subscribedResourceUris.clear();
-        this.activeProgressTokens.clear();
-        const transportClosedReason = transport.closed
-            .then((closedEvent) => closedEvent.reason)
-            .catch((error) => error instanceof Error ? error : new Error(String(error)));
-        const messageLayer = new JsonRpcMessageLayer(transport.readable, transport.writable, this.options.requestTimeoutMs, transportClosedReason);
-        const { onSamplingRequest, onRootsList, onToolsChanged, onResourcesChanged, onResourceUpdated, onPromptsChanged, onLog, onProgress, } = this.options;
-        messageLayer.onRequest("ping", () => ({}));
-        if (onSamplingRequest !== undefined) {
-            messageLayer.onRequest("sampling/createMessage", (params) => onSamplingRequest(params));
-        }
-        messageLayer.onNotification("notifications/tools/list_changed", async () => {
-            if (onToolsChanged === undefined || this.currentServerCapabilities?.tools?.listChanged !== true) {
-                return;
-            }
-            await onToolsChanged();
-        });
-        messageLayer.onNotification("notifications/resources/list_changed", async () => {
-            if (onResourcesChanged === undefined
-                || this.currentServerCapabilities?.resources?.listChanged !== true) {
-                return;
-            }
-            await onResourcesChanged();
-        });
-        messageLayer.onNotification("notifications/resources/updated", async (params) => {
-            if (onResourceUpdated === undefined) {
-                return;
-            }
-            if (typeof params !== "object" || params === null || Array.isArray(params)) {
-                return;
-            }
-            const { uri } = params;
-            if (typeof uri !== "string" || !this.subscribedResourceUris.has(uri)) {
-                return;
-            }
-            await onResourceUpdated(uri);
-        });
-        messageLayer.onNotification("notifications/prompts/list_changed", async () => {
-            if (onPromptsChanged === undefined
-                || this.currentServerCapabilities?.prompts?.listChanged !== true) {
-                return;
-            }
-            await onPromptsChanged();
-        });
-        messageLayer.onNotification("notifications/message", async (params) => {
-            if (onLog === undefined || !isObjectRecord(params) || !isLogLevel(params.level)) {
-                return;
-            }
-            if (!hasOwn(params, "data")) {
-                return;
-            }
-            const message = {
-                level: params.level,
-                data: params.data,
-            };
-            if (params.logger !== undefined) {
-                if (typeof params.logger !== "string") {
-                    return;
-                }
-                message.logger = params.logger;
-            }
-            await onLog(message);
-        });
-        messageLayer.onNotification("notifications/progress", async (params) => {
-            if (onProgress === undefined || !isObjectRecord(params)) {
-                return;
-            }
-            const { progressToken, progress } = params;
-            if (!isRequestId(progressToken) ||
-                typeof progress !== "number" ||
-                !this.activeProgressTokens.has(progressToken)) {
-                return;
-            }
-            const progressParams = {
-                progressToken,
-                progress,
-            };
-            if (params.total !== undefined) {
-                if (typeof params.total !== "number") {
-                    return;
-                }
-                progressParams.total = params.total;
-            }
-            if (params.message !== undefined) {
-                if (typeof params.message !== "string") {
-                    return;
-                }
-                progressParams.message = params.message;
-            }
-            await onProgress(progressParams);
-        });
-        messageLayer.onNotification("notifications/cancelled", () => undefined);
-        this.transport = transport;
-        this.messageLayer = messageLayer;
-        this.currentState = "initializing";
-        this.subscribedResourceUris.clear();
-        this.activeProgressTokens.clear();
-        transport.closed
-            .then((closedEvent) => {
-            if (this.transport !== transport) {
-                return;
-            }
-            this.messageLayer?.dispose(closedEvent.reason);
-            this.messageLayer = null;
-            this.transport = null;
-            this.currentState = "closed";
-        })
-            .catch((error) => {
-            if (this.transport !== transport) {
-                return;
-            }
-            const reason = error instanceof Error ? error : new Error(String(error));
-            this.messageLayer?.dispose(reason);
-            this.messageLayer = null;
-            this.transport = null;
-            this.currentState = "closed";
-        });
-        const capabilities = {
-            ...(this.options.capabilities ?? {}),
-        };
-        if (onSamplingRequest !== undefined && capabilities.sampling === undefined) {
-            capabilities.sampling = {};
-        }
-        if (onRootsList !== undefined) {
-            capabilities.roots = {
-                ...(capabilities.roots ?? {}),
-            };
-        }
-        this.currentClientCapabilities = structuredClone(capabilities);
-        try {
-            const initializeResultValue = await messageLayer.sendRequest("initialize", {
-                protocolVersion: MCP_PROTOCOL_VERSION,
-                clientInfo: this.options.clientInfo,
-                capabilities,
-            });
-            if (!isInitializeResult(initializeResultValue)) {
-                throw new McpError(ERROR_INVALID_REQUEST, "Invalid initialize result");
-            }
-            const initializeResult = initializeResultValue;
-            if (initializeResult.protocolVersion !== MCP_PROTOCOL_VERSION) {
-                throw new McpError(ERROR_INVALID_REQUEST, `Unsupported protocol version: ${initializeResult.protocolVersion}`);
-            }
-            this.currentServerCapabilities = structuredClone(initializeResult.capabilities);
-            this.currentServerInfo = { ...initializeResult.serverInfo };
-            this.currentInstructions = initializeResult.instructions;
-            if (onRootsList !== undefined) {
-                messageLayer.onRequest("roots/list", async () => ({
-                    roots: await onRootsList(),
-                }));
-            }
-            messageLayer.sendNotification("notifications/initialized");
-            this.currentState = "ready";
-            return initializeResult;
-        }
-        catch (error) {
-            if (this.transport === transport) {
-                const reason = error instanceof Error ? error : new Error(String(error));
-                messageLayer.dispose(reason);
-                transport.dispose(reason);
-                this.messageLayer = null;
-                this.transport = null;
-                this.currentState = "disconnected";
-            }
-            throw error;
-        }
-    }
-    getServerCapabilitiesOrThrow() {
-        if (this.currentServerCapabilities === null) {
-            throw new Error("MCP client has not completed initialization");
-        }
-        return this.currentServerCapabilities;
-    }
-    async listTools(params = {}) {
-        const messageLayer = this.getMessageLayerOrThrow();
-        const serverCapabilities = this.getServerCapabilitiesOrThrow();
-        if (serverCapabilities.tools === undefined) {
-            throw new Error("Server does not support tools");
-        }
-        const requestParams = params.cursor === undefined ? undefined : { cursor: params.cursor };
-        const result = await messageLayer.sendRequest("tools/list", requestParams);
-        if (!isToolsListResult(result)) {
-            throw new McpError(ERROR_INVALID_REQUEST, "Invalid tools/list result");
-        }
-        return result;
-    }
-    async callTool(params, options = {}) {
-        const messageLayer = this.getMessageLayerOrThrow();
-        const serverCapabilities = this.getServerCapabilitiesOrThrow();
-        if (serverCapabilities.tools === undefined) {
-            throw new Error("Server does not support tools");
-        }
-        if (options.signal?.aborted) {
-            throw options.signal.reason;
-        }
-        const requestParams = options.progressToken === undefined
-            ? params
-            : {
-                ...params,
-                _meta: {
-                    progressToken: options.progressToken,
-                },
-            };
-        if (options.progressToken !== undefined) {
-            this.activeProgressTokens.set(options.progressToken, (this.activeProgressTokens.get(options.progressToken) ?? 0) + 1);
-        }
-        try {
-            let requestId;
-            let cancellationSent = false;
-            const sendCancellationNotification = () => {
-                if (requestId === undefined || cancellationSent) {
-                    return;
-                }
-                cancellationSent = true;
-                messageLayer.sendNotification("notifications/cancelled", { requestId });
-            };
-            const requestPromise = messageLayer.sendRequest("tools/call", requestParams, {
-                onRequestId: (nextRequestId) => {
-                    requestId = nextRequestId;
-                },
-                onTimeout: sendCancellationNotification,
-            }).then((result) => {
-                if (!isCallToolResult(result)) {
-                    throw new McpError(ERROR_INVALID_REQUEST, "Invalid tool result");
-                }
-                return result;
-            });
-            if (options.signal === undefined) {
-                return await requestPromise;
-            }
-            const signal = options.signal;
-            let abortListener;
-            const abortPromise = new Promise((_, reject) => {
-                const rejectWithAbortReason = () => {
-                    sendCancellationNotification();
-                    if (requestId !== undefined) {
-                        messageLayer.cancelRequest(requestId, signal.reason);
-                    }
-                    reject(signal.reason);
-                };
-                abortListener = rejectWithAbortReason;
-                signal.addEventListener("abort", abortListener, { once: true });
-                if (signal.aborted) {
-                    signal.removeEventListener("abort", abortListener);
-                    rejectWithAbortReason();
-                }
-            });
-            try {
-                return (await Promise.race([requestPromise, abortPromise]));
-            }
-            finally {
-                if (abortListener !== undefined) {
-                    signal.removeEventListener("abort", abortListener);
-                }
-            }
-        }
-        finally {
-            if (options.progressToken !== undefined) {
-                const activeCount = this.activeProgressTokens.get(options.progressToken);
-                if (activeCount === 1) {
-                    this.activeProgressTokens.delete(options.progressToken);
-                }
-                else if (activeCount !== undefined) {
-                    this.activeProgressTokens.set(options.progressToken, activeCount - 1);
-                }
-            }
-        }
-    }
-    async listResources(params = {}) {
-        const messageLayer = this.getMessageLayerOrThrow();
-        const serverCapabilities = this.getServerCapabilitiesOrThrow();
-        if (serverCapabilities.resources === undefined) {
-            throw new Error("Server does not support resources");
-        }
-        const requestParams = params.cursor === undefined ? undefined : { cursor: params.cursor };
-        const result = await messageLayer.sendRequest("resources/list", requestParams);
-        if (!isResourcesListResult(result)) {
-            throw new McpError(ERROR_INVALID_REQUEST, "Invalid resources/list result");
-        }
-        return result;
-    }
-    async listResourceTemplates(params = {}) {
-        const messageLayer = this.getMessageLayerOrThrow();
-        const serverCapabilities = this.getServerCapabilitiesOrThrow();
-        if (serverCapabilities.resources === undefined) {
-            throw new Error("Server does not support resources");
-        }
-        const requestParams = params.cursor === undefined ? undefined : { cursor: params.cursor };
-        const result = await messageLayer.sendRequest("resources/templates/list", requestParams);
-        if (!isResourceTemplatesListResult(result)) {
-            throw new McpError(ERROR_INVALID_REQUEST, "Invalid resources/templates/list result");
-        }
-        return result;
-    }
-    async readResource(params) {
-        const messageLayer = this.getMessageLayerOrThrow();
-        const serverCapabilities = this.getServerCapabilitiesOrThrow();
-        if (serverCapabilities.resources === undefined) {
-            throw new Error("Server does not support resources");
-        }
-        const result = await messageLayer.sendRequest("resources/read", params);
-        if (!isReadResourceResult(result)) {
-            throw new McpError(ERROR_INVALID_REQUEST, "Invalid resources/read result");
-        }
-        return result;
-    }
-    async subscribe(uri) {
-        const messageLayer = this.getMessageLayerOrThrow();
-        const serverCapabilities = this.getServerCapabilitiesOrThrow();
-        if (serverCapabilities.resources?.subscribe !== true) {
-            throw new Error("Server does not support resource subscriptions");
-        }
-        await messageLayer.sendRequest("resources/subscribe", { uri });
-        this.subscribedResourceUris.add(uri);
-    }
-    async unsubscribe(uri) {
-        const messageLayer = this.getMessageLayerOrThrow();
-        const serverCapabilities = this.getServerCapabilitiesOrThrow();
-        if (serverCapabilities.resources?.subscribe !== true) {
-            throw new Error("Server does not support resource subscriptions");
-        }
-        await messageLayer.sendRequest("resources/unsubscribe", { uri });
-        this.subscribedResourceUris.delete(uri);
-    }
-    async listPrompts(params = {}) {
-        const messageLayer = this.getMessageLayerOrThrow();
-        const serverCapabilities = this.getServerCapabilitiesOrThrow();
-        if (serverCapabilities.prompts === undefined) {
-            throw new Error("Server does not support prompts");
-        }
-        const requestParams = params.cursor === undefined ? undefined : { cursor: params.cursor };
-        return (await messageLayer.sendRequest("prompts/list", requestParams));
-    }
-    async getPrompt(params) {
-        const messageLayer = this.getMessageLayerOrThrow();
-        const serverCapabilities = this.getServerCapabilitiesOrThrow();
-        if (serverCapabilities.prompts === undefined) {
-            throw new Error("Server does not support prompts");
-        }
-        const result = await messageLayer.sendRequest("prompts/get", params);
-        if (!isGetPromptResult(result)) {
-            throw new McpError(ERROR_INVALID_REQUEST, "Invalid prompts/get result");
-        }
-        return result;
-    }
-    async complete(params) {
-        const messageLayer = this.getMessageLayerOrThrow();
-        const serverCapabilities = this.getServerCapabilitiesOrThrow();
-        if (serverCapabilities.completions === undefined) {
-            throw new Error("Server does not support completions");
-        }
-        const result = await messageLayer.sendRequest("completion/complete", params);
-        if (!isCompleteResult(result)) {
-            throw new McpError(ERROR_INVALID_REQUEST, "Invalid completion/complete result");
-        }
-        return result;
-    }
-    async setLogLevel(level) {
-        const messageLayer = this.getMessageLayerOrThrow();
-        const serverCapabilities = this.getServerCapabilitiesOrThrow();
-        if (serverCapabilities.logging === undefined) {
-            throw new Error("Server does not support logging");
-        }
-        await messageLayer.sendRequest("logging/setLevel", { level });
-    }
-    async cancel(requestId, reason) {
-        const messageLayer = this.getMessageLayerOrThrow();
-        const params = { requestId };
-        if (reason !== undefined) {
-            params.reason = reason;
-        }
-        messageLayer.sendNotification("notifications/cancelled", params);
-    }
-    async sendRootsChanged() {
-        const messageLayer = this.getMessageLayerOrThrow();
-        if (this.currentClientCapabilities?.roots?.listChanged !== true) {
-            throw new Error("Client did not advertise roots list changes");
-        }
-        messageLayer.sendNotification("notifications/roots/list_changed");
-    }
-    async ping() {
-        const messageLayer = this.getMessageLayerOrThrow();
-        await messageLayer.sendRequest("ping");
-    }
-    async close() {
-        if (this.currentState === "closed") {
-            return;
-        }
-        const closeError = new Error("MCP client closed");
-        this.messageLayer?.dispose(closeError);
-        this.transport?.dispose(closeError);
-        this.messageLayer = null;
-        this.transport = null;
-        this.currentServerCapabilities = null;
-        this.currentClientCapabilities = null;
-        this.currentServerInfo = null;
-        this.currentInstructions = undefined;
-        this.subscribedResourceUris.clear();
-        this.activeProgressTokens.clear();
-        this.currentState = "closed";
-    }
-}
-export const ERROR_PARSE = -32700;
-export const ERROR_INVALID_REQUEST = -32600;
-export const ERROR_METHOD_NOT_FOUND = -32601;
-export const ERROR_INVALID_PARAMS = -32602;
-export const ERROR_INTERNAL = -32603;
-export function createInMemoryTransportPair() {
-    const clientToServer = new PassThrough();
-    const serverToClient = new PassThrough();
-    let disposed = false;
-    let resolveClosed;
-    const closed = new Promise((resolve) => {
-        resolveClosed = resolve;
-    });
-    const resolveClosedOnce = (reason) => {
-        if (resolveClosed === undefined) {
-            return;
-        }
-        const currentResolve = resolveClosed;
-        resolveClosed = undefined;
-        currentResolve({ reason });
-    };
-    const dispose = (reason = new Error("In-memory transport disposed")) => {
-        if (disposed) {
-            return;
-        }
-        disposed = true;
-        if (!clientToServer.destroyed && !clientToServer.writableEnded) {
-            clientToServer.end();
-        }
-        if (!serverToClient.destroyed && !serverToClient.writableEnded) {
-            serverToClient.end();
-        }
-        resolveClosedOnce(reason);
-    };
-    clientToServer.once("error", (error) => {
-        dispose(error instanceof Error ? error : new Error(String(error)));
-    });
-    serverToClient.once("error", (error) => {
-        dispose(error instanceof Error ? error : new Error(String(error)));
-    });
-    return {
-        clientTransport: {
-            readable: serverToClient,
-            writable: clientToServer,
-            closed,
-            dispose,
-        },
-        serverTransport: {
-            readable: clientToServer,
-            writable: serverToClient,
-        },
-    };
-}
-export class SdkTransportAdapter {
-    readable;
-    writable;
-    closed;
-    sdkTransport;
-    readStream = new PassThrough();
-    writeStream = new PassThrough();
-    resolveClosed;
-    disposed = false;
-    constructor(sdkTransport) {
-        this.sdkTransport = sdkTransport;
-        this.readable = this.readStream;
-        this.writable = this.writeStream;
-        this.closed = new Promise((resolve) => {
-            this.resolveClosed = resolve;
-        });
-        this.sdkTransport.onmessage = (message) => {
-            this.readStream.write(serializeJsonRpcMessage(message));
-        };
-        this.sdkTransport.onclose = () => {
-            this.dispose(new Error("SDK transport closed"));
-        };
-        this.sdkTransport.onerror = (error) => {
-            this.dispose(error instanceof Error ? error : new Error(String(error)));
-        };
-        this.readStream.once("error", (error) => {
-            this.dispose(error instanceof Error ? error : new Error(String(error)));
-        });
-        this.writeStream.once("error", (error) => {
-            this.dispose(error instanceof Error ? error : new Error(String(error)));
-        });
-        this.consumeWrittenLines().catch((error) => {
-            this.dispose(error instanceof Error ? error : new Error(String(error)));
-        });
-        this.sdkTransport.start().catch((error) => {
-            this.dispose(error instanceof Error ? error : new Error(String(error)));
-        });
-    }
-    dispose(reason = new Error("SDK transport adapter disposed")) {
-        if (this.disposed) {
-            return;
-        }
-        this.disposed = true;
-        if (!this.writeStream.destroyed && !this.writeStream.writableEnded) {
-            this.writeStream.end();
-        }
-        if (!this.readStream.destroyed && !this.readStream.writableEnded) {
-            this.readStream.end();
-        }
-        if (this.resolveClosed !== undefined) {
-            const resolveClosed = this.resolveClosed;
-            this.resolveClosed = undefined;
-            resolveClosed({ reason });
-        }
-        this.sdkTransport.close().catch(() => undefined);
-    }
-    async consumeWrittenLines() {
-        for await (const line of readLines(this.writeStream)) {
-            if (this.disposed || line.length === 0) {
-                continue;
-            }
-            let parsedMessage;
-            try {
-                parsedMessage = JSON.parse(line);
-            }
-            catch {
-                throw new Error(`Malformed JSON line: ${line}`);
-            }
-            if (typeof parsedMessage !== "object" || parsedMessage === null || Array.isArray(parsedMessage)) {
-                throw new Error(`Malformed JSON line: ${line}`);
-            }
-            await this.sdkTransport.send(parsedMessage);
-        }
-    }
-}
-export async function createSdkTestPair(server, createClient) {
-    const { InMemoryTransport } = await import("@modelcontextprotocol/sdk/inMemory.js");
-    const [clientSdkTransport, serverSdkTransport] = InMemoryTransport.createLinkedPair();
-    const clientTransport = new SdkTransportAdapter(clientSdkTransport);
-    const serverPromise = server.connect(serverSdkTransport);
-    const client = createClient();
-    try {
-        await client.connect(clientTransport);
-    }
-    catch (error) {
-        clientTransport.dispose(new Error("SDK test pair setup failed"));
-        await clientSdkTransport.close();
-        await serverSdkTransport.close();
-        await serverPromise;
-        throw error;
-    }
-    const cleanup = async () => {
-        await client.close();
-        clientTransport.dispose(new Error("SDK test pair cleanup"));
-        await clientSdkTransport.close();
-        await serverSdkTransport.close();
-        await serverPromise;
-    };
-    return { client, cleanup };
-}
-export async function createMockEchoToolServer() {
-    const [{ Server }, { CallToolRequestSchema, ListToolsRequestSchema }] = await Promise.all([
-        import("@modelcontextprotocol/sdk/server/index.js"),
-        import("@modelcontextprotocol/sdk/types.js"),
-    ]);
-    const server = new Server({ name: "mock-echo-tool-server", version: "1.0.0" }, { capabilities: { tools: {} } });
-    const echoTool = {
-        name: "echo",
-        description: "Echoes the provided message.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                message: {
-                    type: "string",
-                },
-            },
-            required: ["message"],
-        },
-    };
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [echoTool],
-    }));
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        if (request.params.name !== "echo") {
-            throw new Error(`Unknown tool: ${request.params.name}`);
-        }
-        const message = request.params.arguments?.message;
-        if (typeof message !== "string") {
-            throw new Error("Echo tool requires a string message argument");
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: message,
-                },
-            ],
-        };
-    });
-    return server;
-}
-export async function createMockMultiToolServer() {
-    const [{ Server }, { CallToolRequestSchema, ListToolsRequestSchema }] = await Promise.all([
-        import("@modelcontextprotocol/sdk/server/index.js"),
-        import("@modelcontextprotocol/sdk/types.js"),
-    ]);
-    const server = new Server({ name: "mock-multi-tool-server", version: "1.0.0" }, { capabilities: { tools: {} } });
-    const tools = [
-        {
-            name: "add",
-            description: "Adds two numbers and returns the sum as text.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    a: { type: "number" },
-                    b: { type: "number" },
-                },
-                required: ["a", "b"],
-            },
-        },
-        {
-            name: "greet",
-            description: "Greets a user with optional formal tone.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    name: { type: "string" },
-                    formal: { type: "boolean" },
-                },
-                required: ["name"],
-            },
-        },
-        {
-            name: "fail",
-            description: "Returns an intentional tool error payload.",
-            inputSchema: {
-                type: "object",
-                properties: {},
-            },
-        },
-    ];
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        if (request.params.name === "add") {
-            const a = request.params.arguments?.a;
-            const b = request.params.arguments?.b;
-            if (typeof a !== "number" || typeof b !== "number") {
-                throw new Error("Add tool requires numeric a and b arguments");
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: String(a + b),
-                    },
-                ],
-            };
-        }
-        if (request.params.name === "greet") {
-            const name = request.params.arguments?.name;
-            const formal = request.params.arguments?.formal;
-            if (typeof name !== "string") {
-                throw new Error("Greet tool requires a string name argument");
-            }
-            if (formal !== undefined && typeof formal !== "boolean") {
-                throw new Error("Greet tool formal argument must be boolean when provided");
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: formal ? `Good day, ${name}.` : `Hello, ${name}!`,
-                    },
-                ],
-            };
-        }
-        if (request.params.name === "fail") {
-            return {
-                isError: true,
-                content: [
-                    {
-                        type: "text",
-                        text: "Intentional tool failure.",
-                    },
-                ],
-            };
-        }
-        throw new Error(`Unknown tool: ${request.params.name}`);
-    });
-    return server;
-}
-export async function createMockPaginatedToolsServer() {
-    const [{ Server }, { ListToolsRequestSchema }] = await Promise.all([
-        import("@modelcontextprotocol/sdk/server/index.js"),
-        import("@modelcontextprotocol/sdk/types.js"),
-    ]);
-    const server = new Server({ name: "mock-paginated-tools-server", version: "1.0.0" }, { capabilities: { tools: {} } });
-    const pageSize = 5;
-    const tools = Array.from({ length: 20 }, (_, index) => ({
-        name: `tool-${index + 1}`,
-        description: `Mock paginated tool ${index + 1}.`,
-        inputSchema: {
-            type: "object",
-            properties: {},
-        },
-    }));
-    server.setRequestHandler(ListToolsRequestSchema, async (request) => {
-        const cursor = request.params?.cursor;
-        const startIndex = cursor === undefined ? 0 : Number(cursor);
-        if (!Number.isInteger(startIndex) ||
-            startIndex < 0 ||
-            startIndex > tools.length ||
-            startIndex % pageSize !== 0) {
-            throw new Error(`Invalid cursor: ${String(cursor)}`);
-        }
-        const pageTools = tools.slice(startIndex, startIndex + pageSize);
-        const nextIndex = startIndex + pageSize;
-        if (nextIndex >= tools.length) {
-            return { tools: pageTools };
-        }
-        return {
-            tools: pageTools,
-            nextCursor: String(nextIndex),
-        };
-    });
-    return server;
-}
-export async function createMockResourceServer() {
-    const [{ Server }, { ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema, },] = await Promise.all([
-        import("@modelcontextprotocol/sdk/server/index.js"),
-        import("@modelcontextprotocol/sdk/types.js"),
-    ]);
-    const server = new Server({ name: "mock-resource-server", version: "1.0.0" }, { capabilities: { resources: {} } });
-    const resources = [
-        {
-            uri: "file:///readme.txt",
-            name: "readme.txt",
-            mimeType: "text/plain",
-        },
-        {
-            uri: "file:///image.png",
-            name: "image.png",
-            mimeType: "image/png",
-        },
-    ];
-    const resourceContentsByUri = new Map([
-        [
-            "file:///readme.txt",
-            {
-                uri: "file:///readme.txt",
-                mimeType: "text/plain",
-                text: "This is a mock README resource.",
-            },
-        ],
-        [
-            "file:///image.png",
-            {
-                uri: "file:///image.png",
-                mimeType: "image/png",
-                blob: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8Xw8AAoMBgL9qj3QAAAAASUVORK5CYII=",
-            },
-        ],
-    ]);
-    const resourceTemplates = [
-        {
-            uriTemplate: "file:///{path}",
-            name: "file-template",
-        },
-    ];
-    server.setRequestHandler(ListResourcesRequestSchema, async () => ({
-        resources,
-    }));
-    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-        const resourceContent = resourceContentsByUri.get(request.params.uri);
-        if (resourceContent === undefined) {
-            throw new Error(`Unknown resource: ${request.params.uri}`);
-        }
-        return {
-            contents: [resourceContent],
-        };
-    });
-    server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => ({
-        resourceTemplates,
-    }));
-    return server;
-}
-export async function createMockSubscribableResourceServer() {
-    const [{ Server }, { ListResourcesRequestSchema, ReadResourceRequestSchema, SubscribeRequestSchema, UnsubscribeRequestSchema, },] = await Promise.all([
-        import("@modelcontextprotocol/sdk/server/index.js"),
-        import("@modelcontextprotocol/sdk/types.js"),
-    ]);
-    const server = new Server({ name: "mock-subscribable-resource-server", version: "1.0.0" }, { capabilities: { resources: { subscribe: true, listChanged: true } } });
-    const resources = [
-        {
-            uri: "file:///readme.txt",
-            name: "readme.txt",
-            mimeType: "text/plain",
-        },
-    ];
-    const resourceContentsByUri = new Map([
-        [
-            "file:///readme.txt",
-            {
-                uri: "file:///readme.txt",
-                mimeType: "text/plain",
-                text: "Initial subscribable resource text.",
-            },
-        ],
-    ]);
-    const subscribedUris = new Set();
-    server.setRequestHandler(ListResourcesRequestSchema, async () => ({
-        resources,
-    }));
-    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-        const resourceContent = resourceContentsByUri.get(request.params.uri);
-        if (resourceContent === undefined) {
-            throw new Error(`Unknown resource: ${request.params.uri}`);
-        }
-        return {
-            contents: [resourceContent],
-        };
-    });
-    server.setRequestHandler(SubscribeRequestSchema, async (request) => {
-        subscribedUris.add(request.params.uri);
-        return {};
-    });
-    server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
-        subscribedUris.delete(request.params.uri);
-        return {};
-    });
-    return Object.assign(server, {
-        triggerResourceUpdated: async (uri, updatedText) => {
-            if (updatedText !== undefined) {
-                const existingContent = resourceContentsByUri.get(uri);
-                if (existingContent === undefined || "blob" in existingContent) {
-                    throw new Error(`Unknown text resource: ${uri}`);
-                }
-                resourceContentsByUri.set(uri, {
-                    uri,
-                    mimeType: existingContent.mimeType,
-                    text: updatedText,
-                });
-            }
-            if (!subscribedUris.has(uri)) {
-                return;
-            }
-            await server.sendResourceUpdated({ uri });
-        },
-        triggerResourceListChanged: async () => {
-            await server.sendResourceListChanged();
-        },
-    });
-}
-export async function createMockPromptServer() {
-    const [{ Server }, { ErrorCode, GetPromptRequestSchema, ListPromptsRequestSchema, McpError: SdkMcpError },] = await Promise.all([
-        import("@modelcontextprotocol/sdk/server/index.js"),
-        import("@modelcontextprotocol/sdk/types.js"),
-    ]);
-    const server = new Server({ name: "mock-prompt-server", version: "1.0.0" }, { capabilities: { prompts: {} } });
-    const promptTemplates = [
-        {
-            prompt: {
-                name: "code_review",
-                description: "Review code for correctness and maintainability.",
-                arguments: [
-                    {
-                        name: "code",
-                        description: "Code to review.",
-                        required: true,
-                    },
-                ],
-            },
-            messages: [
-                {
-                    role: "user",
-                    textTemplate: "Please review the following code:\n{{code}}",
-                },
-                {
-                    role: "assistant",
-                    textTemplate: "I will review the code for potential issues and improvements.",
-                },
-            ],
-        },
-        {
-            prompt: {
-                name: "summarize",
-                description: "Summarize the provided text.",
-            },
-            messages: [
-                {
-                    role: "user",
-                    textTemplate: "Please summarize the provided text.",
-                },
-            ],
-        },
-    ];
-    const promptsByName = new Map(promptTemplates.map((template) => [template.prompt.name, template]));
-    const renderPromptMessage = (textTemplate, argumentsMap) => {
-        if (argumentsMap === undefined) {
-            return textTemplate;
-        }
-        let renderedText = textTemplate;
-        for (const [name, value] of Object.entries(argumentsMap)) {
-            if (typeof value !== "string") {
-                continue;
-            }
-            renderedText = renderedText.split(`{{${name}}}`).join(value);
-        }
-        return renderedText;
-    };
-    server.setRequestHandler(ListPromptsRequestSchema, async () => ({
-        prompts: promptTemplates.map((template) => template.prompt),
-    }));
-    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-        const template = promptsByName.get(request.params.name);
-        if (template === undefined) {
-            throw new SdkMcpError(ErrorCode.InvalidParams, `Unknown prompt: ${request.params.name}`);
-        }
-        const requestArguments = request.params.arguments;
-        for (const argument of template.prompt.arguments ?? []) {
-            if (!argument.required) {
-                continue;
-            }
-            const value = requestArguments?.[argument.name];
-            if (typeof value !== "string") {
-                throw new SdkMcpError(ErrorCode.InvalidParams, `Missing required prompt argument: ${argument.name}`);
-            }
-        }
-        return {
-            description: template.prompt.description,
-            messages: template.messages.map((message) => ({
-                role: message.role,
-                content: {
-                    type: "text",
-                    text: renderPromptMessage(message.textTemplate, requestArguments),
-                },
-            })),
-        };
-    });
-    return server;
-}
-export async function createMockCompletionServer() {
-    const [{ Server }, { CompleteRequestSchema }] = await Promise.all([
-        import("@modelcontextprotocol/sdk/server/index.js"),
-        import("@modelcontextprotocol/sdk/types.js"),
-    ]);
-    const server = new Server({ name: "mock-completion-server", version: "1.0.0" }, { capabilities: { completions: {} } });
-    const promptArgumentCompletions = new Map([
-        ["code_review:language", ["python", "pydantic", "pytest", "pytorch", "pyright", "rust"]],
-    ]);
-    const maxValues = 3;
-    server.setRequestHandler(CompleteRequestSchema, async (request) => {
-        if (request.params.ref.type !== "ref/prompt") {
-            return {
-                completion: {
-                    values: [],
-                },
-            };
-        }
-        const completionKey = `${request.params.ref.name}:${request.params.argument.name}`;
-        const candidates = promptArgumentCompletions.get(completionKey) ?? [];
-        const partialValue = request.params.argument.value.toLowerCase();
-        const matchingValues = candidates.filter((candidate) => candidate.toLowerCase().startsWith(partialValue));
-        const values = matchingValues.slice(0, maxValues);
-        if (values.length < matchingValues.length) {
-            return {
-                completion: {
-                    values,
-                    hasMore: true,
-                    total: matchingValues.length,
-                },
-            };
-        }
-        return {
-            completion: {
-                values,
-            },
-        };
-    });
-    return server;
-}
-export async function createMockProgressServer() {
-    const [{ Server }, { CallToolRequestSchema, ListToolsRequestSchema }] = await Promise.all([
-        import("@modelcontextprotocol/sdk/server/index.js"),
-        import("@modelcontextprotocol/sdk/types.js"),
-    ]);
-    const server = new Server({ name: "mock-progress-server", version: "1.0.0" }, { capabilities: { tools: {} } });
-    const totalSteps = 4;
-    const tool = {
-        name: "slow_task",
-        description: "Runs a simulated slow task and streams progress updates.",
-        inputSchema: {
-            type: "object",
-            properties: {},
-            additionalProperties: false,
-        },
-    };
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [tool],
-    }));
-    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
-        if (request.params.name !== "slow_task") {
-            throw new Error(`Unknown tool: ${request.params.name}`);
-        }
-        const progressToken = request.params._meta?.progressToken;
-        if (progressToken !== undefined) {
-            for (let step = 1; step <= totalSteps; step += 1) {
-                await extra.sendNotification({
-                    method: "notifications/progress",
-                    params: {
-                        progressToken,
-                        progress: step,
-                        total: totalSteps,
-                        message: `Completed step ${step} of ${totalSteps}`,
-                    },
-                });
-                await new Promise((resolve) => {
-                    setTimeout(resolve, 5);
-                });
-            }
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "slow_task complete",
-                },
-            ],
-        };
-    });
-    return server;
-}
-export async function createMockSlowToolServer(options = {}) {
-    const [{ Server }, { CallToolRequestSchema, ListToolsRequestSchema }] = await Promise.all([
-        import("@modelcontextprotocol/sdk/server/index.js"),
-        import("@modelcontextprotocol/sdk/types.js"),
-    ]);
-    const defaultDelayMs = options.delayMs ?? 1_000;
-    const pollIntervalMs = options.pollIntervalMs ?? 10;
-    if (!Number.isFinite(defaultDelayMs) || defaultDelayMs < 0) {
-        throw new Error("createMockSlowToolServer delayMs must be a finite non-negative number");
-    }
-    if (!Number.isFinite(pollIntervalMs) || pollIntervalMs <= 0) {
-        throw new Error("createMockSlowToolServer pollIntervalMs must be a finite positive number");
-    }
-    const server = new Server({ name: "mock-slow-tool-server", version: "1.0.0" }, { capabilities: { tools: {} } });
-    const startedRequestIds = new Set();
-    const cancelledRequestIds = new Set();
-    const tool = {
-        name: "slow",
-        description: "Delays the response and supports cancellation.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                delayMs: {
-                    type: "number",
-                },
-            },
-            additionalProperties: false,
-        },
-    };
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [tool],
-    }));
-    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
-        if (request.params.name !== "slow") {
-            throw new Error(`Unknown tool: ${request.params.name}`);
-        }
-        startedRequestIds.add(extra.requestId);
-        const delayArgument = request.params.arguments?.delayMs;
-        const delayMs = delayArgument === undefined
-            ? defaultDelayMs
-            : typeof delayArgument === "number" && Number.isFinite(delayArgument) && delayArgument >= 0
-                ? delayArgument
-                : NaN;
-        if (!Number.isFinite(delayMs)) {
-            throw new Error("slow tool delayMs argument must be a finite non-negative number");
-        }
-        const startedAt = Date.now();
-        while (Date.now() - startedAt < delayMs) {
-            if (extra.signal.aborted) {
-                cancelledRequestIds.add(extra.requestId);
-                throw new Error("slow tool cancelled");
-            }
-            const elapsedMs = Date.now() - startedAt;
-            const remainingMs = delayMs - elapsedMs;
-            await new Promise((resolve) => {
-                setTimeout(resolve, Math.max(0, Math.min(pollIntervalMs, remainingMs)));
-            });
-        }
-        if (extra.signal.aborted) {
-            cancelledRequestIds.add(extra.requestId);
-            throw new Error("slow tool cancelled");
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `slow complete after ${delayMs}ms`,
-                },
-            ],
-        };
-    });
-    return Object.assign(server, {
-        wasStarted: () => startedRequestIds.size > 0,
-        getStartedRequestIds: () => Array.from(startedRequestIds),
-        wasCancelled: () => cancelledRequestIds.size > 0,
-        getCancelledRequestIds: () => Array.from(cancelledRequestIds),
-    });
-}
-export async function createMockErrorServer() {
-    const [{ Server }, { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError: SdkMcpError },] = await Promise.all([
-        import("@modelcontextprotocol/sdk/server/index.js"),
-        import("@modelcontextprotocol/sdk/types.js"),
-    ]);
-    const server = new Server({ name: "mock-error-server", version: "1.0.0" }, { capabilities: { tools: {} } });
-    const tools = [
-        {
-            name: "invalid_params",
-            description: "Returns a JSON-RPC Invalid Params error.",
-            inputSchema: {
-                type: "object",
-                properties: {},
-                additionalProperties: false,
-            },
-        },
-        {
-            name: "is_error",
-            description: "Returns a tools/call result with isError: true.",
-            inputSchema: {
-                type: "object",
-                properties: {},
-                additionalProperties: false,
-            },
-        },
-        {
-            name: "internal_error",
-            description: "Throws an internal server error.",
-            inputSchema: {
-                type: "object",
-                properties: {},
-                additionalProperties: false,
-            },
-        },
-    ];
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools,
-    }));
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        if (request.params.name === "invalid_params") {
-            throw new SdkMcpError(ErrorCode.InvalidParams, "Intentional invalid params error from mock-error-server.");
-        }
-        if (request.params.name === "is_error") {
-            return {
-                isError: true,
-                content: [
-                    {
-                        type: "text",
-                        text: "Intentional isError tool failure.",
-                    },
-                ],
-            };
-        }
-        if (request.params.name === "internal_error") {
-            throw new Error("Intentional internal error from mock-error-server.");
-        }
-        throw new Error(`Unknown tool: ${request.params.name}`);
-    });
-    return server;
-}
-export async function createMockSamplingServer() {
-    const [{ Server }, { CallToolRequestSchema, ListToolsRequestSchema }] = await Promise.all([
-        import("@modelcontextprotocol/sdk/server/index.js"),
-        import("@modelcontextprotocol/sdk/types.js"),
-    ]);
-    const server = new Server({ name: "mock-sampling-server", version: "1.0.0" }, { capabilities: { tools: {} } });
-    const tool = {
-        name: "sample_message",
-        description: "Requests sampling/createMessage from the client and returns the sampled text.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                topic: {
-                    type: "string",
-                },
-            },
-            required: ["topic"],
-            additionalProperties: false,
-        },
-    };
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [tool],
-    }));
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        if (request.params.name !== "sample_message") {
-            throw new Error(`Unknown tool: ${request.params.name}`);
-        }
-        const topic = request.params.arguments?.topic;
-        if (typeof topic !== "string") {
-            throw new Error("sample_message requires a string topic argument");
-        }
-        const samplingResult = await server.createMessage({
-            messages: [
-                {
-                    role: "user",
-                    content: {
-                        type: "text",
-                        text: `Provide a concise sentence about ${topic}.`,
-                    },
-                },
-            ],
-            maxTokens: 64,
-            modelPreferences: {
-                hints: [{ name: "mock-sampling-model" }],
-                speedPriority: 0.2,
-                intelligencePriority: 0.9,
-            },
-            systemPrompt: "Return exactly one concise sentence.",
-        });
-        const sampledText = samplingResult.content.type === "text"
-            ? samplingResult.content.text
-            : JSON.stringify(samplingResult.content);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Sampled response: ${sampledText}`,
-                },
-            ],
-        };
-    });
-    return server;
-}
-export async function createMockRootsServer() {
-    const [{ Server }, { CallToolRequestSchema, ListToolsRequestSchema, RootsListChangedNotificationSchema, },] = await Promise.all([
-        import("@modelcontextprotocol/sdk/server/index.js"),
-        import("@modelcontextprotocol/sdk/types.js"),
-    ]);
-    const server = new Server({ name: "mock-roots-server", version: "1.0.0" }, { capabilities: { tools: {} } });
-    const tool = {
-        name: "roots_summary",
-        description: "Requests roots/list from the client and returns a summary of roots.",
-        inputSchema: {
-            type: "object",
-            properties: {},
-            additionalProperties: false,
-        },
-    };
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [tool],
-    }));
-    server.setNotificationHandler(RootsListChangedNotificationSchema, async () => {
-        await server.listRoots();
-    });
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        if (request.params.name !== "roots_summary") {
-            throw new Error(`Unknown tool: ${request.params.name}`);
-        }
-        const rootsResult = await server.listRoots();
-        const rootSummary = rootsResult.roots
-            .map((root) => (root.name === undefined ? root.uri : `${root.name} (${root.uri})`))
-            .join(", ");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: rootSummary.length === 0 ? "Roots: none" : `Roots: ${rootSummary}`,
-                },
-            ],
-        };
-    });
-    return server;
-}
-export async function createMockLoggingServer() {
-    const [{ Server }, { CallToolRequestSchema, ListToolsRequestSchema }] = await Promise.all([
-        import("@modelcontextprotocol/sdk/server/index.js"),
-        import("@modelcontextprotocol/sdk/types.js"),
-    ]);
-    const server = new Server({ name: "mock-logging-server", version: "1.0.0" }, { capabilities: { tools: {}, logging: {} } });
-    const tool = {
-        name: "emit_logs",
-        description: "Emits mock log messages at multiple levels.",
-        inputSchema: {
-            type: "object",
-            properties: {},
-            additionalProperties: false,
-        },
-    };
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [tool],
-    }));
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        if (request.params.name !== "emit_logs") {
-            throw new Error(`Unknown tool: ${request.params.name}`);
-        }
-        await server.sendLoggingMessage({
-            level: "debug",
-            logger: "mock-logging-server",
-            data: { message: "Debug message" },
-        });
-        await server.sendLoggingMessage({
-            level: "info",
-            logger: "mock-logging-server",
-            data: { message: "Info message" },
-        });
-        await server.sendLoggingMessage({
-            level: "error",
-            logger: "mock-logging-server",
-            data: { message: "Error message" },
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "Emitted log messages.",
-                },
-            ],
-        };
-    });
-    return server;
-}
-export async function createMockFullFeaturedServer() {
-    const [{ Server }, { CallToolRequestSchema, CompleteRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, },] = await Promise.all([
-        import("@modelcontextprotocol/sdk/server/index.js"),
-        import("@modelcontextprotocol/sdk/types.js"),
-    ]);
-    const server = new Server({ name: "mock-full-featured-server", version: "1.0.0" }, {
-        capabilities: {
-            tools: {},
-            resources: {},
-            prompts: {},
-            logging: {},
-            completions: {},
-        },
-    });
-    const tool = {
-        name: "full_featured_ping",
-        description: "Returns a text response and emits an info log.",
-        inputSchema: {
-            type: "object",
-            properties: {},
-            additionalProperties: false,
-        },
-    };
-    const resources = [
-        {
-            uri: "file:///full-featured.txt",
-            name: "full-featured.txt",
-            mimeType: "text/plain",
-        },
-    ];
-    const prompts = [
-        {
-            name: "full_featured_prompt",
-            description: "Returns a short prompt message for a topic.",
-            arguments: [
-                {
-                    name: "topic",
-                    description: "Topic to include in the prompt output.",
-                    required: false,
-                },
-            ],
-        },
-    ];
-    const completionValues = ["alpha", "beta", "gamma"];
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [tool],
-    }));
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        if (request.params.name !== "full_featured_ping") {
-            throw new Error(`Unknown tool: ${request.params.name}`);
-        }
-        await server.sendLoggingMessage({
-            level: "info",
-            logger: "mock-full-featured-server",
-            data: {
-                message: "full_featured_ping called",
-            },
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "full_featured_ping ok",
-                },
-            ],
-        };
-    });
-    server.setRequestHandler(ListResourcesRequestSchema, async () => ({
-        resources,
-    }));
-    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-        if (request.params.uri !== "file:///full-featured.txt") {
-            throw new Error(`Unknown resource: ${request.params.uri}`);
-        }
-        return {
-            contents: [
-                {
-                    uri: "file:///full-featured.txt",
-                    mimeType: "text/plain",
-                    text: "Mock full-featured resource",
-                },
-            ],
-        };
-    });
-    server.setRequestHandler(ListPromptsRequestSchema, async () => ({
-        prompts,
-    }));
-    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-        if (request.params.name !== "full_featured_prompt") {
-            throw new Error(`Unknown prompt: ${request.params.name}`);
-        }
-        const topic = request.params.arguments?.topic;
-        const topicText = typeof topic === "string" && topic.length > 0 ? topic : "general";
-        return {
-            description: "Mock prompt from full-featured server.",
-            messages: [
-                {
-                    role: "user",
-                    content: {
-                        type: "text",
-                        text: `Provide a short summary for ${topicText}.`,
-                    },
-                },
-            ],
-        };
-    });
-    server.setRequestHandler(CompleteRequestSchema, async (request) => {
-        if (request.params.ref.type !== "ref/prompt" ||
-            request.params.ref.name !== "full_featured_prompt" ||
-            request.params.argument.name !== "topic") {
-            return {
-                completion: {
-                    values: [],
-                },
-            };
-        }
-        const partialValue = request.params.argument.value.toLowerCase();
-        const values = completionValues.filter((value) => value.startsWith(partialValue));
-        return {
-            completion: {
-                values,
-            },
-        };
-    });
-    return server;
-}
-export async function createTestPair(server, createClient) {
-    const { clientTransport, serverTransport } = createInMemoryTransportPair();
-    const serverPromise = server.connect(serverTransport);
-    const client = createClient();
-    try {
-        await client.connect(clientTransport);
-    }
-    catch (error) {
-        clientTransport.dispose(new Error("tiny-stdio-mcp-server test pair setup failed"));
-        await serverPromise;
-        throw error;
-    }
-    const cleanup = async () => {
-        await client.close();
-        clientTransport.dispose(new Error("tiny-stdio-mcp-server test pair cleanup"));
-        await serverPromise;
-    };
-    return { client, cleanup };
-}
-function defaultStdioSpawn(command, args, options) {
-    return spawn(command, args, options);
-}
-function defaultHttpTransportFetch(input, init) {
-    return fetch(input, init);
-}
-export class StdioTransport {
-    readable;
-    writable;
-    closed;
-    child;
-    disposed = false;
-    stderrOutput = "";
-    static STDERR_MAX_LENGTH = 65_536;
-    constructor({ command, args = [], cwd, env, spawn: spawnProcess = defaultStdioSpawn, }) {
-        this.child = spawnProcess(command, args, {
-            cwd,
-            env,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        const child = this.child;
-        this.readable = child.stdout;
-        this.writable = child.stdin;
-        const stderrDecoder = new TextDecoder();
-        child.stderr.on("data", (chunk) => {
-            const decoded = chunk instanceof Uint8Array
-                ? stderrDecoder.decode(chunk, { stream: true })
-                : `${stderrDecoder.decode()}${String(chunk)}`;
-            this.appendStderrOutput(decoded);
-        });
-        child.stderr.once("end", () => {
-            this.appendStderrOutput(stderrDecoder.decode());
-        });
-        this.closed = new Promise((resolve) => {
-            let settled = false;
-            const resolveClosed = (event) => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                resolve(event);
-            };
-            child.once("exit", (code, signal) => {
-                const closedEvent = {
-                    reason: new Error("Stdio transport process exited"),
-                };
-                if (code !== null) {
-                    closedEvent.code = code;
-                }
-                if (signal !== null) {
-                    closedEvent.signal = signal;
-                }
-                resolveClosed(closedEvent);
-            });
-            child.once("error", (error) => {
-                const closedEvent = {
-                    reason: error instanceof Error ? error : new Error(String(error)),
-                };
-                if (child.exitCode !== null) {
-                    closedEvent.code = child.exitCode;
-                }
-                if (child.signalCode !== null) {
-                    closedEvent.signal = child.signalCode;
-                }
-                resolveClosed(closedEvent);
-            });
-        });
-    }
-    getStderrOutput() {
-        return this.stderrOutput;
-    }
-    appendStderrOutput(chunk) {
-        if (chunk.length === 0) {
-            return;
-        }
-        this.stderrOutput += chunk;
-        if (this.stderrOutput.length > StdioTransport.STDERR_MAX_LENGTH) {
-            this.stderrOutput = this.stderrOutput.slice(-StdioTransport.STDERR_MAX_LENGTH);
-        }
-    }
-    dispose(reason = new Error("Stdio transport disposed")) {
-        void reason;
-        if (this.disposed) {
-            return;
-        }
-        this.disposed = true;
-        if (!this.child.stdin.destroyed && !this.child.stdin.writableEnded) {
-            this.child.stdin.end();
-        }
-        if (this.child.exitCode === null && this.child.signalCode === null && !this.child.killed) {
-            this.child.kill("SIGTERM");
-        }
-    }
-}
-export class HttpTransport {
-    readable;
-    writable;
-    closed;
-    url;
-    headers;
-    fetchImpl;
-    readStream = new PassThrough();
-    writeStream = new PassThrough();
-    resolveClosed;
-    sessionId;
-    lastEventId;
-    getSseStreamStarted = false;
-    disposed = false;
-    oauthProvider;
-    oauthMetadataDiscovery;
-    inFlightFetchAbortControllers = new Set();
-    openSseReaders = new Set();
-    constructor({ url, headers = {}, fetch: fetchImpl = defaultHttpTransportFetch, oauth, oauthDiscoveryCache, }) {
-        this.url = url;
-        this.headers = headers;
-        this.fetchImpl = fetchImpl;
-        this.oauthProvider = oauth === undefined
-            ? undefined
-            : createOAuthClientProvider(oauth);
-        this.oauthMetadataDiscovery = oauth === undefined
-            ? undefined
-            : new OAuthMetadataDiscovery({
-                fetch: (input, init) => this.fetchWithAbort(input, init ?? {}),
-                cache: oauthDiscoveryCache,
-            });
-        this.readable = this.readStream;
-        this.writable = this.writeStream;
-        this.closed = new Promise((resolve) => {
-            this.resolveClosed = resolve;
-        });
-        this.readStream.once("error", (error) => {
-            this.dispose(error instanceof Error ? error : new Error(String(error)));
-        });
-        this.writeStream.once("error", (error) => {
-            this.dispose(error instanceof Error ? error : new Error(String(error)));
-        });
-        this.consumeWrittenLines().catch((error) => {
-            this.dispose(error instanceof Error ? error : new Error(String(error)));
-        });
-    }
-    dispose(reason = new Error("HTTP transport disposed")) {
-        if (this.disposed) {
-            return;
-        }
-        this.disposed = true;
-        this.abortInFlightFetches();
-        this.cancelOpenSseReaders();
-        if (!this.writeStream.destroyed && !this.writeStream.writableEnded) {
-            this.writeStream.end();
-        }
-        if (!this.readStream.destroyed && !this.readStream.writableEnded) {
-            this.readStream.end();
-        }
-        void this.closeWithSessionTermination(reason);
-    }
-    async closeWithSessionTermination(reason) {
-        let closeReason = reason;
-        if (this.sessionId !== undefined) {
-            const sessionId = this.sessionId;
-            this.sessionId = undefined;
-            try {
-                await this.sendSessionTerminationRequest(sessionId);
-            }
-            catch (error) {
-                closeReason = error instanceof Error ? error : new Error(String(error));
-            }
-        }
-        const resolveClosed = this.resolveClosed;
-        this.resolveClosed = undefined;
-        resolveClosed?.({ reason: closeReason });
-    }
-    abortInFlightFetches() {
-        for (const abortController of this.inFlightFetchAbortControllers) {
-            abortController.abort();
-        }
-        this.inFlightFetchAbortControllers.clear();
-    }
-    cancelOpenSseReaders() {
-        for (const reader of this.openSseReaders) {
-            void reader.cancel().catch(() => undefined);
-        }
-        this.openSseReaders.clear();
-    }
-    async fetchWithAbort(input, init) {
-        const abortController = new AbortController();
-        this.inFlightFetchAbortControllers.add(abortController);
-        try {
-            return await this.fetchImpl(input, {
-                ...init,
-                signal: abortController.signal,
-            });
-        }
-        finally {
-            this.inFlightFetchAbortControllers.delete(abortController);
-        }
-    }
-    async consumeWrittenLines() {
-        for await (const line of readLines(this.writeStream)) {
-            if (this.disposed || line.length === 0) {
-                continue;
-            }
-            const hasSessionId = this.sessionId !== undefined;
-            const response = await this.fetchWithOAuthRetry({
-                method: "POST",
-                createHeaders: () => this.createPostHeaders(),
-                body: line,
-            });
-            if (hasSessionId && response.status === 404) {
-                this.sessionId = undefined;
-                this.dispose(new Error("HTTP transport session expired (404 response)"));
-                return;
-            }
-            await this.throwForPostHttpError(response);
-            this.captureSessionId(response);
-            this.maybeOpenGetSseStream();
-            void this.forwardResponseMessages(response).catch((error) => {
-                this.dispose(error instanceof Error ? error : new Error(String(error)));
-            });
-        }
-    }
-    async createPostHeaders() {
-        const headers = new Headers(this.headers);
-        headers.set("Accept", "application/json, text/event-stream");
-        headers.set("Content-Type", "application/json");
-        if (this.sessionId !== undefined) {
-            headers.set("Mcp-Session-Id", this.sessionId);
-            headers.set("MCP-Protocol-Version", MCP_PROTOCOL_VERSION);
-        }
-        return this.authorizeRequestHeaders(headers);
-    }
-    async createGetHeaders() {
-        const headers = new Headers(this.headers);
-        headers.set("Accept", "text/event-stream");
-        if (this.sessionId !== undefined) {
-            headers.set("Mcp-Session-Id", this.sessionId);
-            headers.set("MCP-Protocol-Version", MCP_PROTOCOL_VERSION);
-        }
-        if (this.lastEventId !== undefined) {
-            headers.set("Last-Event-ID", this.lastEventId);
-        }
-        return this.authorizeRequestHeaders(headers);
-    }
-    async createDeleteHeaders(sessionId) {
-        const headers = new Headers(this.headers);
-        headers.set("Mcp-Session-Id", sessionId);
-        headers.set("MCP-Protocol-Version", MCP_PROTOCOL_VERSION);
-        return this.authorizeRequestHeaders(headers);
-    }
-    async authorizeRequestHeaders(headers) {
-        await this.oauthProvider?.authorizeRequest?.({
-            requestUrl: new URL(this.url),
-            headers,
-            fetch: this.fetchImpl,
-        });
-        return headers;
-    }
-    captureSessionId(response) {
-        const sessionId = response.headers.get("Mcp-Session-Id");
-        if (sessionId === null || sessionId.length === 0) {
-            return;
-        }
-        if (this.sessionId !== undefined && this.sessionId !== sessionId) {
-            throw new Error("HTTP transport response changed active session ID");
-        }
-        this.sessionId = sessionId;
-    }
-    maybeOpenGetSseStream() {
-        if (this.disposed || this.sessionId === undefined || this.getSseStreamStarted) {
-            return;
-        }
-        this.getSseStreamStarted = true;
-        this.consumeGetSseStream().catch((error) => {
-            if (error instanceof HttpTransportGetSseNotSupportedError || this.disposed) {
-                return;
-            }
-            this.dispose(error instanceof Error ? error : new Error(String(error)));
-        });
-    }
-    async sendSessionTerminationRequest(sessionId) {
-        const response = await this.fetchImpl(this.url, {
-            method: "DELETE",
-            headers: await this.createDeleteHeaders(sessionId),
-        });
-        if (response.status === 405 || response.ok) {
-            return;
-        }
-        const responseBody = (await response.text()).trim();
-        const statusDescriptor = `${response.status} ${response.statusText}`.trim();
-        const message = responseBody.length === 0
-            ? `HTTP transport DELETE failed (${statusDescriptor})`
-            : `HTTP transport DELETE failed (${statusDescriptor}): ${responseBody}`;
-        throw new Error(message);
-    }
-    async consumeGetSseStream() {
-        const response = await this.fetchWithOAuthRetry({
-            method: "GET",
-            createHeaders: () => this.createGetHeaders(),
-        });
-        if (response.status === 405) {
-            throw new HttpTransportGetSseNotSupportedError();
-        }
-        if (response.status === 404) {
-            this.sessionId = undefined;
-            throw new Error("HTTP transport session expired (GET 404 response)");
-        }
-        if (!response.ok) {
-            const responseBody = (await response.text()).trim();
-            const statusDescriptor = `${response.status} ${response.statusText}`.trim();
-            const message = responseBody.length === 0
-                ? `HTTP transport GET failed (${statusDescriptor})`
-                : `HTTP transport GET failed (${statusDescriptor}): ${responseBody}`;
-            throw new Error(message);
-        }
-        const contentType = response.headers.get("Content-Type");
-        if (contentType === null) {
-            return;
-        }
-        if (contentType.toLowerCase().includes("text/event-stream")) {
-            await this.forwardSseResponseMessages(response);
-            this.getSseStreamStarted = false;
-            if (!this.disposed && this.sessionId !== undefined && this.lastEventId !== undefined) {
-                this.maybeOpenGetSseStream();
-            }
-            return;
-        }
-        return;
-    }
-    async throwForPostHttpError(response) {
-        if (response.status < 400) {
-            return;
-        }
-        const responseBody = (await response.text()).trim();
-        const statusDescriptor = `${response.status} ${response.statusText}`.trim();
-        const message = responseBody.length === 0
-            ? `HTTP transport POST failed (${statusDescriptor})`
-            : `HTTP transport POST failed (${statusDescriptor}): ${responseBody}`;
-        throw new Error(message);
-    }
-    async maybeHandleUnauthorizedResponse(response) {
-        if (response.status !== 401 || this.oauthProvider === undefined) {
-            return false;
-        }
-        const discoveryClient = this.oauthMetadataDiscovery;
-        if (discoveryClient === undefined) {
-            return false;
-        }
-        const challenge = parseBearerWwwAuthenticateHeader(response.headers.get("WWW-Authenticate"));
-        const resourceMetadataUrl = challenge?.params.resource_metadata;
-        const discovery = await discoveryClient.discover(this.url, {
-            resourceMetadataUrl,
-        });
-        const result = await this.oauthProvider.handleUnauthorized({
-            requestUrl: new URL(this.url),
-            response: response.clone(),
-            challenge,
-            discovery,
-            fetch: this.fetchImpl,
-        });
-        if (result.action === "retry") {
-            return true;
-        }
-        if (result.error !== undefined) {
-            throw result.error;
-        }
-        return false;
-    }
-    async forwardResponseMessages(response) {
-        if (response.status === 202) {
-            return;
-        }
-        const contentType = response.headers.get("Content-Type");
-        if (contentType === null) {
-            return;
-        }
-        const normalizedContentType = contentType.toLowerCase();
-        if (normalizedContentType.includes("text/event-stream")) {
-            await this.forwardSseResponseMessages(response);
-            return;
-        }
-        if (normalizedContentType.includes("application/json")) {
-            await this.forwardJsonResponseMessage(response);
-            return;
-        }
-        throw new Error("HTTP transport POST returned an unsupported response content type");
-    }
-    async forwardSseResponseMessages(response) {
-        if (response.body === null) {
-            return;
-        }
-        const parser = new SseParser();
-        const decoder = new TextDecoder();
-        const reader = response.body.getReader();
-        this.openSseReaders.add(reader);
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    break;
-                }
-                if (value === undefined) {
-                    continue;
-                }
-                const messages = parser.push(decoder.decode(value, { stream: true }));
-                this.writeSseMessages(messages);
-                this.lastEventId = parser.lastEventId;
-            }
-            const trailingChunk = decoder.decode();
-            if (trailingChunk.length > 0) {
-                this.writeSseMessages(parser.push(trailingChunk));
-                this.lastEventId = parser.lastEventId;
-            }
-            this.writeSseMessages(parser.flush());
-            this.lastEventId = parser.lastEventId;
-        }
-        finally {
-            this.openSseReaders.delete(reader);
-            reader.releaseLock();
-        }
-    }
-    async forwardJsonResponseMessage(response) {
-        const payload = await response.text();
-        if (payload.length === 0) {
-            return;
-        }
-        const parsedPayload = JSON.parse(payload);
-        this.writeReadableLine(JSON.stringify(parsedPayload));
-    }
-    writeSseMessages(messages) {
-        for (const message of messages) {
-            this.writeReadableLine(message.data);
-        }
-    }
-    writeReadableLine(line) {
-        if (this.disposed || this.readStream.destroyed || this.readStream.writableEnded) {
-            return;
-        }
-        this.readStream.write(`${line}\n`);
-    }
-    async fetchWithOAuthRetry(input) {
-        const request = async () => this.fetchWithAbort(this.url, {
-            method: input.method,
-            headers: await input.createHeaders(),
-            body: input.body,
-        });
-        let response = await request();
-        if (await this.maybeHandleUnauthorizedResponse(response)) {
-            response = await request();
-        }
-        const oauthError = this.oauthProvider === undefined
-            ? null
-            : this.readOAuthChallengeError(response);
-        if (oauthError !== null) {
-            throw oauthError;
-        }
-        return response;
-    }
-    readOAuthChallengeError(response) {
-        if (response.status !== 401 && response.status !== 403) {
-            return null;
-        }
-        const challenge = parseBearerWwwAuthenticateHeader(response.headers.get("WWW-Authenticate"));
-        const error = challenge?.params.error;
-        if (error === undefined || error.length === 0) {
-            return null;
-        }
-        return new OAuthError({
-            error,
-            error_description: challenge?.params.error_description,
-            error_uri: challenge?.params.error_uri,
-        }, response.status);
-    }
-}
-class HttpTransportGetSseNotSupportedError extends Error {
-    constructor() {
-        super("HTTP transport server does not support GET SSE streams");
-    }
-}
-export class McpError extends Error {
-    code;
-    constructor(code, message, data) {
-        super(message);
-        this.name = "McpError";
-        this.code = code;
-        if (data !== undefined) {
-            this.data = data;
-        }
-    }
-}
-export function serializeJsonRpcMessage(message) {
-    return `${JSON.stringify(message)}\n`;
-}
-function normalizeLine(line) {
-    return line.endsWith("\r") ? line.slice(0, -1) : line;
-}
-export async function* readLines(stream) {
-    let buffer = "";
-    const decoder = new TextDecoder();
-    for await (const chunk of stream) {
-        buffer +=
-            chunk instanceof Uint8Array
-                ? decoder.decode(chunk, { stream: true })
-                : decoder.decode() + String(chunk);
-        while (true) {
-            const newlineIndex = buffer.indexOf("\n");
-            if (newlineIndex === -1) {
-                break;
-            }
-            const line = buffer.slice(0, newlineIndex);
-            buffer = buffer.slice(newlineIndex + 1);
-            yield normalizeLine(line);
-        }
-    }
-    buffer += decoder.decode();
-    if (buffer.length > 0) {
-        yield normalizeLine(buffer);
-    }
-}
-export class SseParser {
-    buffer = "";
-    eventType;
-    dataLines = [];
-    eventId = "";
-    hasEventId = false;
-    _lastEventId;
-    get lastEventId() {
-        return this._lastEventId;
-    }
-    push(chunk) {
-        if (chunk.length === 0) {
-            return [];
-        }
-        this.buffer += chunk;
-        const messages = [];
-        while (true) {
-            const newlineIndex = this.buffer.indexOf("\n");
-            if (newlineIndex === -1) {
-                break;
-            }
-            const line = normalizeLine(this.buffer.slice(0, newlineIndex));
-            this.buffer = this.buffer.slice(newlineIndex + 1);
-            this.consumeLine(line, messages);
-        }
-        return messages;
-    }
-    flush() {
-        const messages = [];
-        if (this.buffer.length > 0) {
-            this.consumeLine(normalizeLine(this.buffer), messages);
-            this.buffer = "";
-        }
-        this.emitEvent(messages);
-        return messages;
-    }
-    consumeLine(line, messages) {
-        if (line.length === 0) {
-            this.emitEvent(messages);
-            return;
-        }
-        if (line.startsWith(":")) {
-            return;
-        }
-        const separatorIndex = line.indexOf(":");
-        const field = separatorIndex === -1 ? line : line.slice(0, separatorIndex);
-        const rawValue = separatorIndex === -1 ? "" : line.slice(separatorIndex + 1);
-        const value = rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue;
-        if (field === "event") {
-            this.eventType = value;
-            return;
-        }
-        if (field === "data") {
-            this.dataLines.push(value);
-            return;
-        }
-        if (field === "id") {
-            if (value.includes("\0")) {
-                return;
-            }
-            this.eventId = value;
-            this.hasEventId = true;
-        }
-    }
-    emitEvent(messages) {
-        const eventType = this.eventType ?? "message";
-        if (this.hasEventId) {
-            this._lastEventId = this.eventId;
-        }
-        if (this.dataLines.length === 0 || eventType !== "message") {
-            this.resetEvent();
-            return;
-        }
-        const message = {
-            data: this.dataLines.join("\n"),
-        };
-        if (this.hasEventId) {
-            message.id = this.eventId;
-        }
-        messages.push(message);
-        this.resetEvent();
-    }
-    resetEvent() {
-        this.eventType = undefined;
-        this.dataLines = [];
-        this.eventId = "";
-        this.hasEventId = false;
-    }
-}
-export class JsonRpcMessageLayer {
-    requestTimeoutMs;
-    input;
-    output;
-    inputClosedReason;
-    nextRequestId = 1;
-    disposedError;
-    pendingRequests = new Map();
-    activeIncomingRequests = new Map();
-    requestHandlers = new Map();
-    notificationHandlers = new Map();
-    constructor(input, output, requestTimeoutMs = 30_000, inputClosedReason) {
-        if (!Number.isFinite(requestTimeoutMs) || requestTimeoutMs < 0) {
-            throw new Error("requestTimeoutMs must be a non-negative finite number");
-        }
-        this.input = input;
-        this.output = output;
-        this.inputClosedReason = inputClosedReason;
-        this.requestTimeoutMs = requestTimeoutMs;
-        this.consumeInput().catch(() => undefined);
-    }
-    sendNotification(method, params) {
-        if (this.disposedError !== undefined) {
-            throw this.disposedError;
-        }
-        const message = {
-            jsonrpc: "2.0",
-            method,
-        };
-        if (params !== undefined) {
-            message.params = params;
-        }
-        this.output.write(serializeJsonRpcMessage(message));
-    }
-    onRequest(method, handler) {
-        this.requestHandlers.set(method, handler);
-    }
-    onNotification(method, handler) {
-        this.notificationHandlers.set(method, handler);
-    }
-    sendRequest(method, params, options = {}) {
-        if (this.disposedError !== undefined) {
-            throw this.disposedError;
-        }
-        const id = this.nextRequestId;
-        this.nextRequestId += 1;
-        const timeoutMs = options.timeoutMs ?? this.requestTimeoutMs;
-        if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
-            throw new Error("timeoutMs must be a non-negative finite number");
-        }
-        if (options.onRequestId !== undefined) {
-            options.onRequestId(id);
-        }
-        const message = {
-            jsonrpc: "2.0",
-            id,
-            method,
-        };
-        if (params !== undefined) {
-            message.params = params;
-        }
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                this.pendingRequests.delete(id);
-                options.onTimeout?.(id);
-                reject(new Error(`JSON-RPC request "${method}" timed out after ${timeoutMs}ms`));
-            }, timeoutMs);
-            this.pendingRequests.set(id, { resolve, reject, timeout });
-            try {
-                this.output.write(serializeJsonRpcMessage(message));
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                this.pendingRequests.delete(id);
-                reject(error);
-            }
-        });
-    }
-    cancelRequest(requestId, reason) {
-        const pending = this.pendingRequests.get(requestId);
-        if (pending === undefined) {
-            return false;
-        }
-        this.pendingRequests.delete(requestId);
-        clearTimeout(pending.timeout);
-        pending.reject(reason);
-        return true;
-    }
-    dispose(reason = new Error("JSON-RPC message layer disposed")) {
-        if (this.disposedError !== undefined) {
-            return;
-        }
-        this.disposedError = reason;
-        for (const pending of this.pendingRequests.values()) {
-            clearTimeout(pending.timeout);
-            pending.reject(reason);
-        }
-        this.pendingRequests.clear();
-        this.activeIncomingRequests.clear();
-    }
-    async consumeInput() {
-        try {
-            for await (const line of readLines(this.input)) {
-                if (this.disposedError !== undefined) {
-                    break;
-                }
-                if (line.length === 0) {
-                    continue;
-                }
-                let parsedLine;
-                try {
-                    parsedLine = JSON.parse(line);
-                }
-                catch {
-                    await this.processParsedMessage({
-                        type: "invalid",
-                        id: null,
-                        error: parseError(),
-                    });
-                    continue;
-                }
-                if (Array.isArray(parsedLine)) {
-                    for (const message of parsedLine) {
-                        if (this.disposedError !== undefined) {
-                            break;
-                        }
-                        await this.processParsedMessage(parseJsonRpcPayload(message));
-                    }
-                    continue;
-                }
-                await this.processParsedMessage(parseJsonRpcPayload(parsedLine));
-            }
-        }
-        catch (error) {
-            if (this.disposedError === undefined) {
-                this.dispose(error instanceof Error
-                    ? error
-                    : new Error(`JSON-RPC input stream failed: ${String(error)}`));
-            }
-            return;
-        }
-        if (this.disposedError === undefined) {
-            const streamClosedReason = await this.resolveInputStreamClosedReason();
-            if (this.disposedError === undefined) {
-                this.dispose(streamClosedReason);
-            }
-        }
-    }
-    async resolveInputStreamClosedReason() {
-        const streamClosedError = new Error("JSON-RPC input stream closed");
-        if (this.inputClosedReason === undefined) {
-            return streamClosedError;
-        }
-        try {
-            return await Promise.race([
-                this.inputClosedReason,
-                new Promise((resolve) => {
-                    setTimeout(() => {
-                        resolve(streamClosedError);
-                    }, 50);
-                }),
-            ]);
-        }
-        catch {
-            return streamClosedError;
-        }
-    }
-    async processParsedMessage(parsed) {
-        if (parsed.type === "request") {
-            const handler = this.requestHandlers.get(parsed.message.method);
-            if (handler === undefined) {
-                this.output.write(serializeJsonRpcMessage({
-                    jsonrpc: "2.0",
-                    id: parsed.message.id,
-                    error: {
-                        code: ERROR_METHOD_NOT_FOUND,
-                        message: `Method not found: ${parsed.message.method}`,
-                    },
-                }));
-                return;
-            }
-            this.handleIncomingRequest(parsed.message, handler);
-            return;
-        }
-        if (parsed.type === "notification") {
-            if (parsed.message.method === "notifications/cancelled") {
-                this.handleCancellationNotification(parsed.message.params);
-            }
-            const handler = this.notificationHandlers.get(parsed.message.method);
-            if (handler === undefined) {
-                return;
-            }
-            try {
-                await handler(parsed.message.params, {
-                    method: parsed.message.method,
-                });
-            }
-            catch {
-                return;
-            }
-            return;
-        }
-        if (parsed.type === "invalid") {
-            const errorResponse = {
-                jsonrpc: "2.0",
-                id: parsed.id,
-                error: {
-                    code: parsed.error.code,
-                    message: parsed.error.message,
-                },
-            };
-            if (parsed.error.data !== undefined) {
-                errorResponse.error.data = parsed.error.data;
-            }
-            this.output.write(`${JSON.stringify(errorResponse)}\n`);
-            return;
-        }
-        if (parsed.type !== "response") {
-            return;
-        }
-        const pending = this.pendingRequests.get(parsed.message.id);
-        if (pending === undefined) {
-            return;
-        }
-        this.pendingRequests.delete(parsed.message.id);
-        clearTimeout(pending.timeout);
-        if ("result" in parsed.message) {
-            pending.resolve(parsed.message.result);
-            return;
-        }
-        pending.reject(new McpError(parsed.message.error.code, parsed.message.error.message, parsed.message.error.data));
-    }
-    handleIncomingRequest(message, handler) {
-        const activeRequest = {
-            cancelled: false,
-        };
-        this.activeIncomingRequests.set(message.id, activeRequest);
-        void (async () => {
-            try {
-                const result = await handler(message.params, {
-                    id: message.id,
-                    method: message.method,
-                });
-                if (this.disposedError !== undefined || activeRequest.cancelled) {
-                    return;
-                }
-                this.output.write(serializeJsonRpcMessage({
-                    jsonrpc: "2.0",
-                    id: message.id,
-                    result,
-                }));
-            }
-            catch (error) {
-                if (this.disposedError !== undefined || activeRequest.cancelled) {
-                    return;
-                }
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                this.output.write(serializeJsonRpcMessage({
-                    jsonrpc: "2.0",
-                    id: message.id,
-                    error: {
-                        code: ERROR_INTERNAL,
-                        message: errorMessage,
-                    },
-                }));
-            }
-            finally {
-                const inFlightRequest = this.activeIncomingRequests.get(message.id);
-                if (inFlightRequest === activeRequest) {
-                    this.activeIncomingRequests.delete(message.id);
-                }
-            }
-        })();
-    }
-    handleCancellationNotification(params) {
-        if (!isObjectRecord(params)) {
-            return;
-        }
-        const requestId = params.requestId;
-        if (!isRequestId(requestId)) {
-            return;
-        }
-        const activeRequest = this.activeIncomingRequests.get(requestId);
-        if (activeRequest === undefined) {
-            return;
-        }
-        activeRequest.cancelled = true;
-        this.activeIncomingRequests.delete(requestId);
-    }
-}
-function isObjectRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isInitializeResult(value) {
-    if (!isObjectRecord(value) || typeof value.protocolVersion !== "string") {
-        return false;
-    }
-    if (!isServerCapabilities(value.capabilities)) {
-        return false;
-    }
-    if (!isObjectRecord(value.serverInfo)
-        || typeof value.serverInfo.name !== "string"
-        || value.serverInfo.name.length === 0
-        || typeof value.serverInfo.version !== "string"
-        || value.serverInfo.version.length === 0) {
-        return false;
-    }
-    return value.instructions === undefined || typeof value.instructions === "string";
-}
-function isServerCapabilities(value) {
-    if (!isObjectRecord(value)) {
-        return false;
-    }
-    for (const capability of ["prompts", "resources", "tools", "logging", "completions", "experimental"]) {
-        if (value[capability] !== undefined && !isObjectRecord(value[capability])) {
-            return false;
-        }
-    }
-    return true;
-}
-function isCallToolResult(value) {
-    if (!isObjectRecord(value) || !Array.isArray(value.content)) {
-        return false;
-    }
-    if (value.structuredContent !== undefined && !isObjectRecord(value.structuredContent)) {
-        return false;
-    }
-    if (value.isError !== undefined && typeof value.isError !== "boolean") {
-        return false;
-    }
-    return value.content.every(isContentItem);
-}
-function isToolsListResult(value) {
-    return isObjectRecord(value)
-        && Array.isArray(value.tools)
-        && (value.nextCursor === undefined || typeof value.nextCursor === "string");
-}
-function isResourcesListResult(value) {
-    return isObjectRecord(value)
-        && Array.isArray(value.resources)
-        && value.resources.every(isResource)
-        && (value.nextCursor === undefined || typeof value.nextCursor === "string");
-}
-function isResourceTemplatesListResult(value) {
-    return isObjectRecord(value)
-        && Array.isArray(value.resourceTemplates)
-        && value.resourceTemplates.every(isResourceTemplate)
-        && (value.nextCursor === undefined || typeof value.nextCursor === "string");
-}
-function isReadResourceResult(value) {
-    return isObjectRecord(value)
-        && Array.isArray(value.contents)
-        && value.contents.every(isResourceContents);
-}
-function isGetPromptResult(value) {
-    return isObjectRecord(value)
-        && (value.description === undefined || typeof value.description === "string")
-        && Array.isArray(value.messages)
-        && value.messages.every(isPromptMessage);
-}
-function isCompleteResult(value) {
-    return isObjectRecord(value)
-        && isObjectRecord(value.completion)
-        && Array.isArray(value.completion.values)
-        && value.completion.values.every((candidate) => typeof candidate === "string")
-        && (value.completion.hasMore === undefined || typeof value.completion.hasMore === "boolean")
-        && (value.completion.total === undefined || typeof value.completion.total === "number");
-}
-function isResource(value) {
-    return isObjectRecord(value)
-        && typeof value.uri === "string"
-        && typeof value.name === "string"
-        && (value.description === undefined || typeof value.description === "string")
-        && (value.mimeType === undefined || typeof value.mimeType === "string")
-        && (value.size === undefined || typeof value.size === "number");
-}
-function isResourceTemplate(value) {
-    return isObjectRecord(value)
-        && typeof value.uriTemplate === "string"
-        && typeof value.name === "string"
-        && (value.description === undefined || typeof value.description === "string")
-        && (value.mimeType === undefined || typeof value.mimeType === "string");
-}
-function isResourceContents(value) {
-    if (!isObjectRecord(value) || typeof value.uri !== "string") {
-        return false;
-    }
-    if (value.mimeType !== undefined && typeof value.mimeType !== "string") {
-        return false;
-    }
-    const hasText = value.text !== undefined;
-    const hasBlob = value.blob !== undefined;
-    if (!hasText && !hasBlob) {
-        return false;
-    }
-    return (!hasText || typeof value.text === "string")
-        && (!hasBlob || typeof value.blob === "string");
-}
-function isPromptMessage(value) {
-    return isObjectRecord(value)
-        && (value.role === "user" || value.role === "assistant")
-        && isContentItem(value.content);
-}
-function isContentItem(value) {
-    if (!isObjectRecord(value)) {
-        return false;
-    }
-    if (value.type === "text") {
-        return typeof value.text === "string";
-    }
-    if (value.type === "image" || value.type === "audio") {
-        return typeof value.data === "string" && typeof value.mimeType === "string";
-    }
-    if (value.type !== "resource" || !isObjectRecord(value.resource)) {
-        return false;
-    }
-    return isResourceContents(value.resource);
-}
-function hasOwn(value, property) {
-    return Object.prototype.hasOwnProperty.call(value, property);
-}
-function isRequestId(value) {
-    return typeof value === "string" || typeof value === "number";
-}
-function isLogLevel(value) {
-    return (value === "debug" ||
-        value === "info" ||
-        value === "notice" ||
-        value === "warning" ||
-        value === "error" ||
-        value === "critical" ||
-        value === "alert" ||
-        value === "emergency");
-}
-function toRequestId(value) {
-    return isRequestId(value) ? value : null;
-}
-function parseError() {
-    return new McpError(ERROR_PARSE, "Parse error");
-}
-function invalidRequest() {
-    return new McpError(ERROR_INVALID_REQUEST, "Invalid Request");
-}
-function isJsonRpcErrorObject(value) {
-    if (!isObjectRecord(value)) {
-        return false;
-    }
-    if (typeof value.code !== "number" || typeof value.message !== "string") {
-        return false;
-    }
-    return value.data === undefined || hasOwn(value, "data");
-}
-export function parseJsonRpcMessage(line) {
-    let parsed;
-    try {
-        parsed = JSON.parse(line);
-    }
-    catch {
-        return {
-            type: "invalid",
-            id: null,
-            error: parseError(),
-        };
-    }
-    return parseJsonRpcPayload(parsed);
-}
-function parseJsonRpcPayload(parsed) {
-    if (!isObjectRecord(parsed)) {
-        return {
-            type: "invalid",
-            id: null,
-            error: invalidRequest(),
-        };
-    }
-    const id = toRequestId(parsed.id);
-    if (parsed.jsonrpc !== "2.0") {
-        return {
-            type: "invalid",
-            id,
-            error: invalidRequest(),
-        };
-    }
-    const hasMethod = hasOwn(parsed, "method");
-    const hasId = hasOwn(parsed, "id");
-    if (hasMethod) {
-        if (typeof parsed.method !== "string") {
-            return {
-                type: "invalid",
-                id,
-                error: invalidRequest(),
-            };
-        }
-        if (hasId) {
-            if (!isRequestId(parsed.id)) {
-                return {
-                    type: "invalid",
-                    id: null,
-                    error: invalidRequest(),
-                };
-            }
-            const request = {
-                jsonrpc: "2.0",
-                id: parsed.id,
-                method: parsed.method,
-            };
-            if (hasOwn(parsed, "params")) {
-                request.params = parsed.params;
-            }
-            return {
-                type: "request",
-                message: request,
-            };
-        }
-        const notification = {
-            jsonrpc: "2.0",
-            method: parsed.method,
-        };
-        if (hasOwn(parsed, "params")) {
-            notification.params = parsed.params;
-        }
-        return {
-            type: "notification",
-            message: notification,
-        };
-    }
-    if (!hasId || !isRequestId(parsed.id)) {
-        return {
-            type: "invalid",
-            id,
-            error: invalidRequest(),
-        };
-    }
-    const hasResult = hasOwn(parsed, "result");
-    const hasError = hasOwn(parsed, "error");
-    if (hasResult === hasError) {
-        return {
-            type: "invalid",
-            id: parsed.id,
-            error: invalidRequest(),
-        };
-    }
-    if (hasResult) {
-        return {
-            type: "response",
-            message: {
-                jsonrpc: "2.0",
-                id: parsed.id,
-                result: parsed.result,
-            },
-        };
-    }
-    if (!isJsonRpcErrorObject(parsed.error)) {
-        return {
-            type: "invalid",
-            id: parsed.id,
-            error: invalidRequest(),
-        };
-    }
-    return {
-        type: "response",
-        message: {
-            jsonrpc: "2.0",
-            id: parsed.id,
-            error: parsed.error,
-        },
-    };
-}