toolcraft 0.0.232 → 0.0.233

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

@@ -1,14 +1,46 @@
 import * as readline from "readline";
-import { compileJsonSchema, formatIssues } from "toolcraft-schema";
+import { compileJsonSchema, formatIssues, normalizeLegacyNullability } from "toolcraft-schema";
 import { JSON_RPC_ERROR_CODES, ToolError } from "./types.js";
-import { parseMessage, formatSuccessResponse, formatErrorResponse } from "./jsonrpc.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 { 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]);
+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);
@@ -27,12 +59,14 @@ export function createServer(options) {
     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) {
@@ -49,15 +83,50 @@ export function createServer(options) {
     const methods = new Map();
     const notificationListeners = new Set();
     const connectionNotificationListeners = new Map();
-    const defaultLifecycle = {
-        initialized: false,
-        initializeAccepted: false,
-        notificationReady: false,
-        resourceSubscriptions: new Set(),
-        abortController: new AbortController()
-    };
+    const defaultLifecycle = createLifecycleState((notification) => {
+        for (const listener of notificationListeners)
+            listener(notification);
+    }, supportNotifications, supportResourceSubscriptions);
     const messageLifecycles = new Set([defaultLifecycle]);
-    const handleMessageWithLifecycle = async (method, lifecycle, params) => {
+    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: {} };
@@ -73,26 +142,17 @@ export function createServer(options) {
             lifecycle.notificationReady = false;
             const requestedProtocol = typeof params?.protocolVersion === "string" ? params.protocolVersion : undefined;
             const result = {
-                protocolVersion: requestedProtocol !== undefined && SUPPORTED_PROTOCOL_VERSIONS.has(requestedProtocol)
+                protocolVersion: requestedProtocol !== undefined && requestedProtocol !== MODERN_PROTOCOL_VERSION &&
+                    SUPPORTED_PROTOCOL_VERSIONS.has(requestedProtocol)
                     ? requestedProtocol
                     : PROTOCOL_VERSION,
-                capabilities: {
-                    tools: {
-                        ...(supportNotifications ? { listChanged: true } : {})
-                    },
-                    prompts: {
-                        ...(supportNotifications ? { listChanged: true } : {})
-                    },
-                    resources: {
-                        ...(supportNotifications ? { listChanged: true } : {}),
-                        ...(supportResourceSubscriptions ? { subscribe: true } : {})
-                    }
-                },
+                capabilities: describeCapabilities(),
                 serverInfo: {
                     name: options.name,
                     version: options.version
                 }
             };
+            lifecycle.protocolVersion = result.protocolVersion;
             return { result };
         }
         if (method === "notifications/initialized") {
@@ -108,7 +168,7 @@ export function createServer(options) {
             return { result: undefined };
         }
         // All other methods require initialization
-        if (!lifecycle.initialized) {
+        if (!modern && !lifecycle.initialized) {
             return {
                 error: {
                     code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
@@ -123,9 +183,10 @@ export function createServer(options) {
                 delete descriptor.handler;
                 delete descriptor.inputValidator;
                 delete descriptor.outputValidator;
-                toolList.push({
-                    ...descriptor
-                });
+                delete descriptor.parameterHeaders;
+                if (!modern && descriptor.outputSchema?.type !== "object")
+                    delete descriptor.outputSchema;
+                toolList.push(structuredClone(descriptor));
             }
             return { result: { tools: toolList } };
         }
@@ -149,7 +210,14 @@ export function createServer(options) {
                     }
                 };
             }
+            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 {
@@ -162,43 +230,58 @@ export function createServer(options) {
             }
             try {
                 let handlerResult;
-                const admissionTimeout = options.toolCallTimeoutMs === undefined ? undefined : new AbortController();
-                const admissionSignal = AbortSignal.any([
-                    lifecycle.abortController.signal,
-                    ...(admissionTimeout === undefined ? [] : [admissionTimeout.signal])
-                ]);
+                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);
+                        return await tool.handler(toolArgs, { ...handlerContext, signal: admissionSignal });
                     }
                     finally {
                         release();
                     }
                 })();
-                if (options.toolCallTimeoutMs === undefined) {
-                    handlerResult = await handlerPromise;
+                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);
+                            }
+                        });
+                    }
                 }
