toolcraft 0.0.409 → 0.0.411

package/node_modules/tiny-stdio-mcp-server/dist/server.js

@@ -1,1147 +1,7 @@
-import * as readline from "readline";
-import { compileJsonSchema, formatIssues, normalizeLegacyNullability } from "toolcraft-schema";
-import { JSON_RPC_ERROR_CODES, ToolError } from "./types.js";
-import { parseMessage, formatSuccessResponse, formatErrorResponse, isRequestId } from "./jsonrpc.js";
-import { parseUriTemplate } from "./uri-template.js";
-import { toContentBlocks } from "./content/convert.js";
-import { ToolCallAdmission } from "./tool-call-admission.js";
-import { StdioOutput } from "./stdio-output.js";
+import * as readline from "node:readline";
+import { createProtocolServer } from "./protocol-server.js";
 import { StdioInput } from "./stdio-input.js";
-import { isBase64 } from "./base64.js";
-import { selectRequestProtocol, decorateModernResult, MODERN_PROTOCOL_VERSION } from "./protocol.js";
-import { SubscriptionRegistry } from "./subscriptions.js";
-import { waitForRequest } from "./request-cancellation.js";
-import { isJsonValue } from "toolcraft-schema";
-import { isValidUri } from "./uri.js";
-import { getParameterHeaders, validateParameterHeaders } from "./headers.js";
-const PROTOCOL_VERSION = "2025-11-25";
-const SUPPORTED_PROTOCOL_VERSIONS = new Set(["2025-03-26", "2025-06-18", PROTOCOL_VERSION, MODERN_PROTOCOL_VERSION]);
-function createLifecycleState(listener, supportNotifications, supportResourceSubscriptions) {
-    const abortController = new AbortController();
-    const admissions = new Set();
-    const requests = new Map();
-    abortController.signal.addEventListener("abort", () => {
-        for (const admission of admissions)
-            admission.abort(abortController.signal.reason);
-        admissions.clear();
-        for (const request of requests.values())
-            request.abort(abortController.signal.reason);
-        requests.clear();
-    }, { once: true });
-    return {
-        initialized: false,
-        protocolVersion: PROTOCOL_VERSION,
-        initializeAccepted: false,
-        notificationReady: false,
-        resourceSubscriptions: new Set(),
-        abortController,
-        admissions,
-        requests,
-        subscriptions: new SubscriptionRegistry(listener ?? (() => { }), supportNotifications, supportResourceSubscriptions),
-        listener
-    };
-}
-function compileToolSchema(schema) {
-    try {
-        return compileJsonSchema(schema);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`schema is invalid: ${message}`, { cause: error });
-    }
-}
+import { StdioOutput } from "./stdio-output.js";
 export function createServer(options) {
-    if (options.toolCallTimeoutMs !== undefined &&
-        (!Number.isInteger(options.toolCallTimeoutMs) || options.toolCallTimeoutMs <= 0)) {
-        throw new Error("toolCallTimeoutMs must be a positive integer.");
-    }
-    const maxConcurrentToolCalls = options.maxConcurrentToolCalls ?? 4;
-    const maxQueuedToolCalls = options.maxQueuedToolCalls ?? 64;
-    const maxStdioOutputBytes = options.maxStdioOutputBytes ?? 1024 * 1024;
-    const maxPendingStdioMessages = options.maxPendingStdioMessages ?? 128;
-    const maxActiveRequests = options.maxActiveRequests ?? 128;
-    const maxStdioLineBytes = options.maxStdioLineBytes ?? 1024 * 1024;
-    for (const [name, value, minimum] of [
-        ["maxConcurrentToolCalls", maxConcurrentToolCalls, 1],
-        ["maxQueuedToolCalls", maxQueuedToolCalls, 0],
-        ["maxStdioOutputBytes", maxStdioOutputBytes, 1],
-        ["maxPendingStdioMessages", maxPendingStdioMessages, 1],
-        ["maxActiveRequests", maxActiveRequests, 1],
-        ["maxStdioLineBytes", maxStdioLineBytes, 1]
-    ]) {
-        if (!Number.isSafeInteger(value) || value < minimum) {
-            throw new Error(`${name} must be a safe integer greater than or equal to ${minimum}.`);
-        }
-    }
-    const toolAdmission = new ToolCallAdmission(maxConcurrentToolCalls, maxQueuedToolCalls);
-    const supportNotifications = options.supportNotifications !== false;
-    const supportResourceSubscriptions = options.supportResourceSubscriptions !== false;
-    const tools = new Map();
-    const prompts = new Map();
-    const resources = new Map();
-    const resourceTemplates = new Map();
-    const methods = new Map();
-    const notificationListeners = new Set();
-    const connectionNotificationListeners = new Map();
-    const defaultLifecycle = createLifecycleState((notification) => {
-        for (const listener of notificationListeners)
-            listener(notification);
-    }, supportNotifications, supportResourceSubscriptions);
-    const messageLifecycles = new Set([defaultLifecycle]);
-    let activeRequests = 0;
-    const describeCapabilities = () => ({
-        tools: {
-            ...(supportNotifications ? { listChanged: true } : {})
-        },
-        prompts: {
-            ...(supportNotifications ? { listChanged: true } : {})
-        },
-        resources: {
-            ...(supportNotifications ? { listChanged: true } : {}),
-            ...(supportResourceSubscriptions ? { subscribe: true } : {})
-        }
-    });
-    const dispatchMessage = async (method, lifecycle, params, modern = false, requestSignal = lifecycle.abortController.signal, parameterHeaders) => {
-        const handlerContext = {
-            signal: requestSignal,
-            ...(modern && params?.requestState !== undefined
-                ? { requestState: params.requestState }
-                : {}),
-            ...(modern && params?.inputResponses !== undefined
-                ? { inputResponses: params.inputResponses }
-                : {}),
-            clientCapabilities: modern
-                ? (params?._meta)["io.modelcontextprotocol/clientCapabilities"]
-                : {}
-        };
-        if (method === "server/discover") {
-            const result = {
-                resultType: "complete",
-                supportedVersions: [...SUPPORTED_PROTOCOL_VERSIONS].reverse(),
-                capabilities: describeCapabilities(),
-                _meta: {
-                    "io.modelcontextprotocol/serverInfo": { name: options.name, version: options.version }
-                },
-                ttlMs: 0,
-                cacheScope: "private"
-            };
-            return { result };
-        }
-        // Allow ping and initialize before initialization
-        if (method === "ping") {
-            return { result: {} };
-        }
-        if (method === "initialize") {
-            // Re-initialize on the same connection is idempotent: real MCP clients
-            // (e.g. kimi-cli via fastmcp) re-send `initialize` on a persistent
-            // connection per tool call, and the official MCP SDK server re-responds
-            // with InitializeResult instead of erroring. Per-connection isolation is
-            // still enforced by the separate lifecycle object given to each connection.
-            lifecycle.initializeAccepted = true;
-            lifecycle.initialized = true;
-            lifecycle.notificationReady = false;
-            const requestedProtocol = typeof params?.protocolVersion === "string" ? params.protocolVersion : undefined;
-            const result = {
-                protocolVersion: requestedProtocol !== undefined && requestedProtocol !== MODERN_PROTOCOL_VERSION &&
-                    SUPPORTED_PROTOCOL_VERSIONS.has(requestedProtocol)
-                    ? requestedProtocol
-                    : PROTOCOL_VERSION,
-                capabilities: describeCapabilities(),
-                serverInfo: {
-                    name: options.name,
-                    version: options.version
-                }
-            };
-            lifecycle.protocolVersion = result.protocolVersion;
-            return { result };
-        }
-        if (method === "notifications/initialized") {
-            if (!lifecycle.initializeAccepted) {
-                return {
-                    error: {
-                        code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
-                        message: "Server not initialized"
-                    }
-                };
-            }
-            lifecycle.notificationReady = true;
-            return { result: undefined };
-        }
-        // All other methods require initialization
-        if (!modern && !lifecycle.initialized) {
-            return {
-                error: {
-                    code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
-                    message: "Server not initialized"
-                }
-            };
-        }
-        if (method === "tools/list") {
-            const toolList = [];
-            for (const tool of tools.values()) {
-                const descriptor = { ...tool };
-                delete descriptor.handler;
-                delete descriptor.inputValidator;
-                delete descriptor.outputValidator;
-                delete descriptor.parameterHeaders;
-                if (!modern && descriptor.outputSchema?.type !== "object")
-                    delete descriptor.outputSchema;
-                toolList.push(structuredClone(descriptor));
-            }
-            return { result: { tools: toolList } };
-        }
-        if (method === "tools/call") {
-            const toolName = params?.name;
-            if (!toolName) {
-                return {
-                    error: {
-                        code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
-                        message: "Tool name required"
-                    }
-                };
-            }
-            const tool = tools.get(toolName);
-            if (!tool) {
-                const availableTools = [...tools.keys()].slice(0, 20);
-                return {
-                    error: {
-                        code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
-                        message: `Tool not found: ${toolName}${availableTools.length === 0 ? "" : `. Available: ${availableTools.join(", ")}`}`
-                    }
-                };
-            }
-            if (params?.arguments !== undefined && !isJsonObject(params.arguments))
-                return invalidParams("Tool arguments must be an object");
-            const toolArgs = (params?.arguments ?? {});
-            if (modern && parameterHeaders !== undefined) {
-                const headerError = validateParameterHeaders(tool.parameterHeaders, toolArgs, parameterHeaders);
-                if (headerError !== undefined)
-                    return { error: { code: -32020, message: headerError } };
-            }
-            const inputValidation = tool.inputValidator.validate(toolArgs);
-            if (options.validateToolArguments !== false && !inputValidation.ok) {
-                return {
-                    error: {
-                        code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
-                        message: `Invalid tool arguments: ${formatIssues(inputValidation.issues)}`,
-                        data: inputValidation.issues
-                    }
-                };
-            }
-            try {
-                let handlerResult;
-                const admissionController = new AbortController();
-                const sessionSignal = requestSignal;
-                const admissionSignal = admissionController.signal;
-                const cancelAdmission = () => admissionController.abort(sessionSignal.reason);
-                if (sessionSignal.aborted)
-                    admissionController.abort(sessionSignal.reason);
-                else {
-                    lifecycle.admissions.add(admissionController);
-                    if (sessionSignal !== lifecycle.abortController.signal)
-                        sessionSignal.addEventListener("abort", cancelAdmission, { once: true });
-                }
-                const handlerPromise = (async () => {
-                    const release = await toolAdmission.acquire(admissionSignal);
-                    try {
-                        admissionSignal.throwIfAborted();
-                        return await tool.handler(toolArgs, { ...handlerContext, signal: admissionSignal });
-                    }
-                    finally {
-                        release();
-                    }
-                })();
-                try {
-                    if (options.toolCallTimeoutMs === undefined) {
-                        handlerResult = await handlerPromise;
-                    }
-                    else {
-                        let timeout;
-                        handlerResult = await Promise.race([
-                            handlerPromise,
-                            new Promise((_resolve, reject) => {
-                                timeout = setTimeout(() => {
-                                    const error = new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `Tool call timed out: ${toolName}`);
-                                    admissionController.abort(error);
-                                    reject(error);
-                                }, options.toolCallTimeoutMs);
-                            })
-                        ]).finally(() => {
-                            if (timeout !== undefined) {
-                                clearTimeout(timeout);
-                            }
-                        });
-                    }
-                }
-                finally {
-                    lifecycle.admissions.delete(admissionController);
-                    sessionSignal.removeEventListener("abort", cancelAdmission);
-                }
-                if (modern && isInputRequiredResult(handlerResult))
-                    return { result: handlerResult };
-                const outputSchema = modern || tool.outputSchema?.type === "object" ? tool.outputSchema : undefined;
-                const result = normalizeToolResult(handlerResult, tool.outputSchema, modern);
-                const outputValidation = outputSchema === undefined ? undefined : tool.outputValidator?.validate(result.structuredContent);
-                if (result.isError !== true && outputValidation !== undefined && !outputValidation.ok) {
-                    throw new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `Invalid structured tool result: ${formatIssues(outputValidation.issues)}`, outputValidation.issues);
-                }
-                return { result };
-            }
-            catch (err) {
-                if (err instanceof ToolError) {
-                    return {
-                        error: {
-                            code: err.code,
-                            message: err.message,
-                            ...(err.data === undefined ? {} : { data: err.data })
-                        }
-                    };
-                }
-                const errorMessage = err instanceof Error ? err.message : String(err);
-                const result = {
-                    content: [{ type: "text", text: `Error: ${errorMessage}` }],
-                    isError: true
-                };
-                return { result };
-            }
-        }
-        if (method === "prompts/list") {
-            return {
-                result: {
-                    prompts: [...prompts.values()].map(({ handler: _handler, ...prompt }) => structuredClone(prompt))
-                }
-            };
-        }
-        if (method === "prompts/get") {
-            const promptName = typeof params?.name === "string" ? params.name : undefined;
-            if (promptName === undefined) {
-                return invalidParams("Prompt name required");
-            }
-            const prompt = prompts.get(promptName);
-            if (prompt === undefined) {
-                return invalidParams(`Prompt not found: ${promptName}`);
-            }
-            const args = toStringArguments(params?.arguments);
-            if (args === undefined || !hasRequiredPromptArguments(prompt, args)) {
-                return invalidParams("Invalid prompt arguments");
-            }
-            try {
-                const result = await prompt.handler(args, handlerContext);
-                if (modern && isInputRequiredResult(result))
-                    return { result };
-                if (!isGetPromptResult(result, modern || lifecycle.protocolVersion === PROTOCOL_VERSION)) {
-                    return internalError("Invalid prompt result");
-                }
-                return { result };
-            }
-            catch (error) {
-                return internalError(toErrorMessage(error));
-            }
-        }
-        if (method === "resources/list") {
-            return {
-                result: {
-                    resources: [...resources.values()].map(({ handler: _handler, ...resource }) => structuredClone(resource))
-                }
-            };
-        }
-        if (method === "resources/templates/list") {
-            return {
-                result: {
-                    resourceTemplates: [...resourceTemplates.values()].map(({ handler: _handler, template: _template, ...resourceTemplate }) => structuredClone(resourceTemplate))
-                }
-            };
-        }
-        if (method === "resources/read") {
-            const uri = typeof params?.uri === "string" ? params.uri : undefined;
-            if (uri === undefined || !isValidUri(uri)) {
-                return invalidParams("Resource URI required");
-            }
-            const resource = findReadableResource(uri, resources, resourceTemplates);
-            if (resource === undefined) {
-                return resourceNotFound(uri);
-            }
-            try {
-                const result = await resource.handler(uri, handlerContext);
-                if (modern && isInputRequiredResult(result))
-                    return { result };
-                if (!isReadResourceResult(result)) {
-                    return internalError("Invalid resource result");
-                }
-                return { result };
-            }
-            catch (error) {
-                return internalError(toErrorMessage(error));
-            }
-        }
-        if (method === "resources/subscribe" || method === "resources/unsubscribe") {
-            if (!supportResourceSubscriptions) {
-                return {
-                    error: {
-                        code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
-                        message: "Method not found"
-                    }
-                };
-            }
-            const uri = typeof params?.uri === "string" ? params.uri : undefined;
-            if (uri === undefined || !isValidUri(uri)) {
-                return invalidParams("Resource URI required");
-            }
-            if (method === "resources/subscribe" &&
-                findReadableResource(uri, resources, resourceTemplates) === undefined) {
-                return resourceNotFound(uri);
-            }
-            if (method === "resources/subscribe") {
-                lifecycle.resourceSubscriptions.add(uri);
-            }
-            else {
-                lifecycle.resourceSubscriptions.delete(uri);
-            }
-            return { result: {} };
-        }
-        const customMethod = methods.get(method);
-        if (customMethod !== undefined) {
-            try {
-                const result = await customMethod(params, {
-                    signal: requestSignal,
-                    async notify(notificationMethod, notificationParams) {
-                        if (requestSignal.aborted ||
-                            (!modern && !lifecycle.notificationReady) ||
-                            lifecycle.listener === undefined) {
-                            return;
-                        }
-                        await lifecycle.listener({
-                            jsonrpc: "2.0",
-                            method: notificationMethod,
-                            ...(notificationParams === undefined ? {} : { params: notificationParams })
-                        });
-                    }
-                });
-                return { result };
-            }
-            catch (error) {
-                if (error instanceof ToolError) {
-                    return {
-                        error: {
-                            code: error.code,
-                            message: error.message,
-                            ...(error.data === undefined ? {} : { data: error.data })
-                        }
-                    };
-                }
-                return internalError(toErrorMessage(error));
-            }
-        }
-        return {
-            error: {
-                code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
-                message: "Method not found"
-            }
-        };
-    };
-    const handleMessageWithLifecycle = async (method, lifecycle, params, context) => {
-        if (method === "notifications/cancelled") {
-            const id = params?.requestId;
-            if (typeof id === "string" || typeof id === "number") {
-                lifecycle.requests.get(id)?.abort(new Error("Request cancelled"));
-            }
-            return { result: undefined };
-        }
-        const protocol = selectRequestProtocol(method, params, SUPPORTED_PROTOCOL_VERSIONS);
-        if (protocol.error !== undefined)
-            return { error: protocol.error };
-        const directLegacy = !protocol.modern && context === undefined;
-        if (protocol.modern &&
-            context !== undefined &&
-            context.requestId !== undefined &&
-            !isRequestId(context.requestId)) {
-            return {
-                error: { code: JSON_RPC_ERROR_CODES.INVALID_REQUEST, message: "Invalid Request ID" }
-            };
-        }
-        if (activeRequests >= maxActiveRequests) {
-            return { error: { code: -32000, message: "Too many active requests" } };
-        }
-        const key = context?.requestId ?? Symbol("request");
-        if (lifecycle.requests.has(key)) {
-            return {
-                error: {
-                    code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
-                    message: "Request ID is already active"
-                }
-            };
-        }
-        const controller = new AbortController();
-        const parents = context?.signal === undefined ? [] : [context.signal];
-        const signal = controller.signal;
-        if (lifecycle.abortController.signal.aborted)
-            controller.abort(lifecycle.abortController.signal.reason);
-        const abort = (event) => controller.abort(event.target.reason);
-        for (const parent of parents) {
-            if (parent.aborted)
-                controller.abort(parent.reason);
-            else
-                parent.addEventListener("abort", abort, { once: true });
-        }
-        const cleanup = () => {
-            for (const parent of parents)
-                parent.removeEventListener("abort", abort);
-        };
-        if (signal.aborted) {
-            cleanup();
-            return { result: undefined };
-        }
-        lifecycle.requests.set(key, controller);
-        activeRequests += 1;
-        const operation = protocol.modern && method === "subscriptions/listen"
-            ? lifecycle.subscriptions.listen(context?.requestId, params?.notifications, signal)
-            : dispatchMessage(method, lifecycle, params, protocol.modern, directLegacy ? lifecycle.abortController.signal : signal, context?.parameterHeaders);
-        const release = () => {
-            activeRequests -= 1;
-            if (lifecycle.requests.get(key) === controller)
-                lifecycle.requests.delete(key);
-        };
-        void operation.then(release, release);
-        try {
-            const handled = directLegacy ? await operation : await waitForRequest(operation, signal);
-            if (handled === undefined || (!directLegacy && signal.aborted))
-                return { result: undefined };
-            return protocol.modern
-                ? decorateModernResult(method, handled, { name: options.name, version: options.version }, (params?._meta)["io.modelcontextprotocol/clientCapabilities"])
-                : handled;
-        }
-        finally {
-            cleanup();
-            controller.abort();
-        }
-    };
-    const createMessageSession = (listener) => {
-        const lifecycle = createLifecycleState(listener, supportNotifications, supportResourceSubscriptions);
-        messageLifecycles.add(lifecycle);
-        if (listener !== undefined) {
-            connectionNotificationListeners.set(listener, lifecycle);
-        }
-        return {
-            handleMessage: (method, params, context) => handleMessageWithLifecycle(method, lifecycle, params, context),
-            close: () => {
-                lifecycle.abortController.abort();
-                if (listener !== undefined) {
-                    connectionNotificationListeners.delete(listener);
-                }
-                messageLifecycles.delete(lifecycle);
-            }
-        };
-    };
-    const handleMessage = (method, params, context) => handleMessageWithLifecycle(method, defaultLifecycle, params, context);
-    const processLine = async (line, write, messageHandler, subscriptionSignal) => {
-        const parsed = parseMessage(line);
-        if (!parsed.success) {
-            await write(formatErrorResponse(parsed.id, parsed.error) + "\n");
-            return;
-        }
-        const { request, isNotification } = parsed;
-        if (isNotification &&
-            !request.method.startsWith("notifications/") &&
-            selectRequestProtocol(request.method, request.params, SUPPORTED_PROTOCOL_VERSIONS).modern)
-            return;
-        if (isNotification && request.method === "initialize") {
-            return;
-        }
-        if (!isNotification && request.method === "notifications/initialized") {
-            const requestWithId = request;
-            await write(formatErrorResponse(requestWithId.id, {
-                code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
-                message: "Invalid Request"
-            }) + "\n");
-            return;
-        }
-        let handled;
-        try {
-            handled = await messageHandler(request.method, request.params, !isNotification && request.id !== null
-                ? {
-                    requestId: request.id,
-                    ...(request.method === "subscriptions/listen" ? { signal: subscriptionSignal } : {})
-                }
-                : undefined);
-        }
-        catch {
-            if (!isNotification) {
-                const requestWithId = request;
-                await write(formatErrorResponse(requestWithId.id, {
-                    code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
-                    message: "Internal error"
-                }) + "\n");
-            }
-            return;
-        }
-        const { result, error } = handled;
-        if (isNotification) {
-            return;
-        }
-        const requestWithId = request;
-        if (error) {
-            await write(formatErrorResponse(requestWithId.id, error) + "\n");
-        }
-        else if (result !== undefined) {
-            await write(formatSuccessResponse(requestWithId.id, result) + "\n");
-        }
-    };
-    const broadcastNotification = async (method, params, canSend = () => true) => {
-        const notification = {
-            jsonrpc: "2.0",
-            method,
-            ...(params === undefined ? {} : { params })
-        };
-        for (const listener of notificationListeners) {
-            listener(notification);
-        }
-        await Promise.all([...messageLifecycles].map((lifecycle) => lifecycle.subscriptions.emit(method, params)));
-        await Promise.all([...connectionNotificationListeners].map(async ([listener, lifecycle]) => {
-            if (lifecycle.notificationReady && canSend(lifecycle)) {
-                await listener(notification);
-            }
-        }));
-    };
-    const server = {
-        tool(name, description, inputSchema, handler, outputSchema) {
-            assertNonEmptyName(name, "Tool name required");
-            if (tools.has(name)) {
-                throw new Error(`Tool already registered: ${name}`);
-            }
-            const inputSchemaSnapshot = normalizeLegacyNullability(inputSchema);
-            const outputSchemaSnapshot = outputSchema === undefined ? undefined : normalizeLegacyNullability(outputSchema);
-            const inputValidator = compileToolSchema(inputSchemaSnapshot);
-            assertObjectRootSchema(inputSchemaSnapshot, "inputSchema");
-            let outputValidator;
-            if (outputSchemaSnapshot !== undefined) {
-                assertOutputSchema(outputSchemaSnapshot);
-                outputValidator = compileToolSchema(outputSchemaSnapshot);
-            }
-            tools.set(name, {
-                name,
-                description,
-                inputSchema: inputSchemaSnapshot,
-                ...(outputSchemaSnapshot === undefined ? {} : { outputSchema: outputSchemaSnapshot }),
-                handler: handler,
-                inputValidator,
-                parameterHeaders: getParameterHeaders(inputSchemaSnapshot),
-                ...(outputValidator === undefined ? {} : { outputValidator })
-            });
-            return server;
-        },
-        registerTool(definition, handler) {
-            assertNonEmptyName(definition.name, "Tool name required");
-            if (tools.has(definition.name)) {
-                throw new Error(`Tool already registered: ${definition.name}`);
-            }
-            const descriptor = structuredClone(definition);
-            const inputSchema = normalizeLegacyNullability(descriptor.inputSchema);
-            const inputValidator = compileToolSchema(inputSchema);
-            assertObjectRootSchema(inputSchema, "inputSchema");
-            let outputValidator;
-            if (descriptor.outputSchema !== undefined) {
-                descriptor.outputSchema = normalizeLegacyNullability(descriptor.outputSchema);
-                assertOutputSchema(descriptor.outputSchema);
-                outputValidator = compileToolSchema(descriptor.outputSchema);
-            }
-            tools.set(definition.name, {
-                ...descriptor,
-                inputSchema,
-                handler: handler,
-                inputValidator,
-                parameterHeaders: getParameterHeaders(inputSchema),
-                ...(outputValidator === undefined ? {} : { outputValidator })
-            });
-            return server;
-        },
-        prompt(definition, handler) {
-            assertNonEmptyName(definition.name, "Prompt name required");
-            if (prompts.has(definition.name)) {
-                throw new Error(`Prompt already registered: ${definition.name}`);
-            }
-            prompts.set(definition.name, { ...structuredClone(definition), handler });
-            return server;
-        },
-        resource(definition, handler) {
-            if (!isValidUri(definition.uri)) {
-                throw new Error(`Invalid resource URI: ${definition.uri}`);
-            }
-            if (resources.has(definition.uri)) {
-                throw new Error(`Resource already registered: ${definition.uri}`);
-            }
-            resources.set(definition.uri, { ...structuredClone(definition), handler });
-            return server;
-        },
-        resourceTemplate(definition, handler) {
-            const template = parseReadableUriTemplate(definition.uriTemplate);
-            if (resourceTemplates.has(definition.uriTemplate)) {
-                throw new Error(`Resource template already registered: ${definition.uriTemplate}`);
-            }
-            resourceTemplates.set(definition.uriTemplate, { ...structuredClone(definition), handler, template });
-            return server;
-        },
-        method(name, handler) {
-            assertNonEmptyName(name, "Method name required");
-            methods.set(name, handler);
-            return server;
-        },
-        onNotification(listener) {
-            notificationListeners.add(listener);
-            return () => {
-                notificationListeners.delete(listener);
-            };
-        },
-        removeTool(name) {
-            return tools.delete(name);
-        },
-        removePrompt(name) {
-            return prompts.delete(name);
-        },
-        removeResource(uri) {
-            return resources.delete(uri);
-        },
-        removeResourceTemplate(uriTemplate) {
-            return resourceTemplates.delete(uriTemplate);
-        },
-        async notifyToolsChanged() {
-            if (supportNotifications &&
-                [...messageLifecycles].some((lifecycle) => lifecycle.notificationReady || lifecycle.subscriptions.size > 0)) {
-                await broadcastNotification("notifications/tools/list_changed");
-            }
-        },
-        async notifyPromptsChanged() {
-            if (supportNotifications &&
-                [...messageLifecycles].some((lifecycle) => lifecycle.notificationReady || lifecycle.subscriptions.size > 0)) {
-                await broadcastNotification("notifications/prompts/list_changed");
-            }
-        },
-        async notifyResourcesChanged() {
-            if (supportNotifications &&
-                [...messageLifecycles].some((lifecycle) => lifecycle.notificationReady || lifecycle.subscriptions.size > 0)) {
-                await broadcastNotification("notifications/resources/list_changed");
-            }
-        },
-        async notifyResourceUpdated(uri) {
-            if (!supportResourceSubscriptions) {
-                return;
-            }
-            await broadcastNotification("notifications/resources/updated", { uri }, (lifecycle) => lifecycle.resourceSubscriptions.has(uri));
-        },
-        createMessageSession,
-        handleMessage,
-        async listen() {
-            return server.connect({
-                readable: process.stdin,
-                writable: process.stdout
-            });
-        },
-        async connect(transport) {
-            return new Promise((resolve, reject) => {
-                let inputClosed = false;
-                let settled = false;
-                const pendingMessages = new Set();
-                const subscriptions = new AbortController();
-                const output = new StdioOutput(transport.writable, maxStdioOutputBytes, fail, finish);
-                const listener = (notification) => output.write(`${JSON.stringify(notification)}\n`);
-                const session = server.createMessageSession(listener);
-                const input = new StdioInput(maxStdioLineBytes);
-                const rl = readline.createInterface({
-                    input,
-                    crlfDelay: Infinity
-                });
-                function fail(error) {
-                    if (settled)
-                        return;
-                    settled = true;
-                    session.close();
-                    rl.close();
-                    transport.readable.unpipe(input);
-                    input.destroy();
-                    transport.readable.pause();
-                    transport.readable.off("error", fail);
-                    output.abort(error);
-                    pendingMessages.clear();
-                    reject(error);
-                }
-                function finish() {
-                    if (settled || !inputClosed || pendingMessages.size > 0 || output.pending > 0)
-                        return;
-                    settled = true;
-                    session.close();
-                    transport.readable.unpipe(input);
-                    input.destroy();
-                    transport.readable.off("error", fail);
-                    output.close();
-                    resolve();
-                }
-                transport.readable.on("error", fail);
-                input.on("error", fail);
-                rl.on("error", fail);
-                rl.on("line", (line) => {
-                    if (settled)
-                        return;
-                    if (pendingMessages.size >= maxPendingStdioMessages) {
-                        fail(new Error("Stdio pending message limit exceeded"));
-                        return;
-                    }
-                    const message = processLine(line, (data) => output.write(data), session.handleMessage, subscriptions.signal);
-                    if (!settled)
-                        pendingMessages.add(message);
-                    void message.then(() => {
-                        pendingMessages.delete(message);
-                        finish();
-                    }, fail);
-                });
-                rl.on("close", () => {
-                    inputClosed = true;
-                    subscriptions.abort();
-                    finish();
-                });
-                transport.readable.pipe(input);
-            });
-        },
-        async connectSDK(transport) {
-            return new Promise((resolve, reject) => {
-                const listener = (notification) => transport.send(notification);
-                const session = server.createMessageSession(listener);
-                transport.onmessage = async (message) => {
-                    // Ignore responses (we only handle requests/notifications)
-                    if (!("method" in message)) {
-                        return;
-                    }
-                    // Handle notifications (no id) - don't respond
-                    if (!("id" in message) || message.id === undefined) {
-                        if (!message.method.startsWith("notifications/") &&
-                            selectRequestProtocol(message.method, message.params, SUPPORTED_PROTOCOL_VERSIONS)
-                                .modern)
-                            return;
-                        if (message.method === "initialize") {
-                            return;
-                        }
-                        try {
-                            await session.handleMessage(message.method, message.params);
-                        }
-                        catch {
-                            return;
-                        }
-                        return;
-                    }
-                    if (message.method === "notifications/initialized") {
-                        await transport.send({
-                            jsonrpc: "2.0",
-                            id: message.id,
-                            error: {
-                                code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
-                                message: "Invalid Request"
-                            }
-                        });
-                        return;
-                    }
-                    const request = message;
-                    if (selectRequestProtocol(request.method, request.params, SUPPORTED_PROTOCOL_VERSIONS)
-                        .modern &&
-                        !isRequestId(request.id)) {
-                        await transport.send({
-                            jsonrpc: "2.0",
-                            id: null,
-                            error: { code: JSON_RPC_ERROR_CODES.INVALID_REQUEST, message: "Invalid Request ID" }
-                        });
-                        return;
-                    }
-                    let handled;
-                    try {
-                        handled = await session.handleMessage(request.method, request.params, request.id === null ? undefined : { requestId: request.id });
-                    }
-                    catch {
-                        await transport.send({
-                            jsonrpc: "2.0",
-                            id: request.id,
-                            error: {
-                                code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
-                                message: "Internal error"
-                            }
-                        });
-                        return;
-                    }
-                    const { result, error } = handled;
-                    if (error) {
-                        const response = {
-                            jsonrpc: "2.0",
-                            id: request.id,
-                            error
-                        };
-                        await transport.send(response);
-                    }
-                    else if (result !== undefined) {
-                        const response = {
-                            jsonrpc: "2.0",
-                            id: request.id,
-                            result
-                        };
-                        await transport.send(response);
-                    }
-                };
-                transport.onclose = () => {
-                    session.close();
-                    resolve();
-                };
-                void transport.start().catch((error) => {
-                    session.close();
-                    reject(error);
-                });
-            });
-        }
-    };
-    return server;
-}
-function invalidParams(message) {
-    return {
-        error: {
-            code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
-            message
-        }
-    };
-}
-function internalError(message) {
-    return {
-        error: {
-            code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
-            message
-        }
-    };
-}
-function resourceNotFound(uri) {
-    return {
-        error: {
-            code: JSON_RPC_ERROR_CODES.RESOURCE_NOT_FOUND,
-            message: `Resource not found: ${uri}`
-        }
-    };
-}
-function toErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function assertNonEmptyName(name, message) {
-    if (name.length === 0) {
-        throw new Error(message);
-    }
-}
-function parseReadableUriTemplate(uriTemplate) {
-    const template = parseUriTemplate(uriTemplate);
-    if (!isValidUri(template.expand({}))) {
-        throw new Error(`Invalid resource URI template: ${uriTemplate}`);
-    }
-    return template;
-}
-function toStringArguments(value) {
-    if (value === undefined) {
-        return {};
-    }
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        return undefined;
-    }
-    const args = {};
-    for (const [name, argument] of Object.entries(value)) {
-        if (typeof argument !== "string") {
-            return undefined;
-        }
-        args[name] = argument;
-    }
-    return args;
-}
-function hasRequiredPromptArguments(prompt, args) {
-    return (prompt.arguments ?? []).every((argument) => argument.required !== true || args[argument.name] !== undefined);
-}
-function findReadableResource(uri, resources, resourceTemplates) {
-    const resource = resources.get(uri);
-    if (resource !== undefined) {
-        return resource;
-    }
-    return [...resourceTemplates.values()].find((template) => template.template.match(uri) !== null);
-}
-function isInputRequiredResult(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        !Array.isArray(value) &&
-        value.resultType === "input_required");
-}
-function isCallToolResult(value, modern) {
-    if (!hasContentArray(value) || !value.content.every(isContentItem)) {
-        return false;
-    }
-    if (hasOwnProperty(value, "structuredContent") &&
-        value.structuredContent !== undefined &&
-        !(isJsonValue(value.structuredContent) && (modern || isJsonObject(value.structuredContent)))) {
-        return false;
-    }
-    return !(hasOwnProperty(value, "isError") &&
-        value.isError !== undefined &&
-        typeof value.isError !== "boolean");
-}
-function normalizeToolResult(handlerResult, outputSchema, modern) {
-    if (!modern && outputSchema !== undefined && outputSchema.type !== "object") {
-        const result = normalizeToolResult(handlerResult, outputSchema, true);
-        const { structuredContent, ...legacyResult } = result;
-        return {
-            ...legacyResult,
-            content: typeof handlerResult === "string"
-                ? [{ type: "text", text: handlerResult }]
-                : legacyResult.content.length > 0 || structuredContent === undefined
-                    ? legacyResult.content
-                    : [{ type: "text", text: JSON.stringify(structuredContent) }]
-        };
-    }
-    if (hasContentArray(handlerResult) && !isCallToolResult(handlerResult, modern)) {
-        if (outputSchema !== undefined)
-            throw new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, "Invalid tool result");
-        throw new Error("Invalid tool result");
-    }
-    if (outputSchema === undefined) {
-        const result = isCallToolResult(handlerResult, modern)
-            ? handlerResult
-            : { content: toContentBlocks(handlerResult) };
-        if (!isCallToolResult(result, modern)) {
-            throw new Error("Invalid tool result");
-        }
-        return result;
-    }
-    if (isCallToolResult(handlerResult, modern) && handlerResult.isError === true) {
-        return handlerResult;
-    }
-    const callToolResult = isCallToolResult(handlerResult, modern) ? handlerResult : undefined;
-    const structuredContent = callToolResult ? callToolResult.structuredContent : handlerResult;
-    if (!(isJsonValue(structuredContent) && (modern || isJsonObject(structuredContent)))) {
-        throw new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, modern ? "Structured tool result must be JSON" : "Structured tool result must be a JSON object");
-    }
-    return {
-        ...callToolResult,
-        content: callToolResult !== undefined && callToolResult.content.length > 0
-            ? callToolResult.content
-            : [{ type: "text", text: JSON.stringify(structuredContent) }],
-        structuredContent
-    };
-}
-function assertObjectRootSchema(schema, path) {
-    if (typeof schema !== "object" || schema === null || !("type" in schema) || schema.type !== "object") {
-        throw new Error(`${path} root type must be "object"`);
-    }
-}
-function assertOutputSchema(schema) {
-    if (typeof schema !== "object" || schema === null || Array.isArray(schema))
-        throw new Error("outputSchema must be a JSON Schema object");
-}
-function isJsonObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isGetPromptResult(value, modern = false) {
-    if (typeof value !== "object" || value === null || !hasOwnProperty(value, "messages")) {
-        return false;
-    }
-    return ((!hasOwnProperty(value, "description") ||
-        value.description === undefined ||
-        typeof value.description === "string") &&
-        Array.isArray(value.messages) &&
-        value.messages.every((message) => typeof message === "object" &&
-            message !== null &&
-            hasOwnProperty(message, "role") &&
-            (message.role === "user" || message.role === "assistant") &&
-            hasOwnProperty(message, "content") &&
-            (modern ? isContentItem(message.content) : isPromptContentItem(message.content))));
-}
-function isReadResourceResult(value) {
-    if (typeof value !== "object" || value === null || !hasOwnProperty(value, "contents")) {
-        return false;
-    }
-    return Array.isArray(value.contents) && value.contents.every(isResourceContents);
-}
-function hasContentArray(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        hasOwnProperty(value, "content") &&
-        Array.isArray(value.content));
-}
-function isContentItem(value) {
-    if (typeof value !== "object" || value === null || !hasOwnProperty(value, "type")) {
-        return false;
-    }
-    const block = value;
-    if (!hasValidContentAnnotations(block)) {
-        return false;
-    }
-    if (block.type === "text") {
-        return hasOwnProperty(block, "text") && typeof block.text === "string";
-    }
-    if (block.type === "image" || block.type === "audio") {
-        return (hasOwnProperty(block, "data") &&
-            typeof block.data === "string" &&
-            isBase64(block.data) &&
-            hasOwnProperty(block, "mimeType") &&
-            typeof block.mimeType === "string");
-    }
-    if (block.type === "resource_link") {
-        return (hasOwnProperty(block, "uri") &&
-            typeof block.uri === "string" &&
-            isValidUri(block.uri) &&
-            hasOwnProperty(block, "name") &&
-            typeof block.name === "string" &&
-            (!hasOwnProperty(block, "title") ||
-                block.title === undefined ||
-                typeof block.title === "string") &&
-            (!hasOwnProperty(block, "description") ||
-                block.description === undefined ||
-                typeof block.description === "string") &&
-            (!hasOwnProperty(block, "mimeType") ||
-                block.mimeType === undefined ||
-                typeof block.mimeType === "string") &&
-            (!hasOwnProperty(block, "size") || block.size === undefined || typeof block.size === "number"));
-    }
-    if (block.type !== "resource" ||
-        !hasOwnProperty(block, "resource") ||
-        typeof block.resource !== "object" ||
-        block.resource === null) {
-        return false;
-    }
-    return isResourceContents(block.resource);
-}
-function isResourceContents(value) {
-    if (typeof value !== "object" ||
-        value === null ||
-        !hasOwnProperty(value, "uri") ||
-        typeof value.uri !== "string" ||
-        !isValidUri(value.uri)) {
-        return false;
-    }
-    if (hasOwnProperty(value, "mimeType") &&
-        value.mimeType !== undefined &&
-        typeof value.mimeType !== "string") {
-        return false;
-    }
-    return ((hasOwnProperty(value, "text") && typeof value.text === "string") ||
-        (hasOwnProperty(value, "blob") && typeof value.blob === "string" && isBase64(value.blob)));
-}
-function hasValidContentAnnotations(value) {
-    if (!hasOwnProperty(value, "annotations") || value.annotations === undefined) {
-        return true;
-    }
-    if (!isJsonObject(value.annotations)) {
-        return false;
-    }
-    const { audience, priority, lastModified } = value.annotations;
-    return ((audience === undefined ||
-        (Array.isArray(audience) &&
-            audience.every((item) => item === "user" || item === "assistant"))) &&
-        (priority === undefined || typeof priority === "number") &&
-        (lastModified === undefined || typeof lastModified === "string"));
-}
-function isPromptContentItem(value) {
-    if (!isContentItem(value)) {
-        return false;
-    }
-    return !(typeof value === "object" &&
-        value !== null &&
-        hasOwnProperty(value, "type") &&
-        value.type === "resource_link");
-}
-function hasOwnProperty(value, name) {
-    return Object.prototype.hasOwnProperty.call(value, name);
+    return createProtocolServer(options, { readline, StdioInput, StdioOutput });
 }