@amplitude/ai 0.1.0

package/dist/node_modules/.pnpm/@modelcontextprotocol_sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js

@@ -0,0 +1,858 @@
+import { safeParse } from "../server/zod-compat.js";
+import { CancelTaskRequestSchema, CancelTaskResultSchema, CancelledNotificationSchema, CreateTaskResultSchema, ErrorCode, GetTaskPayloadRequestSchema, GetTaskRequestSchema, GetTaskResultSchema, ListTasksRequestSchema, ListTasksResultSchema, McpError, PingRequestSchema, ProgressNotificationSchema, RELATED_TASK_META_KEY, TaskStatusNotificationSchema, isJSONRPCErrorResponse, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResultResponse, isTaskAugmentedRequestParams } from "../types.js";
+import { isTerminal } from "../experimental/tasks/interfaces.js";
+import { getMethodLiteral, parseWithCompat } from "../server/zod-json-schema-compat.js";
+
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
+/**
+* The default request timeout, in miliseconds.
+*/
+const DEFAULT_REQUEST_TIMEOUT_MSEC = 6e4;
+/**
+* Implements MCP protocol framing on top of a pluggable transport, including
+* features like request/response linking, notifications, and progress.
+*/
+var Protocol = class {
+	constructor(_options) {
+		this._options = _options;
+		this._requestMessageId = 0;
+		this._requestHandlers = /* @__PURE__ */ new Map();
+		this._requestHandlerAbortControllers = /* @__PURE__ */ new Map();
+		this._notificationHandlers = /* @__PURE__ */ new Map();
+		this._responseHandlers = /* @__PURE__ */ new Map();
+		this._progressHandlers = /* @__PURE__ */ new Map();
+		this._timeoutInfo = /* @__PURE__ */ new Map();
+		this._pendingDebouncedNotifications = /* @__PURE__ */ new Set();
+		this._taskProgressTokens = /* @__PURE__ */ new Map();
+		this._requestResolvers = /* @__PURE__ */ new Map();
+		this.setNotificationHandler(CancelledNotificationSchema, (notification) => {
+			this._oncancel(notification);
+		});
+		this.setNotificationHandler(ProgressNotificationSchema, (notification) => {
+			this._onprogress(notification);
+		});
+		this.setRequestHandler(PingRequestSchema, (_request) => ({}));
+		this._taskStore = _options?.taskStore;
+		this._taskMessageQueue = _options?.taskMessageQueue;
+		if (this._taskStore) {
+			this.setRequestHandler(GetTaskRequestSchema, async (request, extra) => {
+				const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+				if (!task) throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
+				return { ...task };
+			});
+			this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
+				const handleTaskResult = async () => {
+					const taskId = request.params.taskId;
+					if (this._taskMessageQueue) {
+						let queuedMessage;
+						while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
+							if (queuedMessage.type === "response" || queuedMessage.type === "error") {
+								const message = queuedMessage.message;
+								const requestId = message.id;
+								const resolver = this._requestResolvers.get(requestId);
+								if (resolver) {
+									this._requestResolvers.delete(requestId);
+									if (queuedMessage.type === "response") resolver(message);
+									else {
+										const errorMessage = message;
+										resolver(new McpError(errorMessage.error.code, errorMessage.error.message, errorMessage.error.data));
+									}
+								} else {
+									const messageType = queuedMessage.type === "response" ? "Response" : "Error";
+									this._onerror(/* @__PURE__ */ new Error(`${messageType} handler missing for request ${requestId}`));
+								}
+								continue;
+							}
+							await this._transport?.send(queuedMessage.message, { relatedRequestId: extra.requestId });
+						}
+					}
+					const task = await this._taskStore.getTask(taskId, extra.sessionId);
+					if (!task) throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
+					if (!isTerminal(task.status)) {
+						await this._waitForTaskUpdate(taskId, extra.signal);
+						return await handleTaskResult();
+					}
+					if (isTerminal(task.status)) {
+						const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
+						this._clearTaskQueue(taskId);
+						return {
+							...result,
+							_meta: {
+								...result._meta,
+								[RELATED_TASK_META_KEY]: { taskId }
+							}
+						};
+					}
+					return await handleTaskResult();
+				};
+				return await handleTaskResult();
+			});
+			this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => {
+				try {
+					const { tasks, nextCursor } = await this._taskStore.listTasks(request.params?.cursor, extra.sessionId);
+					return {
+						tasks,
+						nextCursor,
+						_meta: {}
+					};
+				} catch (error) {
+					throw new McpError(ErrorCode.InvalidParams, `Failed to list tasks: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			});
+			this.setRequestHandler(CancelTaskRequestSchema, async (request, extra) => {
+				try {
+					const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+					if (!task) throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request.params.taskId}`);
+					if (isTerminal(task.status)) throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
+					await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
+					this._clearTaskQueue(request.params.taskId);
+					const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+					if (!cancelledTask) throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
+					return {
+						_meta: {},
+						...cancelledTask
+					};
+				} catch (error) {
+					if (error instanceof McpError) throw error;
+					throw new McpError(ErrorCode.InvalidRequest, `Failed to cancel task: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			});
+		}
+	}
+	async _oncancel(notification) {
+		if (!notification.params.requestId) return;
+		this._requestHandlerAbortControllers.get(notification.params.requestId)?.abort(notification.params.reason);
+	}
+	_setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
+		this._timeoutInfo.set(messageId, {
+			timeoutId: setTimeout(onTimeout, timeout),
+			startTime: Date.now(),
+			timeout,
+			maxTotalTimeout,
+			resetTimeoutOnProgress,
+			onTimeout
+		});
+	}
+	_resetTimeout(messageId) {
+		const info = this._timeoutInfo.get(messageId);
+		if (!info) return false;
+		const totalElapsed = Date.now() - info.startTime;
+		if (info.maxTotalTimeout && totalElapsed >= info.maxTotalTimeout) {
+			this._timeoutInfo.delete(messageId);
+			throw McpError.fromError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", {
+				maxTotalTimeout: info.maxTotalTimeout,
+				totalElapsed
+			});
+		}
+		clearTimeout(info.timeoutId);
+		info.timeoutId = setTimeout(info.onTimeout, info.timeout);
+		return true;
+	}
+	_cleanupTimeout(messageId) {
+		const info = this._timeoutInfo.get(messageId);
+		if (info) {
+			clearTimeout(info.timeoutId);
+			this._timeoutInfo.delete(messageId);
+		}
+	}
+	/**
+	* Attaches to the given transport, starts it, and starts listening for messages.
+	*
+	* The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
+	*/
+	async connect(transport) {
+		if (this._transport) throw new Error("Already connected to a transport. Call close() before connecting to a new transport, or use a separate Protocol instance per connection.");
+		this._transport = transport;
+		const _onclose = this.transport?.onclose;
+		this._transport.onclose = () => {
+			_onclose?.();
+			this._onclose();
+		};
+		const _onerror = this.transport?.onerror;
+		this._transport.onerror = (error) => {
+			_onerror?.(error);
+			this._onerror(error);
+		};
+		const _onmessage = this._transport?.onmessage;
+		this._transport.onmessage = (message, extra) => {
+			_onmessage?.(message, extra);
+			if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) this._onresponse(message);
+			else if (isJSONRPCRequest(message)) this._onrequest(message, extra);
+			else if (isJSONRPCNotification(message)) this._onnotification(message);
+			else this._onerror(/* @__PURE__ */ new Error(`Unknown message type: ${JSON.stringify(message)}`));
+		};
+		await this._transport.start();
+	}
+	_onclose() {
+		const responseHandlers = this._responseHandlers;
+		this._responseHandlers = /* @__PURE__ */ new Map();
+		this._progressHandlers.clear();
+		this._taskProgressTokens.clear();
+		this._pendingDebouncedNotifications.clear();
+		for (const controller of this._requestHandlerAbortControllers.values()) controller.abort();
+		this._requestHandlerAbortControllers.clear();
+		const error = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed");
+		this._transport = void 0;
+		this.onclose?.();
+		for (const handler of responseHandlers.values()) handler(error);
+	}
+	_onerror(error) {
+		this.onerror?.(error);
+	}
+	_onnotification(notification) {
+		const handler = this._notificationHandlers.get(notification.method) ?? this.fallbackNotificationHandler;
+		if (handler === void 0) return;
+		Promise.resolve().then(() => handler(notification)).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Uncaught error in notification handler: ${error}`)));
+	}
+	_onrequest(request, extra) {
+		const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
+		const capturedTransport = this._transport;
+		const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
+		if (handler === void 0) {
+			const errorResponse = {
+				jsonrpc: "2.0",
+				id: request.id,
+				error: {
+					code: ErrorCode.MethodNotFound,
+					message: "Method not found"
+				}
+			};
+			if (relatedTaskId && this._taskMessageQueue) this._enqueueTaskMessage(relatedTaskId, {
+				type: "error",
+				message: errorResponse,
+				timestamp: Date.now()
+			}, capturedTransport?.sessionId).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Failed to enqueue error response: ${error}`)));
+			else capturedTransport?.send(errorResponse).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Failed to send an error response: ${error}`)));
+			return;
+		}
+		const abortController = new AbortController();
+		this._requestHandlerAbortControllers.set(request.id, abortController);
+		const taskCreationParams = isTaskAugmentedRequestParams(request.params) ? request.params.task : void 0;
+		const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport?.sessionId) : void 0;
+		const fullExtra = {
+			signal: abortController.signal,
+			sessionId: capturedTransport?.sessionId,
+			_meta: request.params?._meta,
+			sendNotification: async (notification) => {
+				if (abortController.signal.aborted) return;
+				const notificationOptions = { relatedRequestId: request.id };
+				if (relatedTaskId) notificationOptions.relatedTask = { taskId: relatedTaskId };
+				await this.notification(notification, notificationOptions);
+			},
+			sendRequest: async (r, resultSchema, options) => {
+				if (abortController.signal.aborted) throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
+				const requestOptions = {
+					...options,
+					relatedRequestId: request.id
+				};
+				if (relatedTaskId && !requestOptions.relatedTask) requestOptions.relatedTask = { taskId: relatedTaskId };
+				const effectiveTaskId = requestOptions.relatedTask?.taskId ?? relatedTaskId;
+				if (effectiveTaskId && taskStore) await taskStore.updateTaskStatus(effectiveTaskId, "input_required");
+				return await this.request(r, resultSchema, requestOptions);
+			},
+			authInfo: extra?.authInfo,
+			requestId: request.id,
+			requestInfo: extra?.requestInfo,
+			taskId: relatedTaskId,
+			taskStore,
+			taskRequestedTtl: taskCreationParams?.ttl,
+			closeSSEStream: extra?.closeSSEStream,
+			closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
+		};
+		Promise.resolve().then(() => {
+			if (taskCreationParams) this.assertTaskHandlerCapability(request.method);
+		}).then(() => handler(request, fullExtra)).then(async (result) => {
+			if (abortController.signal.aborted) return;
+			const response = {
+				result,
+				jsonrpc: "2.0",
+				id: request.id
+			};
+			if (relatedTaskId && this._taskMessageQueue) await this._enqueueTaskMessage(relatedTaskId, {
+				type: "response",
+				message: response,
+				timestamp: Date.now()
+			}, capturedTransport?.sessionId);
+			else await capturedTransport?.send(response);
+		}, async (error) => {
+			if (abortController.signal.aborted) return;
+			const errorResponse = {
+				jsonrpc: "2.0",
+				id: request.id,
+				error: {
+					code: Number.isSafeInteger(error["code"]) ? error["code"] : ErrorCode.InternalError,
+					message: error.message ?? "Internal error",
+					...error["data"] !== void 0 && { data: error["data"] }
+				}
+			};
+			if (relatedTaskId && this._taskMessageQueue) await this._enqueueTaskMessage(relatedTaskId, {
+				type: "error",
+				message: errorResponse,
+				timestamp: Date.now()
+			}, capturedTransport?.sessionId);
+			else await capturedTransport?.send(errorResponse);
+		}).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Failed to send response: ${error}`))).finally(() => {
+			this._requestHandlerAbortControllers.delete(request.id);
+		});
+	}
+	_onprogress(notification) {
+		const { progressToken, ...params } = notification.params;
+		const messageId = Number(progressToken);
+		const handler = this._progressHandlers.get(messageId);
+		if (!handler) {
+			this._onerror(/* @__PURE__ */ new Error(`Received a progress notification for an unknown token: ${JSON.stringify(notification)}`));
+			return;
+		}
+		const responseHandler = this._responseHandlers.get(messageId);
+		const timeoutInfo = this._timeoutInfo.get(messageId);
+		if (timeoutInfo && responseHandler && timeoutInfo.resetTimeoutOnProgress) try {
+			this._resetTimeout(messageId);
+		} catch (error) {
+			this._responseHandlers.delete(messageId);
+			this._progressHandlers.delete(messageId);
+			this._cleanupTimeout(messageId);
+			responseHandler(error);
+			return;
+		}
+		handler(params);
+	}
+	_onresponse(response) {
+		const messageId = Number(response.id);
+		const resolver = this._requestResolvers.get(messageId);
+		if (resolver) {
+			this._requestResolvers.delete(messageId);
+			if (isJSONRPCResultResponse(response)) resolver(response);
+			else resolver(new McpError(response.error.code, response.error.message, response.error.data));
+			return;
+		}
+		const handler = this._responseHandlers.get(messageId);
+		if (handler === void 0) {
+			this._onerror(/* @__PURE__ */ new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`));
+			return;
+		}
+		this._responseHandlers.delete(messageId);
+		this._cleanupTimeout(messageId);
+		let isTaskResponse = false;
+		if (isJSONRPCResultResponse(response) && response.result && typeof response.result === "object") {
+			const result = response.result;
+			if (result.task && typeof result.task === "object") {
+				const task = result.task;
+				if (typeof task.taskId === "string") {
+					isTaskResponse = true;
+					this._taskProgressTokens.set(task.taskId, messageId);
+				}
+			}
+		}
+		if (!isTaskResponse) this._progressHandlers.delete(messageId);
+		if (isJSONRPCResultResponse(response)) handler(response);
+		else handler(McpError.fromError(response.error.code, response.error.message, response.error.data));
+	}
+	get transport() {
+		return this._transport;
+	}
+	/**
+	* Closes the connection.
+	*/
+	async close() {
+		await this._transport?.close();
+	}
+	/**
+	* Sends a request and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* @example
+	* ```typescript
+	* const stream = protocol.requestStream(request, resultSchema, options);
+	* 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;
+	*   }
+	* }
+	* ```
+	*
+	* @experimental Use `client.experimental.tasks.requestStream()` to access this method.
+	*/
+	async *requestStream(request, resultSchema, options) {
+		const { task } = options ?? {};
+		if (!task) {
+			try {
+				yield {
+					type: "result",
+					result: await this.request(request, resultSchema, options)
+				};
+			} catch (error) {
+				yield {
+					type: "error",
+					error: error instanceof McpError ? error : new McpError(ErrorCode.InternalError, String(error))
+				};
+			}
+			return;
+		}
+		let taskId;
+		try {
+			const createResult = await this.request(request, CreateTaskResultSchema, options);
+			if (createResult.task) {
+				taskId = createResult.task.taskId;
+				yield {
+					type: "taskCreated",
+					task: createResult.task
+				};
+			} else throw new McpError(ErrorCode.InternalError, "Task creation did not return a task");
+			while (true) {
+				const task$1 = await this.getTask({ taskId }, options);
+				yield {
+					type: "taskStatus",
+					task: task$1
+				};
+				if (isTerminal(task$1.status)) {
+					if (task$1.status === "completed") yield {
+						type: "result",
+						result: await this.getTaskResult({ taskId }, resultSchema, options)
+					};
+					else if (task$1.status === "failed") yield {
+						type: "error",
+						error: new McpError(ErrorCode.InternalError, `Task ${taskId} failed`)
+					};
+					else if (task$1.status === "cancelled") yield {
+						type: "error",
+						error: new McpError(ErrorCode.InternalError, `Task ${taskId} was cancelled`)
+					};
+					return;
+				}
+				if (task$1.status === "input_required") {
+					yield {
+						type: "result",
+						result: await this.getTaskResult({ taskId }, resultSchema, options)
+					};
+					return;
+				}
+				const pollInterval = task$1.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
+				await new Promise((resolve) => setTimeout(resolve, pollInterval));
+				options?.signal?.throwIfAborted();
+			}
+		} catch (error) {
+			yield {
+				type: "error",
+				error: error instanceof McpError ? error : new McpError(ErrorCode.InternalError, String(error))
+			};
+		}
+	}
+	/**
+	* Sends a request and waits for a response.
+	*
+	* Do not use this method to emit notifications! Use notification() instead.
+	*/
+	request(request, resultSchema, options) {
+		const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
+		return new Promise((resolve, reject) => {
+			const earlyReject = (error) => {
+				reject(error);
+			};
+			if (!this._transport) {
+				earlyReject(/* @__PURE__ */ new Error("Not connected"));
+				return;
+			}
+			if (this._options?.enforceStrictCapabilities === true) try {
+				this.assertCapabilityForMethod(request.method);
+				if (task) this.assertTaskCapability(request.method);
+			} catch (e) {
+				earlyReject(e);
+				return;
+			}
+			options?.signal?.throwIfAborted();
+			const messageId = this._requestMessageId++;
+			const jsonrpcRequest = {
+				...request,
+				jsonrpc: "2.0",
+				id: messageId
+			};
+			if (options?.onprogress) {
+				this._progressHandlers.set(messageId, options.onprogress);
+				jsonrpcRequest.params = {
+					...request.params,
+					_meta: {
+						...request.params?._meta || {},
+						progressToken: messageId
+					}
+				};
+			}
+			if (task) jsonrpcRequest.params = {
+				...jsonrpcRequest.params,
+				task
+			};
+			if (relatedTask) jsonrpcRequest.params = {
+				...jsonrpcRequest.params,
+				_meta: {
+					...jsonrpcRequest.params?._meta || {},
+					[RELATED_TASK_META_KEY]: relatedTask
+				}
+			};
+			const cancel = (reason) => {
+				this._responseHandlers.delete(messageId);
+				this._progressHandlers.delete(messageId);
+				this._cleanupTimeout(messageId);
+				this._transport?.send({
+					jsonrpc: "2.0",
+					method: "notifications/cancelled",
+					params: {
+						requestId: messageId,
+						reason: String(reason)
+					}
+				}, {
+					relatedRequestId,
+					resumptionToken,
+					onresumptiontoken
+				}).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Failed to send cancellation: ${error}`)));
+				reject(reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason)));
+			};
+			this._responseHandlers.set(messageId, (response) => {
+				if (options?.signal?.aborted) return;
+				if (response instanceof Error) return reject(response);
+				try {
+					const parseResult = safeParse(resultSchema, response.result);
+					if (!parseResult.success) reject(parseResult.error);
+					else resolve(parseResult.data);
+				} catch (error) {
+					reject(error);
+				}
+			});
+			options?.signal?.addEventListener("abort", () => {
+				cancel(options?.signal?.reason);
+			});
+			const timeout = options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
+			const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
+			this._setupTimeout(messageId, timeout, options?.maxTotalTimeout, timeoutHandler, options?.resetTimeoutOnProgress ?? false);
+			const relatedTaskId = relatedTask?.taskId;
+			if (relatedTaskId) {
+				const responseResolver = (response) => {
+					const handler = this._responseHandlers.get(messageId);
+					if (handler) handler(response);
+					else this._onerror(/* @__PURE__ */ new Error(`Response handler missing for side-channeled request ${messageId}`));
+				};
+				this._requestResolvers.set(messageId, responseResolver);
+				this._enqueueTaskMessage(relatedTaskId, {
+					type: "request",
+					message: jsonrpcRequest,
+					timestamp: Date.now()
+				}).catch((error) => {
+					this._cleanupTimeout(messageId);
+					reject(error);
+				});
+			} else this._transport.send(jsonrpcRequest, {
+				relatedRequestId,
+				resumptionToken,
+				onresumptiontoken
+			}).catch((error) => {
+				this._cleanupTimeout(messageId);
+				reject(error);
+			});
+		});
+	}
+	/**
+	* Gets the current status of a task.
+	*
+	* @experimental Use `client.experimental.tasks.getTask()` to access this method.
+	*/
+	async getTask(params, options) {
+		return this.request({
+			method: "tasks/get",
+			params
+		}, GetTaskResultSchema, options);
+	}
+	/**
+	* Retrieves the result of a completed task.
+	*
+	* @experimental Use `client.experimental.tasks.getTaskResult()` to access this method.
+	*/
+	async getTaskResult(params, resultSchema, options) {
+		return this.request({
+			method: "tasks/result",
+			params
+		}, resultSchema, options);
+	}
+	/**
+	* Lists tasks, optionally starting from a pagination cursor.
+	*
+	* @experimental Use `client.experimental.tasks.listTasks()` to access this method.
+	*/
+	async listTasks(params, options) {
+		return this.request({
+			method: "tasks/list",
+			params
+		}, ListTasksResultSchema, options);
+	}
+	/**
+	* Cancels a specific task.
+	*
+	* @experimental Use `client.experimental.tasks.cancelTask()` to access this method.
+	*/
+	async cancelTask(params, options) {
+		return this.request({
+			method: "tasks/cancel",
+			params
+		}, CancelTaskResultSchema, options);
+	}
+	/**
+	* Emits a notification, which is a one-way message that does not expect a response.
+	*/
+	async notification(notification, options) {
+		if (!this._transport) throw new Error("Not connected");
+		this.assertNotificationCapability(notification.method);
+		const relatedTaskId = options?.relatedTask?.taskId;
+		if (relatedTaskId) {
+			const jsonrpcNotification$1 = {
+				...notification,
+				jsonrpc: "2.0",
+				params: {
+					...notification.params,
+					_meta: {
+						...notification.params?._meta || {},
+						[RELATED_TASK_META_KEY]: options.relatedTask
+					}
+				}
+			};
+			await this._enqueueTaskMessage(relatedTaskId, {
+				type: "notification",
+				message: jsonrpcNotification$1,
+				timestamp: Date.now()
+			});
+			return;
+		}
+		if ((this._options?.debouncedNotificationMethods ?? []).includes(notification.method) && !notification.params && !options?.relatedRequestId && !options?.relatedTask) {
+			if (this._pendingDebouncedNotifications.has(notification.method)) return;
+			this._pendingDebouncedNotifications.add(notification.method);
+			Promise.resolve().then(() => {
+				this._pendingDebouncedNotifications.delete(notification.method);
+				if (!this._transport) return;
+				let jsonrpcNotification$1 = {
+					...notification,
+					jsonrpc: "2.0"
+				};
+				if (options?.relatedTask) jsonrpcNotification$1 = {
+					...jsonrpcNotification$1,
+					params: {
+						...jsonrpcNotification$1.params,
+						_meta: {
+							...jsonrpcNotification$1.params?._meta || {},
+							[RELATED_TASK_META_KEY]: options.relatedTask
+						}
+					}
+				};
+				this._transport?.send(jsonrpcNotification$1, options).catch((error) => this._onerror(error));
+			});
+			return;
+		}
+		let jsonrpcNotification = {
+			...notification,
+			jsonrpc: "2.0"
+		};
+		if (options?.relatedTask) jsonrpcNotification = {
+			...jsonrpcNotification,
+			params: {
+				...jsonrpcNotification.params,
+				_meta: {
+					...jsonrpcNotification.params?._meta || {},
+					[RELATED_TASK_META_KEY]: options.relatedTask
+				}
+			}
+		};
+		await this._transport.send(jsonrpcNotification, options);
+	}
+	/**
+	* Registers a handler to invoke when this protocol object receives a request with the given method.
+	*
+	* Note that this will replace any previous request handler for the same method.
+	*/
+	setRequestHandler(requestSchema, handler) {
+		const method = getMethodLiteral(requestSchema);
+		this.assertRequestHandlerCapability(method);
+		this._requestHandlers.set(method, (request, extra) => {
+			const parsed = parseWithCompat(requestSchema, request);
+			return Promise.resolve(handler(parsed, extra));
+		});
+	}
+	/**
+	* Removes the request handler for the given method.
+	*/
+	removeRequestHandler(method) {
+		this._requestHandlers.delete(method);
+	}
+	/**
+	* Asserts that a request handler has not already been set for the given method, in preparation for a new one being automatically installed.
+	*/
+	assertCanSetRequestHandler(method) {
+		if (this._requestHandlers.has(method)) throw new Error(`A request handler for ${method} already exists, which would be overridden`);
+	}
+	/**
+	* Registers a handler to invoke when this protocol object receives a notification with the given method.
+	*
+	* Note that this will replace any previous notification handler for the same method.
+	*/
+	setNotificationHandler(notificationSchema, handler) {
+		const method = getMethodLiteral(notificationSchema);
+		this._notificationHandlers.set(method, (notification) => {
+			const parsed = parseWithCompat(notificationSchema, notification);
+			return Promise.resolve(handler(parsed));
+		});
+	}
+	/**
+	* Removes the notification handler for the given method.
+	*/
+	removeNotificationHandler(method) {
+		this._notificationHandlers.delete(method);
+	}
+	/**
+	* Cleans up the progress handler associated with a task.
+	* This should be called when a task reaches a terminal status.
+	*/
+	_cleanupTaskProgressHandler(taskId) {
+		const progressToken = this._taskProgressTokens.get(taskId);
+		if (progressToken !== void 0) {
+			this._progressHandlers.delete(progressToken);
+			this._taskProgressTokens.delete(taskId);
+		}
+	}
+	/**
+	* Enqueues a task-related message for side-channel delivery via tasks/result.
+	* @param taskId The task ID to associate the message with
+	* @param message The message to enqueue
+	* @param sessionId Optional session ID for binding the operation to a specific session
+	* @throws Error if taskStore is not configured or if enqueue fails (e.g., queue overflow)
+	*
+	* Note: If enqueue fails, it's the TaskMessageQueue implementation's responsibility to handle
+	* the error appropriately (e.g., by failing the task, logging, etc.). The Protocol layer
+	* simply propagates the error.
+	*/
+	async _enqueueTaskMessage(taskId, message, sessionId) {
+		if (!this._taskStore || !this._taskMessageQueue) throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
+		const maxQueueSize = this._options?.maxTaskQueueSize;
+		await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
+	}
+	/**
+	* Clears the message queue for a task and rejects any pending request resolvers.
+	* @param taskId The task ID whose queue should be cleared
+	* @param sessionId Optional session ID for binding the operation to a specific session
+	*/
+	async _clearTaskQueue(taskId, sessionId) {
+		if (this._taskMessageQueue) {
+			const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId);
+			for (const message of messages) if (message.type === "request" && isJSONRPCRequest(message.message)) {
+				const requestId = message.message.id;
+				const resolver = this._requestResolvers.get(requestId);
+				if (resolver) {
+					resolver(new McpError(ErrorCode.InternalError, "Task cancelled or completed"));
+					this._requestResolvers.delete(requestId);
+				} else this._onerror(/* @__PURE__ */ new Error(`Resolver missing for request ${requestId} during task ${taskId} cleanup`));
+			}
+		}
+	}
+	/**
+	* Waits for a task update (new messages or status change) with abort signal support.
+	* Uses polling to check for updates at the task's configured poll interval.
+	* @param taskId The task ID to wait for
+	* @param signal Abort signal to cancel the wait
+	* @returns Promise that resolves when an update occurs or rejects if aborted
+	*/
+	async _waitForTaskUpdate(taskId, signal) {
+		let interval = this._options?.defaultTaskPollInterval ?? 1e3;
+		try {
+			const task = await this._taskStore?.getTask(taskId);
+			if (task?.pollInterval) interval = task.pollInterval;
+		} catch {}
+		return new Promise((resolve, reject) => {
+			if (signal.aborted) {
+				reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
+				return;
+			}
+			const timeoutId = setTimeout(resolve, interval);
+			signal.addEventListener("abort", () => {
+				clearTimeout(timeoutId);
+				reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
+			}, { once: true });
+		});
+	}
+	requestTaskStore(request, sessionId) {
+		const taskStore = this._taskStore;
+		if (!taskStore) throw new Error("No task store configured");
+		return {
+			createTask: async (taskParams) => {
+				if (!request) throw new Error("No request provided");
+				return await taskStore.createTask(taskParams, request.id, {
+					method: request.method,
+					params: request.params
+				}, sessionId);
+			},
+			getTask: async (taskId) => {
+				const task = await taskStore.getTask(taskId, sessionId);
+				if (!task) throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
+				return task;
+			},
+			storeTaskResult: async (taskId, status, result) => {
+				await taskStore.storeTaskResult(taskId, status, result, sessionId);
+				const task = await taskStore.getTask(taskId, sessionId);
+				if (task) {
+					const notification = TaskStatusNotificationSchema.parse({
+						method: "notifications/tasks/status",
+						params: task
+					});
+					await this.notification(notification);
+					if (isTerminal(task.status)) this._cleanupTaskProgressHandler(taskId);
+				}
+			},
+			getTaskResult: (taskId) => {
+				return taskStore.getTaskResult(taskId, sessionId);
+			},
+			updateTaskStatus: async (taskId, status, statusMessage) => {
+				const task = await taskStore.getTask(taskId, sessionId);
+				if (!task) throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
+				if (isTerminal(task.status)) throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
+				await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId);
+				const updatedTask = await taskStore.getTask(taskId, sessionId);
+				if (updatedTask) {
+					const notification = TaskStatusNotificationSchema.parse({
+						method: "notifications/tasks/status",
+						params: updatedTask
+					});
+					await this.notification(notification);
+					if (isTerminal(updatedTask.status)) this._cleanupTaskProgressHandler(taskId);
+				}
+			},
+			listTasks: (cursor) => {
+				return taskStore.listTasks(cursor, sessionId);
+			}
+		};
+	}
+};
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function mergeCapabilities(base, additional) {
+	const result = { ...base };
+	for (const key in additional) {
+		const k = key;
+		const addValue = additional[k];
+		if (addValue === void 0) continue;
+		const baseValue = result[k];
+		if (isPlainObject(baseValue) && isPlainObject(addValue)) result[k] = {
+			...baseValue,
+			...addValue
+		};
+		else result[k] = addValue;
+	}
+	return result;
+}
+
+//#endregion
+export { Protocol, mergeCapabilities };
+//# sourceMappingURL=protocol.js.map