@modelcontextprotocol/server 2.0.0-alpha.2 → 2.0.0-alpha.3

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { $ as PARSE_ERROR, A as parseJSONRPCMessage, B as ListRootsResultSchema, C as isInitializeRequest, D as isJSONRPCRequest, E as isJSONRPCNotification, F as CreateTaskResultSchema, G as ProtocolErrorCode, H as getResultSchema, I as ElicitResultSchema, J as INVALID_PARAMS, K as DEFAULT_NEGOTIATED_PROTOCOL_VERSION, L as EmptyResultSchema, M as CallToolResultSchema, N as CreateMessageResultSchema, O as isJSONRPCResultResponse, P as CreateMessageResultWithToolsSchema, Q as METHOD_NOT_FOUND, R as GetTaskPayloadResultSchema, S as assertCompleteRequestResourceTemplate, T as isJSONRPCErrorResponse, U as ProtocolError, V as LoggingLevelSchema, W as UrlElicitationRequiredError, X as JSONRPC_VERSION, Y as INVALID_REQUEST, Z as LATEST_PROTOCOL_VERSION, _ as mergeCapabilities, a as standardSchemaToJsonSchema, at as SdkError, b as parseSchema, c as createFetchWithInit, ct as OAuthErrorCode, d as deserializeMessage, et as RELATED_TASK_META_KEY, f as serializeMessage, g as Protocol, h as DEFAULT_REQUEST_TIMEOUT_MSEC, i as promptArgumentsFromStandardSchema, it as resourceUrlFromServerUrl, j as CallToolRequestSchema, k as isTaskAugmentedRequestParams, l as validateAndWarnToolName, m as toArrayAsync, n as CfWorkerJsonSchemaValidator, nt as getDisplayName, o as validateStandardSchema, ot as SdkErrorCode, p as takeResult, q as INTERNAL_ERROR, r as AjvJsonSchemaValidator, rt as checkResourceAllowed, s as UriTemplate, st as OAuthError, t as fromJsonSchema$1, tt as SUPPORTED_PROTOCOL_VERSIONS, u as ReadBuffer, v as extractTaskManagerOptions, w as isInitializedNotification, x as assertCompleteRequestPrompt, y as isTerminal, z as JSONRPCMessageSchema } from "./src-IKPjmxu7.mjs";
-import { DefaultJsonSchemaValidator, process } from "@modelcontextprotocol/server/_shims";
+import { $ as LATEST_PROTOCOL_VERSION, A as isTaskAugmentedRequestParams, B as LoggingLevelSchema, C as isInitializeRequest, D as isJSONRPCRequest, E as isJSONRPCNotification, F as CreateMessageResultWithToolsSchema, G as BAGGAGE_META_KEY, H as UnsupportedProtocolVersionError, I as ElicitResultSchema, J as DEFAULT_NEGOTIATED_PROTOCOL_VERSION, K as CLIENT_CAPABILITIES_META_KEY, L as EmptyResultSchema, M as CallToolRequestSchema, N as CallToolResultSchema, O as isJSONRPCResponse, P as CreateMessageResultSchema, Q as JSONRPC_VERSION, R as JSONRPCMessageSchema, S as isCallToolResult, T as isJSONRPCErrorResponse, U as UrlElicitationRequiredError, V as ProtocolError, W as ProtocolErrorCode, X as INVALID_PARAMS, Y as INTERNAL_ERROR, Z as INVALID_REQUEST, _ as validateStandardSchema, a as UriTemplate, at as SUPPORTED_PROTOCOL_VERSIONS, b as assertCompleteRequestPrompt, c as ReadBuffer, ct as getDisplayName, d as serializeMessage, dt as SdkError, et as LOG_LEVEL_META_KEY, f as DEFAULT_REQUEST_TIMEOUT_MSEC, ft as SdkErrorCode, g as standardSchemaToJsonSchema, h as promptArgumentsFromStandardSchema, ht as OAuthErrorCode, i as InMemoryTransport, it as RELATED_TASK_META_KEY, j as parseJSONRPCMessage, k as isJSONRPCResultResponse, l as STDIO_DEFAULT_MAX_BUFFER_SIZE, lt as checkResourceAllowed, m as mergeCapabilities, mt as OAuthError, n as normalizeRawShapeSchema, nt as PARSE_ERROR, o as createFetchWithInit, ot as TRACEPARENT_META_KEY, p as Protocol, pt as SdkHttpError, q as CLIENT_INFO_META_KEY, r as parseSchema, rt as PROTOCOL_VERSION_META_KEY, s as validateAndWarnToolName, st as TRACESTATE_META_KEY, t as fromJsonSchema$1, tt as METHOD_NOT_FOUND, u as deserializeMessage, ut as resourceUrlFromServerUrl, v as isSpecType, w as isInitializedNotification, x as assertCompleteRequestResourceTemplate, y as specTypeSchemas, z as ListRootsResultSchema } from "./src-Pa1iAvsj.mjs";
+import { DefaultJsonSchemaValidator } from "@modelcontextprotocol/server/_shims";
 
 //#region src/server/completable.ts
 const COMPLETABLE_SYMBOL = Symbol.for("mcp.completable");
@@ -56,504 +56,6 @@ function getCompleter(schema) {
 	return schema[COMPLETABLE_SYMBOL]?.complete;
 }
 