-                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}`);
-                                admissionTimeout.abort(error);
-                                reject(error);
-                            }, options.toolCallTimeoutMs);
-                        })
-                    ]).finally(() => {
-                        if (timeout !== undefined) {
-                            clearTimeout(timeout);
-                        }
-                    });
+                finally {
+                    lifecycle.admissions.delete(admissionController);
+                    sessionSignal.removeEventListener("abort", cancelAdmission);
                 }
-                const result = normalizeToolResult(handlerResult, tool.outputSchema);
-                const outputValidation = tool.outputValidator?.validate(result.structuredContent);
+                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);
                 }
@@ -225,7 +308,7 @@ export function createServer(options) {
         if (method === "prompts/list") {
             return {
                 result: {
-                    prompts: [...prompts.values()].map(({ handler: _handler, ...prompt }) => prompt)
+                    prompts: [...prompts.values()].map(({ handler: _handler, ...prompt }) => structuredClone(prompt))
                 }
             };
         }
@@ -243,8 +326,10 @@ export function createServer(options) {
                 return invalidParams("Invalid prompt arguments");
             }
             try {
-                const result = await prompt.handler(args);
-                if (!isGetPromptResult(result)) {
+                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 };
@@ -256,14 +341,14 @@ export function createServer(options) {
         if (method === "resources/list") {
             return {
                 result: {
-                    resources: [...resources.values()].map(({ handler: _handler, ...resource }) => resource)
+                    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 }) => resourceTemplate)
+                    resourceTemplates: [...resourceTemplates.values()].map(({ handler: _handler, template: _template, ...resourceTemplate }) => structuredClone(resourceTemplate))
                 }
             };
         }
@@ -277,7 +362,9 @@ export function createServer(options) {
                 return resourceNotFound(uri);
             }
             try {
-                const result = await resource.handler(uri);
+                const result = await resource.handler(uri, handlerContext);
+                if (modern && isInputRequiredResult(result))
+                    return { result };
                 if (!isReadResourceResult(result)) {
                     return internalError("Invalid resource result");
                 }
@@ -316,9 +403,11 @@ export function createServer(options) {
         if (customMethod !== undefined) {
             try {
                 const result = await customMethod(params, {
-                    signal: lifecycle.abortController.signal,
+                    signal: requestSignal,
                     async notify(notificationMethod, notificationParams) {
-                        if (!lifecycle.notificationReady || lifecycle.listener === undefined) {
+                        if (requestSignal.aborted ||
+                            (!modern && !lifecycle.notificationReady) ||
+                            lifecycle.listener === undefined) {
                             return;
                         }
                         await lifecycle.listener({
@@ -331,6 +420,15 @@ export function createServer(options) {
                 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));
             }
         }
@@ -341,21 +439,90 @@ export function createServer(options) {
             }
         };
     };
-    const createMessageSession = (listener) => {
-        const lifecycle = {
-            initialized: false,
-            initializeAccepted: false,
-            notificationReady: false,
-            resourceSubscriptions: new Set(),
-            abortController: new AbortController(),
-            listener
+    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) => handleMessageWithLifecycle(method, lifecycle, params),
+            handleMessage: (method, params, context) => handleMessageWithLifecycle(method, lifecycle, params, context),
             close: () => {
                 lifecycle.abortController.abort();
                 if (listener !== undefined) {
@@ -365,14 +532,18 @@ export function createServer(options) {
             }
         };
     };
-    const handleMessage = (method, params) => handleMessageWithLifecycle(method, defaultLifecycle, params);
-    const processLine = async (line, write, messageHandler) => {
+    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;
         }
@@ -386,7 +557,12 @@ export function createServer(options) {
         }
         let handled;
         try {
-            handled = await messageHandler(request.method, request.params);
+            handled = await messageHandler(request.method, request.params, !isNotification && request.id !== null
+                ? {
+                    requestId: request.id,
+                    ...(request.method === "subscriptions/listen" ? { signal: subscriptionSignal } : {})
+                }
+                : undefined);
         }
         catch {
             if (!isNotification) {
@@ -419,6 +595,7 @@ export function createServer(options) {
         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);
@@ -431,19 +608,23 @@ export function createServer(options) {
             if (tools.has(name)) {
                 throw new Error(`Tool already registered: ${name}`);
             }
-            const inputValidator = compileToolSchema(inputSchema);
+            const inputSchemaSnapshot = normalizeLegacyNullability(inputSchema);
+            const outputSchemaSnapshot = outputSchema === undefined ? undefined : normalizeLegacyNullability(outputSchema);
+            const inputValidator = compileToolSchema(inputSchemaSnapshot);
+            assertObjectRootSchema(inputSchemaSnapshot, "inputSchema");
             let outputValidator;
-            if (outputSchema !== undefined) {
-                assertObjectRootSchema(outputSchema, "outputSchema");
-                outputValidator = compileToolSchema(outputSchema);
+            if (outputSchemaSnapshot !== undefined) {
+                assertOutputSchema(outputSchemaSnapshot);
+                outputValidator = compileToolSchema(outputSchemaSnapshot);
             }
             tools.set(name, {
                 name,
                 description,
-                inputSchema: inputSchema,
-                ...(outputSchema === undefined ? {} : { outputSchema: outputSchema }),
+                inputSchema: inputSchemaSnapshot,
+                ...(outputSchemaSnapshot === undefined ? {} : { outputSchema: outputSchemaSnapshot }),
                 handler: handler,
                 inputValidator,
+                parameterHeaders: getParameterHeaders(inputSchemaSnapshot),
                 ...(outputValidator === undefined ? {} : { outputValidator })
             });
             return server;
@@ -453,16 +634,22 @@ export function createServer(options) {
             if (tools.has(definition.name)) {
                 throw new Error(`Tool already registered: ${definition.name}`);
             }
-            const inputValidator = compileToolSchema(definition.inputSchema);
+            const descriptor = structuredClone(definition);
+            const inputSchema = normalizeLegacyNullability(descriptor.inputSchema);
+            const inputValidator = compileToolSchema(inputSchema);
+            assertObjectRootSchema(inputSchema, "inputSchema");
             let outputValidator;
-            if (definition.outputSchema !== undefined) {
-                assertObjectRootSchema(definition.outputSchema, "outputSchema");
-                outputValidator = compileToolSchema(definition.outputSchema);
+            if (descriptor.outputSchema !== undefined) {
+                descriptor.outputSchema = normalizeLegacyNullability(descriptor.outputSchema);
+                assertOutputSchema(descriptor.outputSchema);
+                outputValidator = compileToolSchema(descriptor.outputSchema);
             }
             tools.set(definition.name, {
-                ...definition,
+                ...descriptor,
+                inputSchema,
                 handler: handler,
                 inputValidator,
+                parameterHeaders: getParameterHeaders(inputSchema),
                 ...(outputValidator === undefined ? {} : { outputValidator })
             });
             return server;
@@ -472,7 +659,7 @@ export function createServer(options) {
             if (prompts.has(definition.name)) {
                 throw new Error(`Prompt already registered: ${definition.name}`);
             }
-            prompts.set(definition.name, { ...definition, handler });
+            prompts.set(definition.name, { ...structuredClone(definition), handler });
             return server;
         },
         resource(definition, handler) {
@@ -482,7 +669,7 @@ export function createServer(options) {
             if (resources.has(definition.uri)) {
                 throw new Error(`Resource already registered: ${definition.uri}`);
             }
-            resources.set(definition.uri, { ...definition, handler });
+            resources.set(definition.uri, { ...structuredClone(definition), handler });
             return server;
         },
         resourceTemplate(definition, handler) {
@@ -490,7 +677,7 @@ export function createServer(options) {
             if (resourceTemplates.has(definition.uriTemplate)) {
                 throw new Error(`Resource template already registered: ${definition.uriTemplate}`);
             }
-            resourceTemplates.set(definition.uriTemplate, { ...definition, handler, template });
+            resourceTemplates.set(definition.uriTemplate, { ...structuredClone(definition), handler, template });
             return server;
         },
         method(name, handler) {
@@ -518,19 +705,19 @@ export function createServer(options) {
         },
         async notifyToolsChanged() {
             if (supportNotifications &&
-                [...messageLifecycles].some((lifecycle) => lifecycle.notificationReady)) {
+                [...messageLifecycles].some((lifecycle) => lifecycle.notificationReady || lifecycle.subscriptions.size > 0)) {
                 await broadcastNotification("notifications/tools/list_changed");
             }
         },
         async notifyPromptsChanged() {
             if (supportNotifications &&
-                [...messageLifecycles].some((lifecycle) => lifecycle.notificationReady)) {
+                [...messageLifecycles].some((lifecycle) => lifecycle.notificationReady || lifecycle.subscriptions.size > 0)) {
                 await broadcastNotification("notifications/prompts/list_changed");
             }
         },
         async notifyResourcesChanged() {
             if (supportNotifications &&
-                [...messageLifecycles].some((lifecycle) => lifecycle.notificationReady)) {
+                [...messageLifecycles].some((lifecycle) => lifecycle.notificationReady || lifecycle.subscriptions.size > 0)) {
                 await broadcastNotification("notifications/resources/list_changed");
             }
         },
@@ -553,6 +740,7 @@ export function createServer(options) {
                 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);
@@ -596,7 +784,7 @@ export function createServer(options) {
                         fail(new Error("Stdio pending message limit exceeded"));
                         return;
                     }
-                    const message = processLine(line, data => output.write(data), session.handleMessage);
+                    const message = processLine(line, (data) => output.write(data), session.handleMessage, subscriptions.signal);
                     if (!settled)
                         pendingMessages.add(message);
                     void message.then(() => {
@@ -606,6 +794,7 @@ export function createServer(options) {
                 });
                 rl.on("close", () => {
                     inputClosed = true;
+                    subscriptions.abort();
                     finish();
                 });
                 transport.readable.pipe(input);
@@ -622,6 +811,10 @@ export function createServer(options) {
                     }
                     // 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;
                         }
@@ -645,9 +838,19 @@ export function createServer(options) {
                         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);
+                        handled = await session.handleMessage(request.method, request.params, request.id === null ? undefined : { requestId: request.id });
                     }
                     catch {
                         await transport.send({
@@ -718,15 +921,6 @@ function resourceNotFound(uri) {
 function toErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function isValidUri(uri) {
-    try {
-        new URL(uri);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 function assertNonEmptyName(name, message) {
     if (name.length === 0) {
         throw new Error(message);
@@ -765,57 +959,81 @@ function findReadableResource(uri, resources, resourceTemplates) {
     }
     return [...resourceTemplates.values()].find((template) => template.template.match(uri) !== null);
 }
-function isCallToolResult(value) {
+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 &&
-        !isJsonObject(value.structuredContent)) {
+        !(isJsonValue(value.structuredContent) && (modern || isJsonObject(value.structuredContent)))) {
         return false;
     }
     return !(hasOwnProperty(value, "isError") &&
         value.isError !== undefined &&
         typeof value.isError !== "boolean");
 }
-function normalizeToolResult(handlerResult, outputSchema) {
-    if (hasContentArray(handlerResult) && !isCallToolResult(handlerResult)) {
+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)
+        const result = isCallToolResult(handlerResult, modern)
             ? handlerResult
             : { content: toContentBlocks(handlerResult) };
-        if (!isCallToolResult(result)) {
+        if (!isCallToolResult(result, modern)) {
             throw new Error("Invalid tool result");
         }
         return result;
     }
-    if (isCallToolResult(handlerResult) && handlerResult.isError === true) {
+    if (isCallToolResult(handlerResult, modern) && handlerResult.isError === true) {
         return handlerResult;
     }
-    const callToolResult = isCallToolResult(handlerResult) ? handlerResult : undefined;
+    const callToolResult = isCallToolResult(handlerResult, modern) ? handlerResult : undefined;
     const structuredContent = callToolResult ? callToolResult.structuredContent : handlerResult;
-    if (!isJsonObject(structuredContent)) {
-        throw new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, "Structured tool result must be an object");
+    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) }],
-        ...(callToolResult?.isError !== undefined ? { isError: callToolResult.isError } : {}),
         structuredContent
     };
 }
 function assertObjectRootSchema(schema, path) {
-    if (schema.type !== "object") {
+    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) {
+function isGetPromptResult(value, modern = false) {
     if (typeof value !== "object" || value === null || !hasOwnProperty(value, "messages")) {
         return false;
     }
@@ -828,7 +1046,7 @@ function isGetPromptResult(value) {
             hasOwnProperty(message, "role") &&
             (message.role === "user" || message.role === "assistant") &&
             hasOwnProperty(message, "content") &&
-            isPromptContentItem(message.content)));
+            (modern ? isContentItem(message.content) : isPromptContentItem(message.content))));
 }
 function isReadResourceResult(value) {
     if (typeof value !== "object" || value === null || !hasOwnProperty(value, "contents")) {
@@ -915,25 +1133,6 @@ function hasValidContentAnnotations(value) {
         (priority === undefined || typeof priority === "number") &&
         (lastModified === undefined || typeof lastModified === "string"));
 }
-function isBase64(value) {
-    if (value.length === 0) {
-        return true;
-    }
-    if (value.length % 4 !== 0) {
-        return false;
-    }
-    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    const paddingStart = value.indexOf("=");
-    const encoded = paddingStart === -1 ? value : value.slice(0, paddingStart);
-    const padding = paddingStart === -1 ? "" : value.slice(paddingStart);
-    if (padding.length > 2 || [...padding].some((character) => character !== "=")) {
-        return false;
-    }
-    if ([...encoded].some((character) => !alphabet.includes(character))) {
-        return false;
-    }
-    return Buffer.from(value, "base64").toString("base64") === value;
-}
 function isPromptContentItem(value) {
     if (!isContentItem(value)) {
         return false;