kfc-code-cli 0.0.1-alpha.1 → 0.0.1-alpha.3

package/dist/client-CdbQcqne.mjs

@@ -1,2007 +0,0 @@
-#!/usr/bin/env node
-import { a as __toESM, t as __commonJSMin } from "./chunk-pPjepVcp.mjs";
-import { n as require_codegen, t as require_ajv } from "./main.mjs";
-import { A as ProgressNotificationSchema, B as isJSONRPCNotification, C as ListResourceTemplatesResultSchema, D as ListToolsResultSchema, E as ListTasksResultSchema, F as SUPPORTED_PROTOCOL_VERSIONS, H as isJSONRPCResultResponse, I as TaskStatusNotificationSchema, L as ToolListChangedNotificationSchema, M as RELATED_TASK_META_KEY, N as ReadResourceResultSchema, O as McpError, P as ResourceListChangedNotificationSchema, S as ListPromptsResultSchema, T as ListTasksRequestSchema, U as isTaskAugmentedRequestParams, V as isJSONRPCRequest, _ as GetTaskResultSchema, a as CompleteResultSchema, b as LATEST_PROTOCOL_VERSION, c as CreateMessageResultWithToolsSchema, d as ElicitResultSchema, f as EmptyResultSchema, g as GetTaskRequestSchema, h as GetTaskPayloadRequestSchema, i as CancelledNotificationSchema, j as PromptListChangedNotificationSchema, k as PingRequestSchema, l as CreateTaskResultSchema, m as GetPromptResultSchema, n as CancelTaskRequestSchema, o as CreateMessageRequestSchema, p as ErrorCode, r as CancelTaskResultSchema, s as CreateMessageResultSchema, t as CallToolResultSchema, u as ElicitRequestSchema, v as InitializeResultSchema, w as ListResourcesResultSchema, x as ListChangedOptionsBaseSchema, z as isJSONRPCErrorResponse } from "./types-CdOcSyeC.mjs";
-import "zod/v3";
-import * as z4mini from "zod/v4-mini";
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
-function isZ4Schema(s) {
-	return !!s._zod;
-}
-function safeParse(schema, data) {
-	if (isZ4Schema(schema)) return z4mini.safeParse(schema, data);
-	return schema.safeParse(data);
-}
-function getObjectShape(schema) {
-	if (!schema) return void 0;
-	let rawShape;
-	if (isZ4Schema(schema)) rawShape = schema._zod?.def?.shape;
-	else rawShape = schema.shape;
-	if (!rawShape) return void 0;
-	if (typeof rawShape === "function") try {
-		return rawShape();
-	} catch {
-		return;
-	}
-	return rawShape;
-}
-/**
-* Gets the literal value from a schema, if it's a literal schema.
-* Works with both Zod v3 and v4.
-* Returns undefined if the schema is not a literal or the value cannot be determined.
-*/
-function getLiteralValue(schema) {
-	if (isZ4Schema(schema)) {
-		const def = schema._zod?.def;
-		if (def) {
-			if (def.value !== void 0) return def.value;
-			if (Array.isArray(def.values) && def.values.length > 0) return def.values[0];
-		}
-	}
-	const def = schema._def;
-	if (def) {
-		if (def.value !== void 0) return def.value;
-		if (Array.isArray(def.values) && def.values.length > 0) return def.values[0];
-	}
-	const directValue = schema.value;
-	if (directValue !== void 0) return directValue;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
-/**
-* Experimental task interfaces for MCP SDK.
-* WARNING: These APIs are experimental and may change without notice.
-*/
-/**
-* Checks if a task status represents a terminal state.
-* Terminal states are those where the task has finished and will not change.
-*
-* @param status - The task status to check
-* @returns True if the status is terminal (completed, failed, or cancelled)
-* @experimental
-*/
-function isTerminal(status) {
-	return status === "completed" || status === "failed" || status === "cancelled";
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
-function getMethodLiteral(schema) {
-	const methodSchema = getObjectShape(schema)?.method;
-	if (!methodSchema) throw new Error("Schema is missing a method literal");
-	const value = getLiteralValue(methodSchema);
-	if (typeof value !== "string") throw new Error("Schema method literal must be a string");
-	return value;
-}
-function parseWithCompat(schema, data) {
-	const result = safeParse(schema, data);
-	if (!result.success) throw result.error;
-	return result.data;
-}
-/**
-* 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 info of this._timeoutInfo.values()) clearTimeout(info.timeoutId);
-		this._timeoutInfo.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(() => {
-			if (this._requestHandlerAbortControllers.get(request.id) === abortController) 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 = await this.getTask({ taskId }, options);
-				yield {
-					type: "taskStatus",
-					task
-				};
-				if (isTerminal(task.status)) {
-					if (task.status === "completed") yield {
-						type: "result",
-						result: await this.getTaskResult({ taskId }, resultSchema, options)
-					};
-					else if (task.status === "failed") yield {
-						type: "error",
-						error: new McpError(ErrorCode.InternalError, `Task ${taskId} failed`)
-					};
-					else if (task.status === "cancelled") yield {
-						type: "error",
-						error: new McpError(ErrorCode.InternalError, `Task ${taskId} was cancelled`)
-					};
-					return;
-				}
-				if (task.status === "input_required") {
-					yield {
-						type: "result",
-						result: await this.getTaskResult({ taskId }, resultSchema, options)
-					};
-					return;
-				}
-				const pollInterval = task.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 ?? 6e4;
-			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 = {
-				...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,
-				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 = {
-					...notification,
-					jsonrpc: "2.0"
-				};
-				if (options?.relatedTask) jsonrpcNotification = {
-					...jsonrpcNotification,
-					params: {
-						...jsonrpcNotification.params,
-						_meta: {
-							...jsonrpcNotification.params?._meta || {},
-							[RELATED_TASK_META_KEY]: options.relatedTask
-						}
-					}
-				};
-				this._transport?.send(jsonrpcNotification, 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
-//#region ../../node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.18.0/node_modules/ajv-formats/dist/formats.js
-var require_formats = /* @__PURE__ */ __commonJSMin(((exports) => {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.formatNames = exports.fastFormats = exports.fullFormats = void 0;
-	function fmtDef(validate, compare) {
-		return {
-			validate,
-			compare
-		};
-	}
-	exports.fullFormats = {
-		date: fmtDef(date, compareDate),
-		time: fmtDef(getTime(true), compareTime),
-		"date-time": fmtDef(getDateTime(true), compareDateTime),
-		"iso-time": fmtDef(getTime(), compareIsoTime),
-		"iso-date-time": fmtDef(getDateTime(), compareIsoDateTime),
-		duration: /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/,
-		uri,
-		"uri-reference": /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,
-		"uri-template": /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,
-		url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
-		email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
-		hostname: /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i,
-		ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,
-		ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i,
-		regex,
-		uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
-		"json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/,
-		"json-pointer-uri-fragment": /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,
-		"relative-json-pointer": /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,
-		byte,
-		int32: {
-			type: "number",
-			validate: validateInt32
-		},
-		int64: {
-			type: "number",
-			validate: validateInt64
-		},
-		float: {
-			type: "number",
-			validate: validateNumber
-		},
-		double: {
-			type: "number",
-			validate: validateNumber
-		},
-		password: true,
-		binary: true
-	};
-	exports.fastFormats = {
-		...exports.fullFormats,
-		date: fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d$/, compareDate),
-		time: fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareTime),
-		"date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareDateTime),
-		"iso-time": fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoTime),
-		"iso-date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoDateTime),
-		uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,
-		"uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,
-		email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i
-	};
-	exports.formatNames = Object.keys(exports.fullFormats);
-	function isLeapYear(year) {
-		return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
-	}
-	const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
-	const DAYS = [
-		0,
-		31,
-		28,
-		31,
-		30,
-		31,
-		30,
-		31,
-		31,
-		30,
-		31,
-		30,
-		31
-	];
-	function date(str) {
-		const matches = DATE.exec(str);
-		if (!matches) return false;
-		const year = +matches[1];
-		const month = +matches[2];
-		const day = +matches[3];
-		return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]);
-	}
-	function compareDate(d1, d2) {
-		if (!(d1 && d2)) return void 0;
-		if (d1 > d2) return 1;
-		if (d1 < d2) return -1;
-		return 0;
-	}
-	const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
-	function getTime(strictTimeZone) {
-		return function time(str) {
-			const matches = TIME.exec(str);
-			if (!matches) return false;
-			const hr = +matches[1];
-			const min = +matches[2];
-			const sec = +matches[3];
-			const tz = matches[4];
-			const tzSign = matches[5] === "-" ? -1 : 1;
-			const tzH = +(matches[6] || 0);
-			const tzM = +(matches[7] || 0);
-			if (tzH > 23 || tzM > 59 || strictTimeZone && !tz) return false;
-			if (hr <= 23 && min <= 59 && sec < 60) return true;
-			const utcMin = min - tzM * tzSign;
-			const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0);
-			return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61;
-		};
-	}
-	function compareTime(s1, s2) {
-		if (!(s1 && s2)) return void 0;
-		const t1 = (/* @__PURE__ */ new Date("2020-01-01T" + s1)).valueOf();
-		const t2 = (/* @__PURE__ */ new Date("2020-01-01T" + s2)).valueOf();
-		if (!(t1 && t2)) return void 0;
-		return t1 - t2;
-	}
-	function compareIsoTime(t1, t2) {
-		if (!(t1 && t2)) return void 0;
-		const a1 = TIME.exec(t1);
-		const a2 = TIME.exec(t2);
-		if (!(a1 && a2)) return void 0;
-		t1 = a1[1] + a1[2] + a1[3];
-		t2 = a2[1] + a2[2] + a2[3];
-		if (t1 > t2) return 1;
-		if (t1 < t2) return -1;
-		return 0;
-	}
-	const DATE_TIME_SEPARATOR = /t|\s/i;
-	function getDateTime(strictTimeZone) {
-		const time = getTime(strictTimeZone);
-		return function date_time(str) {
-			const dateTime = str.split(DATE_TIME_SEPARATOR);
-			return dateTime.length === 2 && date(dateTime[0]) && time(dateTime[1]);
-		};
-	}
-	function compareDateTime(dt1, dt2) {
-		if (!(dt1 && dt2)) return void 0;
-		const d1 = new Date(dt1).valueOf();
-		const d2 = new Date(dt2).valueOf();
-		if (!(d1 && d2)) return void 0;
-		return d1 - d2;
-	}
-	function compareIsoDateTime(dt1, dt2) {
-		if (!(dt1 && dt2)) return void 0;
-		const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR);
-		const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR);
-		const res = compareDate(d1, d2);
-		if (res === void 0) return void 0;
-		return res || compareTime(t1, t2);
-	}
-	const NOT_URI_FRAGMENT = /\/|:/;
-	const URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
-	function uri(str) {
-		return NOT_URI_FRAGMENT.test(str) && URI.test(str);
-	}
-	const BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
-	function byte(str) {
-		BYTE.lastIndex = 0;
-		return BYTE.test(str);
-	}
-	const MIN_INT32 = -(2 ** 31);
-	const MAX_INT32 = 2 ** 31 - 1;
-	function validateInt32(value) {
-		return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32;
-	}
-	function validateInt64(value) {
-		return Number.isInteger(value);
-	}
-	function validateNumber() {
-		return true;
-	}
-	const Z_ANCHOR = /[^\\]\\Z/;
-	function regex(str) {
-		if (Z_ANCHOR.test(str)) return false;
-		try {
-			new RegExp(str);
-			return true;
-		} catch (e) {
-			return false;
-		}
-	}
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.18.0/node_modules/ajv-formats/dist/limit.js
-var require_limit = /* @__PURE__ */ __commonJSMin(((exports) => {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.formatLimitDefinition = void 0;
-	const ajv_1 = require_ajv();
-	const codegen_1 = require_codegen();
-	const ops = codegen_1.operators;
-	const KWDs = {
-		formatMaximum: {
-			okStr: "<=",
-			ok: ops.LTE,
-			fail: ops.GT
-		},
-		formatMinimum: {
-			okStr: ">=",
-			ok: ops.GTE,
-			fail: ops.LT
-		},
-		formatExclusiveMaximum: {
-			okStr: "<",
-			ok: ops.LT,
-			fail: ops.GTE
-		},
-		formatExclusiveMinimum: {
-			okStr: ">",
-			ok: ops.GT,
-			fail: ops.LTE
-		}
-	};
-	exports.formatLimitDefinition = {
-		keyword: Object.keys(KWDs),
-		type: "string",
-		schemaType: "string",
-		$data: true,
-		error: {
-			message: ({ keyword, schemaCode }) => (0, codegen_1.str)`should be ${KWDs[keyword].okStr} ${schemaCode}`,
-			params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
-		},
-		code(cxt) {
-			const { gen, data, schemaCode, keyword, it } = cxt;
-			const { opts, self } = it;
-			if (!opts.validateFormats) return;
-			const fCxt = new ajv_1.KeywordCxt(it, self.RULES.all.format.definition, "format");
-			if (fCxt.$data) validate$DataFormat();
-			else validateFormat();
-			function validate$DataFormat() {
-				const fmts = gen.scopeValue("formats", {
-					ref: self.formats,
-					code: opts.code.formats
-				});
-				const fmt = gen.const("fmt", (0, codegen_1._)`${fmts}[${fCxt.schemaCode}]`);
-				cxt.fail$data((0, codegen_1.or)((0, codegen_1._)`typeof ${fmt} != "object"`, (0, codegen_1._)`${fmt} instanceof RegExp`, (0, codegen_1._)`typeof ${fmt}.compare != "function"`, compareCode(fmt)));
-			}
-			function validateFormat() {
-				const format = fCxt.schema;
-				const fmtDef = self.formats[format];
-				if (!fmtDef || fmtDef === true) return;
-				if (typeof fmtDef != "object" || fmtDef instanceof RegExp || typeof fmtDef.compare != "function") throw new Error(`"${keyword}": format "${format}" does not define "compare" function`);
-				const fmt = gen.scopeValue("formats", {
-					key: format,
-					ref: fmtDef,
-					code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}` : void 0
-				});
-				cxt.fail$data(compareCode(fmt));
-			}
-			function compareCode(fmt) {
-				return (0, codegen_1._)`${fmt}.compare(${data}, ${schemaCode}) ${KWDs[keyword].fail} 0`;
-			}
-		},
-		dependencies: ["format"]
-	};
-	const formatLimitPlugin = (ajv) => {
-		ajv.addKeyword(exports.formatLimitDefinition);
-		return ajv;
-	};
-	exports.default = formatLimitPlugin;
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.18.0/node_modules/ajv-formats/dist/index.js
-var require_dist = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	const formats_1 = require_formats();
-	const limit_1 = require_limit();
-	const codegen_1 = require_codegen();
-	const fullName = new codegen_1.Name("fullFormats");
-	const fastName = new codegen_1.Name("fastFormats");
-	const formatsPlugin = (ajv, opts = { keywords: true }) => {
-		if (Array.isArray(opts)) {
-			addFormats(ajv, opts, formats_1.fullFormats, fullName);
-			return ajv;
-		}
-		const [formats, exportName] = opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName];
-		addFormats(ajv, opts.formats || formats_1.formatNames, formats, exportName);
-		if (opts.keywords) (0, limit_1.default)(ajv);
-		return ajv;
-	};
-	formatsPlugin.get = (name, mode = "full") => {
-		const f = (mode === "fast" ? formats_1.fastFormats : formats_1.fullFormats)[name];
-		if (!f) throw new Error(`Unknown format "${name}"`);
-		return f;
-	};
-	function addFormats(ajv, list, fs, exportName) {
-		var _a;
-		var _b;
-		(_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 || (_b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
-		for (const f of list) ajv.addFormat(f, fs[f]);
-	}
-	module.exports = exports = formatsPlugin;
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.default = formatsPlugin;
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
-var import_ajv = /* @__PURE__ */ __toESM(require_ajv(), 1);
-var import_dist = /* @__PURE__ */ __toESM(require_dist(), 1);
-function createDefaultAjvInstance() {
-	const ajv = new import_ajv.default({
-		strict: false,
-		validateFormats: true,
-		validateSchema: false,
-		allErrors: true
-	});
-	(0, import_dist.default)(ajv);
-	return ajv;
-}
-/**
-* @example
-* ```typescript
-* // Use with default AJV instance (recommended)
-* import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv';
-* const validator = new AjvJsonSchemaValidator();
-*
-* // Use with custom AJV instance
-* import { Ajv } from 'ajv';
-* const ajv = new Ajv({ strict: true, allErrors: true });
-* const validator = new AjvJsonSchemaValidator(ajv);
-* ```
-*/
-var AjvJsonSchemaValidator = class {
-	/**
-	* Create an AJV validator
-	*
-	* @param ajv - Optional pre-configured AJV instance. If not provided, a default instance will be created.
-	*
-	* @example
-	* ```typescript
-	* // Use default configuration (recommended for most cases)
-	* import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv';
-	* const validator = new AjvJsonSchemaValidator();
-	*
-	* // Or provide custom AJV instance for advanced configuration
-	* import { Ajv } from 'ajv';
-	* import addFormats from 'ajv-formats';
-	*
-	* const ajv = new Ajv({ validateFormats: true });
-	* addFormats(ajv);
-	* const validator = new AjvJsonSchemaValidator(ajv);
-	* ```
-	*/
-	constructor(ajv) {
-		this._ajv = ajv ?? createDefaultAjvInstance();
-	}
-	/**
-	* Create a validator for the given JSON Schema
-	*
-	* The validator is compiled once and can be reused multiple times.
-	* If the schema has an $id, it will be cached by AJV automatically.
-	*
-	* @param schema - Standard JSON Schema object
-	* @returns A validator function that validates input data
-	*/
-	getValidator(schema) {
-		const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? this._ajv.getSchema(schema.$id) ?? this._ajv.compile(schema) : this._ajv.compile(schema);
-		return (input) => {
-			if (ajvValidator(input)) return {
-				valid: true,
-				data: input,
-				errorMessage: void 0
-			};
-			else return {
-				valid: false,
-				data: void 0,
-				errorMessage: this._ajv.errorsText(ajvValidator.errors)
-			};
-		};
-	}
-};
-//#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/client.js
-/**
-* Experimental client task features for MCP SDK.
-* WARNING: These APIs are experimental and may change without notice.
-*
-* @experimental
-*/
-/**
-* Experimental task features for MCP clients.
-*
-* Access via `client.experimental.tasks`:
-* ```typescript
-* const stream = client.experimental.tasks.callToolStream({ name: 'tool', arguments: {} });
-* const task = await client.experimental.tasks.getTask(taskId);
-* ```
-*
-* @experimental
-*/
-var ExperimentalClientTasks = class {
-	constructor(_client) {
-		this._client = _client;
-	}
-	/**
-	* Calls a tool 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 tool execution, allowing you to
-	* observe intermediate task status updates for long-running tool calls.
-	* Automatically validates structured output if the tool has an outputSchema.
-	*
-	* @example
-	* ```typescript
-	* const stream = client.experimental.tasks.callToolStream({ name: 'myTool', arguments: {} });
-	* for await (const message of stream) {
-	*   switch (message.type) {
-	*     case 'taskCreated':
-	*       console.log('Tool execution started:', message.task.taskId);
-	*       break;
-	*     case 'taskStatus':
-	*       console.log('Tool status:', message.task.status);
-	*       break;
-	*     case 'result':
-	*       console.log('Tool result:', message.result);
-	*       break;
-	*     case 'error':
-	*       console.error('Tool error:', message.error);
-	*       break;
-	*   }
-	* }
-	* ```
-	*
-	* @param params - Tool call parameters (name and arguments)
-	* @param resultSchema - Zod schema for validating the result (defaults to CallToolResultSchema)
-	* @param options - Optional request options (timeout, signal, task creation params, etc.)
-	* @returns AsyncGenerator that yields ResponseMessage objects
-	*
-	* @experimental
-	*/
-	async *callToolStream(params, resultSchema = CallToolResultSchema, options) {
-		const clientInternal = this._client;
-		const optionsWithTask = {
-			...options,
-			task: options?.task ?? (clientInternal.isToolTask(params.name) ? {} : void 0)
-		};
-		const stream = clientInternal.requestStream({
-			method: "tools/call",
-			params
-		}, resultSchema, optionsWithTask);
-		const validator = clientInternal.getToolOutputValidator(params.name);
-		for await (const message of stream) {
-			if (message.type === "result" && validator) {
-				const result = message.result;
-				if (!result.structuredContent && !result.isError) {
-					yield {
-						type: "error",
-						error: new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`)
-					};
-					return;
-				}
-				if (result.structuredContent) try {
-					const validationResult = validator(result.structuredContent);
-					if (!validationResult.valid) {
-						yield {
-							type: "error",
-							error: new McpError(ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`)
-						};
-						return;
-					}
-				} catch (error) {
-					if (error instanceof McpError) {
-						yield {
-							type: "error",
-							error
-						};
-						return;
-					}
-					yield {
-						type: "error",
-						error: new McpError(ErrorCode.InvalidParams, `Failed to validate structured content: ${error instanceof Error ? error.message : String(error)}`)
-					};
-					return;
-				}
-			}
-			yield message;
-		}
-	}
-	/**
-	* 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._client.getTask({ taskId }, options);
-	}
-	/**
-	* Retrieves the result of a completed task.
-	*
-	* @param taskId - The task identifier
-	* @param resultSchema - Zod schema for validating the result
-	* @param options - Optional request options
-	* @returns The task result
-	*
-	* @experimental
-	*/
-	async getTaskResult(taskId, resultSchema, options) {
-		return this._client.getTaskResult({ taskId }, resultSchema, 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._client.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._client.cancelTask({ taskId }, options);
-	}
-	/**
-	* 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
-	* @param resultSchema - Zod schema for validating the result
-	* @param options - Optional request options (timeout, signal, task creation params, etc.)
-	* @returns AsyncGenerator that yields ResponseMessage objects
-	*
-	* @experimental
-	*/
-	requestStream(request, resultSchema, options) {
-		return this._client.requestStream(request, resultSchema, options);
-	}
-};
-//#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
-/**
-* 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 by Client.assertTaskCapability and Server.assertTaskHandlerCapability.
-*
-* @param requests - The task requests capability object
-* @param method - The method being checked
-* @param entityName - 'Server' or 'Client' for error messages
-* @throws Error if the capability is not supported
-*
-* @experimental
-*/
-function assertToolsCallTaskCapability(requests, method, entityName) {
-	if (!requests) throw new Error(`${entityName} does not support task creation (required for ${method})`);
-	switch (method) {
-		case "tools/call":
-			if (!requests.tools?.call) throw new Error(`${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 by Server.assertTaskCapability and Client.assertTaskHandlerCapability.
-*
-* @param requests - The task requests capability object
-* @param method - The method being checked
-* @param entityName - 'Server' or 'Client' for error messages
-* @throws Error if the capability is not supported
-*
-* @experimental
-*/
-function assertClientRequestTaskCapability(requests, method, entityName) {
-	if (!requests) throw new Error(`${entityName} does not support task creation (required for ${method})`);
-	switch (method) {
-		case "sampling/createMessage":
-			if (!requests.sampling?.createMessage) throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
-			break;
-		case "elicitation/create":
-			if (!requests.elicitation?.create) throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
-			break;
-		default: break;
-	}
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/client/index.js
-/**
-* Elicitation default application helper. Applies defaults to the data based on the schema.
-*
-* @param schema - The schema to apply defaults to.
-* @param data - The data to apply defaults to.
-*/
-function applyElicitationDefaults(schema, data) {
-	if (!schema || data === null || typeof data !== "object") return;
-	if (schema.type === "object" && schema.properties && typeof schema.properties === "object") {
-		const obj = data;
-		const props = schema.properties;
-		for (const key of Object.keys(props)) {
-			const propSchema = props[key];
-			if (obj[key] === void 0 && Object.prototype.hasOwnProperty.call(propSchema, "default")) obj[key] = propSchema.default;
-			if (obj[key] !== void 0) applyElicitationDefaults(propSchema, obj[key]);
-		}
-	}
-	if (Array.isArray(schema.anyOf)) {
-		for (const sub of schema.anyOf) if (typeof sub !== "boolean") applyElicitationDefaults(sub, data);
-	}
-	if (Array.isArray(schema.oneOf)) {
-		for (const sub of schema.oneOf) if (typeof sub !== "boolean") applyElicitationDefaults(sub, data);
-	}
-}
-/**
-* Determines which elicitation modes are supported based on declared client capabilities.
-*
-* According to the spec:
-* - An empty elicitation capability object defaults to form mode support (backwards compatibility)
-* - URL mode is only supported if explicitly declared
-*
-* @param capabilities - The client's elicitation capabilities
-* @returns An object indicating which modes are supported
-*/
-function getSupportedElicitationModes(capabilities) {
-	if (!capabilities) return {
-		supportsFormMode: false,
-		supportsUrlMode: false
-	};
-	const hasFormCapability = capabilities.form !== void 0;
-	const hasUrlCapability = capabilities.url !== void 0;
-	return {
-		supportsFormMode: hasFormCapability || !hasFormCapability && !hasUrlCapability,
-		supportsUrlMode: hasUrlCapability
-	};
-}
-/**
-* An MCP client on top of a pluggable transport.
-*
-* The client will automatically begin the initialization flow with the server when connect() is called.
-*
-* To use with custom types, extend the base Request/Notification/Result types and pass them as type parameters:
-*
-* ```typescript
-* // Custom schemas
-* const CustomRequestSchema = RequestSchema.extend({...})
-* const CustomNotificationSchema = NotificationSchema.extend({...})
-* const CustomResultSchema = ResultSchema.extend({...})
-*
-* // Type aliases
-* type CustomRequest = z.infer<typeof CustomRequestSchema>
-* type CustomNotification = z.infer<typeof CustomNotificationSchema>
-* type CustomResult = z.infer<typeof CustomResultSchema>
-*
-* // Create typed client
-* const client = new Client<CustomRequest, CustomNotification, CustomResult>({
-*   name: "CustomClient",
-*   version: "1.0.0"
-* })
-* ```
-*/
-var Client = class extends Protocol {
-	/**
-	* Initializes this client with the given name and version information.
-	*/
-	constructor(_clientInfo, options) {
-		super(options);
-		this._clientInfo = _clientInfo;
-		this._cachedToolOutputValidators = /* @__PURE__ */ new Map();
-		this._cachedKnownTaskTools = /* @__PURE__ */ new Set();
-		this._cachedRequiredTaskTools = /* @__PURE__ */ new Set();
-		this._listChangedDebounceTimers = /* @__PURE__ */ new Map();
-		this._capabilities = options?.capabilities ?? {};
-		this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
-		if (options?.listChanged) this._pendingListChangedConfig = options.listChanged;
-	}
-	/**
-	* Set up handlers for list changed notifications based on config and server capabilities.
-	* This should only be called after initialization when server capabilities are known.
-	* Handlers are silently skipped if the server doesn't advertise the corresponding listChanged capability.
-	* @internal
-	*/
-	_setupListChangedHandlers(config) {
-		if (config.tools && this._serverCapabilities?.tools?.listChanged) this._setupListChangedHandler("tools", ToolListChangedNotificationSchema, config.tools, async () => {
-			return (await this.listTools()).tools;
-		});
-		if (config.prompts && this._serverCapabilities?.prompts?.listChanged) this._setupListChangedHandler("prompts", PromptListChangedNotificationSchema, config.prompts, async () => {
-			return (await this.listPrompts()).prompts;
-		});
-		if (config.resources && this._serverCapabilities?.resources?.listChanged) this._setupListChangedHandler("resources", ResourceListChangedNotificationSchema, config.resources, async () => {
-			return (await this.listResources()).resources;
-		});
-	}
-	/**
-	* Access experimental features.
-	*
-	* WARNING: These APIs are experimental and may change without notice.
-	*
-	* @experimental
-	*/
-	get experimental() {
-		if (!this._experimental) this._experimental = { tasks: new ExperimentalClientTasks(this) };
-		return this._experimental;
-	}
-	/**
-	* Registers new capabilities. This can only be called before connecting to a transport.
-	*
-	* The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
-	*/
-	registerCapabilities(capabilities) {
-		if (this.transport) throw new Error("Cannot register capabilities after connecting to transport");
-		this._capabilities = mergeCapabilities(this._capabilities, capabilities);
-	}
-	/**
-	* Override request handler registration to enforce client-side validation for elicitation.
-	*/
-	setRequestHandler(requestSchema, handler) {
-		const methodSchema = getObjectShape(requestSchema)?.method;
-		if (!methodSchema) throw new Error("Schema is missing a method literal");
-		let methodValue;
-		if (isZ4Schema(methodSchema)) {
-			const v4Schema = methodSchema;
-			methodValue = (v4Schema._zod?.def)?.value ?? v4Schema.value;
-		} else {
-			const v3Schema = methodSchema;
-			methodValue = v3Schema._def?.value ?? v3Schema.value;
-		}
-		if (typeof methodValue !== "string") throw new Error("Schema method literal must be a string");
-		const method = methodValue;
-		if (method === "elicitation/create") {
-			const wrappedHandler = async (request, extra) => {
-				const validatedRequest = safeParse(ElicitRequestSchema, request);
-				if (!validatedRequest.success) {
-					const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
-					throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation request: ${errorMessage}`);
-				}
-				const { params } = validatedRequest.data;
-				params.mode = params.mode ?? "form";
-				const { supportsFormMode, supportsUrlMode } = getSupportedElicitationModes(this._capabilities.elicitation);
-				if (params.mode === "form" && !supportsFormMode) throw new McpError(ErrorCode.InvalidParams, "Client does not support form-mode elicitation requests");
-				if (params.mode === "url" && !supportsUrlMode) throw new McpError(ErrorCode.InvalidParams, "Client does not support URL-mode elicitation requests");
-				const result = await Promise.resolve(handler(request, extra));
-				if (params.task) {
-					const taskValidationResult = safeParse(CreateTaskResultSchema, result);
-					if (!taskValidationResult.success) {
-						const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
-						throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
-					}
-					return taskValidationResult.data;
-				}
-				const validationResult = safeParse(ElicitResultSchema, result);
-				if (!validationResult.success) {
-					const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
-					throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation result: ${errorMessage}`);
-				}
-				const validatedResult = validationResult.data;
-				const requestedSchema = params.mode === "form" ? params.requestedSchema : void 0;
-				if (params.mode === "form" && validatedResult.action === "accept" && validatedResult.content && requestedSchema) {
-					if (this._capabilities.elicitation?.form?.applyDefaults) try {
-						applyElicitationDefaults(requestedSchema, validatedResult.content);
-					} catch {}
-				}
-				return validatedResult;
-			};
-			return super.setRequestHandler(requestSchema, wrappedHandler);
-		}
-		if (method === "sampling/createMessage") {
-			const wrappedHandler = async (request, extra) => {
-				const validatedRequest = safeParse(CreateMessageRequestSchema, request);
-				if (!validatedRequest.success) {
-					const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
-					throw new McpError(ErrorCode.InvalidParams, `Invalid sampling request: ${errorMessage}`);
-				}
-				const { params } = validatedRequest.data;
-				const result = await Promise.resolve(handler(request, extra));
-				if (params.task) {
-					const taskValidationResult = safeParse(CreateTaskResultSchema, result);
-					if (!taskValidationResult.success) {
-						const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
-						throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
-					}
-					return taskValidationResult.data;
-				}
-				const validationResult = safeParse(params.tools || params.toolChoice ? CreateMessageResultWithToolsSchema : CreateMessageResultSchema, result);
-				if (!validationResult.success) {
-					const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
-					throw new McpError(ErrorCode.InvalidParams, `Invalid sampling result: ${errorMessage}`);
-				}
-				return validationResult.data;
-			};
-			return super.setRequestHandler(requestSchema, wrappedHandler);
-		}
-		return super.setRequestHandler(requestSchema, handler);
-	}
-	assertCapability(capability, method) {
-		if (!this._serverCapabilities?.[capability]) throw new Error(`Server does not support ${capability} (required for ${method})`);
-	}
-	async connect(transport, options) {
-		await super.connect(transport);
-		if (transport.sessionId !== void 0) return;
-		try {
-			const result = await this.request({
-				method: "initialize",
-				params: {
-					protocolVersion: LATEST_PROTOCOL_VERSION,
-					capabilities: this._capabilities,
-					clientInfo: this._clientInfo
-				}
-			}, InitializeResultSchema, options);
-			if (result === void 0) throw new Error(`Server sent invalid initialize result: ${result}`);
-			if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion)) throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`);
-			this._serverCapabilities = result.capabilities;
-			this._serverVersion = result.serverInfo;
-			if (transport.setProtocolVersion) transport.setProtocolVersion(result.protocolVersion);
-			this._instructions = result.instructions;
-			await this.notification({ method: "notifications/initialized" });
-			if (this._pendingListChangedConfig) {
-				this._setupListChangedHandlers(this._pendingListChangedConfig);
-				this._pendingListChangedConfig = void 0;
-			}
-		} catch (error) {
-			this.close();
-			throw error;
-		}
-	}
-	/**
-	* After initialization has completed, this will be populated with the server's reported capabilities.
-	*/
-	getServerCapabilities() {
-		return this._serverCapabilities;
-	}
-	/**
-	* After initialization has completed, this will be populated with information about the server's name and version.
-	*/
-	getServerVersion() {
-		return this._serverVersion;
-	}
-	/**
-	* After initialization has completed, this may be populated with information about the server's instructions.
-	*/
-	getInstructions() {
-		return this._instructions;
-	}
-	assertCapabilityForMethod(method) {
-		switch (method) {
-			case "logging/setLevel":
-				if (!this._serverCapabilities?.logging) throw new Error(`Server does not support logging (required for ${method})`);
-				break;
-			case "prompts/get":
-			case "prompts/list":
-				if (!this._serverCapabilities?.prompts) throw new Error(`Server does not support prompts (required for ${method})`);
-				break;
-			case "resources/list":
-			case "resources/templates/list":
-			case "resources/read":
-			case "resources/subscribe":
-			case "resources/unsubscribe":
-				if (!this._serverCapabilities?.resources) throw new Error(`Server does not support resources (required for ${method})`);
-				if (method === "resources/subscribe" && !this._serverCapabilities.resources.subscribe) throw new Error(`Server does not support resource subscriptions (required for ${method})`);
-				break;
-			case "tools/call":
-			case "tools/list":
-				if (!this._serverCapabilities?.tools) throw new Error(`Server does not support tools (required for ${method})`);
-				break;
-			case "completion/complete":
-				if (!this._serverCapabilities?.completions) throw new Error(`Server does not support completions (required for ${method})`);
-				break;
-			case "initialize": break;
-			case "ping": break;
-		}
-	}
-	assertNotificationCapability(method) {
-		switch (method) {
-			case "notifications/roots/list_changed":
-				if (!this._capabilities.roots?.listChanged) throw new Error(`Client does not support roots list changed notifications (required for ${method})`);
-				break;
-			case "notifications/initialized": break;
-			case "notifications/cancelled": break;
-			case "notifications/progress": break;
-		}
-	}
-	assertRequestHandlerCapability(method) {
-		if (!this._capabilities) return;
-		switch (method) {
-			case "sampling/createMessage":
-				if (!this._capabilities.sampling) throw new Error(`Client does not support sampling capability (required for ${method})`);
-				break;
-			case "elicitation/create":
-				if (!this._capabilities.elicitation) throw new Error(`Client does not support elicitation capability (required for ${method})`);
-				break;
-			case "roots/list":
-				if (!this._capabilities.roots) throw new Error(`Client does not support roots capability (required for ${method})`);
-				break;
-			case "tasks/get":
-			case "tasks/list":
-			case "tasks/result":
-			case "tasks/cancel":
-				if (!this._capabilities.tasks) throw new Error(`Client does not support tasks capability (required for ${method})`);
-				break;
-			case "ping": break;
-		}
-	}
-	assertTaskCapability(method) {
-		assertToolsCallTaskCapability(this._serverCapabilities?.tasks?.requests, method, "Server");
-	}
-	assertTaskHandlerCapability(method) {
-		if (!this._capabilities) return;
-		assertClientRequestTaskCapability(this._capabilities.tasks?.requests, method, "Client");
-	}
-	async ping(options) {
-		return this.request({ method: "ping" }, EmptyResultSchema, options);
-	}
-	async complete(params, options) {
-		return this.request({
-			method: "completion/complete",
-			params
-		}, CompleteResultSchema, options);
-	}
-	async setLoggingLevel(level, options) {
-		return this.request({
-			method: "logging/setLevel",
-			params: { level }
-		}, EmptyResultSchema, options);
-	}
-	async getPrompt(params, options) {
-		return this.request({
-			method: "prompts/get",
-			params
-		}, GetPromptResultSchema, options);
-	}
-	async listPrompts(params, options) {
-		return this.request({
-			method: "prompts/list",
-			params
-		}, ListPromptsResultSchema, options);
-	}
-	async listResources(params, options) {
-		return this.request({
-			method: "resources/list",
-			params
-		}, ListResourcesResultSchema, options);
-	}
-	async listResourceTemplates(params, options) {
-		return this.request({
-			method: "resources/templates/list",
-			params
-		}, ListResourceTemplatesResultSchema, options);
-	}
-	async readResource(params, options) {
-		return this.request({
-			method: "resources/read",
-			params
-		}, ReadResourceResultSchema, options);
-	}
-	async subscribeResource(params, options) {
-		return this.request({
-			method: "resources/subscribe",
-			params
-		}, EmptyResultSchema, options);
-	}
-	async unsubscribeResource(params, options) {
-		return this.request({
-			method: "resources/unsubscribe",
-			params
-		}, EmptyResultSchema, options);
-	}
-	/**
-	* Calls a tool and waits for the result. Automatically validates structured output if the tool has an outputSchema.
-	*
-	* For task-based execution with streaming behavior, use client.experimental.tasks.callToolStream() instead.
-	*/
-	async callTool(params, resultSchema = CallToolResultSchema, options) {
-		if (this.isToolTaskRequired(params.name)) throw new McpError(ErrorCode.InvalidRequest, `Tool "${params.name}" requires task-based execution. Use client.experimental.tasks.callToolStream() instead.`);
-		const result = await this.request({
-			method: "tools/call",
-			params
-		}, resultSchema, options);
-		const validator = this.getToolOutputValidator(params.name);
-		if (validator) {
-			if (!result.structuredContent && !result.isError) throw new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`);
-			if (result.structuredContent) try {
-				const validationResult = validator(result.structuredContent);
-				if (!validationResult.valid) throw new McpError(ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`);
-			} catch (error) {
-				if (error instanceof McpError) throw error;
-				throw new McpError(ErrorCode.InvalidParams, `Failed to validate structured content: ${error instanceof Error ? error.message : String(error)}`);
-			}
-		}
-		return result;
-	}
-	isToolTask(toolName) {
-		if (!this._serverCapabilities?.tasks?.requests?.tools?.call) return false;
-		return this._cachedKnownTaskTools.has(toolName);
-	}
-	/**
-	* Check if a tool requires task-based execution.
-	* Unlike isToolTask which includes 'optional' tools, this only checks for 'required'.
-	*/
-	isToolTaskRequired(toolName) {
-		return this._cachedRequiredTaskTools.has(toolName);
-	}
-	/**
-	* Cache validators for tool output schemas.
-	* Called after listTools() to pre-compile validators for better performance.
-	*/
-	cacheToolMetadata(tools) {
-		this._cachedToolOutputValidators.clear();
-		this._cachedKnownTaskTools.clear();
-		this._cachedRequiredTaskTools.clear();
-		for (const tool of tools) {
-			if (tool.outputSchema) {
-				const toolValidator = this._jsonSchemaValidator.getValidator(tool.outputSchema);
-				this._cachedToolOutputValidators.set(tool.name, toolValidator);
-			}
-			const taskSupport = tool.execution?.taskSupport;
-			if (taskSupport === "required" || taskSupport === "optional") this._cachedKnownTaskTools.add(tool.name);
-			if (taskSupport === "required") this._cachedRequiredTaskTools.add(tool.name);
-		}
-	}
-	/**
-	* Get cached validator for a tool
-	*/
-	getToolOutputValidator(toolName) {
-		return this._cachedToolOutputValidators.get(toolName);
-	}
-	async listTools(params, options) {
-		const result = await this.request({
-			method: "tools/list",
-			params
-		}, ListToolsResultSchema, options);
-		this.cacheToolMetadata(result.tools);
-		return result;
-	}
-	/**
-	* Set up a single list changed handler.
-	* @internal
-	*/
-	_setupListChangedHandler(listType, notificationSchema, options, fetcher) {
-		const parseResult = ListChangedOptionsBaseSchema.safeParse(options);
-		if (!parseResult.success) throw new Error(`Invalid ${listType} listChanged options: ${parseResult.error.message}`);
-		if (typeof options.onChanged !== "function") throw new Error(`Invalid ${listType} listChanged options: onChanged must be a function`);
-		const { autoRefresh, debounceMs } = parseResult.data;
-		const { onChanged } = options;
-		const refresh = async () => {
-			if (!autoRefresh) {
-				onChanged(null, null);
-				return;
-			}
-			try {
-				onChanged(null, await fetcher());
-			} catch (e) {
-				onChanged(e instanceof Error ? e : new Error(String(e)), null);
-			}
-		};
-		const handler = () => {
-			if (debounceMs) {
-				const existingTimer = this._listChangedDebounceTimers.get(listType);
-				if (existingTimer) clearTimeout(existingTimer);
-				const timer = setTimeout(refresh, debounceMs);
-				this._listChangedDebounceTimers.set(listType, timer);
-			} else refresh();
-		};
-		this.setNotificationHandler(notificationSchema, handler);
-	}
-	async sendRootsListChanged() {
-		return this.notification({ method: "notifications/roots/list_changed" });
-	}
-};
-//#endregion
-export { Client };