mcp-proxy 6.4.3 → 6.4.5

package/dist/{stdio-CvFTizsx.mjs → stdio-_93Y9W6l.mjs}

@@ -1,8 +1,12 @@
 import { createRequire } from "node:module";
 import { randomUUID } from "node:crypto";
+import { TLSSocket } from "node:tls";
+import { Readable } from "stream";
 import { URL as URL$1 } from "node:url";
-import fs from "fs";
 import http from "http";
+import { Http2ServerRequest } from "http2";
+import crypto$1 from "crypto";
+import fs from "fs";
 import https from "https";
 
 //#region rolldown:runtime
@@ -3324,7 +3328,7 @@ function preprocess(fn, schema) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
 const LATEST_PROTOCOL_VERSION = "2025-11-25";
 const DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
 const SUPPORTED_PROTOCOL_VERSIONS = [
@@ -3357,10 +3361,12 @@ const TaskCreationParamsSchema = looseObject({
 	ttl: union([number(), _null()]).optional(),
 	pollInterval: number().optional()
 });
+const TaskMetadataSchema = object({ ttl: number().optional() });
 /**
-* Task association metadata, used to signal which task a message originated from.
+* Metadata for associating messages with a task.
+* Include this in the `_meta` field under the key `io.modelcontextprotocol/related-task`.
 */
-const RelatedTaskMetadataSchema = looseObject({ taskId: string() });
+const RelatedTaskMetadataSchema = object({ taskId: string() });
 const RequestMetaSchema = looseObject({
 	progressToken: ProgressTokenSchema.optional(),
 	[RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
@@ -3368,20 +3374,28 @@ const RequestMetaSchema = looseObject({
 /**
 * Common params for any request.
 */
-const BaseRequestParamsSchema = looseObject({
-	task: TaskCreationParamsSchema.optional(),
-	_meta: RequestMetaSchema.optional()
-});
+const BaseRequestParamsSchema = object({ _meta: RequestMetaSchema.optional() });
+/**
+* Common params for any task-augmented request.
+*/
+const TaskAugmentedRequestParamsSchema = BaseRequestParamsSchema.extend({ task: TaskMetadataSchema.optional() });
+/**
+* Checks if a value is a valid TaskAugmentedRequestParams.
+* @param value - The value to check.
+*
+* @returns True if the value is a valid TaskAugmentedRequestParams, false otherwise.
+*/
+const isTaskAugmentedRequestParams = (value) => TaskAugmentedRequestParamsSchema.safeParse(value).success;
 const RequestSchema = object({
 	method: string(),
-	params: BaseRequestParamsSchema.optional()
+	params: BaseRequestParamsSchema.loose().optional()
 });
-const NotificationsParamsSchema = looseObject({ _meta: object({ [RELATED_TASK_META_KEY]: optional(RelatedTaskMetadataSchema) }).passthrough().optional() });
+const NotificationsParamsSchema = object({ _meta: RequestMetaSchema.optional() });
 const NotificationSchema = object({
 	method: string(),
-	params: NotificationsParamsSchema.optional()
+	params: NotificationsParamsSchema.loose().optional()
 });
-const ResultSchema = looseObject({ _meta: looseObject({ [RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional() }).optional() });
+const ResultSchema = looseObject({ _meta: RequestMetaSchema.optional() });
 /**
 * A uniquely identifying ID for a request in JSON-RPC.
 */
@@ -3406,12 +3420,18 @@ const isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(val
 /**
 * A successful (non-error) response to a request.
 */
-const JSONRPCResponseSchema = object({
+const JSONRPCResultResponseSchema = object({
 	jsonrpc: literal(JSONRPC_VERSION),
 	id: RequestIdSchema,
 	result: ResultSchema
 }).strict();
-const isJSONRPCResponse = (value) => JSONRPCResponseSchema.safeParse(value).success;
+/**
+* Checks if a value is a valid JSONRPCResultResponse.
+* @param value - The value to check.
+*
+* @returns True if the value is a valid JSONRPCResultResponse, false otherwise.
+*/
+const isJSONRPCResultResponse = (value) => JSONRPCResultResponseSchema.safeParse(value).success;
 /**
 * Error codes defined by the JSON-RPC specification.
 */
@@ -3429,28 +3449,35 @@ var ErrorCode;
 /**
 * A response to a request that indicates an error occurred.
 */
-const JSONRPCErrorSchema = object({
+const JSONRPCErrorResponseSchema = object({
 	jsonrpc: literal(JSONRPC_VERSION),
-	id: RequestIdSchema,
+	id: RequestIdSchema.optional(),
 	error: object({
 		code: number().int(),
 		message: string(),
-		data: optional(unknown())
+		data: unknown().optional()
 	})
 }).strict();
-const isJSONRPCError = (value) => JSONRPCErrorSchema.safeParse(value).success;
+/**
+* Checks if a value is a valid JSONRPCErrorResponse.
+* @param value - The value to check.
+*
+* @returns True if the value is a valid JSONRPCErrorResponse, false otherwise.
+*/
+const isJSONRPCErrorResponse = (value) => JSONRPCErrorResponseSchema.safeParse(value).success;
 const JSONRPCMessageSchema = union([
 	JSONRPCRequestSchema,
 	JSONRPCNotificationSchema,
-	JSONRPCResponseSchema,
-	JSONRPCErrorSchema
+	JSONRPCResultResponseSchema,
+	JSONRPCErrorResponseSchema
 ]);
+const JSONRPCResponseSchema = union([JSONRPCResultResponseSchema, JSONRPCErrorResponseSchema]);
 /**
 * A response that indicates success but carries no data.
 */
 const EmptyResultSchema = ResultSchema.strict();
 const CancelledNotificationParamsSchema = NotificationsParamsSchema.extend({
-	requestId: RequestIdSchema,
+	requestId: RequestIdSchema.optional(),
 	reason: string().optional()
 });
 /**
@@ -3472,7 +3499,8 @@ const CancelledNotificationSchema = NotificationSchema.extend({
 const IconSchema = object({
 	src: string(),
 	mimeType: string().optional(),
-	sizes: array(string()).optional()
+	sizes: array(string()).optional(),
+	theme: _enum(["light", "dark"]).optional()
 });
 /**
 * Base schema to add `icons` property.
@@ -3493,7 +3521,8 @@ const ImplementationSchema = BaseMetadataSchema.extend({
 	...BaseMetadataSchema.shape,
 	...IconsSchema.shape,
 	version: string(),
-	websiteUrl: string().optional()
+	websiteUrl: string().optional(),
+	description: string().optional()
 });
 const FormElicitationCapabilitySchema = intersection(object({ applyDefaults: boolean().optional() }), record(string(), unknown()));
 const ElicitationCapabilitySchema = preprocess((value) => {
@@ -3508,22 +3537,22 @@ const ElicitationCapabilitySchema = preprocess((value) => {
 /**
 * Task capabilities for clients, indicating which request types support task creation.
 */
-const ClientTasksCapabilitySchema = object({
-	list: optional(object({}).passthrough()),
-	cancel: optional(object({}).passthrough()),
-	requests: optional(object({
-		sampling: optional(object({ createMessage: optional(object({}).passthrough()) }).passthrough()),
-		elicitation: optional(object({ create: optional(object({}).passthrough()) }).passthrough())
-	}).passthrough())
-}).passthrough();
+const ClientTasksCapabilitySchema = looseObject({
+	list: AssertObjectSchema.optional(),
+	cancel: AssertObjectSchema.optional(),
+	requests: looseObject({
+		sampling: looseObject({ createMessage: AssertObjectSchema.optional() }).optional(),
+		elicitation: looseObject({ create: AssertObjectSchema.optional() }).optional()
+	}).optional()
+});
 /**
 * Task capabilities for servers, indicating which request types support task creation.
 */
-const ServerTasksCapabilitySchema = object({
-	list: optional(object({}).passthrough()),
-	cancel: optional(object({}).passthrough()),
-	requests: optional(object({ tools: optional(object({ call: optional(object({}).passthrough()) }).passthrough()) }).passthrough())
-}).passthrough();
+const ServerTasksCapabilitySchema = looseObject({
+	list: AssertObjectSchema.optional(),
+	cancel: AssertObjectSchema.optional(),
+	requests: looseObject({ tools: looseObject({ call: AssertObjectSchema.optional() }).optional() }).optional()
+});
 /**
 * Capabilities a client may support. Known capabilities are defined here, in this schema, but this is not a closed set: any client can define its own, additional capabilities.
 */
@@ -3535,7 +3564,7 @@ const ClientCapabilitiesSchema = object({
 	}).optional(),
 	elicitation: ElicitationCapabilitySchema.optional(),
 	roots: object({ listChanged: boolean().optional() }).optional(),
-	tasks: optional(ClientTasksCapabilitySchema)
+	tasks: ClientTasksCapabilitySchema.optional()
 });
 const InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
 	protocolVersion: string(),
@@ -3557,14 +3586,14 @@ const ServerCapabilitiesSchema = object({
 	experimental: record(string(), AssertObjectSchema).optional(),
 	logging: AssertObjectSchema.optional(),
 	completions: AssertObjectSchema.optional(),
-	prompts: optional(object({ listChanged: optional(boolean()) })),
+	prompts: object({ listChanged: boolean().optional() }).optional(),
 	resources: object({
 		subscribe: boolean().optional(),
 		listChanged: boolean().optional()
 	}).optional(),
 	tools: object({ listChanged: boolean().optional() }).optional(),
-	tasks: optional(ServerTasksCapabilitySchema)
-}).passthrough();
+	tasks: ServerTasksCapabilitySchema.optional()
+});
 /**
 * After receiving an initialize request from the client, the server sends this response.
 */
@@ -3577,12 +3606,18 @@ const InitializeResultSchema = ResultSchema.extend({
 /**
 * This notification is sent from the client to the server after initialization has finished.
 */
-const InitializedNotificationSchema = NotificationSchema.extend({ method: literal("notifications/initialized") });
+const InitializedNotificationSchema = NotificationSchema.extend({
+	method: literal("notifications/initialized"),
+	params: NotificationsParamsSchema.optional()
+});
 const isInitializedNotification = (value) => InitializedNotificationSchema.safeParse(value).success;
 /**
 * A ping, issued by either the server or the client, to check that the other party is still alive. The receiver must promptly respond, or else may be disconnected.
 */
-const PingRequestSchema = RequestSchema.extend({ method: literal("ping") });
+const PingRequestSchema = RequestSchema.extend({
+	method: literal("ping"),
+	params: BaseRequestParamsSchema.optional()
+});
 const ProgressSchema = object({
 	progress: number(),
 	total: optional(number()),
@@ -3604,19 +3639,23 @@ const ProgressNotificationSchema = NotificationSchema.extend({
 });
 const PaginatedRequestParamsSchema = BaseRequestParamsSchema.extend({ cursor: CursorSchema.optional() });
 const PaginatedRequestSchema = RequestSchema.extend({ params: PaginatedRequestParamsSchema.optional() });
-const PaginatedResultSchema = ResultSchema.extend({ nextCursor: optional(CursorSchema) });
+const PaginatedResultSchema = ResultSchema.extend({ nextCursor: CursorSchema.optional() });
+/**
+* The status of a task.
+* */
+const TaskStatusSchema = _enum([
+	"working",
+	"input_required",
+	"completed",
+	"failed",
+	"cancelled"
+]);
 /**
 * A pollable state object associated with a request.
 */
 const TaskSchema = object({
 	taskId: string(),
-	status: _enum([
-		"working",
-		"input_required",
-		"completed",
-		"failed",
-		"cancelled"
-	]),
+	status: TaskStatusSchema,
 	ttl: union([number(), _null()]),
 	createdAt: string(),
 	lastUpdatedAt: string(),
@@ -3657,6 +3696,13 @@ const GetTaskPayloadRequestSchema = RequestSchema.extend({
 	params: BaseRequestParamsSchema.extend({ taskId: string() })
 });
 /**
+* The response to a tasks/result request.
+* The structure matches the result type of the original request.
+* For example, a tools/call task would return the CallToolResult structure.
+*
+*/
+const GetTaskPayloadResultSchema = ResultSchema.loose();
+/**
 * A request to list tasks.
 */
 const ListTasksRequestSchema = PaginatedRequestSchema.extend({ method: literal("tasks/list") });
@@ -3693,16 +3739,20 @@ const Base64Schema = string().refine((val) => {
 	try {
 		atob(val);
 		return true;
-	} catch (_a) {
+	} catch {
 		return false;
 	}
 }, { message: "Invalid Base64 string" });
 const BlobResourceContentsSchema = ResourceContentsSchema.extend({ blob: Base64Schema });
 /**
+* The sender or recipient of messages and data in a conversation.
+*/
+const RoleSchema = _enum(["user", "assistant"]);
+/**
 * Optional annotations providing clients additional context about a resource.
 */
 const AnnotationsSchema = object({
-	audience: array(_enum(["user", "assistant"])).optional(),
+	audience: array(RoleSchema).optional(),
 	priority: number().min(0).max(1).optional(),
 	lastModified: datetime({ offset: true }).optional()
 });
@@ -3765,7 +3815,10 @@ const ReadResourceResultSchema = ResultSchema.extend({ contents: array(union([Te
 /**
 * An optional notification from the server to the client, informing it that the list of resources it can read from has changed. This may be issued by servers without any previous subscription from the client.
 */
-const ResourceListChangedNotificationSchema = NotificationSchema.extend({ method: literal("notifications/resources/list_changed") });
+const ResourceListChangedNotificationSchema = NotificationSchema.extend({
+	method: literal("notifications/resources/list_changed"),
+	params: NotificationsParamsSchema.optional()
+});
 const SubscribeRequestParamsSchema = ResourceRequestParamsSchema;
 /**
 * Sent from the client to request resources/updated notifications from the server whenever a particular resource changes.
@@ -3870,9 +3923,9 @@ const ToolUseContentSchema = object({
 	type: literal("tool_use"),
 	name: string(),
 	id: string(),
-	input: object({}).passthrough(),
-	_meta: optional(object({}).passthrough())
-}).passthrough();
+	input: record(string(), unknown()),
+	_meta: record(string(), unknown()).optional()
+});
 /**
 * The contents of a resource, embedded into a prompt or tool call result.
 */
@@ -3902,20 +3955,23 @@ const ContentBlockSchema = union([
 * Describes a message returned as part of a prompt.
 */
 const PromptMessageSchema = object({
-	role: _enum(["user", "assistant"]),
+	role: RoleSchema,
 	content: ContentBlockSchema
 });
 /**
 * The server's response to a prompts/get request from the client.
 */
 const GetPromptResultSchema = ResultSchema.extend({
-	description: optional(string()),
+	description: string().optional(),
 	messages: array(PromptMessageSchema)
 });
 /**
 * An optional notification from the server to the client, informing it that the list of prompts it offers has changed. This may be issued by servers without any previous subscription from the client.
 */
-const PromptListChangedNotificationSchema = NotificationSchema.extend({ method: literal("notifications/prompts/list_changed") });
+const PromptListChangedNotificationSchema = NotificationSchema.extend({
+	method: literal("notifications/prompts/list_changed"),
+	params: NotificationsParamsSchema.optional()
+});
 /**
 * Additional properties describing a Tool to clients.
 *
@@ -3958,8 +4014,8 @@ const ToolSchema = object({
 		properties: record(string(), AssertObjectSchema).optional(),
 		required: array(string()).optional()
 	}).catchall(unknown()).optional(),
-	annotations: optional(ToolAnnotationsSchema),
-	execution: optional(ToolExecutionSchema),
+	annotations: ToolAnnotationsSchema.optional(),
+	execution: ToolExecutionSchema.optional(),
 	_meta: record(string(), unknown()).optional()
 });
 /**
@@ -3976,7 +4032,7 @@ const ListToolsResultSchema = PaginatedResultSchema.extend({ tools: array(ToolSc
 const CallToolResultSchema = ResultSchema.extend({
 	content: array(ContentBlockSchema).default([]),
 	structuredContent: record(string(), unknown()).optional(),
-	isError: optional(boolean())
+	isError: boolean().optional()
 });
 /**
 * CallToolResultSchema extended with backwards compatibility to protocol version 2024-10-07.
@@ -3985,9 +4041,9 @@ const CompatibilityCallToolResultSchema = CallToolResultSchema.or(ResultSchema.e
 /**
 * Parameters for a `tools/call` request.
 */
-const CallToolRequestParamsSchema = BaseRequestParamsSchema.extend({
+const CallToolRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
 	name: string(),
-	arguments: optional(record(string(), unknown()))
+	arguments: record(string(), unknown()).optional()
 });
 /**
 * Used by the client to invoke a tool provided by the server.
@@ -3999,7 +4055,18 @@ const CallToolRequestSchema = RequestSchema.extend({
 /**
 * An optional notification from the server to the client, informing it that the list of tools it offers has changed. This may be issued by servers without any previous subscription from the client.
 */
-const ToolListChangedNotificationSchema = NotificationSchema.extend({ method: literal("notifications/tools/list_changed") });
+const ToolListChangedNotificationSchema = NotificationSchema.extend({
+	method: literal("notifications/tools/list_changed"),
+	params: NotificationsParamsSchema.optional()
+});
+/**
+* Base schema for list changed subscription options (without callback).
+* Used internally for Zod validation of autoRefresh and debounceMs.
+*/
+const ListChangedOptionsBaseSchema = object({
+	autoRefresh: boolean().default(true),
+	debounceMs: number().int().nonnegative().default(300)
+});
 /**
 * The severity of a log message.
 */
@@ -4047,19 +4114,19 @@ const ModelHintSchema = object({ name: string().optional() });
 * The server's preferences for model selection, requested of the client during sampling.
 */
 const ModelPreferencesSchema = object({
-	hints: optional(array(ModelHintSchema)),
-	costPriority: optional(number().min(0).max(1)),
-	speedPriority: optional(number().min(0).max(1)),
-	intelligencePriority: optional(number().min(0).max(1))
+	hints: array(ModelHintSchema).optional(),
+	costPriority: number().min(0).max(1).optional(),
+	speedPriority: number().min(0).max(1).optional(),
+	intelligencePriority: number().min(0).max(1).optional()
 });
 /**
 * Controls tool usage behavior in sampling requests.
 */
-const ToolChoiceSchema = object({ mode: optional(_enum([
+const ToolChoiceSchema = object({ mode: _enum([
 	"auto",
 	"required",
 	"none"
-])) });
+]).optional() });
 /**
 * The result of a tool execution, provided by the user (server).
 * Represents the outcome of invoking a tool requested via ToolUseContent.
@@ -4068,10 +4135,10 @@ const ToolResultContentSchema = object({
 	type: literal("tool_result"),
 	toolUseId: string().describe("The unique identifier for the corresponding tool call."),
 	content: array(ContentBlockSchema).default([]),
-	structuredContent: object({}).passthrough().optional(),
-	isError: optional(boolean()),
-	_meta: optional(object({}).passthrough())
-}).passthrough();
+	structuredContent: object({}).loose().optional(),
+	isError: boolean().optional(),
+	_meta: record(string(), unknown()).optional()
+});
 /**
 * Basic content types for sampling responses (without tool use).
 * Used for backwards-compatible CreateMessageResult when tools are not used.
@@ -4096,14 +4163,14 @@ const SamplingMessageContentBlockSchema = discriminatedUnion("type", [
 * Describes a message issued to or received from an LLM API.
 */
 const SamplingMessageSchema = object({
-	role: _enum(["user", "assistant"]),
+	role: RoleSchema,
 	content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)]),
-	_meta: optional(object({}).passthrough())
-}).passthrough();
+	_meta: record(string(), unknown()).optional()
+});
 /**
 * Parameters for a `sampling/createMessage` request.
 */
-const CreateMessageRequestParamsSchema = BaseRequestParamsSchema.extend({
+const CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
 	messages: array(SamplingMessageSchema),
 	modelPreferences: ModelPreferencesSchema.optional(),
 	systemPrompt: string().optional(),
@@ -4116,8 +4183,8 @@ const CreateMessageRequestParamsSchema = BaseRequestParamsSchema.extend({
 	maxTokens: number().int(),
 	stopSequences: array(string()).optional(),
 	metadata: AssertObjectSchema.optional(),
-	tools: optional(array(ToolSchema)),
-	toolChoice: optional(ToolChoiceSchema)
+	tools: array(ToolSchema).optional(),
+	toolChoice: ToolChoiceSchema.optional()
 });
 /**
 * A request from the server to sample an LLM via the client. The client has full discretion over which model to select. The client should also inform the user before beginning sampling, to allow them to inspect the request (human in the loop) and decide whether to approve it.
@@ -4138,7 +4205,7 @@ const CreateMessageResultSchema = ResultSchema.extend({
 		"stopSequence",
 		"maxTokens"
 	]).or(string())),
-	role: _enum(["user", "assistant"]),
+	role: RoleSchema,
 	content: SamplingContentSchema
 });
 /**
@@ -4153,7 +4220,7 @@ const CreateMessageResultWithToolsSchema = ResultSchema.extend({
 		"maxTokens",
 		"toolUse"
 	]).or(string())),
-	role: _enum(["user", "assistant"]),
+	role: RoleSchema,
 	content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)])
 });
 /**
@@ -4283,7 +4350,7 @@ const PrimitiveSchemaDefinitionSchema = union([
 /**
 * Parameters for an `elicitation/create` request for form-based elicitation.
 */
-const ElicitRequestFormParamsSchema = BaseRequestParamsSchema.extend({
+const ElicitRequestFormParamsSchema = TaskAugmentedRequestParamsSchema.extend({
 	mode: literal("form").optional(),
 	message: string(),
 	requestedSchema: object({
@@ -4295,7 +4362,7 @@ const ElicitRequestFormParamsSchema = BaseRequestParamsSchema.extend({
 /**
 * Parameters for an `elicitation/create` request for URL-based elicitation.
 */
-const ElicitRequestURLParamsSchema = BaseRequestParamsSchema.extend({
+const ElicitRequestURLParamsSchema = TaskAugmentedRequestParamsSchema.extend({
 	mode: literal("url"),
 	message: string(),
 	elicitationId: string(),
@@ -4396,7 +4463,10 @@ const RootSchema = object({
 /**
 * Sent from the server to request a list of root URIs from the client.
 */
-const ListRootsRequestSchema = RequestSchema.extend({ method: literal("roots/list") });
+const ListRootsRequestSchema = RequestSchema.extend({
+	method: literal("roots/list"),
+	params: BaseRequestParamsSchema.optional()
+});
 /**
 * The client's response to a roots/list request from the server.
 */
@@ -4404,7 +4474,10 @@ const ListRootsResultSchema = ResultSchema.extend({ roots: array(RootSchema) });
 /**
 * A notification from the client to the server, informing it that the list of roots has changed.
 */
-const RootsListChangedNotificationSchema = NotificationSchema.extend({ method: literal("notifications/roots/list_changed") });
+const RootsListChangedNotificationSchema = NotificationSchema.extend({
+	method: literal("notifications/roots/list_changed"),
+	params: NotificationsParamsSchema.optional()
+});
 const ClientRequestSchema = union([
 	PingRequestSchema,
 	InitializeRequestSchema,
@@ -4421,7 +4494,8 @@ const ClientRequestSchema = union([
 	ListToolsRequestSchema,
 	GetTaskRequestSchema,
 	GetTaskPayloadRequestSchema,
-	ListTasksRequestSchema
+	ListTasksRequestSchema,
+	CancelTaskRequestSchema
 ]);
 const ClientNotificationSchema = union([
 	CancelledNotificationSchema,
@@ -4447,7 +4521,8 @@ const ServerRequestSchema = union([
 	ListRootsRequestSchema,
 	GetTaskRequestSchema,
 	GetTaskPayloadRequestSchema,
-	ListTasksRequestSchema
+	ListTasksRequestSchema,
+	CancelTaskRequestSchema
 ]);
 const ServerNotificationSchema = union([
 	CancelledNotificationSchema,
@@ -4502,8 +4577,7 @@ var UrlElicitationRequiredError = class extends McpError {
 		super(ErrorCode.UrlElicitationRequired, message, { elicitations });
 	}
 	get elicitations() {
-		var _a, _b;
-		return (_b = (_a = this.data) === null || _a === void 0 ? void 0 : _a.elicitations) !== null && _b !== void 0 ? _b : [];
+		return this.data?.elicitations ?? [];
 	}
 };
 
@@ -5003,7 +5077,7 @@ var require_setprototypeof = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 }));
 
 //#endregion
-//#region node_modules/.pnpm/statuses@2.0.1/node_modules/statuses/codes.json
+//#region node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/codes.json
 var require_codes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = {
 		"100": "Continue",
@@ -5073,7 +5147,7 @@ var require_codes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/statuses@2.0.1/node_modules/statuses/index.js
+//#region node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/index.js
 /*!
 * statuses
 * Copyright(c) 2014 Jonathan Ong
@@ -5241,7 +5315,7 @@ var require_toidentifier = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/http-errors@2.0.0/node_modules/http-errors/index.js
+//#region node_modules/.pnpm/http-errors@2.0.1/node_modules/http-errors/index.js
 /*!
 * http-errors
 * Copyright(c) 2014 Jonathan Ong
@@ -5430,10 +5504,13 @@ var require_http_errors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	}
 	/**
 	* Get a class name from a name identifier.
+	*
+	* @param {string} name
+	* @returns {string}
 	* @private
 	*/
 	function toClassName(name) {
-		return name.substr(-5) !== "Error" ? name + "Error" : name;
+		return name.slice(-5) === "Error" ? name : name + "Error";
 	}
 }));
 
@@ -14212,7 +14289,7 @@ var require_unpipe = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/raw-body@3.0.1/node_modules/raw-body/index.js
+//#region node_modules/.pnpm/raw-body@3.0.2/node_modules/raw-body/index.js
 /*!
 * raw-body
 * Copyright(c) 2013-2014 Jonathan Ong
@@ -14233,7 +14310,7 @@ var require_raw_body = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* Module exports.
 	* @public
 	*/
-	module.exports = getRawBody$2;
+	module.exports = getRawBody$1;
 	/**
 	* Module variables.
 	* @private
@@ -14265,7 +14342,7 @@ var require_raw_body = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @param {function} [callback]
 	* @public
 	*/
-	function getRawBody$2(stream, options, callback) {
+	function getRawBody$1(stream, options, callback) {
 		var done = callback;
 		var opts = options || {};
 		if (stream === void 0) throw new TypeError("argument stream is required");
@@ -14510,10 +14587,10 @@ var require_content_type = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/sse.js
-var import_raw_body$1 = /* @__PURE__ */ __toESM(require_raw_body(), 1);
-var import_content_type$1 = /* @__PURE__ */ __toESM(require_content_type(), 1);
-const MAXIMUM_MESSAGE_SIZE$1 = "4mb";
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/sse.js
+var import_raw_body = /* @__PURE__ */ __toESM(require_raw_body(), 1);
+var import_content_type = /* @__PURE__ */ __toESM(require_content_type(), 1);
+const MAXIMUM_MESSAGE_SIZE = "4mb";
 /**
 * Server transport for SSE: this will send messages over an SSE connection and receive messages from HTTP POST requests.
 *
@@ -14563,9 +14640,8 @@ var SSEServerTransport = class {
 		this.res.write(`event: endpoint\ndata: ${relativeUrlWithSession}\n\n`);
 		this._sseResponse = this.res;
 		this.res.on("close", () => {
-			var _a;
 			this._sseResponse = void 0;
-			(_a = this.onclose) === null || _a === void 0 || _a.call(this);
+			this.onclose?.();
 		});
 	}
 	/**
@@ -14574,7 +14650,6 @@ var SSEServerTransport = class {
 	* This should be called when a POST request is made to send a message to the server.
 	*/
 	async handlePostMessage(req, res, parsedBody) {
-		var _a, _b, _c, _d;
 		if (!this._sseResponse) {
 			const message = "SSE connection not established";
 			res.writeHead(500).end(message);
@@ -14583,22 +14658,28 @@ var SSEServerTransport = class {
 		const validationError = this.validateRequestHeaders(req);
 		if (validationError) {
 			res.writeHead(403).end(validationError);
-			(_a = this.onerror) === null || _a === void 0 || _a.call(this, new Error(validationError));
+			this.onerror?.(new Error(validationError));
 			return;
 		}
 		const authInfo = req.auth;
-		const requestInfo = { headers: req.headers };
+		const host = req.headers.host;
+		const protocol = req.socket instanceof TLSSocket ? "https" : "http";
+		const fullUrl = host && req.url ? new URL$1(req.url, `${protocol}://${host}`) : void 0;
+		const requestInfo = {
+			headers: req.headers,
+			url: fullUrl
+		};
 		let body;
 		try {
-			const ct = import_content_type$1.parse((_b = req.headers["content-type"]) !== null && _b !== void 0 ? _b : "");
+			const ct = import_content_type.parse(req.headers["content-type"] ?? "");
 			if (ct.type !== "application/json") throw new Error(`Unsupported content-type: ${ct.type}`);
-			body = parsedBody !== null && parsedBody !== void 0 ? parsedBody : await (0, import_raw_body$1.default)(req, {
-				limit: MAXIMUM_MESSAGE_SIZE$1,
-				encoding: (_c = ct.parameters.charset) !== null && _c !== void 0 ? _c : "utf-8"
+			body = parsedBody ?? await (0, import_raw_body.default)(req, {
+				limit: MAXIMUM_MESSAGE_SIZE,
+				encoding: ct.parameters.charset ?? "utf-8"
 			});
 		} catch (error$1) {
 			res.writeHead(400).end(String(error$1));
-			(_d = this.onerror) === null || _d === void 0 || _d.call(this, error$1);
+			this.onerror?.(error$1);
 			return;
 		}
 		try {
@@ -14606,7 +14687,7 @@ var SSEServerTransport = class {
 				requestInfo,
 				authInfo
 			});
-		} catch (_e) {
+		} catch {
 			res.writeHead(400).end(`Invalid message: ${body}`);
 			return;
 		}
@@ -14616,21 +14697,19 @@ var SSEServerTransport = class {
 	* Handle a client message, regardless of how it arrived. This can be used to inform the server of messages that arrive via a means different than HTTP POST.
 	*/
 	async handleMessage(message, extra) {
-		var _a, _b;
 		let parsedMessage;
 		try {
 			parsedMessage = JSONRPCMessageSchema.parse(message);
 		} catch (error$1) {
-			(_a = this.onerror) === null || _a === void 0 || _a.call(this, error$1);
+			this.onerror?.(error$1);
 			throw error$1;
 		}
-		(_b = this.onmessage) === null || _b === void 0 || _b.call(this, parsedMessage, extra);
+		this.onmessage?.(parsedMessage, extra);
 	}
 	async close() {
-		var _a, _b;
-		(_a = this._sseResponse) === null || _a === void 0 || _a.end();
+		this._sseResponse?.end();
 		this._sseResponse = void 0;
-		(_b = this.onclose) === null || _b === void 0 || _b.call(this);
+		this.onclose?.();
 	}
 	async send(message) {
 		if (!this._sseResponse) throw new Error("Not connected");
@@ -14647,31 +14726,469 @@ var SSEServerTransport = class {
 };
 
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/streamableHttp.js
-var import_raw_body = /* @__PURE__ */ __toESM(require_raw_body(), 1);
-var import_content_type = /* @__PURE__ */ __toESM(require_content_type(), 1);
-const MAXIMUM_MESSAGE_SIZE = "4mb";
+//#region node_modules/.pnpm/@hono+node-server@1.19.11_hono@4.12.7/node_modules/@hono/node-server/dist/index.mjs
+var RequestError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "RequestError";
+	}
+};
+var toRequestError = (e) => {
+	if (e instanceof RequestError) return e;
+	return new RequestError(e.message, { cause: e });
+};
+var GlobalRequest = global.Request;
+var Request = class extends GlobalRequest {
+	constructor(input, options) {
+		if (typeof input === "object" && getRequestCache in input) input = input[getRequestCache]();
+		if (typeof options?.body?.getReader !== "undefined") options.duplex ??= "half";
+		super(input, options);
+	}
+};
+var newHeadersFromIncoming = (incoming) => {
+	const headerRecord = [];
+	const rawHeaders = incoming.rawHeaders;
+	for (let i$3 = 0; i$3 < rawHeaders.length; i$3 += 2) {
+		const { [i$3]: key$1, [i$3 + 1]: value } = rawHeaders;
+		if (key$1.charCodeAt(0) !== 58) headerRecord.push([key$1, value]);
+	}
+	return new Headers(headerRecord);
+};
+var wrapBodyStream = Symbol("wrapBodyStream");
+var newRequestFromIncoming = (method, url$1, headers, incoming, abortController) => {
+	const init = {
+		method,
+		headers,
+		signal: abortController.signal
+	};
+	if (method === "TRACE") {
+		init.method = "GET";
+		const req = new Request(url$1, init);
+		Object.defineProperty(req, "method", { get() {
+			return "TRACE";
+		} });
+		return req;
+	}
+	if (!(method === "GET" || method === "HEAD")) if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) init.body = new ReadableStream({ start(controller) {
+		controller.enqueue(incoming.rawBody);
+		controller.close();
+	} });
+	else if (incoming[wrapBodyStream]) {
+		let reader;
+		init.body = new ReadableStream({ async pull(controller) {
+			try {
+				reader ||= Readable.toWeb(incoming).getReader();
+				const { done, value } = await reader.read();
+				if (done) controller.close();
+				else controller.enqueue(value);
+			} catch (error$1) {
+				controller.error(error$1);
+			}
+		} });
+	} else init.body = Readable.toWeb(incoming);
+	return new Request(url$1, init);
+};
+var getRequestCache = Symbol("getRequestCache");
+var requestCache = Symbol("requestCache");
+var incomingKey = Symbol("incomingKey");
+var urlKey = Symbol("urlKey");
+var headersKey = Symbol("headersKey");
+var abortControllerKey = Symbol("abortControllerKey");
+var requestPrototype = {
+	get method() {
+		return this[incomingKey].method || "GET";
+	},
+	get url() {
+		return this[urlKey];
+	},
+	get headers() {
+		return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
+	},
+	[Symbol("getAbortController")]() {
+		this[getRequestCache]();
+		return this[abortControllerKey];
+	},
+	[getRequestCache]() {
+		this[abortControllerKey] ||= new AbortController();
+		return this[requestCache] ||= newRequestFromIncoming(this.method, this[urlKey], this.headers, this[incomingKey], this[abortControllerKey]);
+	}
+};
+[
+	"body",
+	"bodyUsed",
+	"cache",
+	"credentials",
+	"destination",
+	"integrity",
+	"mode",
+	"redirect",
+	"referrer",
+	"referrerPolicy",
+	"signal",
+	"keepalive"
+].forEach((k) => {
+	Object.defineProperty(requestPrototype, k, { get() {
+		return this[getRequestCache]()[k];
+	} });
+});
+[
+	"arrayBuffer",
+	"blob",
+	"clone",
+	"formData",
+	"json",
+	"text"
+].forEach((k) => {
+	Object.defineProperty(requestPrototype, k, { value: function() {
+		return this[getRequestCache]()[k]();
+	} });
+});
+Object.setPrototypeOf(requestPrototype, Request.prototype);
+var newRequest = (incoming, defaultHostname) => {
+	const req = Object.create(requestPrototype);
+	req[incomingKey] = incoming;
+	const incomingUrl = incoming.url || "";
+	if (incomingUrl[0] !== "/" && (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
+		if (incoming instanceof Http2ServerRequest) throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
+		try {
+			req[urlKey] = new URL(incomingUrl).href;
+		} catch (e) {
+			throw new RequestError("Invalid absolute URL", { cause: e });
+		}
+		return req;
+	}
+	const host = (incoming instanceof Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
+	if (!host) throw new RequestError("Missing host header");
+	let scheme;
+	if (incoming instanceof Http2ServerRequest) {
+		scheme = incoming.scheme;
+		if (!(scheme === "http" || scheme === "https")) throw new RequestError("Unsupported scheme");
+	} else scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
+	const url$1 = new URL(`${scheme}://${host}${incomingUrl}`);
+	if (url$1.hostname.length !== host.length && url$1.hostname !== host.replace(/:\d+$/, "")) throw new RequestError("Invalid host header");
+	req[urlKey] = url$1.href;
+	return req;
+};
+var responseCache = Symbol("responseCache");
+var getResponseCache = Symbol("getResponseCache");
+var cacheKey = Symbol("cache");
+var GlobalResponse = global.Response;
+var Response2 = class _Response {
+	#body;
+	#init;
+	[getResponseCache]() {
+		delete this[cacheKey];
+		return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+	}
+	constructor(body, init) {
+		let headers;
+		this.#body = body;
+		if (init instanceof _Response) {
+			const cachedGlobalResponse = init[responseCache];
+			if (cachedGlobalResponse) {
+				this.#init = cachedGlobalResponse;
+				this[getResponseCache]();
+				return;
+			} else {
+				this.#init = init.#init;
+				headers = new Headers(init.#init.headers);
+			}
+		} else this.#init = init;
+		if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) this[cacheKey] = [
+			init?.status || 200,
+			body,
+			headers || init?.headers
+		];
+	}
+	get headers() {
+		const cache = this[cacheKey];
+		if (cache) {
+			if (!(cache[2] instanceof Headers)) cache[2] = new Headers(cache[2] || { "content-type": "text/plain; charset=UTF-8" });
+			return cache[2];
+		}
+		return this[getResponseCache]().headers;
+	}
+	get status() {
+		return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+	}
+	get ok() {
+		const status$1 = this.status;
+		return status$1 >= 200 && status$1 < 300;
+	}
+};
+[
+	"body",
+	"bodyUsed",
+	"redirected",
+	"statusText",
+	"trailers",
+	"type",
+	"url"
+].forEach((k) => {
+	Object.defineProperty(Response2.prototype, k, { get() {
+		return this[getResponseCache]()[k];
+	} });
+});
+[
+	"arrayBuffer",
+	"blob",
+	"clone",
+	"formData",
+	"json",
+	"text"
+].forEach((k) => {
+	Object.defineProperty(Response2.prototype, k, { value: function() {
+		return this[getResponseCache]()[k]();
+	} });
+});
+Object.setPrototypeOf(Response2, GlobalResponse);
+Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+async function readWithoutBlocking(readPromise) {
+	return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+	const cancel = (error$1) => {
+		reader.cancel(error$1).catch(() => {});
+	};
+	writable.on("close", cancel);
+	writable.on("error", cancel);
+	(currentReadPromise ?? reader.read()).then(flow, handleStreamError);
+	return reader.closed.finally(() => {
+		writable.off("close", cancel);
+		writable.off("error", cancel);
+	});
+	function handleStreamError(error$1) {
+		if (error$1) writable.destroy(error$1);
+	}
+	function onDrain() {
+		reader.read().then(flow, handleStreamError);
+	}
+	function flow({ done, value }) {
+		try {
+			if (done) writable.end();
+			else if (!writable.write(value)) writable.once("drain", onDrain);
+			else return reader.read().then(flow, handleStreamError);
+		} catch (e) {
+			handleStreamError(e);
+		}
+	}
+}
+function writeFromReadableStream(stream, writable) {
+	if (stream.locked) throw new TypeError("ReadableStream is locked.");
+	else if (writable.destroyed) return;
+	return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
+var buildOutgoingHttpHeaders = (headers) => {
+	const res = {};
+	if (!(headers instanceof Headers)) headers = new Headers(headers ?? void 0);
+	const cookies = [];
+	for (const [k, v] of headers) if (k === "set-cookie") cookies.push(v);
+	else res[k] = v;
+	if (cookies.length > 0) res["set-cookie"] = cookies;
+	res["content-type"] ??= "text/plain; charset=UTF-8";
+	return res;
+};
+var X_ALREADY_SENT = "x-hono-already-sent";
+if (typeof global.crypto === "undefined") global.crypto = crypto$1;
+var outgoingEnded = Symbol("outgoingEnded");
+var handleRequestError = () => new Response(null, { status: 400 });
+var handleFetchError = (e) => new Response(null, { status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500 });
+var handleResponseError$1 = (e, outgoing) => {
+	const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
+	if (err.code === "ERR_STREAM_PREMATURE_CLOSE") console.info("The user aborted a request.");
+	else {
+		console.error(e);
+		if (!outgoing.headersSent) outgoing.writeHead(500, { "Content-Type": "text/plain" });
+		outgoing.end(`Error: ${err.message}`);
+		outgoing.destroy(err);
+	}
+};
+var flushHeaders = (outgoing) => {
+	if ("flushHeaders" in outgoing && outgoing.writable) outgoing.flushHeaders();
+};
+var responseViaCache = async (res, outgoing) => {
+	let [status$1, body, header] = res[cacheKey];
+	let hasContentLength = false;
+	if (!header) header = { "content-type": "text/plain; charset=UTF-8" };
+	else if (header instanceof Headers) {
+		hasContentLength = header.has("content-length");
+		header = buildOutgoingHttpHeaders(header);
+	} else if (Array.isArray(header)) {
+		const headerObj = new Headers(header);
+		hasContentLength = headerObj.has("content-length");
+		header = buildOutgoingHttpHeaders(headerObj);
+	} else for (const key$1 in header) if (key$1.length === 14 && key$1.toLowerCase() === "content-length") {
+		hasContentLength = true;
+		break;
+	}
+	if (!hasContentLength) {
+		if (typeof body === "string") header["Content-Length"] = Buffer.byteLength(body);
+		else if (body instanceof Uint8Array) header["Content-Length"] = body.byteLength;
+		else if (body instanceof Blob) header["Content-Length"] = body.size;
+	}
+	outgoing.writeHead(status$1, header);
+	if (typeof body === "string" || body instanceof Uint8Array) outgoing.end(body);
+	else if (body instanceof Blob) outgoing.end(new Uint8Array(await body.arrayBuffer()));
+	else {
+		flushHeaders(outgoing);
+		await writeFromReadableStream(body, outgoing)?.catch((e) => handleResponseError$1(e, outgoing));
+	}
+	outgoing[outgoingEnded]?.();
+};
+var isPromise = (res) => typeof res.then === "function";
+var responseViaResponseObject = async (res, outgoing, options = {}) => {
+	if (isPromise(res)) if (options.errorHandler) try {
+		res = await res;
+	} catch (err) {
+		const errRes = await options.errorHandler(err);
+		if (!errRes) return;
+		res = errRes;
+	}
+	else res = await res.catch(handleFetchError);
+	if (cacheKey in res) return responseViaCache(res, outgoing);
+	const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+	if (res.body) {
+		const reader = res.body.getReader();
+		const values = [];
+		let done = false;
+		let currentReadPromise = void 0;
+		if (resHeaderRecord["transfer-encoding"] !== "chunked") {
+			let maxReadCount = 2;
+			for (let i$3 = 0; i$3 < maxReadCount; i$3++) {
+				currentReadPromise ||= reader.read();
+				const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+					console.error(e);
+					done = true;
+				});
+				if (!chunk) {
+					if (i$3 === 1) {
+						await new Promise((resolve$2) => setTimeout(resolve$2));
+						maxReadCount = 3;
+						continue;
+					}
+					break;
+				}
+				currentReadPromise = void 0;
+				if (chunk.value) values.push(chunk.value);
+				if (chunk.done) {
+					done = true;
+					break;
+				}
+			}
+			if (done && !("content-length" in resHeaderRecord)) resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+		}
+		outgoing.writeHead(res.status, resHeaderRecord);
+		values.forEach((value) => {
+			outgoing.write(value);
+		});
+		if (done) outgoing.end();
+		else {
+			if (values.length === 0) flushHeaders(outgoing);
+			await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
+		}
+	} else if (resHeaderRecord[X_ALREADY_SENT]) {} else {
+		outgoing.writeHead(res.status, resHeaderRecord);
+		outgoing.end();
+	}
+	outgoing[outgoingEnded]?.();
+};
+var getRequestListener = (fetchCallback, options = {}) => {
+	const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
+	if (options.overrideGlobalObjects !== false && global.Request !== Request) {
+		Object.defineProperty(global, "Request", { value: Request });
+		Object.defineProperty(global, "Response", { value: Response2 });
+	}
+	return async (incoming, outgoing) => {
+		let res, req;
+		try {
+			req = newRequest(incoming, options.hostname);
+			let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+			if (!incomingEnded) {
+				incoming[wrapBodyStream] = true;
+				incoming.on("end", () => {
+					incomingEnded = true;
+				});
+				if (incoming instanceof Http2ServerRequest) outgoing[outgoingEnded] = () => {
+					if (!incomingEnded) setTimeout(() => {
+						if (!incomingEnded) setTimeout(() => {
+							incoming.destroy();
+							outgoing.destroy();
+						});
+					});
+				};
+			}
+			outgoing.on("close", () => {
+				if (req[abortControllerKey]) {
+					if (incoming.errored) req[abortControllerKey].abort(incoming.errored.toString());
+					else if (!outgoing.writableFinished) req[abortControllerKey].abort("Client connection prematurely closed.");
+				}
+				if (!incomingEnded) setTimeout(() => {
+					if (!incomingEnded) setTimeout(() => {
+						incoming.destroy();
+					});
+				});
+			});
+			res = fetchCallback(req, {
+				incoming,
+				outgoing
+			});
+			if (cacheKey in res) return responseViaCache(res, outgoing);
+		} catch (e) {
+			if (!res) if (options.errorHandler) {
+				res = await options.errorHandler(req ? e : toRequestError(e));
+				if (!res) return;
+			} else if (!req) res = handleRequestError();
+			else res = handleFetchError(e);
+			else return handleResponseError$1(e, outgoing);
+		}
+		try {
+			return await responseViaResponseObject(res, outgoing, options);
+		} catch (e) {
+			return handleResponseError$1(e, outgoing);
+		}
+	};
+};
+
+//#endregion
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js
 /**
-* Server transport for Streamable HTTP: this implements the MCP Streamable HTTP transport specification.
-* It supports both SSE streaming and direct HTTP responses.
+* Web Standards Streamable HTTP Server Transport
+*
+* This is the core transport implementation using Web Standard APIs (Request, Response, ReadableStream).
+* It can run on any runtime that supports Web Standards: Node.js 18+, Cloudflare Workers, Deno, Bun, etc.
+*
+* For Node.js Express/HTTP compatibility, use `StreamableHTTPServerTransport` which wraps this transport.
+*/
+/**
+* Server transport for Web Standards Streamable HTTP: this implements the MCP Streamable HTTP transport specification
+* using Web Standard APIs (Request, Response, ReadableStream).
+*
+* This transport works on any runtime that supports Web Standards: Node.js 18+, Cloudflare Workers, Deno, Bun, etc.
 *
 * Usage example:
 *
 * ```typescript
 * // Stateful mode - server sets the session ID
-* const statefulTransport = new StreamableHTTPServerTransport({
-*   sessionIdGenerator: () => randomUUID(),
+* const statefulTransport = new WebStandardStreamableHTTPServerTransport({
+*   sessionIdGenerator: () => crypto.randomUUID(),
 * });
 *
 * // Stateless mode - explicitly set session ID to undefined
-* const statelessTransport = new StreamableHTTPServerTransport({
+* const statelessTransport = new WebStandardStreamableHTTPServerTransport({
 *   sessionIdGenerator: undefined,
 * });
 *
-* // Using with pre-parsed request body
-* app.post('/mcp', (req, res) => {
-*   transport.handleRequest(req, res, req.body);
+* // Hono.js usage
+* app.all('/mcp', async (c) => {
+*   return transport.handleRequest(c.req.raw);
 * });
+*
+* // Cloudflare Workers usage
+* export default {
+*   async fetch(request: Request): Promise<Response> {
+*     return transport.handleRequest(request);
+*   }
+* };
 * ```
 *
 * In stateful mode:
@@ -14685,10 +15202,10 @@ const MAXIMUM_MESSAGE_SIZE = "4mb";
 * - No Session ID is included in any responses
 * - No session validation is performed
 */
-var StreamableHTTPServerTransport = class {
-	constructor(options) {
-		var _a, _b;
+var WebStandardStreamableHTTPServerTransport = class {
+	constructor(options = {}) {
 		this._started = false;
+		this._hasHandledRequest = false;
 		this._streamMapping = /* @__PURE__ */ new Map();
 		this._requestToStreamMapping = /* @__PURE__ */ new Map();
 		this._requestResponseMap = /* @__PURE__ */ new Map();
@@ -14696,13 +15213,13 @@ var StreamableHTTPServerTransport = class {
 		this._enableJsonResponse = false;
 		this._standaloneSseStreamId = "_GET_stream";
 		this.sessionIdGenerator = options.sessionIdGenerator;
-		this._enableJsonResponse = (_a = options.enableJsonResponse) !== null && _a !== void 0 ? _a : false;
+		this._enableJsonResponse = options.enableJsonResponse ?? false;
 		this._eventStore = options.eventStore;
 		this._onsessioninitialized = options.onsessioninitialized;
 		this._onsessionclosed = options.onsessionclosed;
 		this._allowedHosts = options.allowedHosts;
 		this._allowedOrigins = options.allowedOrigins;
-		this._enableDnsRebindingProtection = (_b = options.enableDnsRebindingProtection) !== null && _b !== void 0 ? _b : false;
+		this._enableDnsRebindingProtection = options.enableDnsRebindingProtection ?? false;
 		this._retryInterval = options.retryInterval;
 	}
 	/**
@@ -14714,140 +15231,146 @@ var StreamableHTTPServerTransport = class {
 		this._started = true;
 	}
 	/**
+	* Helper to create a JSON error response
+	*/
+	createJsonErrorResponse(status$1, code, message, options) {
+		const error$1 = {
+			code,
+			message
+		};
+		if (options?.data !== void 0) error$1.data = options.data;
+		return new Response(JSON.stringify({
+			jsonrpc: "2.0",
+			error: error$1,
+			id: null
+		}), {
+			status: status$1,
+			headers: {
+				"Content-Type": "application/json",
+				...options?.headers
+			}
+		});
+	}
+	/**
 	* Validates request headers for DNS rebinding protection.
-	* @returns Error message if validation fails, undefined if validation passes.
+	* @returns Error response if validation fails, undefined if validation passes.
 	*/
 	validateRequestHeaders(req) {
 		if (!this._enableDnsRebindingProtection) return;
 		if (this._allowedHosts && this._allowedHosts.length > 0) {
-			const hostHeader = req.headers.host;
-			if (!hostHeader || !this._allowedHosts.includes(hostHeader)) return `Invalid Host header: ${hostHeader}`;
+			const hostHeader = req.headers.get("host");
+			if (!hostHeader || !this._allowedHosts.includes(hostHeader)) {
+				const error$1 = `Invalid Host header: ${hostHeader}`;
+				this.onerror?.(new Error(error$1));
+				return this.createJsonErrorResponse(403, -32e3, error$1);
+			}
 		}
 		if (this._allowedOrigins && this._allowedOrigins.length > 0) {
-			const originHeader = req.headers.origin;
-			if (originHeader && !this._allowedOrigins.includes(originHeader)) return `Invalid Origin header: ${originHeader}`;
+			const originHeader = req.headers.get("origin");
+			if (originHeader && !this._allowedOrigins.includes(originHeader)) {
+				const error$1 = `Invalid Origin header: ${originHeader}`;
+				this.onerror?.(new Error(error$1));
+				return this.createJsonErrorResponse(403, -32e3, error$1);
+			}
 		}
 	}
 	/**
-	* Handles an incoming HTTP request, whether GET or POST
+	* Handles an incoming HTTP request, whether GET, POST, or DELETE
+	* Returns a Response object (Web Standard)
 	*/
-	async handleRequest(req, res, parsedBody) {
-		var _a;
+	async handleRequest(req, options) {
+		if (!this.sessionIdGenerator && this._hasHandledRequest) throw new Error("Stateless transport cannot be reused across requests. Create a new transport per request.");
+		this._hasHandledRequest = true;
 		const validationError = this.validateRequestHeaders(req);
-		if (validationError) {
-			res.writeHead(403).end(JSON.stringify({
-				jsonrpc: "2.0",
-				error: {
-					code: -32e3,
-					message: validationError
-				},
-				id: null
-			}));
-			(_a = this.onerror) === null || _a === void 0 || _a.call(this, new Error(validationError));
-			return;
+		if (validationError) return validationError;
+		switch (req.method) {
+			case "POST": return this.handlePostRequest(req, options);
+			case "GET": return this.handleGetRequest(req);
+			case "DELETE": return this.handleDeleteRequest(req);
+			default: return this.handleUnsupportedRequest();
 		}
-		if (req.method === "POST") await this.handlePostRequest(req, res, parsedBody);
-		else if (req.method === "GET") await this.handleGetRequest(req, res);
-		else if (req.method === "DELETE") await this.handleDeleteRequest(req, res);
-		else await this.handleUnsupportedRequest(res);
 	}
 	/**
 	* Writes a priming event to establish resumption capability.
 	* Only sends if eventStore is configured (opt-in for resumability) and
 	* the client's protocol version supports empty SSE data (>= 2025-11-25).
 	*/
-	async _maybeWritePrimingEvent(res, streamId, protocolVersion) {
+	async writePrimingEvent(controller, encoder, streamId, protocolVersion) {
 		if (!this._eventStore) return;
 		if (protocolVersion < "2025-11-25") return;
 		const primingEventId = await this._eventStore.storeEvent(streamId, {});
 		let primingEvent = `id: ${primingEventId}\ndata: \n\n`;
 		if (this._retryInterval !== void 0) primingEvent = `id: ${primingEventId}\nretry: ${this._retryInterval}\ndata: \n\n`;
-		res.write(primingEvent);
+		controller.enqueue(encoder.encode(primingEvent));
 	}
 	/**
 	* Handles GET requests for SSE stream
 	*/
-	async handleGetRequest(req, res) {
-		const acceptHeader = req.headers.accept;
-		if (!(acceptHeader === null || acceptHeader === void 0 ? void 0 : acceptHeader.includes("text/event-stream"))) {
-			res.writeHead(406).end(JSON.stringify({
-				jsonrpc: "2.0",
-				error: {
-					code: -32e3,
-					message: "Not Acceptable: Client must accept text/event-stream"
-				},
-				id: null
-			}));
-			return;
-		}
-		if (!this.validateSession(req, res)) return;
-		if (!this.validateProtocolVersion(req, res)) return;
+	async handleGetRequest(req) {
+		if (!req.headers.get("accept")?.includes("text/event-stream")) {
+			this.onerror?.(/* @__PURE__ */ new Error("Not Acceptable: Client must accept text/event-stream"));
+			return this.createJsonErrorResponse(406, -32e3, "Not Acceptable: Client must accept text/event-stream");
+		}
+		const sessionError = this.validateSession(req);
+		if (sessionError) return sessionError;
+		const protocolError = this.validateProtocolVersion(req);
+		if (protocolError) return protocolError;
 		if (this._eventStore) {
-			const lastEventId = req.headers["last-event-id"];
-			if (lastEventId) {
-				await this.replayEvents(lastEventId, res);
-				return;
-			}
+			const lastEventId = req.headers.get("last-event-id");
+			if (lastEventId) return this.replayEvents(lastEventId);
 		}
+		if (this._streamMapping.get(this._standaloneSseStreamId) !== void 0) {
+			this.onerror?.(/* @__PURE__ */ new Error("Conflict: Only one SSE stream is allowed per session"));
+			return this.createJsonErrorResponse(409, -32e3, "Conflict: Only one SSE stream is allowed per session");
+		}
+		const encoder = new TextEncoder();
+		let streamController;
+		const readable = new ReadableStream({
+			start: (controller) => {
+				streamController = controller;
+			},
+			cancel: () => {
+				this._streamMapping.delete(this._standaloneSseStreamId);
+			}
+		});
 		const headers = {
 			"Content-Type": "text/event-stream",
 			"Cache-Control": "no-cache, no-transform",
 			Connection: "keep-alive"
 		};
 		if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
-		if (this._streamMapping.get(this._standaloneSseStreamId) !== void 0) {
-			res.writeHead(409).end(JSON.stringify({
-				jsonrpc: "2.0",
-				error: {
-					code: -32e3,
-					message: "Conflict: Only one SSE stream is allowed per session"
-				},
-				id: null
-			}));
-			return;
-		}
-		res.writeHead(200, headers).flushHeaders();
-		this._streamMapping.set(this._standaloneSseStreamId, res);
-		res.on("close", () => {
-			this._streamMapping.delete(this._standaloneSseStreamId);
-		});
-		res.on("error", (error$1) => {
-			var _a;
-			(_a = this.onerror) === null || _a === void 0 || _a.call(this, error$1);
+		this._streamMapping.set(this._standaloneSseStreamId, {
+			controller: streamController,
+			encoder,
+			cleanup: () => {
+				this._streamMapping.delete(this._standaloneSseStreamId);
+				try {
+					streamController.close();
+				} catch {}
+			}
 		});
+		return new Response(readable, { headers });
 	}
 	/**
 	* Replays events that would have been sent after the specified event ID
 	* Only used when resumability is enabled
 	*/
-	async replayEvents(lastEventId, res) {
-		var _a;
-		if (!this._eventStore) return;
+	async replayEvents(lastEventId) {
+		if (!this._eventStore) {
+			this.onerror?.(/* @__PURE__ */ new Error("Event store not configured"));
+			return this.createJsonErrorResponse(400, -32e3, "Event store not configured");
+		}
 		try {
 			let streamId;
 			if (this._eventStore.getStreamIdForEventId) {
 				streamId = await this._eventStore.getStreamIdForEventId(lastEventId);
 				if (!streamId) {
-					res.writeHead(400).end(JSON.stringify({
-						jsonrpc: "2.0",
-						error: {
-							code: -32e3,
-							message: "Invalid event ID format"
-						},
-						id: null
-					}));
-					return;
+					this.onerror?.(/* @__PURE__ */ new Error("Invalid event ID format"));
+					return this.createJsonErrorResponse(400, -32e3, "Invalid event ID format");
 				}
 				if (this._streamMapping.get(streamId) !== void 0) {
-					res.writeHead(409).end(JSON.stringify({
-						jsonrpc: "2.0",
-						error: {
-							code: -32e3,
-							message: "Conflict: Stream already has an active connection"
-						},
-						id: null
-					}));
-					return;
+					this.onerror?.(/* @__PURE__ */ new Error("Conflict: Stream already has an active connection"));
+					return this.createJsonErrorResponse(409, -32e3, "Conflict: Stream already has an active connection");
 				}
 			}
 			const headers = {
@@ -14856,275 +15379,267 @@ var StreamableHTTPServerTransport = class {
 				Connection: "keep-alive"
 			};
 			if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
-			res.writeHead(200, headers).flushHeaders();
+			const encoder = new TextEncoder();
+			let streamController;
+			const readable = new ReadableStream({
+				start: (controller) => {
+					streamController = controller;
+				},
+				cancel: () => {}
+			});
 			const replayedStreamId = await this._eventStore.replayEventsAfter(lastEventId, { send: async (eventId, message) => {
-				var _a$1;
-				if (!this.writeSSEEvent(res, message, eventId)) {
-					(_a$1 = this.onerror) === null || _a$1 === void 0 || _a$1.call(this, /* @__PURE__ */ new Error("Failed replay events"));
-					res.end();
+				if (!this.writeSSEEvent(streamController, encoder, message, eventId)) {
+					this.onerror?.(/* @__PURE__ */ new Error("Failed replay events"));
+					try {
+						streamController.close();
+					} catch {}
 				}
 			} });
-			this._streamMapping.set(replayedStreamId, res);
-			res.on("close", () => {
-				this._streamMapping.delete(replayedStreamId);
-			});
-			res.on("error", (error$1) => {
-				var _a$1;
-				(_a$1 = this.onerror) === null || _a$1 === void 0 || _a$1.call(this, error$1);
+			this._streamMapping.set(replayedStreamId, {
+				controller: streamController,
+				encoder,
+				cleanup: () => {
+					this._streamMapping.delete(replayedStreamId);
+					try {
+						streamController.close();
+					} catch {}
+				}
 			});
+			return new Response(readable, { headers });
 		} catch (error$1) {
-			(_a = this.onerror) === null || _a === void 0 || _a.call(this, error$1);
+			this.onerror?.(error$1);
+			return this.createJsonErrorResponse(500, -32e3, "Error replaying events");
 		}
 	}
 	/**
-	* Writes an event to the SSE stream with proper formatting
+	* Writes an event to an SSE stream via controller with proper formatting
 	*/
-	writeSSEEvent(res, message, eventId) {
-		let eventData = `event: message\n`;
-		if (eventId) eventData += `id: ${eventId}\n`;
-		eventData += `data: ${JSON.stringify(message)}\n\n`;
-		return res.write(eventData);
+	writeSSEEvent(controller, encoder, message, eventId) {
+		try {
+			let eventData = `event: message\n`;
+			if (eventId) eventData += `id: ${eventId}\n`;
+			eventData += `data: ${JSON.stringify(message)}\n\n`;
+			controller.enqueue(encoder.encode(eventData));
+			return true;
+		} catch (error$1) {
+			this.onerror?.(error$1);
+			return false;
+		}
 	}
 	/**
 	* Handles unsupported requests (PUT, PATCH, etc.)
 	*/
-	async handleUnsupportedRequest(res) {
-		res.writeHead(405, { Allow: "GET, POST, DELETE" }).end(JSON.stringify({
+	handleUnsupportedRequest() {
+		this.onerror?.(/* @__PURE__ */ new Error("Method not allowed."));
+		return new Response(JSON.stringify({
 			jsonrpc: "2.0",
 			error: {
 				code: -32e3,
 				message: "Method not allowed."
 			},
 			id: null
-		}));
+		}), {
+			status: 405,
+			headers: {
+				Allow: "GET, POST, DELETE",
+				"Content-Type": "application/json"
+			}
+		});
 	}
 	/**
 	* Handles POST requests containing JSON-RPC messages
 	*/
-	async handlePostRequest(req, res, parsedBody) {
-		var _a, _b, _c, _d, _e, _f;
+	async handlePostRequest(req, options) {
 		try {
-			const acceptHeader = req.headers.accept;
-			if (!(acceptHeader === null || acceptHeader === void 0 ? void 0 : acceptHeader.includes("application/json")) || !acceptHeader.includes("text/event-stream")) {
-				res.writeHead(406).end(JSON.stringify({
-					jsonrpc: "2.0",
-					error: {
-						code: -32e3,
-						message: "Not Acceptable: Client must accept both application/json and text/event-stream"
-					},
-					id: null
-				}));
-				return;
+			const acceptHeader = req.headers.get("accept");
+			if (!acceptHeader?.includes("application/json") || !acceptHeader.includes("text/event-stream")) {
+				this.onerror?.(/* @__PURE__ */ new Error("Not Acceptable: Client must accept both application/json and text/event-stream"));
+				return this.createJsonErrorResponse(406, -32e3, "Not Acceptable: Client must accept both application/json and text/event-stream");
 			}
-			const ct = req.headers["content-type"];
+			const ct = req.headers.get("content-type");
 			if (!ct || !ct.includes("application/json")) {
-				res.writeHead(415).end(JSON.stringify({
-					jsonrpc: "2.0",
-					error: {
-						code: -32e3,
-						message: "Unsupported Media Type: Content-Type must be application/json"
-					},
-					id: null
-				}));
-				return;
+				this.onerror?.(/* @__PURE__ */ new Error("Unsupported Media Type: Content-Type must be application/json"));
+				return this.createJsonErrorResponse(415, -32e3, "Unsupported Media Type: Content-Type must be application/json");
 			}
-			const authInfo = req.auth;
-			const requestInfo = { headers: req.headers };
+			const requestInfo = {
+				headers: Object.fromEntries(req.headers.entries()),
+				url: new URL(req.url)
+			};
 			let rawMessage;
-			if (parsedBody !== void 0) rawMessage = parsedBody;
-			else {
-				const body = await (0, import_raw_body.default)(req, {
-					limit: MAXIMUM_MESSAGE_SIZE,
-					encoding: (_a = import_content_type.parse(ct).parameters.charset) !== null && _a !== void 0 ? _a : "utf-8"
-				});
-				rawMessage = JSON.parse(body.toString());
+			if (options?.parsedBody !== void 0) rawMessage = options.parsedBody;
+			else try {
+				rawMessage = await req.json();
+			} catch {
+				this.onerror?.(/* @__PURE__ */ new Error("Parse error: Invalid JSON"));
+				return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON");
 			}
 			let messages;
-			if (Array.isArray(rawMessage)) messages = rawMessage.map((msg) => JSONRPCMessageSchema.parse(msg));
-			else messages = [JSONRPCMessageSchema.parse(rawMessage)];
+			try {
+				if (Array.isArray(rawMessage)) messages = rawMessage.map((msg) => JSONRPCMessageSchema.parse(msg));
+				else messages = [JSONRPCMessageSchema.parse(rawMessage)];
+			} catch {
+				this.onerror?.(/* @__PURE__ */ new Error("Parse error: Invalid JSON-RPC message"));
+				return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON-RPC message");
+			}
 			const isInitializationRequest = messages.some(isInitializeRequest);
 			if (isInitializationRequest) {
 				if (this._initialized && this.sessionId !== void 0) {
-					res.writeHead(400).end(JSON.stringify({
-						jsonrpc: "2.0",
-						error: {
-							code: -32600,
-							message: "Invalid Request: Server already initialized"
-						},
-						id: null
-					}));
-					return;
+					this.onerror?.(/* @__PURE__ */ new Error("Invalid Request: Server already initialized"));
+					return this.createJsonErrorResponse(400, -32600, "Invalid Request: Server already initialized");
 				}
 				if (messages.length > 1) {
-					res.writeHead(400).end(JSON.stringify({
-						jsonrpc: "2.0",
-						error: {
-							code: -32600,
-							message: "Invalid Request: Only one initialization request is allowed"
-						},
-						id: null
-					}));
-					return;
+					this.onerror?.(/* @__PURE__ */ new Error("Invalid Request: Only one initialization request is allowed"));
+					return this.createJsonErrorResponse(400, -32600, "Invalid Request: Only one initialization request is allowed");
 				}
-				this.sessionId = (_b = this.sessionIdGenerator) === null || _b === void 0 ? void 0 : _b.call(this);
+				this.sessionId = this.sessionIdGenerator?.();
 				this._initialized = true;
 				if (this.sessionId && this._onsessioninitialized) await Promise.resolve(this._onsessioninitialized(this.sessionId));
 			}
 			if (!isInitializationRequest) {
-				if (!this.validateSession(req, res)) return;
-				if (!this.validateProtocolVersion(req, res)) return;
+				const sessionError = this.validateSession(req);
+				if (sessionError) return sessionError;
+				const protocolError = this.validateProtocolVersion(req);
+				if (protocolError) return protocolError;
 			}
-			const hasRequests = messages.some(isJSONRPCRequest);
-			if (!hasRequests) {
-				res.writeHead(202).end();
-				for (const message of messages) (_c = this.onmessage) === null || _c === void 0 || _c.call(this, message, {
-					authInfo,
+			if (!messages.some(isJSONRPCRequest)) {
+				for (const message of messages) this.onmessage?.(message, {
+					authInfo: options?.authInfo,
 					requestInfo
 				});
-			} else if (hasRequests) {
-				const streamId = randomUUID();
-				const initRequest = messages.find((m) => isInitializeRequest(m));
-				const clientProtocolVersion = initRequest ? initRequest.params.protocolVersion : (_d = req.headers["mcp-protocol-version"]) !== null && _d !== void 0 ? _d : DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
-				if (!this._enableJsonResponse) {
-					const headers = {
-						"Content-Type": "text/event-stream",
-						"Cache-Control": "no-cache",
-						Connection: "keep-alive"
-					};
-					if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
-					res.writeHead(200, headers);
-					await this._maybeWritePrimingEvent(res, streamId, clientProtocolVersion);
-				}
-				for (const message of messages) if (isJSONRPCRequest(message)) {
-					this._streamMapping.set(streamId, res);
-					this._requestToStreamMapping.set(message.id, streamId);
-				}
-				res.on("close", () => {
-					this._streamMapping.delete(streamId);
+				return new Response(null, { status: 202 });
+			}
+			const streamId = crypto.randomUUID();
+			const initRequest = messages.find((m) => isInitializeRequest(m));
+			const clientProtocolVersion = initRequest ? initRequest.params.protocolVersion : req.headers.get("mcp-protocol-version") ?? DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
+			if (this._enableJsonResponse) return new Promise((resolve$2) => {
+				this._streamMapping.set(streamId, {
+					resolveJson: resolve$2,
+					cleanup: () => {
+						this._streamMapping.delete(streamId);
+					}
 				});
-				res.on("error", (error$1) => {
-					var _a$1;
-					(_a$1 = this.onerror) === null || _a$1 === void 0 || _a$1.call(this, error$1);
+				for (const message of messages) if (isJSONRPCRequest(message)) this._requestToStreamMapping.set(message.id, streamId);
+				for (const message of messages) this.onmessage?.(message, {
+					authInfo: options?.authInfo,
+					requestInfo
 				});
-				for (const message of messages) {
-					let closeSSEStream;
-					let closeStandaloneSSEStream;
-					if (isJSONRPCRequest(message) && this._eventStore && clientProtocolVersion >= "2025-11-25") {
-						closeSSEStream = () => {
-							this.closeSSEStream(message.id);
-						};
-						closeStandaloneSSEStream = () => {
-							this.closeStandaloneSSEStream();
-						};
+			});
+			const encoder = new TextEncoder();
+			let streamController;
+			const readable = new ReadableStream({
+				start: (controller) => {
+					streamController = controller;
+				},
+				cancel: () => {
+					this._streamMapping.delete(streamId);
+				}
+			});
+			const headers = {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache",
+				Connection: "keep-alive"
+			};
+			if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
+			for (const message of messages) if (isJSONRPCRequest(message)) {
+				this._streamMapping.set(streamId, {
+					controller: streamController,
+					encoder,
+					cleanup: () => {
+						this._streamMapping.delete(streamId);
+						try {
+							streamController.close();
+						} catch {}
 					}
-					(_e = this.onmessage) === null || _e === void 0 || _e.call(this, message, {
-						authInfo,
-						requestInfo,
-						closeSSEStream,
-						closeStandaloneSSEStream
-					});
+				});
+				this._requestToStreamMapping.set(message.id, streamId);
+			}
+			await this.writePrimingEvent(streamController, encoder, streamId, clientProtocolVersion);
+			for (const message of messages) {
+				let closeSSEStream;
+				let closeStandaloneSSEStream;
+				if (isJSONRPCRequest(message) && this._eventStore && clientProtocolVersion >= "2025-11-25") {
+					closeSSEStream = () => {
+						this.closeSSEStream(message.id);
+					};
+					closeStandaloneSSEStream = () => {
+						this.closeStandaloneSSEStream();
+					};
 				}
+				this.onmessage?.(message, {
+					authInfo: options?.authInfo,
+					requestInfo,
+					closeSSEStream,
+					closeStandaloneSSEStream
+				});
 			}
+			return new Response(readable, {
+				status: 200,
+				headers
+			});
 		} catch (error$1) {
-			res.writeHead(400).end(JSON.stringify({
-				jsonrpc: "2.0",
-				error: {
-					code: -32700,
-					message: "Parse error",
-					data: String(error$1)
-				},
-				id: null
-			}));
-			(_f = this.onerror) === null || _f === void 0 || _f.call(this, error$1);
+			this.onerror?.(error$1);
+			return this.createJsonErrorResponse(400, -32700, "Parse error", { data: String(error$1) });
 		}
 	}
 	/**
 	* Handles DELETE requests to terminate sessions
 	*/
-	async handleDeleteRequest(req, res) {
-		var _a;
-		if (!this.validateSession(req, res)) return;
-		if (!this.validateProtocolVersion(req, res)) return;
-		await Promise.resolve((_a = this._onsessionclosed) === null || _a === void 0 ? void 0 : _a.call(this, this.sessionId));
+	async handleDeleteRequest(req) {
+		const sessionError = this.validateSession(req);
+		if (sessionError) return sessionError;
+		const protocolError = this.validateProtocolVersion(req);
+		if (protocolError) return protocolError;
+		await Promise.resolve(this._onsessionclosed?.(this.sessionId));
 		await this.close();
-		res.writeHead(200).end();
+		return new Response(null, { status: 200 });
 	}
 	/**
-	* Validates session ID for non-initialization requests
-	* Returns true if the session is valid, false otherwise
+	* Validates session ID for non-initialization requests.
+	* Returns Response error if invalid, undefined otherwise
 	*/
-	validateSession(req, res) {
-		if (this.sessionIdGenerator === void 0) return true;
+	validateSession(req) {
+		if (this.sessionIdGenerator === void 0) return;
 		if (!this._initialized) {
-			res.writeHead(400).end(JSON.stringify({
-				jsonrpc: "2.0",
-				error: {
-					code: -32e3,
-					message: "Bad Request: Server not initialized"
-				},
-				id: null
-			}));
-			return false;
+			this.onerror?.(/* @__PURE__ */ new Error("Bad Request: Server not initialized"));
+			return this.createJsonErrorResponse(400, -32e3, "Bad Request: Server not initialized");
 		}
-		const sessionId = req.headers["mcp-session-id"];
+		const sessionId = req.headers.get("mcp-session-id");
 		if (!sessionId) {
-			res.writeHead(400).end(JSON.stringify({
-				jsonrpc: "2.0",
-				error: {
-					code: -32e3,
-					message: "Bad Request: Mcp-Session-Id header is required"
-				},
-				id: null
-			}));
-			return false;
-		} else if (Array.isArray(sessionId)) {
-			res.writeHead(400).end(JSON.stringify({
-				jsonrpc: "2.0",
-				error: {
-					code: -32e3,
-					message: "Bad Request: Mcp-Session-Id header must be a single value"
-				},
-				id: null
-			}));
-			return false;
-		} else if (sessionId !== this.sessionId) {
-			res.writeHead(404).end(JSON.stringify({
-				jsonrpc: "2.0",
-				error: {
-					code: -32001,
-					message: "Session not found"
-				},
-				id: null
-			}));
-			return false;
+			this.onerror?.(/* @__PURE__ */ new Error("Bad Request: Mcp-Session-Id header is required"));
+			return this.createJsonErrorResponse(400, -32e3, "Bad Request: Mcp-Session-Id header is required");
+		}
+		if (sessionId !== this.sessionId) {
+			this.onerror?.(/* @__PURE__ */ new Error("Session not found"));
+			return this.createJsonErrorResponse(404, -32001, "Session not found");
 		}
-		return true;
 	}
-	validateProtocolVersion(req, res) {
-		var _a;
-		let protocolVersion = (_a = req.headers["mcp-protocol-version"]) !== null && _a !== void 0 ? _a : DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
-		if (Array.isArray(protocolVersion)) protocolVersion = protocolVersion[protocolVersion.length - 1];
-		if (!SUPPORTED_PROTOCOL_VERSIONS.includes(protocolVersion)) {
-			res.writeHead(400).end(JSON.stringify({
-				jsonrpc: "2.0",
-				error: {
-					code: -32e3,
-					message: `Bad Request: Unsupported protocol version (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`
-				},
-				id: null
-			}));
-			return false;
+	/**
+	* Validates the MCP-Protocol-Version header on incoming requests.
+	*
+	* For initialization: Version negotiation handles unknown versions gracefully
+	* (server responds with its supported version).
+	*
+	* For subsequent requests with MCP-Protocol-Version header:
+	* - Accept if in supported list
+	* - 400 if unsupported
+	*
+	* For HTTP requests without the MCP-Protocol-Version header:
+	* - Accept and default to the version negotiated at initialization
+	*/
+	validateProtocolVersion(req) {
+		const protocolVersion = req.headers.get("mcp-protocol-version");
+		if (protocolVersion !== null && !SUPPORTED_PROTOCOL_VERSIONS.includes(protocolVersion)) {
+			this.onerror?.(/* @__PURE__ */ new Error(`Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`));
+			return this.createJsonErrorResponse(400, -32e3, `Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`);
 		}
-		return true;
 	}
 	async close() {
-		var _a;
-		this._streamMapping.forEach((response) => {
-			response.end();
+		this._streamMapping.forEach(({ cleanup }) => {
+			cleanup();
 		});
 		this._streamMapping.clear();
 		this._requestResponseMap.clear();
-		(_a = this.onclose) === null || _a === void 0 || _a.call(this);
+		this.onclose?.();
 	}
 	/**
 	* Close an SSE stream for a specific request, triggering client reconnection.
@@ -15135,10 +15650,7 @@ var StreamableHTTPServerTransport = class {
 		const streamId = this._requestToStreamMapping.get(requestId);
 		if (!streamId) return;
 		const stream = this._streamMapping.get(streamId);
-		if (stream) {
-			stream.end();
-			this._streamMapping.delete(streamId);
-		}
+		if (stream) stream.cleanup();
 	}
 	/**
 	* Close the standalone GET SSE stream, triggering client reconnection.
@@ -15146,44 +15658,46 @@ var StreamableHTTPServerTransport = class {
 	*/
 	closeStandaloneSSEStream() {
 		const stream = this._streamMapping.get(this._standaloneSseStreamId);
-		if (stream) {
-			stream.end();
-			this._streamMapping.delete(this._standaloneSseStreamId);
-		}
+		if (stream) stream.cleanup();
 	}
 	async send(message, options) {
-		let requestId = options === null || options === void 0 ? void 0 : options.relatedRequestId;
-		if (isJSONRPCResponse(message) || isJSONRPCError(message)) requestId = message.id;
+		let requestId = options?.relatedRequestId;
+		if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) requestId = message.id;
 		if (requestId === void 0) {
-			if (isJSONRPCResponse(message) || isJSONRPCError(message)) throw new Error("Cannot send a response on a standalone SSE stream unless resuming a previous client request");
+			if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) throw new Error("Cannot send a response on a standalone SSE stream unless resuming a previous client request");
 			let eventId;
 			if (this._eventStore) eventId = await this._eventStore.storeEvent(this._standaloneSseStreamId, message);
 			const standaloneSse = this._streamMapping.get(this._standaloneSseStreamId);
 			if (standaloneSse === void 0) return;
-			this.writeSSEEvent(standaloneSse, message, eventId);
+			if (standaloneSse.controller && standaloneSse.encoder) this.writeSSEEvent(standaloneSse.controller, standaloneSse.encoder, message, eventId);
 			return;
 		}
 		const streamId = this._requestToStreamMapping.get(requestId);
-		const response = this._streamMapping.get(streamId);
 		if (!streamId) throw new Error(`No connection established for request ID: ${String(requestId)}`);
-		if (!this._enableJsonResponse) {
+		const stream = this._streamMapping.get(streamId);
+		if (!this._enableJsonResponse && stream?.controller && stream?.encoder) {
 			let eventId;
 			if (this._eventStore) eventId = await this._eventStore.storeEvent(streamId, message);
-			if (response) this.writeSSEEvent(response, message, eventId);
+			this.writeSSEEvent(stream.controller, stream.encoder, message, eventId);
 		}
-		if (isJSONRPCResponse(message) || isJSONRPCError(message)) {
+		if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
 			this._requestResponseMap.set(requestId, message);
-			const relatedIds = Array.from(this._requestToStreamMapping.entries()).filter(([_$1, streamId$1]) => this._streamMapping.get(streamId$1) === response).map(([id]) => id);
+			const relatedIds = Array.from(this._requestToStreamMapping.entries()).filter(([_$1, sid]) => sid === streamId).map(([id]) => id);
 			if (relatedIds.every((id) => this._requestResponseMap.has(id))) {
-				if (!response) throw new Error(`No connection established for request ID: ${String(requestId)}`);
-				if (this._enableJsonResponse) {
+				if (!stream) throw new Error(`No connection established for request ID: ${String(requestId)}`);
+				if (this._enableJsonResponse && stream.resolveJson) {
 					const headers = { "Content-Type": "application/json" };
 					if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
 					const responses = relatedIds.map((id) => this._requestResponseMap.get(id));
-					response.writeHead(200, headers);
-					if (responses.length === 1) response.end(JSON.stringify(responses[0]));
-					else response.end(JSON.stringify(responses));
-				} else response.end();
+					if (responses.length === 1) stream.resolveJson(new Response(JSON.stringify(responses[0]), {
+						status: 200,
+						headers
+					}));
+					else stream.resolveJson(new Response(JSON.stringify(responses), {
+						status: 200,
+						headers
+					}));
+				} else stream.cleanup();
 				for (const id of relatedIds) {
 					this._requestResponseMap.delete(id);
 					this._requestToStreamMapping.delete(id);
@@ -15193,6 +15707,153 @@ var StreamableHTTPServerTransport = class {
 	}
 };
 
+//#endregion
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/streamableHttp.js
+/**
+* Node.js HTTP Streamable HTTP Server Transport
+*
+* This is a thin wrapper around `WebStandardStreamableHTTPServerTransport` that provides
+* compatibility with Node.js HTTP server (IncomingMessage/ServerResponse).
+*
+* For web-standard environments (Cloudflare Workers, Deno, Bun), use `WebStandardStreamableHTTPServerTransport` directly.
+*/
+/**
+* Server transport for Streamable HTTP: this implements the MCP Streamable HTTP transport specification.
+* It supports both SSE streaming and direct HTTP responses.
+*
+* This is a wrapper around `WebStandardStreamableHTTPServerTransport` that provides Node.js HTTP compatibility.
+* It uses the `@hono/node-server` library to convert between Node.js HTTP and Web Standard APIs.
+*
+* Usage example:
+*
+* ```typescript
+* // Stateful mode - server sets the session ID
+* const statefulTransport = new StreamableHTTPServerTransport({
+*   sessionIdGenerator: () => randomUUID(),
+* });
+*
+* // Stateless mode - explicitly set session ID to undefined
+* const statelessTransport = new StreamableHTTPServerTransport({
+*   sessionIdGenerator: undefined,
+* });
+*
+* // Using with pre-parsed request body
+* app.post('/mcp', (req, res) => {
+*   transport.handleRequest(req, res, req.body);
+* });
+* ```
+*
+* In stateful mode:
+* - Session ID is generated and included in response headers
+* - Session ID is always included in initialization responses
+* - Requests with invalid session IDs are rejected with 404 Not Found
+* - Non-initialization requests without a session ID are rejected with 400 Bad Request
+* - State is maintained in-memory (connections, message history)
+*
+* In stateless mode:
+* - No Session ID is included in any responses
+* - No session validation is performed
+*/
+var StreamableHTTPServerTransport = class {
+	constructor(options = {}) {
+		this._requestContext = /* @__PURE__ */ new WeakMap();
+		this._webStandardTransport = new WebStandardStreamableHTTPServerTransport(options);
+		this._requestListener = getRequestListener(async (webRequest) => {
+			const context = this._requestContext.get(webRequest);
+			return this._webStandardTransport.handleRequest(webRequest, {
+				authInfo: context?.authInfo,
+				parsedBody: context?.parsedBody
+			});
+		}, { overrideGlobalObjects: false });
+	}
+	/**
+	* Gets the session ID for this transport instance.
+	*/
+	get sessionId() {
+		return this._webStandardTransport.sessionId;
+	}
+	/**
+	* Sets callback for when the transport is closed.
+	*/
+	set onclose(handler) {
+		this._webStandardTransport.onclose = handler;
+	}
+	get onclose() {
+		return this._webStandardTransport.onclose;
+	}
+	/**
+	* Sets callback for transport errors.
+	*/
+	set onerror(handler) {
+		this._webStandardTransport.onerror = handler;
+	}
+	get onerror() {
+		return this._webStandardTransport.onerror;
+	}
+	/**
+	* Sets callback for incoming messages.
+	*/
+	set onmessage(handler) {
+		this._webStandardTransport.onmessage = handler;
+	}
+	get onmessage() {
+		return this._webStandardTransport.onmessage;
+	}
+	/**
+	* Starts the transport. This is required by the Transport interface but is a no-op
+	* for the Streamable HTTP transport as connections are managed per-request.
+	*/
+	async start() {
+		return this._webStandardTransport.start();
+	}
+	/**
+	* Closes the transport and all active connections.
+	*/
+	async close() {
+		return this._webStandardTransport.close();
+	}
+	/**
+	* Sends a JSON-RPC message through the transport.
+	*/
+	async send(message, options) {
+		return this._webStandardTransport.send(message, options);
+	}
+	/**
+	* Handles an incoming HTTP request, whether GET or POST.
+	*
+	* This method converts Node.js HTTP objects to Web Standard Request/Response
+	* and delegates to the underlying WebStandardStreamableHTTPServerTransport.
+	*
+	* @param req - Node.js IncomingMessage, optionally with auth property from middleware
+	* @param res - Node.js ServerResponse
+	* @param parsedBody - Optional pre-parsed body from body-parser middleware
+	*/
+	async handleRequest(req, res, parsedBody) {
+		const authInfo = req.auth;
+		await getRequestListener(async (webRequest) => {
+			return this._webStandardTransport.handleRequest(webRequest, {
+				authInfo,
+				parsedBody
+			});
+		}, { overrideGlobalObjects: false })(req, res);
+	}
+	/**
+	* Close an SSE stream for a specific request, triggering client reconnection.
+	* Use this to implement polling behavior during long-running operations -
+	* client will reconnect after the retry interval specified in the priming event.
+	*/
+	closeSSEStream(requestId) {
+		this._webStandardTransport.closeSSEStream(requestId);
+	}
+	/**
+	* Close the standalone GET SSE stream, triggering client reconnection.
+	* Use this to implement polling behavior for server-initiated notifications.
+	*/
+	closeStandaloneSSEStream() {
+		this._webStandardTransport.closeStandaloneSSEStream();
+	}
+};
+
 //#endregion
 //#region src/startHTTPServer.ts
 const getBody = (request) => {
@@ -15592,6 +16253,10 @@ const startHTTPServer = async ({ apiKey, authenticate, cors, createServer, enabl
 			res.writeHead(200).end("pong");
 			return;
 		}
+		if (onUnhandledRequest) {
+			await onUnhandledRequest(req, res);
+			if (res.writableEnded) return;
+		}
 		if (!authMiddleware.validateRequest(req)) {
 			const authResponse = authMiddleware.getUnauthorizedResponse();
 			res.writeHead(401, authResponse.headers);
@@ -15622,8 +16287,7 @@ const startHTTPServer = async ({ apiKey, authenticate, cors, createServer, enabl
 			res,
 			stateless
 		})) return;
-		if (onUnhandledRequest) await onUnhandledRequest(req, res);
-		else res.writeHead(404).end();
+		res.writeHead(404).end();
 	};
 	let httpServer;
 	if (sslCa || sslCert || sslKey) {
@@ -15666,7 +16330,7 @@ const startHTTPServer = async ({ apiKey, authenticate, cors, createServer, enabl
 };
 
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
 function isZ4Schema(s) {
 	return !!s._zod;
 }
@@ -15675,15 +16339,14 @@ function safeParse(schema, data) {
 	return schema.safeParse(data);
 }
 function getObjectShape(schema) {
-	var _a, _b;
 	if (!schema) return void 0;
 	let rawShape;
-	if (isZ4Schema(schema)) rawShape = (_b = (_a = schema._zod) === null || _a === void 0 ? void 0 : _a.def) === null || _b === void 0 ? void 0 : _b.shape;
+	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 (_c) {
+	} catch {
 		return;
 	}
 	return rawShape;
@@ -15694,9 +16357,8 @@ function getObjectShape(schema) {
 * Returns undefined if the schema is not a literal or the value cannot be determined.
 */
 function getLiteralValue(schema) {
-	var _a;
 	if (isZ4Schema(schema)) {
-		const def$31 = (_a = schema._zod) === null || _a === void 0 ? void 0 : _a.def;
+		const def$31 = schema._zod?.def;
 		if (def$31) {
 			if (def$31.value !== void 0) return def$31.value;
 			if (Array.isArray(def$31.values) && def$31.values.length > 0) return def$31.values[0];
@@ -15712,7 +16374,7 @@ function getLiteralValue(schema) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/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.
@@ -15730,10 +16392,9 @@ function isTerminal(status$1) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/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/server/zod-json-schema-compat.js
 function getMethodLiteral(schema) {
-	const shape = getObjectShape(schema);
-	const methodSchema = shape === null || shape === void 0 ? void 0 : shape.method;
+	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");
@@ -15746,7 +16407,7 @@ function parseWithCompat(schema, data) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.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.
 */
@@ -15775,8 +16436,8 @@ var Protocol = class {
 			this._onprogress(notification);
 		});
 		this.setRequestHandler(PingRequestSchema, (_request) => ({}));
-		this._taskStore = _options === null || _options === void 0 ? void 0 : _options.taskStore;
-		this._taskMessageQueue = _options === null || _options === void 0 ? void 0 : _options.taskMessageQueue;
+		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);
@@ -15785,7 +16446,6 @@ var Protocol = class {
 			});
 			this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
 				const handleTaskResult = async () => {
-					var _a;
 					const taskId = request.params.taskId;
 					if (this._taskMessageQueue) {
 						let queuedMessage;
@@ -15807,7 +16467,7 @@ var Protocol = class {
 								}
 								continue;
 							}
-							await ((_a = this._transport) === null || _a === void 0 ? void 0 : _a.send(queuedMessage.message, { relatedRequestId: extra.requestId }));
+							await this._transport?.send(queuedMessage.message, { relatedRequestId: extra.requestId });
 						}
 					}
 					const task = await this._taskStore.getTask(taskId, extra.sessionId);
@@ -15832,9 +16492,8 @@ var Protocol = class {
 				return await handleTaskResult();
 			});
 			this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => {
-				var _a;
 				try {
-					const { tasks, nextCursor } = await this._taskStore.listTasks((_a = request.params) === null || _a === void 0 ? void 0 : _a.cursor, extra.sessionId);
+					const { tasks, nextCursor } = await this._taskStore.listTasks(request.params?.cursor, extra.sessionId);
 					return {
 						tasks,
 						nextCursor,
@@ -15865,8 +16524,8 @@ var Protocol = class {
 		}
 	}
 	async _oncancel(notification) {
-		const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
-		controller === null || controller === void 0 || controller.abort(notification.params.reason);
+		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, {
@@ -15906,22 +16565,22 @@ var Protocol = class {
 	* 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) {
-		var _a, _b, _c;
+		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 = (_a = this.transport) === null || _a === void 0 ? void 0 : _a.onclose;
+		const _onclose = this.transport?.onclose;
 		this._transport.onclose = () => {
-			_onclose === null || _onclose === void 0 || _onclose();
+			_onclose?.();
 			this._onclose();
 		};
-		const _onerror = (_b = this.transport) === null || _b === void 0 ? void 0 : _b.onerror;
+		const _onerror = this.transport?.onerror;
 		this._transport.onerror = (error$1) => {
-			_onerror === null || _onerror === void 0 || _onerror(error$1);
+			_onerror?.(error$1);
 			this._onerror(error$1);
 		};
-		const _onmessage = (_c = this._transport) === null || _c === void 0 ? void 0 : _c.onmessage;
+		const _onmessage = this._transport?.onmessage;
 		this._transport.onmessage = (message, extra) => {
-			_onmessage === null || _onmessage === void 0 || _onmessage(message, extra);
-			if (isJSONRPCResponse(message) || isJSONRPCError(message)) this._onresponse(message);
+			_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)}`));
@@ -15929,32 +16588,30 @@ var Protocol = class {
 		await this._transport.start();
 	}
 	_onclose() {
-		var _a;
 		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$1 = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed");
 		this._transport = void 0;
-		(_a = this.onclose) === null || _a === void 0 || _a.call(this);
+		this.onclose?.();
 		for (const handler of responseHandlers.values()) handler(error$1);
 	}
 	_onerror(error$1) {
-		var _a;
-		(_a = this.onerror) === null || _a === void 0 || _a.call(this, error$1);
+		this.onerror?.(error$1);
 	}
 	_onnotification(notification) {
-		var _a;
-		const handler = (_a = this._notificationHandlers.get(notification.method)) !== null && _a !== void 0 ? _a : this.fallbackNotificationHandler;
+		const handler = this._notificationHandlers.get(notification.method) ?? this.fallbackNotificationHandler;
 		if (handler === void 0) return;
 		Promise.resolve().then(() => handler(notification)).catch((error$1) => this._onerror(/* @__PURE__ */ new Error(`Uncaught error in notification handler: ${error$1}`)));
 	}
 	_onrequest(request, extra) {
-		var _a, _b, _c, _d, _e, _f;
-		const handler = (_a = this._requestHandlers.get(request.method)) !== null && _a !== void 0 ? _a : this.fallbackRequestHandler;
+		const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
 		const capturedTransport = this._transport;
-		const relatedTaskId = (_d = (_c = (_b = request.params) === null || _b === void 0 ? void 0 : _b._meta) === null || _c === void 0 ? void 0 : _c[RELATED_TASK_META_KEY]) === null || _d === void 0 ? void 0 : _d.taskId;
+		const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
 		if (handler === void 0) {
 			const errorResponse = {
 				jsonrpc: "2.0",
@@ -15968,42 +16625,43 @@ var Protocol = class {
 				type: "error",
 				message: errorResponse,
 				timestamp: Date.now()
-			}, capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId).catch((error$1) => this._onerror(/* @__PURE__ */ new Error(`Failed to enqueue error response: ${error$1}`)));
-			else capturedTransport === null || capturedTransport === void 0 || capturedTransport.send(errorResponse).catch((error$1) => this._onerror(/* @__PURE__ */ new Error(`Failed to send an error response: ${error$1}`)));
+			}, capturedTransport?.sessionId).catch((error$1) => this._onerror(/* @__PURE__ */ new Error(`Failed to enqueue error response: ${error$1}`)));
+			else capturedTransport?.send(errorResponse).catch((error$1) => this._onerror(/* @__PURE__ */ new Error(`Failed to send an error response: ${error$1}`)));
 			return;
 		}
 		const abortController = new AbortController();
 		this._requestHandlerAbortControllers.set(request.id, abortController);
-		const taskCreationParams = (_e = request.params) === null || _e === void 0 ? void 0 : _e.task;
-		const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId) : void 0;
+		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 === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId,
-			_meta: (_f = request.params) === null || _f === void 0 ? void 0 : _f._meta,
+			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) => {
-				var _a$1, _b$1;
+				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 = (_b$1 = (_a$1 = requestOptions.relatedTask) === null || _a$1 === void 0 ? void 0 : _a$1.taskId) !== null && _b$1 !== void 0 ? _b$1 : 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 === null || extra === void 0 ? void 0 : extra.authInfo,
+			authInfo: extra?.authInfo,
 			requestId: request.id,
-			requestInfo: extra === null || extra === void 0 ? void 0 : extra.requestInfo,
+			requestInfo: extra?.requestInfo,
 			taskId: relatedTaskId,
 			taskStore,
-			taskRequestedTtl: taskCreationParams === null || taskCreationParams === void 0 ? void 0 : taskCreationParams.ttl,
-			closeSSEStream: extra === null || extra === void 0 ? void 0 : extra.closeSSEStream,
-			closeStandaloneSSEStream: extra === null || extra === void 0 ? void 0 : extra.closeStandaloneSSEStream
+			taskRequestedTtl: taskCreationParams?.ttl,
+			closeSSEStream: extra?.closeSSEStream,
+			closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
 		};
 		Promise.resolve().then(() => {
 			if (taskCreationParams) this.assertTaskHandlerCapability(request.method);
@@ -16018,17 +16676,16 @@ var Protocol = class {
 				type: "response",
 				message: response,
 				timestamp: Date.now()
-			}, capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId);
-			else await (capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send(response));
+			}, capturedTransport?.sessionId);
+			else await capturedTransport?.send(response);
 		}, async (error$1) => {
-			var _a$1;
 			if (abortController.signal.aborted) return;
 			const errorResponse = {
 				jsonrpc: "2.0",
 				id: request.id,
 				error: {
 					code: Number.isSafeInteger(error$1["code"]) ? error$1["code"] : ErrorCode.InternalError,
-					message: (_a$1 = error$1.message) !== null && _a$1 !== void 0 ? _a$1 : "Internal error",
+					message: error$1.message ?? "Internal error",
 					...error$1["data"] !== void 0 && { data: error$1["data"] }
 				}
 			};
@@ -16036,8 +16693,8 @@ var Protocol = class {
 				type: "error",
 				message: errorResponse,
 				timestamp: Date.now()
-			}, capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId);
-			else await (capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send(errorResponse));
+			}, capturedTransport?.sessionId);
+			else await capturedTransport?.send(errorResponse);
 		}).catch((error$1) => this._onerror(/* @__PURE__ */ new Error(`Failed to send response: ${error$1}`))).finally(() => {
 			this._requestHandlerAbortControllers.delete(request.id);
 		});
@@ -16068,7 +16725,7 @@ var Protocol = class {
 		const resolver = this._requestResolvers.get(messageId);
 		if (resolver) {
 			this._requestResolvers.delete(messageId);
-			if (isJSONRPCResponse(response)) resolver(response);
+			if (isJSONRPCResultResponse(response)) resolver(response);
 			else resolver(new McpError(response.error.code, response.error.message, response.error.data));
 			return;
 		}
@@ -16080,7 +16737,7 @@ var Protocol = class {
 		this._responseHandlers.delete(messageId);
 		this._cleanupTimeout(messageId);
 		let isTaskResponse = false;
-		if (isJSONRPCResponse(response) && response.result && typeof response.result === "object") {
+		if (isJSONRPCResultResponse(response) && response.result && typeof response.result === "object") {
 			const result = response.result;
 			if (result.task && typeof result.task === "object") {
 				const task = result.task;
@@ -16091,7 +16748,7 @@ var Protocol = class {
 			}
 		}
 		if (!isTaskResponse) this._progressHandlers.delete(messageId);
-		if (isJSONRPCResponse(response)) handler(response);
+		if (isJSONRPCResultResponse(response)) handler(response);
 		else handler(McpError.fromError(response.error.code, response.error.message, response.error.data));
 	}
 	get transport() {
@@ -16101,8 +16758,7 @@ var Protocol = class {
 	* Closes the connection.
 	*/
 	async close() {
-		var _a;
-		await ((_a = this._transport) === null || _a === void 0 ? void 0 : _a.close());
+		await this._transport?.close();
 	}
 	/**
 	* Sends a request and returns an AsyncGenerator that yields response messages.
@@ -16132,8 +16788,7 @@ var Protocol = class {
 	* @experimental Use `client.experimental.tasks.requestStream()` to access this method.
 	*/
 	async *requestStream(request, resultSchema, options) {
-		var _a, _b, _c, _d;
-		const { task } = options !== null && options !== void 0 ? options : {};
+		const { task } = options ?? {};
 		if (!task) {
 			try {
 				yield {
@@ -16186,9 +16841,9 @@ var Protocol = class {
 					};
 					return;
 				}
-				const pollInterval = (_c = (_a = task$1.pollInterval) !== null && _a !== void 0 ? _a : (_b = this._options) === null || _b === void 0 ? void 0 : _b.defaultTaskPollInterval) !== null && _c !== void 0 ? _c : 1e3;
+				const pollInterval = task$1.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
 				await new Promise((resolve$2) => setTimeout(resolve$2, pollInterval));
-				(_d = options === null || options === void 0 ? void 0 : options.signal) === null || _d === void 0 || _d.throwIfAborted();
+				options?.signal?.throwIfAborted();
 			}
 		} catch (error$1) {
 			yield {
@@ -16203,9 +16858,8 @@ var Protocol = class {
 	* Do not use this method to emit notifications! Use notification() instead.
 	*/
 	request(request, resultSchema, options) {
-		const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options !== null && options !== void 0 ? options : {};
+		const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
 		return new Promise((resolve$2, reject) => {
-			var _a, _b, _c, _d, _e, _f, _g;
 			const earlyReject = (error$1) => {
 				reject(error$1);
 			};
@@ -16213,26 +16867,26 @@ var Protocol = class {
 				earlyReject(/* @__PURE__ */ new Error("Not connected"));
 				return;
 			}
-			if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.enforceStrictCapabilities) === true) try {
+			if (this._options?.enforceStrictCapabilities === true) try {
 				this.assertCapabilityForMethod(request.method);
 				if (task) this.assertTaskCapability(request.method);
 			} catch (e) {
 				earlyReject(e);
 				return;
 			}
-			(_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 || _b.throwIfAborted();
+			options?.signal?.throwIfAborted();
 			const messageId = this._requestMessageId++;
 			const jsonrpcRequest = {
 				...request,
 				jsonrpc: "2.0",
 				id: messageId
 			};
-			if (options === null || options === void 0 ? void 0 : options.onprogress) {
+			if (options?.onprogress) {
 				this._progressHandlers.set(messageId, options.onprogress);
 				jsonrpcRequest.params = {
 					...request.params,
 					_meta: {
-						...((_c = request.params) === null || _c === void 0 ? void 0 : _c._meta) || {},
+						...request.params?._meta || {},
 						progressToken: messageId
 					}
 				};
@@ -16244,16 +16898,15 @@ var Protocol = class {
 			if (relatedTask) jsonrpcRequest.params = {
 				...jsonrpcRequest.params,
 				_meta: {
-					...((_d = jsonrpcRequest.params) === null || _d === void 0 ? void 0 : _d._meta) || {},
+					...jsonrpcRequest.params?._meta || {},
 					[RELATED_TASK_META_KEY]: relatedTask
 				}
 			};
 			const cancel = (reason) => {
-				var _a$1;
 				this._responseHandlers.delete(messageId);
 				this._progressHandlers.delete(messageId);
 				this._cleanupTimeout(messageId);
-				(_a$1 = this._transport) === null || _a$1 === void 0 || _a$1.send({
+				this._transport?.send({
 					jsonrpc: "2.0",
 					method: "notifications/cancelled",
 					params: {
@@ -16268,8 +16921,7 @@ var Protocol = class {
 				reject(reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason)));
 			};
 			this._responseHandlers.set(messageId, (response) => {
-				var _a$1;
-				if ((_a$1 = options === null || options === void 0 ? void 0 : options.signal) === null || _a$1 === void 0 ? void 0 : _a$1.aborted) return;
+				if (options?.signal?.aborted) return;
 				if (response instanceof Error) return reject(response);
 				try {
 					const parseResult = safeParse(resultSchema, response.result);
@@ -16279,14 +16931,13 @@ var Protocol = class {
 					reject(error$1);
 				}
 			});
-			(_e = options === null || options === void 0 ? void 0 : options.signal) === null || _e === void 0 || _e.addEventListener("abort", () => {
-				var _a$1;
-				cancel((_a$1 = options === null || options === void 0 ? void 0 : options.signal) === null || _a$1 === void 0 ? void 0 : _a$1.reason);
+			options?.signal?.addEventListener("abort", () => {
+				cancel(options?.signal?.reason);
 			});
-			const timeout = (_f = options === null || options === void 0 ? void 0 : options.timeout) !== null && _f !== void 0 ? _f : DEFAULT_REQUEST_TIMEOUT_MSEC;
+			const timeout = options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
 			const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
-			this._setupTimeout(messageId, timeout, options === null || options === void 0 ? void 0 : options.maxTotalTimeout, timeoutHandler, (_g = options === null || options === void 0 ? void 0 : options.resetTimeoutOnProgress) !== null && _g !== void 0 ? _g : false);
-			const relatedTaskId = relatedTask === null || relatedTask === void 0 ? void 0 : relatedTask.taskId;
+			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);
@@ -16360,10 +17011,9 @@ var Protocol = class {
 	* Emits a notification, which is a one-way message that does not expect a response.
 	*/
 	async notification(notification, options) {
-		var _a, _b, _c, _d, _e;
 		if (!this._transport) throw new Error("Not connected");
 		this.assertNotificationCapability(notification.method);
-		const relatedTaskId = (_a = options === null || options === void 0 ? void 0 : options.relatedTask) === null || _a === void 0 ? void 0 : _a.taskId;
+		const relatedTaskId = options?.relatedTask?.taskId;
 		if (relatedTaskId) {
 			const jsonrpcNotification$1 = {
 				...notification,
@@ -16371,7 +17021,7 @@ var Protocol = class {
 				params: {
 					...notification.params,
 					_meta: {
-						...((_b = notification.params) === null || _b === void 0 ? void 0 : _b._meta) || {},
+						...notification.params?._meta || {},
 						[RELATED_TASK_META_KEY]: options.relatedTask
 					}
 				}
@@ -16383,28 +17033,27 @@ var Protocol = class {
 			});
 			return;
 		}
-		if (((_d = (_c = this._options) === null || _c === void 0 ? void 0 : _c.debouncedNotificationMethods) !== null && _d !== void 0 ? _d : []).includes(notification.method) && !notification.params && !(options === null || options === void 0 ? void 0 : options.relatedRequestId) && !(options === null || options === void 0 ? void 0 : options.relatedTask)) {
+		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(() => {
-				var _a$1, _b$1;
 				this._pendingDebouncedNotifications.delete(notification.method);
 				if (!this._transport) return;
 				let jsonrpcNotification$1 = {
 					...notification,
 					jsonrpc: "2.0"
 				};
-				if (options === null || options === void 0 ? void 0 : options.relatedTask) jsonrpcNotification$1 = {
+				if (options?.relatedTask) jsonrpcNotification$1 = {
 					...jsonrpcNotification$1,
 					params: {
 						...jsonrpcNotification$1.params,
 						_meta: {
-							...((_a$1 = jsonrpcNotification$1.params) === null || _a$1 === void 0 ? void 0 : _a$1._meta) || {},
+							...jsonrpcNotification$1.params?._meta || {},
 							[RELATED_TASK_META_KEY]: options.relatedTask
 						}
 					}
 				};
-				(_b$1 = this._transport) === null || _b$1 === void 0 || _b$1.send(jsonrpcNotification$1, options).catch((error$1) => this._onerror(error$1));
+				this._transport?.send(jsonrpcNotification$1, options).catch((error$1) => this._onerror(error$1));
 			});
 			return;
 		}
@@ -16412,12 +17061,12 @@ var Protocol = class {
 			...notification,
 			jsonrpc: "2.0"
 		};
-		if (options === null || options === void 0 ? void 0 : options.relatedTask) jsonrpcNotification = {
+		if (options?.relatedTask) jsonrpcNotification = {
 			...jsonrpcNotification,
 			params: {
 				...jsonrpcNotification.params,
 				_meta: {
-					...((_e = jsonrpcNotification.params) === null || _e === void 0 ? void 0 : _e._meta) || {},
+					...jsonrpcNotification.params?._meta || {},
 					[RELATED_TASK_META_KEY]: options.relatedTask
 				}
 			}
@@ -16490,9 +17139,8 @@ var Protocol = class {
 	* simply propagates the error.
 	*/
 	async _enqueueTaskMessage(taskId, message, sessionId) {
-		var _a;
 		if (!this._taskStore || !this._taskMessageQueue) throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
-		const maxQueueSize = (_a = this._options) === null || _a === void 0 ? void 0 : _a.maxTaskQueueSize;
+		const maxQueueSize = this._options?.maxTaskQueueSize;
 		await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
 	}
 	/**
@@ -16521,12 +17169,11 @@ var Protocol = class {
 	* @returns Promise that resolves when an update occurs or rejects if aborted
 	*/
 	async _waitForTaskUpdate(taskId, signal) {
-		var _a, _b, _c;
-		let interval = (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.defaultTaskPollInterval) !== null && _b !== void 0 ? _b : 1e3;
+		let interval = this._options?.defaultTaskPollInterval ?? 1e3;
 		try {
-			const task = await ((_c = this._taskStore) === null || _c === void 0 ? void 0 : _c.getTask(taskId));
-			if (task === null || task === void 0 ? void 0 : task.pollInterval) interval = task.pollInterval;
-		} catch (_d) {}
+			const task = await this._taskStore?.getTask(taskId);
+			if (task?.pollInterval) interval = task.pollInterval;
+		} catch {}
 		return new Promise((resolve$2, reject) => {
 			if (signal.aborted) {
 				reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -16611,7 +17258,7 @@ function mergeCapabilities(base, additional) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/codegen/code.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/codegen/code.js
 var require_code$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = void 0;
@@ -16747,7 +17394,7 @@ var require_code$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/codegen/scope.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/codegen/scope.js
 var require_scope = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = void 0;
@@ -16885,7 +17532,7 @@ var require_scope = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/codegen/index.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/codegen/index.js
 var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.or = exports.and = exports.not = exports.CodeGen = exports.operators = exports.varKinds = exports.ValueScopeName = exports.ValueScope = exports.Scope = exports.Name = exports.regexpCode = exports.stringify = exports.getProperty = exports.nil = exports.strConcat = exports.str = exports._ = void 0;
@@ -17555,7 +18202,7 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/util.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/util.js
 var require_util = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.checkStrictMode = exports.getErrorPath = exports.Type = exports.useFunc = exports.setEvaluated = exports.evaluatedPropsToName = exports.mergeEvaluated = exports.eachItem = exports.unescapeJsonPointer = exports.escapeJsonPointer = exports.escapeFragment = exports.unescapeFragment = exports.schemaRefOrVal = exports.schemaHasRulesButRef = exports.schemaHasRules = exports.checkUnknownRules = exports.alwaysValidSchema = exports.toHash = void 0;
@@ -17697,7 +18344,7 @@ var require_util = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/names.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/names.js
 var require_names = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const codegen_1$36 = require_codegen();
@@ -17723,12 +18370,12 @@ var require_names = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/errors.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/errors.js
 var require_errors = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = void 0;
 	const codegen_1$35 = require_codegen();
-	const util_1$29 = require_util();
+	const util_1$30 = require_util();
 	const names_1$7 = require_names();
 	exports.keywordError = { message: ({ keyword }) => (0, codegen_1$35.str)`must pass "${keyword}" keyword validation` };
 	exports.keyword$DataError = { message: ({ keyword, schemaType }) => schemaType ? (0, codegen_1$35.str)`"${keyword}" keyword must be ${schemaType} ($data)` : (0, codegen_1$35.str)`"${keyword}" keyword is invalid ($data)` };
@@ -17801,12 +18448,12 @@ var require_errors = /* @__PURE__ */ __commonJSMin(((exports) => {
 		return gen.object(...keyValues);
 	}
 	function errorInstancePath({ errorPath }, { instancePath }) {
-		const instPath = instancePath ? (0, codegen_1$35.str)`${errorPath}${(0, util_1$29.getErrorPath)(instancePath, util_1$29.Type.Str)}` : errorPath;
+		const instPath = instancePath ? (0, codegen_1$35.str)`${errorPath}${(0, util_1$30.getErrorPath)(instancePath, util_1$30.Type.Str)}` : errorPath;
 		return [names_1$7.default.instancePath, (0, codegen_1$35.strConcat)(names_1$7.default.instancePath, instPath)];
 	}
 	function errorSchemaPath({ keyword, it: { errSchemaPath } }, { schemaPath, parentSchema }) {
 		let schPath = parentSchema ? errSchemaPath : (0, codegen_1$35.str)`${errSchemaPath}/${keyword}`;
-		if (schemaPath) schPath = (0, codegen_1$35.str)`${schPath}${(0, util_1$29.getErrorPath)(schemaPath, util_1$29.Type.Str)}`;
+		if (schemaPath) schPath = (0, codegen_1$35.str)`${schPath}${(0, util_1$30.getErrorPath)(schemaPath, util_1$30.Type.Str)}`;
 		return [E.schemaPath, schPath];
 	}
 	function extraErrorProps(cxt, { params, message }, keyValues) {
@@ -17820,7 +18467,7 @@ var require_errors = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/validate/boolSchema.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/boolSchema.js
 var require_boolSchema = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.boolOrEmptySchema = exports.topBoolOrEmptySchema = void 0;
@@ -17863,7 +18510,7 @@ var require_boolSchema = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/rules.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/rules.js
 var require_rules = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.getRules = exports.isJSONType = void 0;
@@ -17922,7 +18569,7 @@ var require_rules = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/validate/applicability.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/applicability.js
 var require_applicability = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = void 0;
@@ -17943,7 +18590,7 @@ var require_applicability = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/validate/dataType.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/dataType.js
 var require_dataType = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = void 0;
@@ -17951,7 +18598,7 @@ var require_dataType = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const applicability_1$1 = require_applicability();
 	const errors_1$2 = require_errors();
 	const codegen_1$33 = require_codegen();
-	const util_1$28 = require_util();
+	const util_1$29 = require_util();
 	var DataType;
 	(function(DataType$1) {
 		DataType$1[DataType$1["Correct"] = 0] = "Correct";
@@ -18068,7 +18715,7 @@ var require_dataType = /* @__PURE__ */ __commonJSMin(((exports) => {
 	function checkDataTypes(dataTypes, data, strictNums, correct) {
 		if (dataTypes.length === 1) return checkDataType(dataTypes[0], data, strictNums, correct);
 		let cond;
-		const types = (0, util_1$28.toHash)(dataTypes);
+		const types = (0, util_1$29.toHash)(dataTypes);
 		if (types.array && types.object) {
 			const notObj = (0, codegen_1$33._)`typeof ${data} != "object"`;
 			cond = types.null ? notObj : (0, codegen_1$33._)`!${data} || ${notObj}`;
@@ -18092,7 +18739,7 @@ var require_dataType = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.reportTypeError = reportTypeError;
 	function getTypeErrorContext(it) {
 		const { gen, data, schema } = it;
-		const schemaCode = (0, util_1$28.schemaRefOrVal)(it, schema, "type");
+		const schemaCode = (0, util_1$29.schemaRefOrVal)(it, schema, "type");
 		return {
 			gen,
 			keyword: "type",
@@ -18108,12 +18755,12 @@ var require_dataType = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/validate/defaults.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/defaults.js
 var require_defaults = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.assignDefaults = void 0;
 	const codegen_1$32 = require_codegen();
-	const util_1$27 = require_util();
+	const util_1$28 = require_util();
 	function assignDefaults(it, ty) {
 		const { properties, items } = it.schema;
 		if (ty === "object" && properties) for (const key$1 in properties) assignDefault(it, key$1, properties[key$1].default);
@@ -18125,7 +18772,7 @@ var require_defaults = /* @__PURE__ */ __commonJSMin(((exports) => {
 		if (defaultValue === void 0) return;
 		const childData = (0, codegen_1$32._)`${data}${(0, codegen_1$32.getProperty)(prop)}`;
 		if (compositeRule) {
-			(0, util_1$27.checkStrictMode)(it, `default is ignored for: ${childData}`);
+			(0, util_1$28.checkStrictMode)(it, `default is ignored for: ${childData}`);
 			return;
 		}
 		let condition = (0, codegen_1$32._)`${childData} === undefined`;
@@ -18135,12 +18782,12 @@ var require_defaults = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/code.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/code.js
 var require_code = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.validateUnion = exports.validateArray = exports.usePattern = exports.callValidateCode = exports.schemaProperties = exports.allSchemaProperties = exports.noPropertyInData = exports.propertyInData = exports.isOwnProperty = exports.hasPropFunc = exports.reportMissingProp = exports.checkMissingProp = exports.checkReportMissingProp = void 0;
 	const codegen_1$31 = require_codegen();
-	const util_1$26 = require_util();
+	const util_1$27 = require_util();
 	const names_1$5 = require_names();
 	const util_2$1 = require_util();
 	function checkReportMissingProp(cxt, prop) {
@@ -18186,7 +18833,7 @@ var require_code = /* @__PURE__ */ __commonJSMin(((exports) => {
 	}
 	exports.allSchemaProperties = allSchemaProperties;
 	function schemaProperties(it, schemaMap) {
-		return allSchemaProperties(schemaMap).filter((p) => !(0, util_1$26.alwaysValidSchema)(it, schemaMap[p]));
+		return allSchemaProperties(schemaMap).filter((p) => !(0, util_1$27.alwaysValidSchema)(it, schemaMap[p]));
 	}
 	exports.schemaProperties = schemaProperties;
 	function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) {
@@ -18231,7 +18878,7 @@ var require_code = /* @__PURE__ */ __commonJSMin(((exports) => {
 				cxt.subschema({
 					keyword,
 					dataProp: i$3,
-					dataPropType: util_1$26.Type.Num
+					dataPropType: util_1$27.Type.Num
 				}, valid);
 				gen.if((0, codegen_1$31.not)(valid), notValid);
 			});
@@ -18242,7 +18889,7 @@ var require_code = /* @__PURE__ */ __commonJSMin(((exports) => {
 		const { gen, schema, keyword, it } = cxt;
 		/* istanbul ignore if */
 		if (!Array.isArray(schema)) throw new Error("ajv implementation error");
-		if (schema.some((sch) => (0, util_1$26.alwaysValidSchema)(it, sch)) && !it.opts.unevaluated) return;
+		if (schema.some((sch) => (0, util_1$27.alwaysValidSchema)(it, sch)) && !it.opts.unevaluated) return;
 		const valid = gen.let("valid", false);
 		const schValid = gen.name("_valid");
 		gen.block(() => schema.forEach((_sch, i$3) => {
@@ -18260,7 +18907,7 @@ var require_code = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/validate/keyword.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/keyword.js
 var require_keyword = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.validateKeywordUsage = exports.validSchemaType = exports.funcKeywordCode = exports.macroKeywordCode = void 0;
@@ -18367,12 +19014,12 @@ var require_keyword = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/validate/subschema.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/subschema.js
 var require_subschema = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = void 0;
 	const codegen_1$29 = require_codegen();
-	const util_1$25 = require_util();
+	const util_1$26 = require_util();
 	function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
 		if (keyword !== void 0 && schema !== void 0) throw new Error("both \"keyword\" and \"schema\" passed, only one allowed");
 		if (keyword !== void 0) {
@@ -18384,7 +19031,7 @@ var require_subschema = /* @__PURE__ */ __commonJSMin(((exports) => {
 			} : {
 				schema: sch[schemaProp],
 				schemaPath: (0, codegen_1$29._)`${it.schemaPath}${(0, codegen_1$29.getProperty)(keyword)}${(0, codegen_1$29.getProperty)(schemaProp)}`,
-				errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1$25.escapeFragment)(schemaProp)}`
+				errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1$26.escapeFragment)(schemaProp)}`
 			};
 		}
 		if (schema !== void 0) {
@@ -18405,7 +19052,7 @@ var require_subschema = /* @__PURE__ */ __commonJSMin(((exports) => {
 		if (dataProp !== void 0) {
 			const { errorPath, dataPathArr, opts } = it;
 			dataContextProps(gen.let("data", (0, codegen_1$29._)`${it.data}${(0, codegen_1$29.getProperty)(dataProp)}`, true));
-			subschema.errorPath = (0, codegen_1$29.str)`${errorPath}${(0, util_1$25.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;
+			subschema.errorPath = (0, codegen_1$29.str)`${errorPath}${(0, util_1$26.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;
 			subschema.parentDataProperty = (0, codegen_1$29._)`${dataProp}`;
 			subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty];
 		}
@@ -18542,11 +19189,11 @@ var require_json_schema_traverse = /* @__PURE__ */ __commonJSMin(((exports, modu
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/resolve.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/resolve.js
 var require_resolve = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = void 0;
-	const util_1$24 = require_util();
+	const util_1$25 = require_util();
 	const equal$2 = require_fast_deep_equal();
 	const traverse = require_json_schema_traverse();
 	const SIMPLE_INLINED = new Set([
@@ -18596,7 +19243,7 @@ var require_resolve = /* @__PURE__ */ __commonJSMin(((exports) => {
 			if (key$1 === "$ref") return Infinity;
 			count++;
 			if (SIMPLE_INLINED.has(key$1)) continue;
-			if (typeof schema[key$1] == "object") (0, util_1$24.eachItem)(schema[key$1], (sch) => count += countKeys(sch));
+			if (typeof schema[key$1] == "object") (0, util_1$25.eachItem)(schema[key$1], (sch) => count += countKeys(sch));
 			if (count === Infinity) return Infinity;
 		}
 		return count;
@@ -18670,7 +19317,7 @@ var require_resolve = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/validate/index.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/index.js
 var require_validate = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.getData = exports.KeywordCxt = exports.validateFunctionCode = void 0;
@@ -18684,7 +19331,7 @@ var require_validate = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const codegen_1$28 = require_codegen();
 	const names_1$3 = require_names();
 	const resolve_1$3 = require_resolve();
-	const util_1$23 = require_util();
+	const util_1$24 = require_util();
 	const errors_1 = require_errors();
 	function validateFunctionCode(it) {
 		if (isSchemaObj(it)) {
@@ -18773,7 +19420,7 @@ var require_validate = /* @__PURE__ */ __commonJSMin(((exports) => {
 		gen.var(valid, (0, codegen_1$28._)`${errsCount} === ${names_1$3.default.errors}`);
 	}
 	function checkKeywords(it) {
-		(0, util_1$23.checkUnknownRules)(it);
+		(0, util_1$24.checkUnknownRules)(it);
 		checkRefsAndKeywords(it);
 	}
 	function typeAndKeywords(it, errsCount) {
@@ -18783,11 +19430,11 @@ var require_validate = /* @__PURE__ */ __commonJSMin(((exports) => {
 	}
 	function checkRefsAndKeywords(it) {
 		const { schema, errSchemaPath, opts, self } = it;
-		if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1$23.schemaHasRulesButRef)(schema, self.RULES)) self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
+		if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1$24.schemaHasRulesButRef)(schema, self.RULES)) self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
 	}
 	function checkNoDefault(it) {
 		const { schema, opts } = it;
-		if (schema.default !== void 0 && opts.useDefaults && opts.strictSchema) (0, util_1$23.checkStrictMode)(it, "default is ignored in the schema root");
+		if (schema.default !== void 0 && opts.useDefaults && opts.strictSchema) (0, util_1$24.checkStrictMode)(it, "default is ignored in the schema root");
 	}
 	function updateContext(it) {
 		const schId = it.schema[it.opts.schemaId];
@@ -18821,7 +19468,7 @@ var require_validate = /* @__PURE__ */ __commonJSMin(((exports) => {
 	function schemaKeywords(it, types, typeErrors, errsCount) {
 		const { gen, schema, data, allErrors, opts, self } = it;
 		const { RULES } = self;
-		if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1$23.schemaHasRulesButRef)(schema, RULES))) {
+		if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1$24.schemaHasRulesButRef)(schema, RULES))) {
 			gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
 			return;
 		}
@@ -18896,7 +19543,7 @@ var require_validate = /* @__PURE__ */ __commonJSMin(((exports) => {
 	function strictTypesError(it, msg) {
 		const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
 		msg += ` at "${schemaPath}" (strictTypes)`;
-		(0, util_1$23.checkStrictMode)(it, msg, it.opts.strictTypes);
+		(0, util_1$24.checkStrictMode)(it, msg, it.opts.strictTypes);
 	}
 	var KeywordCxt = class {
 		constructor(it, def$30, keyword) {
@@ -18907,7 +19554,7 @@ var require_validate = /* @__PURE__ */ __commonJSMin(((exports) => {
 			this.data = it.data;
 			this.schema = it.schema[keyword];
 			this.$data = def$30.$data && it.opts.$data && this.schema && this.schema.$data;
-			this.schemaValue = (0, util_1$23.schemaRefOrVal)(it, this.schema, keyword, this.$data);
+			this.schemaValue = (0, util_1$24.schemaRefOrVal)(it, this.schema, keyword, this.$data);
 			this.schemaType = def$30.schemaType;
 			this.parentSchema = it.schema;
 			this.params = {};
@@ -19033,8 +19680,8 @@ var require_validate = /* @__PURE__ */ __commonJSMin(((exports) => {
 		mergeEvaluated(schemaCxt, toName) {
 			const { it, gen } = this;
 			if (!it.opts.unevaluated) return;
-			if (it.props !== true && schemaCxt.props !== void 0) it.props = util_1$23.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName);
-			if (it.items !== true && schemaCxt.items !== void 0) it.items = util_1$23.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName);
+			if (it.props !== true && schemaCxt.props !== void 0) it.props = util_1$24.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName);
+			if (it.items !== true && schemaCxt.items !== void 0) it.items = util_1$24.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName);
 		}
 		mergeValidEvaluated(schemaCxt, valid) {
 			const { it, gen } = this;
@@ -19078,7 +19725,7 @@ var require_validate = /* @__PURE__ */ __commonJSMin(((exports) => {
 		let expr = data;
 		const segments = jsonPointer.split("/");
 		for (const segment of segments) if (segment) {
-			data = (0, codegen_1$28._)`${data}${(0, codegen_1$28.getProperty)((0, util_1$23.unescapeJsonPointer)(segment))}`;
+			data = (0, codegen_1$28._)`${data}${(0, codegen_1$28.getProperty)((0, util_1$24.unescapeJsonPointer)(segment))}`;
 			expr = (0, codegen_1$28._)`${expr} && ${data}`;
 		}
 		return expr;
@@ -19090,7 +19737,7 @@ var require_validate = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/runtime/validation_error.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/runtime/validation_error.js
 var require_validation_error = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	var ValidationError = class extends Error {
@@ -19104,7 +19751,7 @@ var require_validation_error = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/ref_error.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/ref_error.js
 var require_ref_error = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const resolve_1$2 = require_resolve();
@@ -19119,7 +19766,7 @@ var require_ref_error = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/index.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/index.js
 var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = void 0;
@@ -19127,7 +19774,7 @@ var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const validation_error_1$2 = require_validation_error();
 	const names_1$2 = require_names();
 	const resolve_1$1 = require_resolve();
-	const util_1$22 = require_util();
+	const util_1$23 = require_util();
 	const validate_1$3 = require_validate();
 	var SchemaEnv = class {
 		constructor(env) {
@@ -19311,14 +19958,14 @@ var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
 		if (((_a = parsedRef.fragment) === null || _a === void 0 ? void 0 : _a[0]) !== "/") return;
 		for (const part of parsedRef.fragment.slice(1).split("/")) {
 			if (typeof schema === "boolean") return;
-			const partSchema = schema[(0, util_1$22.unescapeFragment)(part)];
+			const partSchema = schema[(0, util_1$23.unescapeFragment)(part)];
 			if (partSchema === void 0) return;
 			schema = partSchema;
 			const schId = typeof schema === "object" && schema[this.opts.schemaId];
 			if (!PREVENT_SCOPE_CHANGE.has(part) && schId) baseId = (0, resolve_1$1.resolveUrl)(this.opts.uriResolver, baseId, schId);
 		}
 		let env;
-		if (typeof schema != "boolean" && schema.$ref && !(0, util_1$22.schemaHasRulesButRef)(schema, this.RULES)) {
+		if (typeof schema != "boolean" && schema.$ref && !(0, util_1$23.schemaHasRulesButRef)(schema, this.RULES)) {
 			const $ref = (0, resolve_1$1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
 			env = resolveSchema.call(this, root, $ref);
 		}
@@ -19334,7 +19981,7 @@ var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/refs/data.json
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/refs/data.json
 var require_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = {
 		"$id": "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",
@@ -20049,7 +20696,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/runtime/uri.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/runtime/uri.js
 var require_uri = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const uri$1 = require_fast_uri();
@@ -20058,7 +20705,7 @@ var require_uri = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/core.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/core.js
 var require_core$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0;
@@ -20113,7 +20760,7 @@ var require_core$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const codegen_2 = require_codegen();
 	const resolve_1 = require_resolve();
 	const dataType_1$1 = require_dataType();
-	const util_1$21 = require_util();
+	const util_1$22 = require_util();
 	const $dataRefSchema = require_data();
 	const uri_1 = require_uri();
 	const defaultRegExp = (str$1, flags) => new RegExp(str$1, flags);
@@ -20375,8 +21022,8 @@ var require_core$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 					return this;
 				}
 				case "object": {
-					const cacheKey = schemaKeyRef;
-					this._cache.delete(cacheKey);
+					const cacheKey$1 = schemaKeyRef;
+					this._cache.delete(cacheKey$1);
 					let id = schemaKeyRef[this.opts.schemaId];
 					if (id) {
 						id = (0, resolve_1.normalizeId)(id);
@@ -20407,7 +21054,7 @@ var require_core$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 			} else throw new Error("invalid addKeywords parameters");
 			checkKeyword.call(this, keyword, def$30);
 			if (!def$30) {
-				(0, util_1$21.eachItem)(keyword, (kwd) => addRule.call(this, kwd));
+				(0, util_1$22.eachItem)(keyword, (kwd) => addRule.call(this, kwd));
 				return this;
 			}
 			keywordMetaschema.call(this, def$30);
@@ -20416,7 +21063,7 @@ var require_core$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 				type: (0, dataType_1$1.getJSONTypes)(def$30.type),
 				schemaType: (0, dataType_1$1.getJSONTypes)(def$30.schemaType)
 			};
-			(0, util_1$21.eachItem)(keyword, definition.type.length === 0 ? (k) => addRule.call(this, k, definition) : (k) => definition.type.forEach((t) => addRule.call(this, k, definition, t)));
+			(0, util_1$22.eachItem)(keyword, definition.type.length === 0 ? (k) => addRule.call(this, k, definition) : (k) => definition.type.forEach((t) => addRule.call(this, k, definition, t)));
 			return this;
 		}
 		getKeyword(keyword) {
@@ -20572,7 +21219,7 @@ var require_core$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
 	function checkKeyword(keyword, def$30) {
 		const { RULES } = this;
-		(0, util_1$21.eachItem)(keyword, (kwd) => {
+		(0, util_1$22.eachItem)(keyword, (kwd) => {
 			if (RULES.keywords[kwd]) throw new Error(`Keyword ${kwd} is already defined`);
 			if (!KEYWORD_NAME.test(kwd)) throw new Error(`Keyword ${kwd} has invalid name`);
 		});
@@ -20628,7 +21275,7 @@ var require_core$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/core/id.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/core/id.js
 var require_id = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const def$29 = {
@@ -20641,7 +21288,7 @@ var require_id = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/core/ref.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/core/ref.js
 var require_ref = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.callRef = exports.getValidate = void 0;
@@ -20650,7 +21297,7 @@ var require_ref = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const codegen_1$25 = require_codegen();
 	const names_1$1 = require_names();
 	const compile_1$1 = require_compile();
-	const util_1$20 = require_util();
+	const util_1$21 = require_util();
 	const def$28 = {
 		keyword: "$ref",
 		schemaType: "string",
@@ -20727,16 +21374,16 @@ var require_ref = /* @__PURE__ */ __commonJSMin(((exports) => {
 			if (!it.opts.unevaluated) return;
 			const schEvaluated = (_a = sch === null || sch === void 0 ? void 0 : sch.validate) === null || _a === void 0 ? void 0 : _a.evaluated;
 			if (it.props !== true) if (schEvaluated && !schEvaluated.dynamicProps) {
-				if (schEvaluated.props !== void 0) it.props = util_1$20.mergeEvaluated.props(gen, schEvaluated.props, it.props);
+				if (schEvaluated.props !== void 0) it.props = util_1$21.mergeEvaluated.props(gen, schEvaluated.props, it.props);
 			} else {
 				const props = gen.var("props", (0, codegen_1$25._)`${source}.evaluated.props`);
-				it.props = util_1$20.mergeEvaluated.props(gen, props, it.props, codegen_1$25.Name);
+				it.props = util_1$21.mergeEvaluated.props(gen, props, it.props, codegen_1$25.Name);
 			}
 			if (it.items !== true) if (schEvaluated && !schEvaluated.dynamicItems) {
-				if (schEvaluated.items !== void 0) it.items = util_1$20.mergeEvaluated.items(gen, schEvaluated.items, it.items);
+				if (schEvaluated.items !== void 0) it.items = util_1$21.mergeEvaluated.items(gen, schEvaluated.items, it.items);
 			} else {
 				const items = gen.var("items", (0, codegen_1$25._)`${source}.evaluated.items`);
-				it.items = util_1$20.mergeEvaluated.items(gen, items, it.items, codegen_1$25.Name);
+				it.items = util_1$21.mergeEvaluated.items(gen, items, it.items, codegen_1$25.Name);
 			}
 		}
 	}
@@ -20745,7 +21392,7 @@ var require_ref = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/core/index.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/core/index.js
 var require_core = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const id_1 = require_id();
@@ -20764,7 +21411,7 @@ var require_core = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/validation/limitNumber.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/limitNumber.js
 var require_limitNumber = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const codegen_1$24 = require_codegen();
@@ -20809,7 +21456,7 @@ var require_limitNumber = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/validation/multipleOf.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/multipleOf.js
 var require_multipleOf = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const codegen_1$23 = require_codegen();
@@ -20834,7 +21481,7 @@ var require_multipleOf = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/runtime/ucs2length.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/runtime/ucs2length.js
 var require_ucs2length = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	function ucs2length(str$1) {
@@ -20857,11 +21504,11 @@ var require_ucs2length = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/validation/limitLength.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/limitLength.js
 var require_limitLength = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const codegen_1$22 = require_codegen();
-	const util_1$19 = require_util();
+	const util_1$20 = require_util();
 	const ucs2length_1 = require_ucs2length();
 	const def$25 = {
 		keyword: ["maxLength", "minLength"],
@@ -20878,7 +21525,7 @@ var require_limitLength = /* @__PURE__ */ __commonJSMin(((exports) => {
 		code(cxt) {
 			const { keyword, data, schemaCode, it } = cxt;
 			const op = keyword === "maxLength" ? codegen_1$22.operators.GT : codegen_1$22.operators.LT;
-			const len = it.opts.unicode === false ? (0, codegen_1$22._)`${data}.length` : (0, codegen_1$22._)`${(0, util_1$19.useFunc)(cxt.gen, ucs2length_1.default)}(${data})`;
+			const len = it.opts.unicode === false ? (0, codegen_1$22._)`${data}.length` : (0, codegen_1$22._)`${(0, util_1$20.useFunc)(cxt.gen, ucs2length_1.default)}(${data})`;
 			cxt.fail$data((0, codegen_1$22._)`${len} ${op} ${schemaCode}`);
 		}
 	};
@@ -20886,10 +21533,11 @@ var require_limitLength = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/validation/pattern.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/pattern.js
 var require_pattern = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const code_1$7 = require_code();
+	const util_1$19 = require_util();
 	const codegen_1$21 = require_codegen();
 	const def$24 = {
 		keyword: "pattern",
@@ -20901,17 +21549,25 @@ var require_pattern = /* @__PURE__ */ __commonJSMin(((exports) => {
 			params: ({ schemaCode }) => (0, codegen_1$21._)`{pattern: ${schemaCode}}`
 		},
 		code(cxt) {
-			const { data, $data, schema, schemaCode, it } = cxt;
+			const { gen, data, $data, schema, schemaCode, it } = cxt;
 			const u = it.opts.unicodeRegExp ? "u" : "";
-			const regExp = $data ? (0, codegen_1$21._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1$7.usePattern)(cxt, schema);
-			cxt.fail$data((0, codegen_1$21._)`!${regExp}.test(${data})`);
+			if ($data) {
+				const { regExp } = it.opts.code;
+				const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1$21._)`new RegExp` : (0, util_1$19.useFunc)(gen, regExp);
+				const valid = gen.let("valid");
+				gen.try(() => gen.assign(valid, (0, codegen_1$21._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
+				cxt.fail$data((0, codegen_1$21._)`!${valid}`);
+			} else {
+				const regExp = (0, code_1$7.usePattern)(cxt, schema);
+				cxt.fail$data((0, codegen_1$21._)`!${regExp}.test(${data})`);
+			}
 		}
 	};
 	exports.default = def$24;
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/validation/limitProperties.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/limitProperties.js
 var require_limitProperties = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const codegen_1$20 = require_codegen();
@@ -20937,7 +21593,7 @@ var require_limitProperties = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/validation/required.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/required.js
 var require_required = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const code_1$6 = require_code();
@@ -21005,7 +21661,7 @@ var require_required = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/validation/limitItems.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/limitItems.js
 var require_limitItems = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const codegen_1$18 = require_codegen();
@@ -21031,7 +21687,7 @@ var require_limitItems = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/runtime/equal.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/runtime/equal.js
 var require_equal = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const equal = require_fast_deep_equal();
@@ -21040,7 +21696,7 @@ var require_equal = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js
 var require_uniqueItems = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const dataType_1 = require_dataType();
@@ -21105,7 +21761,7 @@ var require_uniqueItems = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/validation/const.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/const.js
 var require_const = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const codegen_1$16 = require_codegen();
@@ -21128,7 +21784,7 @@ var require_const = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/validation/enum.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/enum.js
 var require_enum = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const codegen_1$15 = require_codegen();
@@ -21173,7 +21829,7 @@ var require_enum = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/validation/index.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/index.js
 var require_validation = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const limitNumber_1 = require_limitNumber();
@@ -21210,7 +21866,7 @@ var require_validation = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/additionalItems.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/additionalItems.js
 var require_additionalItems = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.validateAdditionalItems = void 0;
@@ -21263,7 +21919,7 @@ var require_additionalItems = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/items.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/items.js
 var require_items = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.validateTuple = void 0;
@@ -21317,7 +21973,7 @@ var require_items = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/prefixItems.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/prefixItems.js
 var require_prefixItems = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const items_1$1 = require_items();
@@ -21332,7 +21988,7 @@ var require_prefixItems = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/items2020.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/items2020.js
 var require_items2020 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const codegen_1$12 = require_codegen();
@@ -21361,7 +22017,7 @@ var require_items2020 = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/contains.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/contains.js
 var require_contains = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const codegen_1$11 = require_codegen();
@@ -21447,7 +22103,7 @@ var require_contains = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/dependencies.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/dependencies.js
 var require_dependencies = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0;
@@ -21529,7 +22185,7 @@ var require_dependencies = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/propertyNames.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/propertyNames.js
 var require_propertyNames = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const codegen_1$9 = require_codegen();
@@ -21567,7 +22223,7 @@ var require_propertyNames = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js
 var require_additionalProperties = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const code_1$2 = require_code();
@@ -21658,7 +22314,7 @@ var require_additionalProperties = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/properties.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/properties.js
 var require_properties = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const validate_1$1 = require_validate();
@@ -21705,7 +22361,7 @@ var require_properties = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/patternProperties.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/patternProperties.js
 var require_patternProperties = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const code_1 = require_code();
@@ -21762,7 +22418,7 @@ var require_patternProperties = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/not.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/not.js
 var require_not = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const util_1$5 = require_util();
@@ -21791,7 +22447,7 @@ var require_not = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/anyOf.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/anyOf.js
 var require_anyOf = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const def$6 = {
@@ -21805,7 +22461,7 @@ var require_anyOf = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/oneOf.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/oneOf.js
 var require_oneOf = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const codegen_1$6 = require_codegen();
@@ -21853,7 +22509,7 @@ var require_oneOf = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/allOf.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/allOf.js
 var require_allOf = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const util_1$3 = require_util();
@@ -21880,7 +22536,7 @@ var require_allOf = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/if.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/if.js
 var require_if = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const codegen_1$5 = require_codegen();
@@ -21938,7 +22594,7 @@ var require_if = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/thenElse.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/thenElse.js
 var require_thenElse = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const util_1$1 = require_util();
@@ -21953,7 +22609,7 @@ var require_thenElse = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/applicator/index.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/index.js
 var require_applicator = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const additionalItems_1 = require_additionalItems();
@@ -21995,7 +22651,7 @@ var require_applicator = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/format/format.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/format/format.js
 var require_format$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const codegen_1$4 = require_codegen();
@@ -22085,7 +22741,7 @@ var require_format$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/format/index.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/format/index.js
 var require_format = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const format = [require_format$1().default];
@@ -22093,7 +22749,7 @@ var require_format = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/metadata.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/metadata.js
 var require_metadata = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.contentVocabulary = exports.metadataVocabulary = void 0;
@@ -22114,7 +22770,7 @@ var require_metadata = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/draft7.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/draft7.js
 var require_draft7 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const core_1$1 = require_core();
@@ -22134,7 +22790,7 @@ var require_draft7 = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/discriminator/types.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/discriminator/types.js
 var require_types = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.DiscrError = void 0;
@@ -22146,7 +22802,7 @@ var require_types = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/discriminator/index.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/discriminator/index.js
 var require_discriminator = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const codegen_1$3 = require_codegen();
@@ -22241,7 +22897,7 @@ var require_discriminator = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/refs/json-schema-draft-07.json
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/refs/json-schema-draft-07.json
 var require_json_schema_draft_07 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = {
 		"$schema": "http://json-schema.org/draft-07/schema#",
@@ -22380,7 +23036,7 @@ var require_json_schema_draft_07 = /* @__PURE__ */ __commonJSMin(((exports, modu
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/ajv.js
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/ajv.js
 var require_ajv = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv = void 0;
@@ -22473,7 +23129,7 @@ var require_ajv = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.17.1/node_modules/ajv-formats/dist/formats.js
+//#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;
@@ -22662,7 +23318,7 @@ var require_formats = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.17.1/node_modules/ajv-formats/dist/limit.js
+//#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;
@@ -22742,7 +23398,7 @@ var require_limit = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.17.1/node_modules/ajv-formats/dist/index.js
+//#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();
@@ -22777,11 +23433,11 @@ var require_dist = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
-var import_ajv = require_ajv();
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/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.Ajv({
+	const ajv = new import_ajv.default({
 		strict: false,
 		validateFormats: true,
 		validateSchema: false,
@@ -22825,7 +23481,7 @@ var AjvJsonSchemaValidator = class {
 	* ```
 	*/
 	constructor(ajv) {
-		this._ajv = ajv !== null && ajv !== void 0 ? ajv : createDefaultAjvInstance();
+		this._ajv = ajv ?? createDefaultAjvInstance();
 	}
 	/**
 	* Create a validator for the given JSON Schema
@@ -22837,8 +23493,7 @@ var AjvJsonSchemaValidator = class {
 	* @returns A validator function that validates input data
 	*/
 	getValidator(schema) {
-		var _a;
-		const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? (_a = this._ajv.getSchema(schema.$id)) !== null && _a !== void 0 ? _a : this._ajv.compile(schema) : this._ajv.compile(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,
@@ -22855,7 +23510,7 @@ var AjvJsonSchemaValidator = class {
 };
 
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/client.js
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/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.
@@ -22914,11 +23569,10 @@ var ExperimentalClientTasks = class {
 	* @experimental
 	*/
 	async *callToolStream(params, resultSchema = CallToolResultSchema, options) {
-		var _a;
 		const clientInternal = this._client;
 		const optionsWithTask = {
 			...options,
-			task: (_a = options === null || options === void 0 ? void 0 : options.task) !== null && _a !== void 0 ? _a : clientInternal.isToolTask(params.name) ? {} : void 0
+			task: options?.task ?? (clientInternal.isToolTask(params.name) ? {} : void 0)
 		};
 		const stream = clientInternal.requestStream({
 			method: "tools/call",
@@ -23030,7 +23684,7 @@ var ExperimentalClientTasks = class {
 };
 
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/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.
@@ -23049,11 +23703,10 @@ var ExperimentalClientTasks = class {
 * @experimental
 */
 function assertToolsCallTaskCapability(requests, method, entityName) {
-	var _a;
 	if (!requests) throw new Error(`${entityName} does not support task creation (required for ${method})`);
 	switch (method) {
 		case "tools/call":
-			if (!((_a = requests.tools) === null || _a === void 0 ? void 0 : _a.call)) throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
+			if (!requests.tools?.call) throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
 			break;
 		default: break;
 	}
@@ -23070,21 +23723,20 @@ function assertToolsCallTaskCapability(requests, method, entityName) {
 * @experimental
 */
 function assertClientRequestTaskCapability(requests, method, entityName) {
-	var _a, _b;
 	if (!requests) throw new Error(`${entityName} does not support task creation (required for ${method})`);
 	switch (method) {
 		case "sampling/createMessage":
-			if (!((_a = requests.sampling) === null || _a === void 0 ? void 0 : _a.createMessage)) throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
+			if (!requests.sampling?.createMessage) throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
 			break;
 		case "elicitation/create":
-			if (!((_b = requests.elicitation) === null || _b === void 0 ? void 0 : _b.create)) throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
+			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.24.3_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/client/index.js
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/client/index.js
 /**
 * Elicitation default application helper. Applies defaults to the data based on the schema.
 *
@@ -23102,8 +23754,12 @@ function applyElicitationDefaults(schema, data) {
 			if (obj[key$1] !== void 0) applyElicitationDefaults(propSchema, obj[key$1]);
 		}
 	}
-	if (Array.isArray(schema.anyOf)) for (const sub of schema.anyOf) applyElicitationDefaults(sub, data);
-	if (Array.isArray(schema.oneOf)) for (const sub of schema.oneOf) applyElicitationDefaults(sub, data);
+	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.
@@ -23157,14 +23813,32 @@ var Client = class extends Protocol {
 	* Initializes this client with the given name and version information.
 	*/
 	constructor(_clientInfo, options) {
-		var _a, _b;
 		super(options);
 		this._clientInfo = _clientInfo;
 		this._cachedToolOutputValidators = /* @__PURE__ */ new Map();
 		this._cachedKnownTaskTools = /* @__PURE__ */ new Set();
 		this._cachedRequiredTaskTools = /* @__PURE__ */ new Set();
-		this._capabilities = (_a = options === null || options === void 0 ? void 0 : options.capabilities) !== null && _a !== void 0 ? _a : {};
-		this._jsonSchemaValidator = (_b = options === null || options === void 0 ? void 0 : options.jsonSchemaValidator) !== null && _b !== void 0 ? _b : new AjvJsonSchemaValidator();
+		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$1) {
+		if (config$1.tools && this._serverCapabilities?.tools?.listChanged) this._setupListChangedHandler("tools", ToolListChangedNotificationSchema, config$1.tools, async () => {
+			return (await this.listTools()).tools;
+		});
+		if (config$1.prompts && this._serverCapabilities?.prompts?.listChanged) this._setupListChangedHandler("prompts", PromptListChangedNotificationSchema, config$1.prompts, async () => {
+			return (await this.listPrompts()).prompts;
+		});
+		if (config$1.resources && this._serverCapabilities?.resources?.listChanged) this._setupListChangedHandler("resources", ResourceListChangedNotificationSchema, config$1.resources, async () => {
+			return (await this.listResources()).resources;
+		});
 	}
 	/**
 	* Access experimental features.
@@ -23190,35 +23864,30 @@ var Client = class extends Protocol {
 	* Override request handler registration to enforce client-side validation for elicitation.
 	*/
 	setRequestHandler(requestSchema, handler) {
-		var _a, _b, _c;
-		const shape = getObjectShape(requestSchema);
-		const methodSchema = shape === null || shape === void 0 ? void 0 : shape.method;
+		const methodSchema = getObjectShape(requestSchema)?.method;
 		if (!methodSchema) throw new Error("Schema is missing a method literal");
 		let methodValue;
 		if (isZ4Schema(methodSchema)) {
 			const v4Schema = methodSchema;
-			const v4Def = (_a = v4Schema._zod) === null || _a === void 0 ? void 0 : _a.def;
-			methodValue = (_b = v4Def === null || v4Def === void 0 ? void 0 : v4Def.value) !== null && _b !== void 0 ? _b : v4Schema.value;
+			methodValue = (v4Schema._zod?.def)?.value ?? v4Schema.value;
 		} else {
 			const v3Schema = methodSchema;
-			const legacyDef = v3Schema._def;
-			methodValue = (_c = legacyDef === null || legacyDef === void 0 ? void 0 : legacyDef.value) !== null && _c !== void 0 ? _c : v3Schema.value;
+			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) => {
-				var _a$1, _b$1, _c$1;
 				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;
-				const mode = (_a$1 = params.mode) !== null && _a$1 !== void 0 ? _a$1 : "form";
+				params.mode = params.mode ?? "form";
 				const { supportsFormMode, supportsUrlMode } = getSupportedElicitationModes(this._capabilities.elicitation);
-				if (mode === "form" && !supportsFormMode) throw new McpError(ErrorCode.InvalidParams, "Client does not support form-mode elicitation requests");
-				if (mode === "url" && !supportsUrlMode) throw new McpError(ErrorCode.InvalidParams, "Client does not support URL-mode elicitation requests");
+				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);
@@ -23234,11 +23903,11 @@ var Client = class extends Protocol {
 					throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation result: ${errorMessage}`);
 				}
 				const validatedResult = validationResult.data;
-				const requestedSchema = mode === "form" ? params.requestedSchema : void 0;
-				if (mode === "form" && validatedResult.action === "accept" && validatedResult.content && requestedSchema) {
-					if ((_c$1 = (_b$1 = this._capabilities.elicitation) === null || _b$1 === void 0 ? void 0 : _b$1.form) === null || _c$1 === void 0 ? void 0 : _c$1.applyDefaults) try {
+				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 (_d) {}
+					} catch {}
 				}
 				return validatedResult;
 			};
@@ -23261,7 +23930,7 @@ var Client = class extends Protocol {
 					}
 					return taskValidationResult.data;
 				}
-				const validationResult = safeParse(CreateMessageResultSchema, result);
+				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}`);
@@ -23273,8 +23942,7 @@ var Client = class extends Protocol {
 		return super.setRequestHandler(requestSchema, handler);
 	}
 	assertCapability(capability, method) {
-		var _a;
-		if (!((_a = this._serverCapabilities) === null || _a === void 0 ? void 0 : _a[capability])) throw new Error(`Server does not support ${capability} (required for ${method})`);
+		if (!this._serverCapabilities?.[capability]) throw new Error(`Server does not support ${capability} (required for ${method})`);
 	}
 	async connect(transport, options) {
 		await super.connect(transport);
@@ -23295,6 +23963,10 @@ var Client = class extends Protocol {
 			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$1) {
 			this.close();
 			throw error$1;
@@ -23319,39 +23991,37 @@ var Client = class extends Protocol {
 		return this._instructions;
 	}
 	assertCapabilityForMethod(method) {
-		var _a, _b, _c, _d, _e;
 		switch (method) {
 			case "logging/setLevel":
-				if (!((_a = this._serverCapabilities) === null || _a === void 0 ? void 0 : _a.logging)) throw new Error(`Server does not support logging (required for ${method})`);
+				if (!this._serverCapabilities?.logging) throw new Error(`Server does not support logging (required for ${method})`);
 				break;
 			case "prompts/get":
 			case "prompts/list":
-				if (!((_b = this._serverCapabilities) === null || _b === void 0 ? void 0 : _b.prompts)) throw new Error(`Server does not support prompts (required for ${method})`);
+				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 (!((_c = this._serverCapabilities) === null || _c === void 0 ? void 0 : _c.resources)) throw new Error(`Server does not support resources (required for ${method})`);
+				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 (!((_d = this._serverCapabilities) === null || _d === void 0 ? void 0 : _d.tools)) throw new Error(`Server does not support tools (required for ${method})`);
+				if (!this._serverCapabilities?.tools) throw new Error(`Server does not support tools (required for ${method})`);
 				break;
 			case "completion/complete":
-				if (!((_e = this._serverCapabilities) === null || _e === void 0 ? void 0 : _e.completions)) throw new Error(`Server does not support completions (required for ${method})`);
+				if (!this._serverCapabilities?.completions) throw new Error(`Server does not support completions (required for ${method})`);
 				break;
 			case "initialize": break;
 			case "ping": break;
 		}
 	}
 	assertNotificationCapability(method) {
-		var _a;
 		switch (method) {
 			case "notifications/roots/list_changed":
-				if (!((_a = this._capabilities.roots) === null || _a === void 0 ? void 0 : _a.listChanged)) throw new Error(`Client does not support roots list changed notifications (required for ${method})`);
+				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;
@@ -23380,13 +24050,11 @@ var Client = class extends Protocol {
 		}
 	}
 	assertTaskCapability(method) {
-		var _a, _b;
-		assertToolsCallTaskCapability((_b = (_a = this._serverCapabilities) === null || _a === void 0 ? void 0 : _a.tasks) === null || _b === void 0 ? void 0 : _b.requests, method, "Server");
+		assertToolsCallTaskCapability(this._serverCapabilities?.tasks?.requests, method, "Server");
 	}
 	assertTaskHandlerCapability(method) {
-		var _a;
 		if (!this._capabilities) return;
-		assertClientRequestTaskCapability((_a = this._capabilities.tasks) === null || _a === void 0 ? void 0 : _a.requests, method, "Client");
+		assertClientRequestTaskCapability(this._capabilities.tasks?.requests, method, "Client");
 	}
 	async ping(options) {
 		return this.request({ method: "ping" }, EmptyResultSchema, options);
@@ -23470,8 +24138,7 @@ var Client = class extends Protocol {
 		return result;
 	}
 	isToolTask(toolName) {
-		var _a, _b, _c, _d;
-		if (!((_d = (_c = (_b = (_a = this._serverCapabilities) === null || _a === void 0 ? void 0 : _a.tasks) === null || _b === void 0 ? void 0 : _b.requests) === null || _c === void 0 ? void 0 : _c.tools) === null || _d === void 0 ? void 0 : _d.call)) return false;
+		if (!this._serverCapabilities?.tasks?.requests?.tools?.call) return false;
 		return this._cachedKnownTaskTools.has(toolName);
 	}
 	/**
@@ -23486,7 +24153,6 @@ var Client = class extends Protocol {
 	* Called after listTools() to pre-compile validators for better performance.
 	*/
 	cacheToolMetadata(tools) {
-		var _a;
 		this._cachedToolOutputValidators.clear();
 		this._cachedKnownTaskTools.clear();
 		this._cachedRequiredTaskTools.clear();
@@ -23495,7 +24161,7 @@ var Client = class extends Protocol {
 				const toolValidator = this._jsonSchemaValidator.getValidator(tool.outputSchema);
 				this._cachedToolOutputValidators.set(tool.name, toolValidator);
 			}
-			const taskSupport = (_a = tool.execution) === null || _a === void 0 ? void 0 : _a.taskSupport;
+			const taskSupport = tool.execution?.taskSupport;
 			if (taskSupport === "required" || taskSupport === "optional") this._cachedKnownTaskTools.add(tool.name);
 			if (taskSupport === "required") this._cachedRequiredTaskTools.add(tool.name);
 		}
@@ -23514,13 +24180,44 @@ var Client = class extends Protocol {
 		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
-//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
 /**
 * Experimental server task features for MCP SDK.
 * WARNING: These APIs are experimental and may change without notice.
@@ -23561,6 +24258,136 @@ var ExperimentalServerTasks = class {
 		return this._server.requestStream(request, resultSchema, options);
 	}
 	/**
+	* Sends a sampling request and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* For task-augmented requests, yields 'taskCreated' and 'taskStatus' messages
+	* before the final result.
+	*
+	* @example
+	* ```typescript
+	* const stream = server.experimental.tasks.createMessageStream({
+	*     messages: [{ role: 'user', content: { type: 'text', text: 'Hello' } }],
+	*     maxTokens: 100
+	* }, {
+	*     onprogress: (progress) => {
+	*         // Handle streaming tokens via progress notifications
+	*         console.log('Progress:', progress.message);
+	*     }
+	* });
+	*
+	* for await (const message of stream) {
+	*     switch (message.type) {
+	*         case 'taskCreated':
+	*             console.log('Task created:', message.task.taskId);
+	*             break;
+	*         case 'taskStatus':
+	*             console.log('Task status:', message.task.status);
+	*             break;
+	*         case 'result':
+	*             console.log('Final result:', message.result);
+	*             break;
+	*         case 'error':
+	*             console.error('Error:', message.error);
+	*             break;
+	*     }
+	* }
+	* ```
+	*
+	* @param params - The sampling request parameters
+	* @param options - Optional request options (timeout, signal, task creation params, onprogress, etc.)
+	* @returns AsyncGenerator that yields ResponseMessage objects
+	*
+	* @experimental
+	*/
+	createMessageStream(params, options) {
+		const clientCapabilities = this._server.getClientCapabilities();
+		if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) throw new Error("Client does not support sampling tools capability.");
+		if (params.messages.length > 0) {
+			const lastMessage = params.messages[params.messages.length - 1];
+			const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
+			const hasToolResults = lastContent.some((c) => c.type === "tool_result");
+			const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : void 0;
+			const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
+			const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
+			if (hasToolResults) {
+				if (lastContent.some((c) => c.type !== "tool_result")) throw new Error("The last message must contain only tool_result content if any is present");
+				if (!hasPreviousToolUse) throw new Error("tool_result blocks are not matching any tool_use from the previous message");
+			}
+			if (hasPreviousToolUse) {
+				const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
+				const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
+				if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
+			}
+		}
+		return this.requestStream({
+			method: "sampling/createMessage",
+			params
+		}, CreateMessageResultSchema, options);
+	}
+	/**
+	* Sends an elicitation request and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* For task-augmented requests (especially URL-based elicitation), yields 'taskCreated'
+	* and 'taskStatus' messages before the final result.
+	*
+	* @example
+	* ```typescript
+	* const stream = server.experimental.tasks.elicitInputStream({
+	*     mode: 'url',
+	*     message: 'Please authenticate',
+	*     elicitationId: 'auth-123',
+	*     url: 'https://example.com/auth'
+	* }, {
+	*     task: { ttl: 300000 } // Task-augmented for long-running auth flow
+	* });
+	*
+	* for await (const message of stream) {
+	*     switch (message.type) {
+	*         case 'taskCreated':
+	*             console.log('Task created:', message.task.taskId);
+	*             break;
+	*         case 'taskStatus':
+	*             console.log('Task status:', message.task.status);
+	*             break;
+	*         case 'result':
+	*             console.log('User action:', message.result.action);
+	*             break;
+	*         case 'error':
+	*             console.error('Error:', message.error);
+	*             break;
+	*     }
+	* }
+	* ```
+	*
+	* @param params - The elicitation request parameters
+	* @param options - Optional request options (timeout, signal, task creation params, etc.)
+	* @returns AsyncGenerator that yields ResponseMessage objects
+	*
+	* @experimental
+	*/
+	elicitInputStream(params, options) {
+		const clientCapabilities = this._server.getClientCapabilities();
+		const mode = params.mode ?? "form";
+		switch (mode) {
+			case "url":
+				if (!clientCapabilities?.elicitation?.url) throw new Error("Client does not support url elicitation.");
+				break;
+			case "form":
+				if (!clientCapabilities?.elicitation?.form) throw new Error("Client does not support form elicitation.");
+				break;
+		}
+		const normalizedParams = mode === "form" && params.mode === void 0 ? {
+			...params,
+			mode: "form"
+		} : params;
+		return this.requestStream({
+			method: "elicitation/create",
+			params: normalizedParams
+		}, ElicitResultSchema, options);
+	}
+	/**
 	* Gets the current status of a task.
 	*
 	* @param taskId - The task identifier
@@ -23611,7 +24438,7 @@ var ExperimentalServerTasks = class {
 };
 
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
 /**
 * An MCP server on top of a pluggable transport.
 *
@@ -23643,7 +24470,6 @@ var Server = class extends Protocol {
 	* Initializes this server with the given name and version information.
 	*/
 	constructor(_serverInfo, options) {
-		var _a, _b;
 		super(options);
 		this._serverInfo = _serverInfo;
 		this._loggingLevels = /* @__PURE__ */ new Map();
@@ -23652,17 +24478,13 @@ var Server = class extends Protocol {
 			const currentLevel = this._loggingLevels.get(sessionId);
 			return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
 		};
-		this._capabilities = (_a = options === null || options === void 0 ? void 0 : options.capabilities) !== null && _a !== void 0 ? _a : {};
-		this._instructions = options === null || options === void 0 ? void 0 : options.instructions;
-		this._jsonSchemaValidator = (_b = options === null || options === void 0 ? void 0 : options.jsonSchemaValidator) !== null && _b !== void 0 ? _b : new AjvJsonSchemaValidator();
+		this._capabilities = options?.capabilities ?? {};
+		this._instructions = options?.instructions;
+		this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
 		this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request));
-		this.setNotificationHandler(InitializedNotificationSchema, () => {
-			var _a$1;
-			return (_a$1 = this.oninitialized) === null || _a$1 === void 0 ? void 0 : _a$1.call(this);
-		});
+		this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.());
 		if (this._capabilities.logging) this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
-			var _a$1;
-			const transportSessionId = extra.sessionId || ((_a$1 = extra.requestInfo) === null || _a$1 === void 0 ? void 0 : _a$1.headers["mcp-session-id"]) || void 0;
+			const transportSessionId = extra.sessionId || extra.requestInfo?.headers["mcp-session-id"] || void 0;
 			const { level } = request.params;
 			const parseResult = LoggingLevelSchema.safeParse(level);
 			if (parseResult.success) this._loggingLevels.set(transportSessionId, parseResult.data);
@@ -23693,19 +24515,15 @@ var Server = class extends Protocol {
 	* Override request handler registration to enforce server-side validation for tools/call.
 	*/
 	setRequestHandler(requestSchema, handler) {
-		var _a, _b, _c;
-		const shape = getObjectShape(requestSchema);
-		const methodSchema = shape === null || shape === void 0 ? void 0 : shape.method;
+		const methodSchema = getObjectShape(requestSchema)?.method;
 		if (!methodSchema) throw new Error("Schema is missing a method literal");
 		let methodValue;
 		if (isZ4Schema(methodSchema)) {
 			const v4Schema = methodSchema;
-			const v4Def = (_a = v4Schema._zod) === null || _a === void 0 ? void 0 : _a.def;
-			methodValue = (_b = v4Def === null || v4Def === void 0 ? void 0 : v4Def.value) !== null && _b !== void 0 ? _b : v4Schema.value;
+			methodValue = (v4Schema._zod?.def)?.value ?? v4Schema.value;
 		} else {
 			const v3Schema = methodSchema;
-			const legacyDef = v3Schema._def;
-			methodValue = (_c = legacyDef === null || legacyDef === void 0 ? void 0 : legacyDef.value) !== null && _c !== void 0 ? _c : v3Schema.value;
+			methodValue = v3Schema._def?.value ?? v3Schema.value;
 		}
 		if (typeof methodValue !== "string") throw new Error("Schema method literal must be a string");
 		if (methodValue === "tools/call") {
@@ -23737,22 +24555,20 @@ var Server = class extends Protocol {
 		return super.setRequestHandler(requestSchema, handler);
 	}
 	assertCapabilityForMethod(method) {
-		var _a, _b, _c;
 		switch (method) {
 			case "sampling/createMessage":
-				if (!((_a = this._clientCapabilities) === null || _a === void 0 ? void 0 : _a.sampling)) throw new Error(`Client does not support sampling (required for ${method})`);
+				if (!this._clientCapabilities?.sampling) throw new Error(`Client does not support sampling (required for ${method})`);
 				break;
 			case "elicitation/create":
-				if (!((_b = this._clientCapabilities) === null || _b === void 0 ? void 0 : _b.elicitation)) throw new Error(`Client does not support elicitation (required for ${method})`);
+				if (!this._clientCapabilities?.elicitation) throw new Error(`Client does not support elicitation (required for ${method})`);
 				break;
 			case "roots/list":
-				if (!((_c = this._clientCapabilities) === null || _c === void 0 ? void 0 : _c.roots)) throw new Error(`Client does not support listing roots (required for ${method})`);
+				if (!this._clientCapabilities?.roots) throw new Error(`Client does not support listing roots (required for ${method})`);
 				break;
 			case "ping": break;
 		}
 	}
 	assertNotificationCapability(method) {
-		var _a, _b;
 		switch (method) {
 			case "notifications/message":
 				if (!this._capabilities.logging) throw new Error(`Server does not support logging (required for ${method})`);
@@ -23768,7 +24584,7 @@ var Server = class extends Protocol {
 				if (!this._capabilities.prompts) throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`);
 				break;
 			case "notifications/elicitation/complete":
-				if (!((_b = (_a = this._clientCapabilities) === null || _a === void 0 ? void 0 : _a.elicitation) === null || _b === void 0 ? void 0 : _b.url)) throw new Error(`Client does not support URL elicitation (required for ${method})`);
+				if (!this._clientCapabilities?.elicitation?.url) throw new Error(`Client does not support URL elicitation (required for ${method})`);
 				break;
 			case "notifications/cancelled": break;
 			case "notifications/progress": break;
@@ -23807,13 +24623,11 @@ var Server = class extends Protocol {
 		}
 	}
 	assertTaskCapability(method) {
-		var _a, _b;
-		assertClientRequestTaskCapability((_b = (_a = this._clientCapabilities) === null || _a === void 0 ? void 0 : _a.tasks) === null || _b === void 0 ? void 0 : _b.requests, method, "Client");
+		assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, "Client");
 	}
 	assertTaskHandlerCapability(method) {
-		var _a;
 		if (!this._capabilities) return;
-		assertToolsCallTaskCapability((_a = this._capabilities.tasks) === null || _a === void 0 ? void 0 : _a.requests, method, "Server");
+		assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, "Server");
 	}
 	async _oninitialize(request) {
 		const requestedVersion = request.params.protocolVersion;
@@ -23845,9 +24659,8 @@ var Server = class extends Protocol {
 		return this.request({ method: "ping" }, EmptyResultSchema);
 	}
 	async createMessage(params, options) {
-		var _a, _b;
 		if (params.tools || params.toolChoice) {
-			if (!((_b = (_a = this._clientCapabilities) === null || _a === void 0 ? void 0 : _a.sampling) === null || _b === void 0 ? void 0 : _b.tools)) throw new Error("Client does not support sampling tools capability.");
+			if (!this._clientCapabilities?.sampling?.tools) throw new Error("Client does not support sampling tools capability.");
 		}
 		if (params.messages.length > 0) {
 			const lastMessage = params.messages[params.messages.length - 1];
@@ -23883,10 +24696,9 @@ var Server = class extends Protocol {
 	* @returns The result of the elicitation request.
 	*/
 	async elicitInput(params, options) {
-		var _a, _b, _c, _d, _e;
-		switch ((_a = params.mode) !== null && _a !== void 0 ? _a : "form") {
+		switch (params.mode ?? "form") {
 			case "url": {
-				if (!((_c = (_b = this._clientCapabilities) === null || _b === void 0 ? void 0 : _b.elicitation) === null || _c === void 0 ? void 0 : _c.url)) throw new Error("Client does not support url elicitation.");
+				if (!this._clientCapabilities?.elicitation?.url) throw new Error("Client does not support url elicitation.");
 				const urlParams = params;
 				return this.request({
 					method: "elicitation/create",
@@ -23894,7 +24706,7 @@ var Server = class extends Protocol {
 				}, ElicitResultSchema, options);
 			}
 			case "form": {
-				if (!((_e = (_d = this._clientCapabilities) === null || _d === void 0 ? void 0 : _d.elicitation) === null || _e === void 0 ? void 0 : _e.form)) throw new Error("Client does not support form elicitation.");
+				if (!this._clientCapabilities?.elicitation?.form) throw new Error("Client does not support form elicitation.");
 				const formParams = params.mode === "form" ? params : {
 					...params,
 					mode: "form"
@@ -23923,8 +24735,7 @@ var Server = class extends Protocol {
 	* @returns A function that emits the completion notification when awaited.
 	*/
 	createElicitationCompletionNotifier(elicitationId, options) {
-		var _a, _b;
-		if (!((_b = (_a = this._clientCapabilities) === null || _a === void 0 ? void 0 : _a.elicitation) === null || _b === void 0 ? void 0 : _b.url)) throw new Error("Client does not support URL elicitation (required for notifications/elicitation/complete)");
+		if (!this._clientCapabilities?.elicitation?.url) throw new Error("Client does not support URL elicitation (required for notifications/elicitation/complete)");
 		return () => this.notification({
 			method: "notifications/elicitation/complete",
 			params: { elicitationId }
@@ -23969,7 +24780,7 @@ var Server = class extends Protocol {
 };
 
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
 /**
 * Buffers a continuous stdio stream into discrete JSON-RPC messages.
 */
@@ -23997,5 +24808,5 @@ function serializeMessage(message) {
 }
 
 //#endregion
-export { NEVER as C, __toESM as D, __commonJSMin as E, _coercedNumber as S, AuthenticationMiddleware as T, looseObject as _, startHTTPServer as a, string as b, LATEST_PROTOCOL_VERSION as c, isJSONRPCResponse as d, ZodNumber as f, literal as g, boolean as h, Client as i, isInitializedNotification as l, array as m, serializeMessage as n, proxyServer as o, any as p, Server as r, JSONRPCMessageSchema as s, ReadBuffer as t, isJSONRPCRequest as u, number as v, InMemoryEventStore as w, url as x, object as y };
-//# sourceMappingURL=stdio-CvFTizsx.mjs.map
+export { NEVER as C, __toESM as D, __commonJSMin as E, _coercedNumber as S, AuthenticationMiddleware as T, looseObject as _, startHTTPServer as a, string as b, LATEST_PROTOCOL_VERSION as c, isJSONRPCResultResponse as d, ZodNumber as f, literal as g, boolean as h, Client as i, isInitializedNotification as l, array as m, serializeMessage as n, proxyServer as o, any as p, Server as r, JSONRPCMessageSchema as s, ReadBuffer as t, isJSONRPCRequest as u, number as v, InMemoryEventStore as w, url as x, object as y };
+//# sourceMappingURL=stdio-_93Y9W6l.mjs.map