toolcraft 0.0.5 → 0.0.7

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

@@ -0,0 +1,2404 @@
+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;
+    currentServerInfo = null;
+    currentInstructions;
+    options;
+    transport = null;
+    messageLayer = null;
+    constructor(options) {
+        this.options = options;
+    }
+    get state() {
+        return this.currentState;
+    }
+    get serverCapabilities() {
+        return 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");
+        }
+        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, 30_000, 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));
+        }
+        if (onRootsList !== undefined) {
+            messageLayer.onRequest("roots/list", async () => ({
+                roots: await onRootsList(),
+            }));
+        }
+        messageLayer.onNotification("notifications/tools/list_changed", async () => {
+            if (onToolsChanged === undefined) {
+                return;
+            }
+            await onToolsChanged();
+        });
+        messageLayer.onNotification("notifications/resources/list_changed", async () => {
+            if (onResourcesChanged === undefined) {
+                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") {
+                return;
+            }
+            await onResourceUpdated(uri);
+        });
+        messageLayer.onNotification("notifications/prompts/list_changed", async () => {
+            if (onPromptsChanged === undefined) {
+                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") {
+                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";
+        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 ?? {}),
+            };
+        }
+        const initializeResult = (await messageLayer.sendRequest("initialize", {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            clientInfo: this.options.clientInfo,
+            capabilities,
+        }));
+        if (initializeResult.protocolVersion !== MCP_PROTOCOL_VERSION) {
+            throw new McpError(ERROR_INVALID_REQUEST, `Unsupported protocol version: ${initializeResult.protocolVersion}`);
+        }
+        this.currentServerCapabilities = initializeResult.capabilities;
+        this.currentServerInfo = initializeResult.serverInfo;
+        this.currentInstructions = initializeResult.instructions;
+        messageLayer.sendNotification("notifications/initialized");
+        this.currentState = "ready";
+        return initializeResult;
+    }
+    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 };
+        return (await messageLayer.sendRequest("tools/list", requestParams));
+    }
+    async callTool(params, options = {}) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.tools === undefined) {
+            throw new Error("Server does not support tools");
+        }
+        const requestParams = options.progressToken === undefined
+            ? params
+            : {
+                ...params,
+                _meta: {
+                    progressToken: options.progressToken,
+                },
+            };
+        let requestId;
+        const requestPromise = messageLayer.sendRequest("tools/call", requestParams, {
+            onRequestId: (nextRequestId) => {
+                requestId = nextRequestId;
+            },
+        });
+        if (options.signal === undefined) {
+            return await requestPromise;
+        }
+        const signal = options.signal;
+        let abortListener;
+        const abortPromise = new Promise((_, reject) => {
+            const rejectWithAbortReason = () => {
+                if (requestId !== undefined) {
+                    messageLayer.sendNotification("notifications/cancelled", { requestId });
+                }
+                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);
+            }
+        }
+    }
+    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 };
+        return (await messageLayer.sendRequest("resources/list", requestParams));
+    }
+    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 };
+        return (await messageLayer.sendRequest("resources/templates/list", requestParams));
+    }
+    async readResource(params) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.resources === undefined) {
+            throw new Error("Server does not support resources");
+        }
+        return (await messageLayer.sendRequest("resources/read", params));
+    }
+    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 });
+    }
+    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 });
+    }
+    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");
+        }
+        return (await messageLayer.sendRequest("prompts/get", params));
+    }
+    async complete(params) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.completions === undefined) {
+            throw new Error("Server does not support completions");
+        }
+        return (await messageLayer.sendRequest("completion/complete", params));
+    }
+    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();
+        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.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;
+        child.stderr.on("data", (chunk) => {
+            this.stderrOutput += chunkToString(chunk);
+            if (this.stderrOutput.length > StdioTransport.STDERR_MAX_LENGTH) {
+                this.stderrOutput = this.stderrOutput.slice(-StdioTransport.STDERR_MAX_LENGTH);
+            }
+        });
+        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;
+    }
+    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();
+        this.terminateSession();
+        if (!this.writeStream.destroyed && !this.writeStream.writableEnded) {
+            this.writeStream.end();
+        }
+        if (!this.readStream.destroyed && !this.readStream.writableEnded) {
+            this.readStream.end();
+        }
+        const resolveClosed = this.resolveClosed;
+        this.resolveClosed = undefined;
+        resolveClosed?.({ reason });
+    }
+    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();
+            await this.forwardResponseMessages(response);
+        }
+    }
+    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);
+        }
+        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);
+        }
+        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);
+        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;
+        }
+        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)));
+        });
+    }
+    terminateSession() {
+        if (this.sessionId === undefined) {
+            return;
+        }
+        const sessionId = this.sessionId;
+        this.sessionId = undefined;
+        this.sendSessionTerminationRequest(sessionId).catch(() => undefined);
+    }
+    async sendSessionTerminationRequest(sessionId) {
+        const response = await this.fetchImpl(this.url, {
+            method: "DELETE",
+            headers: await this.createDeleteHeaders(sessionId),
+        });
+        if (response.status === 405) {
+            return;
+        }
+    }
+    async consumeGetSseStream() {
+        const response = await this.fetchWithOAuthRetry({
+            method: "GET",
+            createHeaders: () => this.createGetHeaders(),
+        });
+        if (response.status === 405) {
+            throw new HttpTransportGetSseNotSupportedError();
+        }
+        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();
+            }
+        }
+    }
+    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);
+        }
+    }
+    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 chunkToString(chunk) {
+    if (typeof chunk === "string") {
+        return chunk;
+    }
+    if (chunk instanceof Uint8Array) {
+        return Buffer.from(chunk).toString("utf8");
+    }
+    return String(chunk);
+}
+function normalizeLine(line) {
+    return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+export async function* readLines(stream) {
+    let buffer = "";
+    for await (const chunk of stream) {
+        buffer += chunkToString(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);
+        }
+    }
+    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);
+                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);
+            }
+        });
+    }
+    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 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,
+        },
+    };
+}