-//#endregion
-//#region ../core/src/experimental/tasks/helpers.ts
-/**
-* Experimental task capability assertion helpers.
-* WARNING: These APIs are experimental and may change without notice.
-*
-* @experimental
-*/
-/**
-* Asserts that task creation is supported for `tools/call`.
-* Used to implement the `assertTaskCapability` or `assertTaskHandlerCapability` abstract methods on Protocol.
-*
-* @param requests - The task requests capability object
-* @param method - The method being checked
-* @param entityName - `'Server'` or `'Client'` for error messages
-* @throws {@linkcode SdkError} with {@linkcode SdkErrorCode.CapabilityNotSupported} if the capability is not supported
-*
-* @experimental
-*/
-function assertToolsCallTaskCapability(requests, method, entityName) {
-	if (!requests) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `${entityName} does not support task creation (required for ${method})`);
-	switch (method) {
-		case "tools/call":
-			if (!requests.tools?.call) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `${entityName} does not support task creation for tools/call (required for ${method})`);
-			break;
-		default: break;
-	}
-}
-/**
-* Asserts that task creation is supported for `sampling/createMessage` or `elicitation/create`.
-* Used to implement the `assertTaskCapability` or `assertTaskHandlerCapability` abstract methods on Protocol.
-*
-* @param requests - The task requests capability object
-* @param method - The method being checked
-* @param entityName - `'Server'` or `'Client'` for error messages
-* @throws {@linkcode SdkError} with {@linkcode SdkErrorCode.CapabilityNotSupported} if the capability is not supported
-*
-* @experimental
-*/
-function assertClientRequestTaskCapability(requests, method, entityName) {
-	if (!requests) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `${entityName} does not support task creation (required for ${method})`);
-	switch (method) {
-		case "sampling/createMessage":
-			if (!requests.sampling?.createMessage) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
-			break;
-		case "elicitation/create":
-			if (!requests.elicitation?.create) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `${entityName} does not support task creation for elicitation/create (required for ${method})`);
-			break;
-		default: break;
-	}
-}
-
-//#endregion
-//#region ../core/src/experimental/tasks/stores/inMemory.ts
-/**
-* In-memory {@linkcode TaskStore} implementation for development and testing.
-* For production, use a database or distributed cache.
-* @experimental
-*/
-var InMemoryTaskStore = class {
-	tasks = /* @__PURE__ */ new Map();
-	cleanupTimers = /* @__PURE__ */ new Map();
-	/**
-	* Generates a unique task ID using Web Crypto API.
-	*/
-	generateTaskId() {
-		return crypto.randomUUID().replaceAll("-", "");
-	}
-	/** {@inheritDoc TaskStore.createTask} */
-	async createTask(taskParams, requestId, request, sessionId) {
-		const taskId = this.generateTaskId();
-		if (this.tasks.has(taskId)) throw new Error(`Task with ID ${taskId} already exists`);
-		const actualTtl = taskParams.ttl ?? null;
-		const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-		const task = {
-			taskId,
-			status: "working",
-			ttl: actualTtl,
-			createdAt,
-			lastUpdatedAt: createdAt,
-			pollInterval: taskParams.pollInterval ?? 1e3
-		};
-		this.tasks.set(taskId, {
-			task,
-			request,
-			requestId,
-			sessionId
-		});
-		if (actualTtl) {
-			const timer = setTimeout(() => {
-				this.tasks.delete(taskId);
-				this.cleanupTimers.delete(taskId);
-			}, actualTtl);
-			this.cleanupTimers.set(taskId, timer);
-		}
-		return task;
-	}
-	/**
-	* Retrieves a stored task, enforcing session ownership when a sessionId is provided.
-	* Returns undefined if the task does not exist or belongs to a different session.
-	*/
-	getStoredTask(taskId, sessionId) {
-		const stored = this.tasks.get(taskId);
-		if (!stored) return;
-		if (sessionId !== void 0 && stored.sessionId !== void 0 && stored.sessionId !== sessionId) return;
-		return stored;
-	}
-	async getTask(taskId, sessionId) {
-		const stored = this.getStoredTask(taskId, sessionId);
-		return stored ? { ...stored.task } : null;
-	}
-	/** {@inheritDoc TaskStore.storeTaskResult} */
-	async storeTaskResult(taskId, status, result, sessionId) {
-		const stored = this.getStoredTask(taskId, sessionId);
-		if (!stored) throw new Error(`Task with ID ${taskId} not found`);
-		if (isTerminal(stored.task.status)) throw new Error(`Cannot store result for task ${taskId} in terminal status '${stored.task.status}'. Task results can only be stored once.`);
-		stored.result = result;
-		stored.task.status = status;
-		stored.task.lastUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
-		if (stored.task.ttl) {
-			const existingTimer = this.cleanupTimers.get(taskId);
-			if (existingTimer) clearTimeout(existingTimer);
-			const timer = setTimeout(() => {
-				this.tasks.delete(taskId);
-				this.cleanupTimers.delete(taskId);
-			}, stored.task.ttl);
-			this.cleanupTimers.set(taskId, timer);
-		}
-	}
-	/** {@inheritDoc TaskStore.getTaskResult} */
-	async getTaskResult(taskId, sessionId) {
-		const stored = this.getStoredTask(taskId, sessionId);
-		if (!stored) throw new Error(`Task with ID ${taskId} not found`);
-		if (!stored.result) throw new Error(`Task ${taskId} has no result stored`);
-		return stored.result;
-	}
-	/** {@inheritDoc TaskStore.updateTaskStatus} */
-	async updateTaskStatus(taskId, status, statusMessage, sessionId) {
-		const stored = this.getStoredTask(taskId, sessionId);
-		if (!stored) throw new Error(`Task with ID ${taskId} not found`);
-		if (isTerminal(stored.task.status)) throw new Error(`Cannot update task ${taskId} from terminal status '${stored.task.status}' to '${status}'. Terminal states (completed, failed, cancelled) cannot transition to other states.`);
-		stored.task.status = status;
-		if (statusMessage) stored.task.statusMessage = statusMessage;
-		stored.task.lastUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
-		if (isTerminal(status) && stored.task.ttl) {
-			const existingTimer = this.cleanupTimers.get(taskId);
-			if (existingTimer) clearTimeout(existingTimer);
-			const timer = setTimeout(() => {
-				this.tasks.delete(taskId);
-				this.cleanupTimers.delete(taskId);
-			}, stored.task.ttl);
-			this.cleanupTimers.set(taskId, timer);
-		}
-	}
-	/** {@inheritDoc TaskStore.listTasks} */
-	async listTasks(cursor, sessionId) {
-		const PAGE_SIZE = 10;
-		const filteredTaskIds = [...this.tasks.entries()].filter(([, stored]) => {
-			if (sessionId === void 0 || stored.sessionId === void 0) return true;
-			return stored.sessionId === sessionId;
-		}).map(([taskId]) => taskId);
-		let startIndex = 0;
-		if (cursor) {
-			const cursorIndex = filteredTaskIds.indexOf(cursor);
-			if (cursorIndex === -1) throw new Error(`Invalid cursor: ${cursor}`);
-			else startIndex = cursorIndex + 1;
-		}
-		const pageTaskIds = filteredTaskIds.slice(startIndex, startIndex + PAGE_SIZE);
-		return {
-			tasks: pageTaskIds.map((taskId) => {
-				return { ...this.tasks.get(taskId).task };
-			}),
-			nextCursor: startIndex + PAGE_SIZE < filteredTaskIds.length ? pageTaskIds.at(-1) : void 0
-		};
-	}
-	/**
-	* Cleanup all timers (useful for testing or graceful shutdown)
-	*/
-	cleanup() {
-		for (const timer of this.cleanupTimers.values()) clearTimeout(timer);
-		this.cleanupTimers.clear();
-		this.tasks.clear();
-	}
-	/**
-	* Get all tasks (useful for debugging)
-	*/
-	getAllTasks() {
-		return [...this.tasks.values()].map((stored) => ({ ...stored.task }));
-	}
-};
-/**
-* In-memory {@linkcode TaskMessageQueue} implementation for development and testing.
-* For production, use Redis or another distributed queue.
-* @experimental
-*/
-var InMemoryTaskMessageQueue = class {
-	queues = /* @__PURE__ */ new Map();
-	/**
-	* Generates a queue key from taskId.
-	* SessionId is intentionally ignored because taskIds are globally unique
-	* and tasks need to be accessible across HTTP requests/sessions.
-	*/
-	getQueueKey(taskId, _sessionId) {
-		return taskId;
-	}
-	/**
-	* Gets or creates a queue for the given task and session.
-	*/
-	getQueue(taskId, sessionId) {
-		const key = this.getQueueKey(taskId, sessionId);
-		let queue = this.queues.get(key);
-		if (!queue) {
-			queue = [];
-			this.queues.set(key, queue);
-		}
-		return queue;
-	}
-	/**
-	* Adds a message to the end of the queue for a specific task.
-	* Atomically checks queue size and throws if maxSize would be exceeded.
-	* @param taskId The task identifier
-	* @param message The message to enqueue
-	* @param sessionId Optional session ID for binding the operation to a specific session
-	* @param maxSize Optional maximum queue size - if specified and queue is full, throws an error
-	* @throws Error if maxSize is specified and would be exceeded
-	*/
-	async enqueue(taskId, message, sessionId, maxSize) {
-		const queue = this.getQueue(taskId, sessionId);
-		if (maxSize !== void 0 && queue.length >= maxSize) throw new Error(`Task message queue overflow: queue size (${queue.length}) exceeds maximum (${maxSize})`);
-		queue.push(message);
-	}
-	/**
-	* Removes and returns the first message from the queue for a specific task.
-	* @param taskId The task identifier
-	* @param sessionId Optional session ID for binding the query to a specific session
-	* @returns The first message, or `undefined` if the queue is empty
-	*/
-	async dequeue(taskId, sessionId) {
-		return this.getQueue(taskId, sessionId).shift();
-	}
-	/**
-	* Removes and returns all messages from the queue for a specific task.
-	* @param taskId The task identifier
-	* @param sessionId Optional session ID for binding the query to a specific session
-	* @returns Array of all messages that were in the queue
-	*/
-	async dequeueAll(taskId, sessionId) {
-		const key = this.getQueueKey(taskId, sessionId);
-		const queue = this.queues.get(key) ?? [];
-		this.queues.delete(key);
-		return queue;
-	}
-};
-
-//#endregion
-//#region src/experimental/tasks/mcpServer.ts
-/**
-* Experimental task features for {@linkcode McpServer}.
-*
-* Access via `server.experimental.tasks`:
-* ```typescript
-* server.experimental.tasks.registerToolTask('long-running', config, handler);
-* ```
-*
-* @experimental
-*/
-var ExperimentalMcpServerTasks = class {
-	constructor(_mcpServer) {
-		this._mcpServer = _mcpServer;
-	}
-	registerToolTask(name, config, handler) {
-		const execution = {
-			taskSupport: "required",
-			...config.execution
-		};
-		if (execution.taskSupport === "forbidden") throw new Error(`Cannot register task-based tool '${name}' with taskSupport 'forbidden'. Use registerTool() instead.`);
-		return this._mcpServer._createRegisteredTool(name, config.title, config.description, config.inputSchema, config.outputSchema, config.annotations, execution, config._meta, handler);
-	}
-};
-
-//#endregion
-//#region src/experimental/tasks/server.ts
-/**
-* Experimental task features for low-level MCP servers.
-*
-* Access via `server.experimental.tasks`:
-* ```typescript
-* const stream = server.experimental.tasks.requestStream(request, options);
-* ```
-*
-* For high-level server usage with task-based tools, use {@linkcode index.McpServer | McpServer}.experimental.tasks instead.
-*
-* @experimental
-*/
-var ExperimentalServerTasks = class {
-	constructor(_server) {
-		this._server = _server;
-	}
-	get _module() {
-		return this._server.taskManager;
-	}
-	/**
-	* Sends a request and returns an AsyncGenerator that yields response messages.
-	* The generator is guaranteed to end with either a `'result'` or `'error'` message.
-	*
-	* This method provides streaming access to request processing, allowing you to
-	* observe intermediate task status updates for task-augmented requests.
-	*
-	* @param request - The request to send (method name determines the result schema)
-	* @param options - Optional request options (timeout, signal, task creation params, etc.)
-	* @returns AsyncGenerator that yields {@linkcode ResponseMessage} objects
-	*
-	* @experimental
-	*/
-	requestStream(request, options) {
-		const resultSchema = getResultSchema(request.method);
-		return this._module.requestStream(request, resultSchema, options);
-	}
-	/**
-	* Sends a sampling request and returns an AsyncGenerator that yields response messages.
-	* The generator is guaranteed to end with either a 'result' or 'error' message.
-	*
-	* For task-augmented requests, yields 'taskCreated' and 'taskStatus' messages
-	* before the final result.
-	*
-	* @example
-	* ```typescript
-	* const stream = server.experimental.tasks.createMessageStream({
-	*     messages: [{ role: 'user', content: { type: 'text', text: 'Hello' } }],
-	*     maxTokens: 100
-	* }, {
-	*     onprogress: (progress) => {
-	*         // Handle streaming tokens via progress notifications
-	*         console.log('Progress:', progress.message);
-	*     }
-	* });
-	*
-	* for await (const message of stream) {
-	*     switch (message.type) {
-	*         case 'taskCreated':
-	*             console.log('Task created:', message.task.taskId);
-	*             break;
-	*         case 'taskStatus':
-	*             console.log('Task status:', message.task.status);
-	*             break;
-	*         case 'result':
-	*             console.log('Final result:', message.result);
-	*             break;
-	*         case 'error':
-	*             console.error('Error:', message.error);
-	*             break;
-	*     }
-	* }
-	* ```
-	*
-	* @param params - The sampling request parameters
-	* @param options - Optional request options (timeout, signal, task creation params, onprogress, etc.)
-	* @returns AsyncGenerator that yields ResponseMessage objects
-	*
-	* @experimental
-	*/
-	createMessageStream(params, options) {
-		const clientCapabilities = this._server.getClientCapabilities();
-		if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) throw new SdkError(SdkErrorCode.CapabilityNotSupported, "Client does not support sampling tools capability.");
-		if (params.messages.length > 0) {
-			const lastMessage = params.messages.at(-1);
-			const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
-			const hasToolResults = lastContent.some((c) => c.type === "tool_result");
-			const previousMessage = params.messages.length > 1 ? params.messages.at(-2) : void 0;
-			const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
-			const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
-			if (hasToolResults) {
-				if (lastContent.some((c) => c.type !== "tool_result")) throw new Error("The last message must contain only tool_result content if any is present");
-				if (!hasPreviousToolUse) throw new Error("tool_result blocks are not matching any tool_use from the previous message");
-			}
-			if (hasPreviousToolUse) {
-				const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
-				const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
-				if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
-			}
-		}
-		return this.requestStream({
-			method: "sampling/createMessage",
-			params
-		}, options);
-	}
-	/**
-	* Sends an elicitation request and returns an AsyncGenerator that yields response messages.
-	* The generator is guaranteed to end with either a 'result' or 'error' message.
-	*
-	* For task-augmented requests (especially URL-based elicitation), yields 'taskCreated'
-	* and 'taskStatus' messages before the final result.
-	*
-	* @example
-	* ```typescript
-	* const stream = server.experimental.tasks.elicitInputStream({
-	*     mode: 'url',
-	*     message: 'Please authenticate',
-	*     elicitationId: 'auth-123',
-	*     url: 'https://example.com/auth'
-	* }, {
-	*     task: { ttl: 300000 } // Task-augmented for long-running auth flow
-	* });
-	*
-	* for await (const message of stream) {
-	*     switch (message.type) {
-	*         case 'taskCreated':
-	*             console.log('Task created:', message.task.taskId);
-	*             break;
-	*         case 'taskStatus':
-	*             console.log('Task status:', message.task.status);
-	*             break;
-	*         case 'result':
-	*             console.log('User action:', message.result.action);
-	*             break;
-	*         case 'error':
-	*             console.error('Error:', message.error);
-	*             break;
-	*     }
-	* }
-	* ```
-	*
-	* @param params - The elicitation request parameters
-	* @param options - Optional request options (timeout, signal, task creation params, etc.)
-	* @returns AsyncGenerator that yields ResponseMessage objects
-	*
-	* @experimental
-	*/
-	elicitInputStream(params, options) {
-		const clientCapabilities = this._server.getClientCapabilities();
-		const mode = params.mode ?? "form";
-		switch (mode) {
-			case "url":
-				if (!clientCapabilities?.elicitation?.url) throw new SdkError(SdkErrorCode.CapabilityNotSupported, "Client does not support url elicitation.");
-				break;
-			case "form":
-				if (!clientCapabilities?.elicitation?.form) throw new SdkError(SdkErrorCode.CapabilityNotSupported, "Client does not support form elicitation.");
-				break;
-		}
-		const normalizedParams = mode === "form" && params.mode !== "form" ? {
-			...params,
-			mode: "form"
-		} : params;
-		return this.requestStream({
-			method: "elicitation/create",
-			params: normalizedParams
-		}, options);
-	}
-	/**
-	* Gets the current status of a task.
-	*
-	* @param taskId - The task identifier
-	* @param options - Optional request options
-	* @returns The task status
-	*
-	* @experimental
-	*/
-	async getTask(taskId, options) {
-		return this._module.getTask({ taskId }, options);
-	}
-	/**
-	* Retrieves the result of a completed task.
-	*
-	* @param taskId - The task identifier
-	* @param options - Optional request options
-	* @returns The task result. The payload structure matches the result type of the
-	*   original request (e.g., a `tools/call` task returns a `CallToolResult`).
-	*
-	* @experimental
-	*/
-	async getTaskResult(taskId, options) {
-		return this._module.getTaskResult({ taskId }, GetTaskPayloadResultSchema, options);
-	}
-	/**
-	* Lists tasks with optional pagination.
-	*
-	* @param cursor - Optional pagination cursor
-	* @param options - Optional request options
-	* @returns List of tasks with optional next cursor
-	*
-	* @experimental
-	*/
-	async listTasks(cursor, options) {
-		return this._module.listTasks(cursor ? { cursor } : void 0, options);
-	}
-	/**
-	* Cancels a running task.
-	*
-	* @param taskId - The task identifier
-	* @param options - Optional request options
-	*
-	* @experimental
-	*/
-	async cancelTask(taskId, options) {
-		return this._module.cancelTask({ taskId }, options);
-	}
-};
-
 //#endregion
 //#region src/server/server.ts
 /**
@@ -566,10 +68,10 @@ var ExperimentalServerTasks = class {
 var Server = class extends Protocol {
 	_clientCapabilities;
 	_clientVersion;
+	_negotiatedProtocolVersion;
 	_capabilities;
 	_instructions;
 	_jsonSchemaValidator;
-	_experimental;
 	/**
 	* Callback for when initialization has fully completed (i.e., the client has sent an `notifications/initialized` notification).
 	*/
