toolcraft 0.0.410 → 0.0.412

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

@@ -0,0 +1,1156 @@
+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 { 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 });
+    }
+}
+export function createProtocolServer(options, stdio) {
+    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();
+    // Workers permit AbortController only inside a request, but tool registration
+    // belongs at module scope. Allocate the direct-call lifecycle on first use.
+    let defaultLifecycle;
+    const messageLifecycles = new Set();
+    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, localContext) => {
+        const handlerContext = {
+            signal: requestSignal,
+            localContext,
+            ...(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, context?.localContext);
+        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) => {
+        if (defaultLifecycle === undefined) {
+            defaultLifecycle = createLifecycleState((notification) => {
+                for (const listener of notificationListeners)
+                    listener(notification);
+            }, supportNotifications, supportResourceSubscriptions);
+            messageLifecycles.add(defaultLifecycle);
+        }
+        return 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) {
+            if (stdio === undefined)
+                throw new Error("Stdio is unavailable in the protocol-only entry point");
+            const { readline, StdioInput, StdioOutput } = stdio;
+            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);
+}