@@ -578,22 +80,22 @@ var Server = class extends Protocol {
 	* Initializes this server with the given name and version information.
 	*/
 	constructor(_serverInfo, options) {
-		super({
-			...options,
-			tasks: extractTaskManagerOptions(options?.capabilities?.tasks)
-		});
+		super(options);
 		this._serverInfo = _serverInfo;
 		this._capabilities = options?.capabilities ? { ...options.capabilities } : {};
 		this._instructions = options?.instructions;
 		this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new DefaultJsonSchemaValidator();
-		if (options?.capabilities?.tasks) {
-			const { taskStore, taskMessageQueue, defaultTaskPollInterval, maxTaskQueueSize, ...wireCapabilities } = options.capabilities.tasks;
-			this._capabilities.tasks = wireCapabilities;
-		}
 		this.setRequestHandler("initialize", (request) => this._oninitialize(request));
 		this.setNotificationHandler("notifications/initialized", () => this.oninitialized?.());
 		if (this._capabilities.logging) this._registerLoggingHandler();
 	}
+	/**
+	* Registers the built-in `logging/setLevel` request handler.
+	*
+	* @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
+	* Remains functional during the deprecation window (at least twelve months).
+	* Migrate to stderr logging (STDIO servers) or OpenTelemetry.
+	*/
 	_registerLoggingHandler() {
 		this.setRequestHandler("logging/setLevel", async (request, ctx) => {
 			const transportSessionId = ctx.sessionId || ctx.http?.req?.headers.get("mcp-session-id") || void 0;
@@ -625,17 +127,6 @@ var Server = class extends Protocol {
 			} : void 0
 		};
 	}
-	/**
-	* Access experimental features.
-	*
-	* WARNING: These APIs are experimental and may change without notice.
-	*
-	* @experimental
-	*/
-	get experimental() {
-		if (!this._experimental) this._experimental = { tasks: new ExperimentalServerTasks(this) };
-		return this._experimental;
-	}
 	_loggingLevels = /* @__PURE__ */ new Map();
 	LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
 	isMessageIgnored = (level, sessionId) => {
@@ -654,36 +145,24 @@ var Server = class extends Protocol {
 		if (!hadLogging && this._capabilities.logging) this._registerLoggingHandler();
 	}
 	/**
-	* Override request handler registration to enforce server-side validation for `tools/call`.
+	* Enforces server-side validation for `tools/call` results regardless of how the
+	* handler was registered.
 	*/
-	setRequestHandler(method, handler) {
-		if (method === "tools/call") {
-			const wrappedHandler = async (request, ctx) => {
-				const validatedRequest = parseSchema(CallToolRequestSchema, request);
-				if (!validatedRequest.success) {
-					const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
-					throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
-				}
-				const { params } = validatedRequest.data;
-				const result = await Promise.resolve(handler(request, ctx));
-				if (params.task) {
-					const taskValidationResult = parseSchema(CreateTaskResultSchema, result);
-					if (!taskValidationResult.success) {
-						const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
-						throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
-					}
-					return taskValidationResult.data;
-				}
-				const validationResult = parseSchema(CallToolResultSchema, result);
-				if (!validationResult.success) {
-					const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
-					throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
-				}
-				return validationResult.data;
-			};
-			return super.setRequestHandler(method, wrappedHandler);
-		}
-		return super.setRequestHandler(method, handler);
+	_wrapHandler(method, handler) {
+		if (method !== "tools/call") return handler;
+		return async (request, ctx) => {
+			const validatedRequest = parseSchema(CallToolRequestSchema, request);
+			if (!validatedRequest.success) {
+				const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+				throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
+			}
+			const validationResult = parseSchema(CallToolResultSchema, await handler(request, ctx));
+			if (!validationResult.success) {
+				const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+				throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
+			}
+			return validationResult.data;
+		};
 	}
 	assertCapabilityForMethod(method) {
 		switch (method) {
@@ -746,17 +225,12 @@ var Server = class extends Protocol {
 			case "initialize": break;
 		}
 	}
-	assertTaskCapability(method) {
-		assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, "Client");
-	}
-	assertTaskHandlerCapability(method) {
-		assertToolsCallTaskCapability(this._capabilities?.tasks?.requests, method, "Server");
-	}
 	async _oninitialize(request) {
 		const requestedVersion = request.params.protocolVersion;
 		this._clientCapabilities = request.params.capabilities;
 		this._clientVersion = request.params.clientInfo;
 		const protocolVersion = this._supportedProtocolVersions.includes(requestedVersion) ? requestedVersion : this._supportedProtocolVersions[0] ?? LATEST_PROTOCOL_VERSION;
+		this._negotiatedProtocolVersion = protocolVersion;
 		this.transport?.setProtocolVersion?.(protocolVersion);
 		return {
 			protocolVersion,
@@ -778,6 +252,14 @@ var Server = class extends Protocol {
 		return this._clientVersion;
 	}
 	/**
+	* After initialization has completed, this will be populated with the protocol version negotiated
+	* with the client (the version the server responded with during the initialize handshake), or
+	* `undefined` before initialization.
+	*/
+	getNegotiatedProtocolVersion() {
+		return this._negotiatedProtocolVersion;
+	}
+	/**
 	* Returns the current server capabilities.
 	*/
 	getCapabilities() {
@@ -867,6 +349,13 @@ var Server = class extends Protocol {
 			params: { elicitationId }
 		}, options);
 	}
+	/**
+	* Requests the list of roots from the client.
+	*
+	* @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
+	* Remains functional during the deprecation window (at least twelve months).
+	* Migrate to passing paths via tool parameters, resource URIs, or configuration.
+	*/
 	async listRoots(params, options) {
 		return this._requestWithSchema({
 			method: "roots/list",
@@ -879,6 +368,10 @@ var Server = class extends Protocol {
 	* @see {@linkcode LoggingMessageNotification}
 	* @param params
 	* @param sessionId Optional for stateless transports and backward compatibility.
+	*
+	* @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
+	* Remains functional during the deprecation window (at least twelve months).
+	* Migrate to stderr logging (STDIO servers) or OpenTelemetry.
 	*/
 	async sendLoggingMessage(params, sessionId) {
 		if (this._capabilities.logging && !this.isMessageIgnored(params.level, sessionId)) return this.notification({
@@ -927,20 +420,11 @@ var McpServer = class {
 	_registeredResourceTemplates = {};
 	_registeredTools = {};
 	_registeredPrompts = {};
-	_experimental;
 	constructor(serverInfo, options) {
 		this.server = new Server(serverInfo, options);
-	}
-	/**
-	* Access experimental features.
-	*
-	* WARNING: These APIs are experimental and may change without notice.
-	*
-	* @experimental
-	*/
-	get experimental() {
-		if (!this._experimental) this._experimental = { tasks: new ExperimentalMcpServerTasks(this) };
-		return this._experimental;
+		if (options?.capabilities?.tools) this.setToolRequestHandlers();
+		if (options?.capabilities?.resources) this.setResourceRequestHandlers();
+		if (options?.capabilities?.prompts) this.setPromptRequestHandlers();
 	}
 	/**
 	* Attaches to the given transport, starts it, and starts listening for messages.
@@ -976,6 +460,7 @@ var McpServer = class {
 				description: tool.description,
 				inputSchema: tool.inputSchema ? standardSchemaToJsonSchema(tool.inputSchema, "input") : EMPTY_OBJECT_JSON_SCHEMA,
 				annotations: tool.annotations,
+				icons: tool.icons,
 				execution: tool.execution,
 				_meta: tool._meta
 			};
@@ -987,15 +472,8 @@ var McpServer = class {
 			if (!tool) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
 			if (!tool.enabled) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Tool ${request.params.name} disabled`);
 			try {
-				const isTaskRequest = !!request.params.task;
-				const taskSupport = tool.execution?.taskSupport;
-				const isTaskHandler = "createTask" in tool.handler;
-				if ((taskSupport === "required" || taskSupport === "optional") && !isTaskHandler) throw new ProtocolError(ProtocolErrorCode.InternalError, `Tool ${request.params.name} has taskSupport '${taskSupport}' but was not registered with registerToolTask`);
-				if (taskSupport === "required" && !isTaskRequest) throw new ProtocolError(ProtocolErrorCode.MethodNotFound, `Tool ${request.params.name} requires task augmentation (taskSupport: 'required')`);
-				if (taskSupport === "optional" && !isTaskRequest && isTaskHandler) return await this.handleAutomaticTaskPolling(tool, request, ctx);
 				const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
 				const result = await this.executeToolHandler(tool, args, ctx);
-				if (isTaskRequest) return result;
 				await this.validateToolOutput(tool, result, request.params.name);
 				return result;
 			} catch (error) {
@@ -1034,36 +512,17 @@ var McpServer = class {
 	*/
 	async validateToolOutput(tool, result, toolName) {
 		if (!tool.outputSchema) return;
-		if (!("content" in result)) return;
 		if (result.isError) return;
 		if (!result.structuredContent) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`);
 		const parseResult = await validateStandardSchema(tool.outputSchema, result.structuredContent);
 		if (!parseResult.success) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${parseResult.error}`);
 	}
 	/**
-	* Executes a tool handler (either regular or task-based).
+	* Executes a tool handler.
 	*/
 	async executeToolHandler(tool, args, ctx) {
 		return tool.executor(args, ctx);
 	}
-	/**
-	* Handles automatic task polling for tools with `taskSupport` `'optional'`.
-	*/
-	async handleAutomaticTaskPolling(tool, request, ctx) {
-		if (!ctx.task?.store) throw new Error("No task store provided for task-capable tool.");
-		const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
-		const createTaskResult = await tool.executor(args, ctx);
-		const taskId = createTaskResult.task.taskId;
-		let task = createTaskResult.task;
-		const pollInterval = task.pollInterval ?? 5e3;
-		while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-			await new Promise((resolve) => setTimeout(resolve, pollInterval));
-			const updatedTask = await ctx.task.store.getTask(taskId);
-			if (!updatedTask) throw new ProtocolError(ProtocolErrorCode.InternalError, `Task ${taskId} not found during polling`);
-			task = updatedTask;
-		}
-		return await ctx.task.store.getTaskResult(taskId);
-	}
 	_completionHandlerInitialized = false;
 	setCompletionRequestHandler() {
 		if (this._completionHandlerInitialized) return;
@@ -1161,6 +620,7 @@ var McpServer = class {
 				title: prompt.title,
 				description: prompt.description,
 				arguments: prompt.argsSchema ? promptArgumentsFromStandardSchema(prompt.argsSchema) : void 0,
+				icons: prompt.icons,
 				_meta: prompt._meta
 			};
 		}) }));
@@ -1241,13 +701,14 @@ var McpServer = class {
 		if (Array.isArray(variableNames) && variableNames.some((v) => !!template.completeCallback(v))) this.setCompletionRequestHandler();
 		return registeredResourceTemplate;
 	}
-	_createRegisteredPrompt(name, title, description, argsSchema, callback, _meta) {
+	_createRegisteredPrompt(name, title, description, argsSchema, callback, icons, _meta) {
 		let currentArgsSchema = argsSchema;
 		let currentCallback = callback;
 		const registeredPrompt = {
 			title,
 			description,
 			argsSchema,
+			icons,
 			_meta,
 			handler: createPromptHandler(name, argsSchema, callback),
 			enabled: true,
@@ -1261,6 +722,7 @@ var McpServer = class {
 				}
 				if (updates.title !== void 0) registeredPrompt.title = updates.title;
 				if (updates.description !== void 0) registeredPrompt.description = updates.description;
+				if (updates.icons !== void 0) registeredPrompt.icons = updates.icons;
 				if (updates._meta !== void 0) registeredPrompt._meta = updates._meta;
 				let needsHandlerRegen = false;
 				if (updates.argsSchema !== void 0) {
@@ -1288,7 +750,7 @@ var McpServer = class {
 		}
 		return registeredPrompt;
 	}
-	_createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, execution, _meta, handler) {
+	_createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, icons, execution, _meta, handler) {
 		validateAndWarnToolName(name);
 		let currentHandler = handler;
 		const registeredTool = {
@@ -1297,6 +759,7 @@ var McpServer = class {
 			inputSchema,
 			outputSchema,
 			annotations,
+			icons,
 			execution,
 			_meta,
 			handler,
@@ -1326,6 +789,7 @@ var McpServer = class {
 				if (needsExecutorRegen) registeredTool.executor = createToolExecutor(registeredTool.inputSchema, currentHandler);
 				if (updates.outputSchema !== void 0) registeredTool.outputSchema = updates.outputSchema;
 				if (updates.annotations !== void 0) registeredTool.annotations = updates.annotations;
+				if (updates.icons !== void 0) registeredTool.icons = updates.icons;
 				if (updates._meta !== void 0) registeredTool._meta = updates._meta;
 				if (updates.enabled !== void 0) registeredTool.enabled = updates.enabled;
 				this.sendToolListChanged();
@@ -1336,67 +800,15 @@ var McpServer = class {
 		this.sendToolListChanged();
 		return registeredTool;
 	}
-	/**
-	* Registers a tool with a config object and callback.
-	*
-	* @example
-	* ```ts source="./mcp.examples.ts#McpServer_registerTool_basic"
-	* server.registerTool(
-	*     'calculate-bmi',
-	*     {
-	*         title: 'BMI Calculator',
-	*         description: 'Calculate Body Mass Index',
-	*         inputSchema: z.object({
-	*             weightKg: z.number(),
-	*             heightM: z.number()
-	*         }),
-	*         outputSchema: z.object({ bmi: z.number() })
-	*     },
-	*     async ({ weightKg, heightM }) => {
-	*         const output = { bmi: weightKg / (heightM * heightM) };
-	*         return {
-	*             content: [{ type: 'text', text: JSON.stringify(output) }],
-	*             structuredContent: output
-	*         };
-	*     }
-	* );
-	* ```
-	*/
 	registerTool(name, config, cb) {
 		if (this._registeredTools[name]) throw new Error(`Tool ${name} is already registered`);
-		const { title, description, inputSchema, outputSchema, annotations, _meta } = config;
-		return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, _meta, cb);
+		const { title, description, inputSchema, outputSchema, annotations, icons, _meta } = config;
+		return this._createRegisteredTool(name, title, description, normalizeRawShapeSchema(inputSchema), normalizeRawShapeSchema(outputSchema), annotations, icons, void 0, _meta, cb);
 	}
-	/**
-	* Registers a prompt with a config object and callback.
-	*
-	* @example
-	* ```ts source="./mcp.examples.ts#McpServer_registerPrompt_basic"
-	* server.registerPrompt(
-	*     'review-code',
-	*     {
-	*         title: 'Code Review',
-	*         description: 'Review code for best practices',
-	*         argsSchema: z.object({ code: z.string() })
-	*     },
-	*     ({ code }) => ({
-	*         messages: [
-	*             {
-	*                 role: 'user' as const,
-	*                 content: {
-	*                     type: 'text' as const,
-	*                     text: `Please review this code:\n\n${code}`
-	*                 }
-	*             }
-	*         ]
-	*     })
-	* );
-	* ```
-	*/
 	registerPrompt(name, config, cb) {
 		if (this._registeredPrompts[name]) throw new Error(`Prompt ${name} is already registered`);
-		const { title, description, argsSchema, _meta } = config;
-		const registeredPrompt = this._createRegisteredPrompt(name, title, description, argsSchema, cb, _meta);
+		const { title, description, argsSchema, icons, _meta } = config;
+		const registeredPrompt = this._createRegisteredPrompt(name, title, description, normalizeRawShapeSchema(argsSchema), cb, icons, _meta);
 		this.setPromptRequestHandlers();
 		this.sendPromptListChanged();
 		return registeredPrompt;
@@ -1422,6 +834,10 @@ var McpServer = class {
 	*     data: 'Processing complete'
 	* });
 	* ```
+	*
+	* @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
+	* Remains functional during the deprecation window (at least twelve months).
+	* Migrate to stderr logging (STDIO servers) or OpenTelemetry.
 	*/
 	async sendLoggingMessage(params, sessionId) {
 		return this.server.sendLoggingMessage(params, sessionId);
@@ -1480,21 +896,6 @@ var ResourceTemplate = class {
 * When `inputSchema` is undefined, the handler is called with just `(ctx)`.
 */
 function createToolExecutor(inputSchema, handler) {
-	if ("createTask" in handler) {
-		const taskHandler = handler;
-		return async (args, ctx) => {
-			if (!ctx.task?.store) throw new Error("No task store provided.");
-			const taskCtx = {
-				...ctx,
-				task: {
-					store: ctx.task.store,
-					requestedTtl: ctx.task?.requestedTtl
-				}
-			};
-			if (inputSchema) return taskHandler.createTask(args, taskCtx);
-			return taskHandler.createTask(taskCtx);
-		};
-	}
 	if (inputSchema) {
 		const callback$1 = handler;
 		return async (args, ctx) => callback$1(args, ctx);
@@ -1621,101 +1022,6 @@ function hostHeaderValidationResponse(req, allowedHostnames) {
 	});
 }
 
-//#endregion
-//#region src/server/stdio.ts
-/**
-* Server transport for stdio: this communicates with an MCP client by reading from the current process' `stdin` and writing to `stdout`.
-*
-* This transport is only available in Node.js environments.
-*
-* @example
-* ```ts source="./stdio.examples.ts#StdioServerTransport_basicUsage"
-* const server = new McpServer({ name: 'my-server', version: '1.0.0' });
-* const transport = new StdioServerTransport();
-* await server.connect(transport);
-* ```
-*/
-var StdioServerTransport = class {
-	_readBuffer = new ReadBuffer();
-	_started = false;
-	_closed = false;
-	constructor(_stdin = process.stdin, _stdout = process.stdout) {
-		this._stdin = _stdin;
-		this._stdout = _stdout;
-	}
-	onclose;
-	onerror;
-	onmessage;
-	_ondata = (chunk) => {
-		this._readBuffer.append(chunk);
-		this.processReadBuffer();
-	};
-	_onerror = (error) => {
-		this.onerror?.(error);
-	};
-	_onstdouterror = (error) => {
-		this.onerror?.(error);
-		this.close().catch(() => {});
-	};
-	/**
-	* Starts listening for messages on `stdin`.
-	*/
-	async start() {
-		if (this._started) throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");
-		this._started = true;
-		this._stdin.on("data", this._ondata);
-		this._stdin.on("error", this._onerror);
-		this._stdout.on("error", this._onstdouterror);
-	}
-	processReadBuffer() {
-		while (true) try {
-			const message = this._readBuffer.readMessage();
-			if (message === null) break;
-			this.onmessage?.(message);
-		} catch (error) {
-			this.onerror?.(error);
-		}
-	}
-	async close() {
-		if (this._closed) return;
-		this._closed = true;
-		this._stdin.off("data", this._ondata);
-		this._stdin.off("error", this._onerror);
-		this._stdout.off("error", this._onstdouterror);
-		if (this._stdin.listenerCount("data") === 0) this._stdin.pause();
-		this._readBuffer.clear();
-		this.onclose?.();
-	}
-	send(message) {
-		if (this._closed) return Promise.reject(/* @__PURE__ */ new Error("StdioServerTransport is closed"));
-		return new Promise((resolve, reject) => {
-			const json = serializeMessage(message);
-			let settled = false;
-			const onError = (error) => {
-				if (settled) return;
-				settled = true;
-				this._stdout.off("error", onError);
-				this._stdout.off("drain", onDrain);
-				reject(error);
-			};
-			const onDrain = () => {
-				if (settled) return;
-				settled = true;
-				this._stdout.off("error", onError);
-				this._stdout.off("drain", onDrain);
-				resolve();
-			};
-			this._stdout.once("error", onError);
-			if (this._stdout.write(json)) {
-				if (settled) return;
-				settled = true;
-				this._stdout.off("error", onError);
-				resolve();
-			} else if (!settled) this._stdout.once("drain", onDrain);
-		});
-	}
-};
-
 //#endregion
 //#region src/server/streamableHttp.ts
 /**
@@ -1772,6 +1078,7 @@ var StdioServerTransport = class {
 var WebStandardStreamableHTTPServerTransport = class {
 	sessionIdGenerator;
 	_started = false;
+	_closed = false;
 	_streamMapping = /* @__PURE__ */ new Map();
 	_requestToStreamMapping = /* @__PURE__ */ new Map();
 	_requestResponseMap = /* @__PURE__ */ new Map();
@@ -1876,13 +1183,29 @@ var WebStandardStreamableHTTPServerTransport = class {
 		}
 	}
 	/**
+	* Returns true if the client's protocol version supports empty SSE data in
+	* priming events (the fix shipped with protocol version `2025-11-25`).
+	*
+	* The version is checked for membership in this transport instance's
+	* supported protocol versions rather than with an open-ended
+	* `>= '2025-11-25'` comparison: the value may come from an `initialize`
+	* request body, which (unlike the `MCP-Protocol-Version` header) is not
+	* validated against `supportedProtocolVersions` before reaching this
+	* check. An unknown future version string must not silently enable
+	* behavior reserved for versions this transport actually supports.
+	*/
+	supportsEmptySSEData(protocolVersion) {
+		return this._supportedProtocolVersions.includes(protocolVersion) && protocolVersion >= "2025-11-25";
+	}
+	/**
 	* Writes a priming event to establish resumption capability.
 	* Only sends if `eventStore` is configured (opt-in for resumability) and
-	* the client's protocol version supports empty SSE data (>= `2025-11-25`).
+	* the client's protocol version supports empty SSE data (a supported
+	* version that is >= `2025-11-25`).
 	*/
 	async writePrimingEvent(controller, encoder, streamId, protocolVersion) {
 		if (!this._eventStore) return;
-		if (protocolVersion < "2025-11-25") return;
+		if (!this.supportsEmptySSEData(protocolVersion)) return;
 		const primingEventId = await this._eventStore.storeEvent(streamId, {});
 		let primingEvent = `id: ${primingEventId}\ndata: \n\n`;
 		if (this._retryInterval !== void 0) primingEvent = `id: ${primingEventId}\nretry: ${this._retryInterval}\ndata: \n\n`;
@@ -2135,7 +1458,7 @@ var WebStandardStreamableHTTPServerTransport = class {
 			for (const message of messages) {
 				let closeSSEStream;
 				let closeStandaloneSSEStream;
-				if (isJSONRPCRequest(message) && this._eventStore && clientProtocolVersion >= "2025-11-25") {
+				if (isJSONRPCRequest(message) && this._eventStore && this.supportsEmptySSEData(clientProtocolVersion)) {
 					closeSSEStream = () => {
 						this.closeSSEStream(message.id);
 					};
@@ -2213,6 +1536,8 @@ var WebStandardStreamableHTTPServerTransport = class {
 		}
 	}
 	async close() {
+		if (this._closed) return;
+		this._closed = true;
 		for (const { cleanup } of this._streamMapping.values()) cleanup();
 		this._streamMapping.clear();
 		this._requestResponseMap.clear();
@@ -2292,5 +1617,5 @@ function fromJsonSchema(schema, validator) {
 }
 
 //#endregion
-export { AjvJsonSchemaValidator, CfWorkerJsonSchemaValidator, DEFAULT_NEGOTIATED_PROTOCOL_VERSION, DEFAULT_REQUEST_TIMEOUT_MSEC, ExperimentalMcpServerTasks, ExperimentalServerTasks, INTERNAL_ERROR, INVALID_PARAMS, INVALID_REQUEST, InMemoryTaskMessageQueue, InMemoryTaskStore, JSONRPC_VERSION, LATEST_PROTOCOL_VERSION, METHOD_NOT_FOUND, McpServer, OAuthError, OAuthErrorCode, PARSE_ERROR, ProtocolError, ProtocolErrorCode, RELATED_TASK_META_KEY, ReadBuffer, ResourceTemplate, SUPPORTED_PROTOCOL_VERSIONS, SdkError, SdkErrorCode, Server, StdioServerTransport, UriTemplate, UrlElicitationRequiredError, WebStandardStreamableHTTPServerTransport, assertClientRequestTaskCapability, assertCompleteRequestPrompt, assertCompleteRequestResourceTemplate, assertToolsCallTaskCapability, checkResourceAllowed, completable, createFetchWithInit, deserializeMessage, fromJsonSchema, getDisplayName, hostHeaderValidationResponse, isCompletable, isInitializeRequest, isInitializedNotification, isJSONRPCErrorResponse, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResultResponse, isTaskAugmentedRequestParams, isTerminal, localhostAllowedHostnames, parseJSONRPCMessage, resourceUrlFromServerUrl, serializeMessage, takeResult, toArrayAsync, validateHostHeader };
+export { BAGGAGE_META_KEY, CLIENT_CAPABILITIES_META_KEY, CLIENT_INFO_META_KEY, DEFAULT_NEGOTIATED_PROTOCOL_VERSION, DEFAULT_REQUEST_TIMEOUT_MSEC, INTERNAL_ERROR, INVALID_PARAMS, INVALID_REQUEST, InMemoryTransport, JSONRPC_VERSION, LATEST_PROTOCOL_VERSION, LOG_LEVEL_META_KEY, METHOD_NOT_FOUND, McpServer, OAuthError, OAuthErrorCode, PARSE_ERROR, PROTOCOL_VERSION_META_KEY, ProtocolError, ProtocolErrorCode, RELATED_TASK_META_KEY, ReadBuffer, ResourceTemplate, STDIO_DEFAULT_MAX_BUFFER_SIZE, SUPPORTED_PROTOCOL_VERSIONS, SdkError, SdkErrorCode, SdkHttpError, Server, TRACEPARENT_META_KEY, TRACESTATE_META_KEY, UnsupportedProtocolVersionError, UriTemplate, UrlElicitationRequiredError, WebStandardStreamableHTTPServerTransport, assertCompleteRequestPrompt, assertCompleteRequestResourceTemplate, checkResourceAllowed, completable, createFetchWithInit, deserializeMessage, fromJsonSchema, getDisplayName, hostHeaderValidationResponse, isCallToolResult, isCompletable, isInitializeRequest, isInitializedNotification, isJSONRPCErrorResponse, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResponse, isJSONRPCResultResponse, isSpecType, isTaskAugmentedRequestParams, localhostAllowedHostnames, parseJSONRPCMessage, resourceUrlFromServerUrl, serializeMessage, specTypeSchemas, validateHostHeader };
 //# sourceMappingURL=index.mjs.map