@mcp-b/webmcp-ts-sdk 2.0.0 → 2.0.2

package/dist/index.js

@@ -1,88 +1,4733 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { mergeCapabilities, mergeCapabilities as mergeCapabilities$1 } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import { CallToolRequestSchema, CallToolResultSchema, CreateMessageRequestSchema, CreateMessageResultSchema, ElicitRequestSchema, ElicitResultSchema, ErrorCode, GetPromptRequestSchema, GetPromptResultSchema, InitializeRequestSchema, InitializeResultSchema, JSONRPCMessageSchema, LATEST_PROTOCOL_VERSION, ListPromptsRequestSchema, ListPromptsResultSchema, ListResourcesRequestSchema, ListResourcesResultSchema, ListToolsRequestSchema, ListToolsResultSchema, LoggingLevelSchema, ReadResourceRequestSchema, ReadResourceResultSchema, ResourceListChangedNotificationSchema, SUPPORTED_PROTOCOL_VERSIONS, ToolListChangedNotificationSchema } from "@modelcontextprotocol/sdk/types.js";
-import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z3rt from "zod/v3";
+import * as z4mini from "zod/v4-mini";
+import * as z from "zod/v4";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { ZodOptional } from "zod";
+import { isPlainObject, validateArgsWithSchema } from "@mcp-b/webmcp-polyfill";
 
-//#region src/no-op-validator.ts
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
+function isZ4Schema(s) {
+	return !!s._zod;
+}
+function objectFromShape(shape) {
+	const values = Object.values(shape);
+	if (values.length === 0) return z4mini.object({});
+	const allV4 = values.every(isZ4Schema);
+	const allV3 = values.every((s) => !isZ4Schema(s));
+	if (allV4) return z4mini.object(shape);
+	if (allV3) return z3rt.object(shape);
+	throw new Error("Mixed Zod versions detected in object shape.");
+}
+function safeParse(schema, data) {
+	if (isZ4Schema(schema)) return z4mini.safeParse(schema, data);
+	return schema.safeParse(data);
+}
+async function safeParseAsync(schema, data) {
+	if (isZ4Schema(schema)) return await z4mini.safeParseAsync(schema, data);
+	return await schema.safeParseAsync(data);
+}
+function getObjectShape(schema) {
+	if (!schema) return void 0;
+	let rawShape;
+	if (isZ4Schema(schema)) rawShape = schema._zod?.def?.shape;
+	else rawShape = schema.shape;
+	if (!rawShape) return void 0;
+	if (typeof rawShape === "function") try {
+		return rawShape();
+	} catch {
+		return;
+	}
+	return rawShape;
+}
+/**
+* Normalizes a schema to an object schema. Handles both:
+* - Already-constructed object schemas (v3 or v4)
+* - Raw shapes that need to be wrapped into object schemas
+*/
+function normalizeObjectSchema(schema) {
+	if (!schema) return void 0;
+	if (typeof schema === "object") {
+		const asV3 = schema;
+		const asV4 = schema;
+		if (!asV3._def && !asV4._zod) {
+			const values = Object.values(schema);
+			if (values.length > 0 && values.every((v) => typeof v === "object" && v !== null && (v._def !== void 0 || v._zod !== void 0 || typeof v.parse === "function"))) return objectFromShape(schema);
+		}
+	}
+	if (isZ4Schema(schema)) {
+		const def = schema._zod?.def;
+		if (def && (def.type === "object" || def.shape !== void 0)) return schema;
+	} else if (schema.shape !== void 0) return schema;
+}
+/**
+* Safely extracts an error message from a parse result error.
+* Zod errors can have different structures, so we handle various cases.
+*/
+function getParseErrorMessage(error) {
+	if (error && typeof error === "object") {
+		if ("message" in error && typeof error.message === "string") return error.message;
+		if ("issues" in error && Array.isArray(error.issues) && error.issues.length > 0) {
+			const firstIssue = error.issues[0];
+			if (firstIssue && typeof firstIssue === "object" && "message" in firstIssue) return String(firstIssue.message);
+		}
+		try {
+			return JSON.stringify(error);
+		} catch {
+			return String(error);
+		}
+	}
+	return String(error);
+}
+/**
+* Gets the description from a schema, if available.
+* Works with both Zod v3 and v4.
+*
+* Both versions expose a `.description` getter that returns the description
+* from their respective internal storage (v3: _def, v4: globalRegistry).
+*/
+function getSchemaDescription(schema) {
+	return schema.description;
+}
+/**
+* Checks if a schema is optional.
+* Works with both Zod v3 and v4.
+*/
+function isSchemaOptional(schema) {
+	if (isZ4Schema(schema)) return schema._zod?.def?.type === "optional";
+	const v3Schema = schema;
+	if (typeof schema.isOptional === "function") return schema.isOptional();
+	return v3Schema._def?.typeName === "ZodOptional";
+}
+/**
+* Gets the literal value from a schema, if it's a literal schema.
+* Works with both Zod v3 and v4.
+* Returns undefined if the schema is not a literal or the value cannot be determined.
+*/
+function getLiteralValue(schema) {
+	if (isZ4Schema(schema)) {
+		const def$1 = schema._zod?.def;
+		if (def$1) {
+			if (def$1.value !== void 0) return def$1.value;
+			if (Array.isArray(def$1.values) && def$1.values.length > 0) return def$1.values[0];
+		}
+	}
+	const def = schema._def;
+	if (def) {
+		if (def.value !== void 0) return def.value;
+		if (Array.isArray(def.values) && def.values.length > 0) return def.values[0];
+	}
+	const directValue = schema.value;
+	if (directValue !== void 0) return directValue;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
+const LATEST_PROTOCOL_VERSION = "2025-11-25";
+const SUPPORTED_PROTOCOL_VERSIONS = [
+	LATEST_PROTOCOL_VERSION,
+	"2025-06-18",
+	"2025-03-26",
+	"2024-11-05",
+	"2024-10-07"
+];
+const RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
+const JSONRPC_VERSION = "2.0";
+/**
+* Assert 'object' type schema.
+*
+* @internal
+*/
+const AssertObjectSchema = z.custom((v) => v !== null && (typeof v === "object" || typeof v === "function"));
+/**
+* A progress token, used to associate progress notifications with the original request.
+*/
+const ProgressTokenSchema = z.union([z.string(), z.number().int()]);
+/**
+* An opaque token used to represent a cursor for pagination.
+*/
+const CursorSchema = z.string();
+/**
+* Task creation parameters, used to ask that the server create a task to represent a request.
+*/
+const TaskCreationParamsSchema = z.looseObject({
+	ttl: z.union([z.number(), z.null()]).optional(),
+	pollInterval: z.number().optional()
+});
+const TaskMetadataSchema = z.object({ ttl: z.number().optional() });
+/**
+* Metadata for associating messages with a task.
+* Include this in the `_meta` field under the key `io.modelcontextprotocol/related-task`.
+*/
+const RelatedTaskMetadataSchema = z.object({ taskId: z.string() });
+const RequestMetaSchema = z.looseObject({
+	progressToken: ProgressTokenSchema.optional(),
+	[RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
+});
+/**
+* Common params for any request.
+*/
+const BaseRequestParamsSchema = z.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 = z.object({
+	method: z.string(),
+	params: BaseRequestParamsSchema.loose().optional()
+});
+const NotificationsParamsSchema = z.object({ _meta: RequestMetaSchema.optional() });
+const NotificationSchema = z.object({
+	method: z.string(),
+	params: NotificationsParamsSchema.loose().optional()
+});
+const ResultSchema = z.looseObject({ _meta: RequestMetaSchema.optional() });
+/**
+* A uniquely identifying ID for a request in JSON-RPC.
+*/
+const RequestIdSchema = z.union([z.string(), z.number().int()]);
+/**
+* A request that expects a response.
+*/
+const JSONRPCRequestSchema = z.object({
+	jsonrpc: z.literal(JSONRPC_VERSION),
+	id: RequestIdSchema,
+	...RequestSchema.shape
+}).strict();
+const isJSONRPCRequest = (value) => JSONRPCRequestSchema.safeParse(value).success;
+/**
+* A notification which does not expect a response.
+*/
+const JSONRPCNotificationSchema = z.object({
+	jsonrpc: z.literal(JSONRPC_VERSION),
+	...NotificationSchema.shape
+}).strict();
+const isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value).success;
+/**
+* A successful (non-error) response to a request.
+*/
+const JSONRPCResultResponseSchema = z.object({
+	jsonrpc: z.literal(JSONRPC_VERSION),
+	id: RequestIdSchema,
+	result: ResultSchema
+}).strict();
+/**
+* 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.
+*/
+var ErrorCode;
+(function(ErrorCode$1) {
+	ErrorCode$1[ErrorCode$1["ConnectionClosed"] = -32e3] = "ConnectionClosed";
+	ErrorCode$1[ErrorCode$1["RequestTimeout"] = -32001] = "RequestTimeout";
+	ErrorCode$1[ErrorCode$1["ParseError"] = -32700] = "ParseError";
+	ErrorCode$1[ErrorCode$1["InvalidRequest"] = -32600] = "InvalidRequest";
+	ErrorCode$1[ErrorCode$1["MethodNotFound"] = -32601] = "MethodNotFound";
+	ErrorCode$1[ErrorCode$1["InvalidParams"] = -32602] = "InvalidParams";
+	ErrorCode$1[ErrorCode$1["InternalError"] = -32603] = "InternalError";
+	ErrorCode$1[ErrorCode$1["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired";
+})(ErrorCode || (ErrorCode = {}));
+/**
+* A response to a request that indicates an error occurred.
+*/
+const JSONRPCErrorResponseSchema = z.object({
+	jsonrpc: z.literal(JSONRPC_VERSION),
+	id: RequestIdSchema.optional(),
+	error: z.object({
+		code: z.number().int(),
+		message: z.string(),
+		data: z.unknown().optional()
+	})
+}).strict();
+/**
+* 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 = z.union([
+	JSONRPCRequestSchema,
+	JSONRPCNotificationSchema,
+	JSONRPCResultResponseSchema,
+	JSONRPCErrorResponseSchema
+]);
+const JSONRPCResponseSchema = z.union([JSONRPCResultResponseSchema, JSONRPCErrorResponseSchema]);
+/**
+* A response that indicates success but carries no data.
+*/
+const EmptyResultSchema = ResultSchema.strict();
+const CancelledNotificationParamsSchema = NotificationsParamsSchema.extend({
+	requestId: RequestIdSchema.optional(),
+	reason: z.string().optional()
+});
+/**
+* This notification can be sent by either side to indicate that it is cancelling a previously-issued request.
+*
+* The request SHOULD still be in-flight, but due to communication latency, it is always possible that this notification MAY arrive after the request has already finished.
+*
+* This notification indicates that the result will be unused, so any associated processing SHOULD cease.
+*
+* A client MUST NOT attempt to cancel its `initialize` request.
+*/
+const CancelledNotificationSchema = NotificationSchema.extend({
+	method: z.literal("notifications/cancelled"),
+	params: CancelledNotificationParamsSchema
+});
+/**
+* Icon schema for use in tools, prompts, resources, and implementations.
+*/
+const IconSchema = z.object({
+	src: z.string(),
+	mimeType: z.string().optional(),
+	sizes: z.array(z.string()).optional(),
+	theme: z.enum(["light", "dark"]).optional()
+});
+/**
+* Base schema to add `icons` property.
+*
+*/
+const IconsSchema = z.object({ icons: z.array(IconSchema).optional() });
+/**
+* Base metadata interface for common properties across resources, tools, prompts, and implementations.
+*/
+const BaseMetadataSchema = z.object({
+	name: z.string(),
+	title: z.string().optional()
+});
+/**
+* Describes the name and version of an MCP implementation.
+*/
+const ImplementationSchema = BaseMetadataSchema.extend({
+	...BaseMetadataSchema.shape,
+	...IconsSchema.shape,
+	version: z.string(),
+	websiteUrl: z.string().optional(),
+	description: z.string().optional()
+});
+const FormElicitationCapabilitySchema = z.intersection(z.object({ applyDefaults: z.boolean().optional() }), z.record(z.string(), z.unknown()));
+const ElicitationCapabilitySchema = z.preprocess((value) => {
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		if (Object.keys(value).length === 0) return { form: {} };
+	}
+	return value;
+}, z.intersection(z.object({
+	form: FormElicitationCapabilitySchema.optional(),
+	url: AssertObjectSchema.optional()
+}), z.record(z.string(), z.unknown()).optional()));
+/**
+* Task capabilities for clients, indicating which request types support task creation.
+*/
+const ClientTasksCapabilitySchema = z.looseObject({
+	list: AssertObjectSchema.optional(),
+	cancel: AssertObjectSchema.optional(),
+	requests: z.looseObject({
+		sampling: z.looseObject({ createMessage: AssertObjectSchema.optional() }).optional(),
+		elicitation: z.looseObject({ create: AssertObjectSchema.optional() }).optional()
+	}).optional()
+});
+/**
+* Task capabilities for servers, indicating which request types support task creation.
+*/
+const ServerTasksCapabilitySchema = z.looseObject({
+	list: AssertObjectSchema.optional(),
+	cancel: AssertObjectSchema.optional(),
+	requests: z.looseObject({ tools: z.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.
+*/
+const ClientCapabilitiesSchema = z.object({
+	experimental: z.record(z.string(), AssertObjectSchema).optional(),
+	sampling: z.object({
+		context: AssertObjectSchema.optional(),
+		tools: AssertObjectSchema.optional()
+	}).optional(),
+	elicitation: ElicitationCapabilitySchema.optional(),
+	roots: z.object({ listChanged: z.boolean().optional() }).optional(),
+	tasks: ClientTasksCapabilitySchema.optional()
+});
+const InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
+	protocolVersion: z.string(),
+	capabilities: ClientCapabilitiesSchema,
+	clientInfo: ImplementationSchema
+});
+/**
+* This request is sent from the client to the server when it first connects, asking it to begin initialization.
+*/
+const InitializeRequestSchema = RequestSchema.extend({
+	method: z.literal("initialize"),
+	params: InitializeRequestParamsSchema
+});
+/**
+* Capabilities that a server may support. Known capabilities are defined here, in this schema, but this is not a closed set: any server can define its own, additional capabilities.
+*/
+const ServerCapabilitiesSchema = z.object({
+	experimental: z.record(z.string(), AssertObjectSchema).optional(),
+	logging: AssertObjectSchema.optional(),
+	completions: AssertObjectSchema.optional(),
+	prompts: z.object({ listChanged: z.boolean().optional() }).optional(),
+	resources: z.object({
+		subscribe: z.boolean().optional(),
+		listChanged: z.boolean().optional()
+	}).optional(),
+	tools: z.object({ listChanged: z.boolean().optional() }).optional(),
+	tasks: ServerTasksCapabilitySchema.optional()
+});
+/**
+* After receiving an initialize request from the client, the server sends this response.
+*/
+const InitializeResultSchema = ResultSchema.extend({
+	protocolVersion: z.string(),
+	capabilities: ServerCapabilitiesSchema,
+	serverInfo: ImplementationSchema,
+	instructions: z.string().optional()
+});
+/**
+* This notification is sent from the client to the server after initialization has finished.
+*/
+const InitializedNotificationSchema = NotificationSchema.extend({
+	method: z.literal("notifications/initialized"),
+	params: NotificationsParamsSchema.optional()
+});
+/**
+* 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: z.literal("ping"),
+	params: BaseRequestParamsSchema.optional()
+});
+const ProgressSchema = z.object({
+	progress: z.number(),
+	total: z.optional(z.number()),
+	message: z.optional(z.string())
+});
+const ProgressNotificationParamsSchema = z.object({
+	...NotificationsParamsSchema.shape,
+	...ProgressSchema.shape,
+	progressToken: ProgressTokenSchema
+});
+/**
+* An out-of-band notification used to inform the receiver of a progress update for a long-running request.
+*
+* @category notifications/progress
+*/
+const ProgressNotificationSchema = NotificationSchema.extend({
+	method: z.literal("notifications/progress"),
+	params: ProgressNotificationParamsSchema
+});
+const PaginatedRequestParamsSchema = BaseRequestParamsSchema.extend({ cursor: CursorSchema.optional() });
+const PaginatedRequestSchema = RequestSchema.extend({ params: PaginatedRequestParamsSchema.optional() });
+const PaginatedResultSchema = ResultSchema.extend({ nextCursor: CursorSchema.optional() });
+/**
+* The status of a task.
+* */
+const TaskStatusSchema = z.enum([
+	"working",
+	"input_required",
+	"completed",
+	"failed",
+	"cancelled"
+]);
+/**
+* A pollable state object associated with a request.
+*/
+const TaskSchema = z.object({
+	taskId: z.string(),
+	status: TaskStatusSchema,
+	ttl: z.union([z.number(), z.null()]),
+	createdAt: z.string(),
+	lastUpdatedAt: z.string(),
+	pollInterval: z.optional(z.number()),
+	statusMessage: z.optional(z.string())
+});
+/**
+* Result returned when a task is created, containing the task data wrapped in a task field.
+*/
+const CreateTaskResultSchema = ResultSchema.extend({ task: TaskSchema });
+/**
+* Parameters for task status notification.
+*/
+const TaskStatusNotificationParamsSchema = NotificationsParamsSchema.merge(TaskSchema);
+/**
+* A notification sent when a task's status changes.
+*/
+const TaskStatusNotificationSchema = NotificationSchema.extend({
+	method: z.literal("notifications/tasks/status"),
+	params: TaskStatusNotificationParamsSchema
+});
+/**
+* A request to get the state of a specific task.
+*/
+const GetTaskRequestSchema = RequestSchema.extend({
+	method: z.literal("tasks/get"),
+	params: BaseRequestParamsSchema.extend({ taskId: z.string() })
+});
+/**
+* The response to a tasks/get request.
+*/
+const GetTaskResultSchema = ResultSchema.merge(TaskSchema);
+/**
+* A request to get the result of a specific task.
+*/
+const GetTaskPayloadRequestSchema = RequestSchema.extend({
+	method: z.literal("tasks/result"),
+	params: BaseRequestParamsSchema.extend({ taskId: z.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: z.literal("tasks/list") });
+/**
+* The response to a tasks/list request.
+*/
+const ListTasksResultSchema = PaginatedResultSchema.extend({ tasks: z.array(TaskSchema) });
+/**
+* A request to cancel a specific task.
+*/
+const CancelTaskRequestSchema = RequestSchema.extend({
+	method: z.literal("tasks/cancel"),
+	params: BaseRequestParamsSchema.extend({ taskId: z.string() })
+});
+/**
+* The response to a tasks/cancel request.
+*/
+const CancelTaskResultSchema = ResultSchema.merge(TaskSchema);
+/**
+* The contents of a specific resource or sub-resource.
+*/
+const ResourceContentsSchema = z.object({
+	uri: z.string(),
+	mimeType: z.optional(z.string()),
+	_meta: z.record(z.string(), z.unknown()).optional()
+});
+const TextResourceContentsSchema = ResourceContentsSchema.extend({ text: z.string() });
+/**
+* A Zod schema for validating Base64 strings that is more performant and
+* robust for very large inputs than the default regex-based check. It avoids
+* stack overflows by using the native `atob` function for validation.
+*/
+const Base64Schema = z.string().refine((val) => {
+	try {
+		atob(val);
+		return true;
+	} 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 = z.enum(["user", "assistant"]);
+/**
+* Optional annotations providing clients additional context about a resource.
+*/
+const AnnotationsSchema = z.object({
+	audience: z.array(RoleSchema).optional(),
+	priority: z.number().min(0).max(1).optional(),
+	lastModified: z.iso.datetime({ offset: true }).optional()
+});
+/**
+* A known resource that the server is capable of reading.
+*/
+const ResourceSchema = z.object({
+	...BaseMetadataSchema.shape,
+	...IconsSchema.shape,
+	uri: z.string(),
+	description: z.optional(z.string()),
+	mimeType: z.optional(z.string()),
+	annotations: AnnotationsSchema.optional(),
+	_meta: z.optional(z.looseObject({}))
+});
+/**
+* A template description for resources available on the server.
+*/
+const ResourceTemplateSchema = z.object({
+	...BaseMetadataSchema.shape,
+	...IconsSchema.shape,
+	uriTemplate: z.string(),
+	description: z.optional(z.string()),
+	mimeType: z.optional(z.string()),
+	annotations: AnnotationsSchema.optional(),
+	_meta: z.optional(z.looseObject({}))
+});
+/**
+* Sent from the client to request a list of resources the server has.
+*/
+const ListResourcesRequestSchema = PaginatedRequestSchema.extend({ method: z.literal("resources/list") });
+/**
+* The server's response to a resources/list request from the client.
+*/
+const ListResourcesResultSchema = PaginatedResultSchema.extend({ resources: z.array(ResourceSchema) });
+/**
+* Sent from the client to request a list of resource templates the server has.
+*/
+const ListResourceTemplatesRequestSchema = PaginatedRequestSchema.extend({ method: z.literal("resources/templates/list") });
+/**
+* The server's response to a resources/templates/list request from the client.
+*/
+const ListResourceTemplatesResultSchema = PaginatedResultSchema.extend({ resourceTemplates: z.array(ResourceTemplateSchema) });
+const ResourceRequestParamsSchema = BaseRequestParamsSchema.extend({ uri: z.string() });
+/**
+* Parameters for a `resources/read` request.
+*/
+const ReadResourceRequestParamsSchema = ResourceRequestParamsSchema;
+/**
+* Sent from the client to the server, to read a specific resource URI.
+*/
+const ReadResourceRequestSchema = RequestSchema.extend({
+	method: z.literal("resources/read"),
+	params: ReadResourceRequestParamsSchema
+});
+/**
+* The server's response to a resources/read request from the client.
+*/
+const ReadResourceResultSchema = ResultSchema.extend({ contents: z.array(z.union([TextResourceContentsSchema, BlobResourceContentsSchema])) });
+/**
+* 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: z.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.
+*/
+const SubscribeRequestSchema = RequestSchema.extend({
+	method: z.literal("resources/subscribe"),
+	params: SubscribeRequestParamsSchema
+});
+const UnsubscribeRequestParamsSchema = ResourceRequestParamsSchema;
+/**
+* Sent from the client to request cancellation of resources/updated notifications from the server. This should follow a previous resources/subscribe request.
+*/
+const UnsubscribeRequestSchema = RequestSchema.extend({
+	method: z.literal("resources/unsubscribe"),
+	params: UnsubscribeRequestParamsSchema
+});
+/**
+* Parameters for a `notifications/resources/updated` notification.
+*/
+const ResourceUpdatedNotificationParamsSchema = NotificationsParamsSchema.extend({ uri: z.string() });
+/**
+* A notification from the server to the client, informing it that a resource has changed and may need to be read again. This should only be sent if the client previously sent a resources/subscribe request.
+*/
+const ResourceUpdatedNotificationSchema = NotificationSchema.extend({
+	method: z.literal("notifications/resources/updated"),
+	params: ResourceUpdatedNotificationParamsSchema
+});
+/**
+* Describes an argument that a prompt can accept.
+*/
+const PromptArgumentSchema = z.object({
+	name: z.string(),
+	description: z.optional(z.string()),
+	required: z.optional(z.boolean())
+});
+/**
+* A prompt or prompt template that the server offers.
+*/
+const PromptSchema = z.object({
+	...BaseMetadataSchema.shape,
+	...IconsSchema.shape,
+	description: z.optional(z.string()),
+	arguments: z.optional(z.array(PromptArgumentSchema)),
+	_meta: z.optional(z.looseObject({}))
+});
+/**
+* Sent from the client to request a list of prompts and prompt templates the server has.
+*/
+const ListPromptsRequestSchema = PaginatedRequestSchema.extend({ method: z.literal("prompts/list") });
+/**
+* The server's response to a prompts/list request from the client.
+*/
+const ListPromptsResultSchema = PaginatedResultSchema.extend({ prompts: z.array(PromptSchema) });
+/**
+* Parameters for a `prompts/get` request.
+*/
+const GetPromptRequestParamsSchema = BaseRequestParamsSchema.extend({
+	name: z.string(),
+	arguments: z.record(z.string(), z.string()).optional()
+});
+/**
+* Used by the client to get a prompt provided by the server.
+*/
+const GetPromptRequestSchema = RequestSchema.extend({
+	method: z.literal("prompts/get"),
+	params: GetPromptRequestParamsSchema
+});
+/**
+* Text provided to or from an LLM.
+*/
+const TextContentSchema = z.object({
+	type: z.literal("text"),
+	text: z.string(),
+	annotations: AnnotationsSchema.optional(),
+	_meta: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* An image provided to or from an LLM.
+*/
+const ImageContentSchema = z.object({
+	type: z.literal("image"),
+	data: Base64Schema,
+	mimeType: z.string(),
+	annotations: AnnotationsSchema.optional(),
+	_meta: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* An Audio provided to or from an LLM.
+*/
+const AudioContentSchema = z.object({
+	type: z.literal("audio"),
+	data: Base64Schema,
+	mimeType: z.string(),
+	annotations: AnnotationsSchema.optional(),
+	_meta: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* A tool call request from an assistant (LLM).
+* Represents the assistant's request to use a tool.
+*/
+const ToolUseContentSchema = z.object({
+	type: z.literal("tool_use"),
+	name: z.string(),
+	id: z.string(),
+	input: z.record(z.string(), z.unknown()),
+	_meta: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* The contents of a resource, embedded into a prompt or tool call result.
+*/
+const EmbeddedResourceSchema = z.object({
+	type: z.literal("resource"),
+	resource: z.union([TextResourceContentsSchema, BlobResourceContentsSchema]),
+	annotations: AnnotationsSchema.optional(),
+	_meta: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* A resource that the server is capable of reading, included in a prompt or tool call result.
+*
+* Note: resource links returned by tools are not guaranteed to appear in the results of `resources/list` requests.
+*/
+const ResourceLinkSchema = ResourceSchema.extend({ type: z.literal("resource_link") });
+/**
+* A content block that can be used in prompts and tool results.
+*/
+const ContentBlockSchema = z.union([
+	TextContentSchema,
+	ImageContentSchema,
+	AudioContentSchema,
+	ResourceLinkSchema,
+	EmbeddedResourceSchema
+]);
+/**
+* Describes a message returned as part of a prompt.
+*/
+const PromptMessageSchema = z.object({
+	role: RoleSchema,
+	content: ContentBlockSchema
+});
+/**
+* The server's response to a prompts/get request from the client.
+*/
+const GetPromptResultSchema = ResultSchema.extend({
+	description: z.string().optional(),
+	messages: z.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: z.literal("notifications/prompts/list_changed"),
+	params: NotificationsParamsSchema.optional()
+});
+/**
+* Additional properties describing a Tool to clients.
+*
+* NOTE: all properties in ToolAnnotations are **hints**.
+* They are not guaranteed to provide a faithful description of
+* tool behavior (including descriptive properties like `title`).
+*
+* Clients should never make tool use decisions based on ToolAnnotations
+* received from untrusted servers.
+*/
+const ToolAnnotationsSchema = z.object({
+	title: z.string().optional(),
+	readOnlyHint: z.boolean().optional(),
+	destructiveHint: z.boolean().optional(),
+	idempotentHint: z.boolean().optional(),
+	openWorldHint: z.boolean().optional()
+});
+/**
+* Execution-related properties for a tool.
+*/
+const ToolExecutionSchema = z.object({ taskSupport: z.enum([
+	"required",
+	"optional",
+	"forbidden"
+]).optional() });
+/**
+* Definition for a tool the client can call.
+*/
+const ToolSchema = z.object({
+	...BaseMetadataSchema.shape,
+	...IconsSchema.shape,
+	description: z.string().optional(),
+	inputSchema: z.object({
+		type: z.literal("object"),
+		properties: z.record(z.string(), AssertObjectSchema).optional(),
+		required: z.array(z.string()).optional()
+	}).catchall(z.unknown()),
+	outputSchema: z.object({
+		type: z.literal("object"),
+		properties: z.record(z.string(), AssertObjectSchema).optional(),
+		required: z.array(z.string()).optional()
+	}).catchall(z.unknown()).optional(),
+	annotations: ToolAnnotationsSchema.optional(),
+	execution: ToolExecutionSchema.optional(),
+	_meta: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* Sent from the client to request a list of tools the server has.
+*/
+const ListToolsRequestSchema = PaginatedRequestSchema.extend({ method: z.literal("tools/list") });
+/**
+* The server's response to a tools/list request from the client.
+*/
+const ListToolsResultSchema = PaginatedResultSchema.extend({ tools: z.array(ToolSchema) });
+/**
+* The server's response to a tool call.
+*/
+const CallToolResultSchema = ResultSchema.extend({
+	content: z.array(ContentBlockSchema).default([]),
+	structuredContent: z.record(z.string(), z.unknown()).optional(),
+	isError: z.boolean().optional()
+});
+/**
+* CallToolResultSchema extended with backwards compatibility to protocol version 2024-10-07.
+*/
+const CompatibilityCallToolResultSchema = CallToolResultSchema.or(ResultSchema.extend({ toolResult: z.unknown() }));
+/**
+* Parameters for a `tools/call` request.
+*/
+const CallToolRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
+	name: z.string(),
+	arguments: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* Used by the client to invoke a tool provided by the server.
+*/
+const CallToolRequestSchema = RequestSchema.extend({
+	method: z.literal("tools/call"),
+	params: CallToolRequestParamsSchema
+});
+/**
+* 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: z.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 = z.object({
+	autoRefresh: z.boolean().default(true),
+	debounceMs: z.number().int().nonnegative().default(300)
+});
+/**
+* The severity of a log message.
+*/
+const LoggingLevelSchema = z.enum([
+	"debug",
+	"info",
+	"notice",
+	"warning",
+	"error",
+	"critical",
+	"alert",
+	"emergency"
+]);
+/**
+* Parameters for a `logging/setLevel` request.
+*/
+const SetLevelRequestParamsSchema = BaseRequestParamsSchema.extend({ level: LoggingLevelSchema });
+/**
+* A request from the client to the server, to enable or adjust logging.
+*/
+const SetLevelRequestSchema = RequestSchema.extend({
+	method: z.literal("logging/setLevel"),
+	params: SetLevelRequestParamsSchema
+});
+/**
+* Parameters for a `notifications/message` notification.
+*/
+const LoggingMessageNotificationParamsSchema = NotificationsParamsSchema.extend({
+	level: LoggingLevelSchema,
+	logger: z.string().optional(),
+	data: z.unknown()
+});
+/**
+* Notification of a log message passed from server to client. If no logging/setLevel request has been sent from the client, the server MAY decide which messages to send automatically.
+*/
+const LoggingMessageNotificationSchema = NotificationSchema.extend({
+	method: z.literal("notifications/message"),
+	params: LoggingMessageNotificationParamsSchema
+});
+/**
+* Hints to use for model selection.
+*/
+const ModelHintSchema = z.object({ name: z.string().optional() });
+/**
+* The server's preferences for model selection, requested of the client during sampling.
+*/
+const ModelPreferencesSchema = z.object({
+	hints: z.array(ModelHintSchema).optional(),
+	costPriority: z.number().min(0).max(1).optional(),
+	speedPriority: z.number().min(0).max(1).optional(),
+	intelligencePriority: z.number().min(0).max(1).optional()
+});
+/**
+* Controls tool usage behavior in sampling requests.
+*/
+const ToolChoiceSchema = z.object({ mode: z.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.
+*/
+const ToolResultContentSchema = z.object({
+	type: z.literal("tool_result"),
+	toolUseId: z.string().describe("The unique identifier for the corresponding tool call."),
+	content: z.array(ContentBlockSchema).default([]),
+	structuredContent: z.object({}).loose().optional(),
+	isError: z.boolean().optional(),
+	_meta: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* Basic content types for sampling responses (without tool use).
+* Used for backwards-compatible CreateMessageResult when tools are not used.
+*/
+const SamplingContentSchema = z.discriminatedUnion("type", [
+	TextContentSchema,
+	ImageContentSchema,
+	AudioContentSchema
+]);
+/**
+* Content block types allowed in sampling messages.
+* This includes text, image, audio, tool use requests, and tool results.
+*/
+const SamplingMessageContentBlockSchema = z.discriminatedUnion("type", [
+	TextContentSchema,
+	ImageContentSchema,
+	AudioContentSchema,
+	ToolUseContentSchema,
+	ToolResultContentSchema
+]);
+/**
+* Describes a message issued to or received from an LLM API.
+*/
+const SamplingMessageSchema = z.object({
+	role: RoleSchema,
+	content: z.union([SamplingMessageContentBlockSchema, z.array(SamplingMessageContentBlockSchema)]),
+	_meta: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* Parameters for a `sampling/createMessage` request.
+*/
+const CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
+	messages: z.array(SamplingMessageSchema),
+	modelPreferences: ModelPreferencesSchema.optional(),
+	systemPrompt: z.string().optional(),
+	includeContext: z.enum([
+		"none",
+		"thisServer",
+		"allServers"
+	]).optional(),
+	temperature: z.number().optional(),
+	maxTokens: z.number().int(),
+	stopSequences: z.array(z.string()).optional(),
+	metadata: AssertObjectSchema.optional(),
+	tools: z.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.
+*/
+const CreateMessageRequestSchema = RequestSchema.extend({
+	method: z.literal("sampling/createMessage"),
+	params: CreateMessageRequestParamsSchema
+});
+/**
+* The client's response to a sampling/create_message request from the server.
+* This is the backwards-compatible version that returns single content (no arrays).
+* Used when the request does not include tools.
+*/
+const CreateMessageResultSchema = ResultSchema.extend({
+	model: z.string(),
+	stopReason: z.optional(z.enum([
+		"endTurn",
+		"stopSequence",
+		"maxTokens"
+	]).or(z.string())),
+	role: RoleSchema,
+	content: SamplingContentSchema
+});
+/**
+* The client's response to a sampling/create_message request when tools were provided.
+* This version supports array content for tool use flows.
+*/
+const CreateMessageResultWithToolsSchema = ResultSchema.extend({
+	model: z.string(),
+	stopReason: z.optional(z.enum([
+		"endTurn",
+		"stopSequence",
+		"maxTokens",
+		"toolUse"
+	]).or(z.string())),
+	role: RoleSchema,
+	content: z.union([SamplingMessageContentBlockSchema, z.array(SamplingMessageContentBlockSchema)])
+});
+/**
+* Primitive schema definition for boolean fields.
+*/
+const BooleanSchemaSchema = z.object({
+	type: z.literal("boolean"),
+	title: z.string().optional(),
+	description: z.string().optional(),
+	default: z.boolean().optional()
+});
+/**
+* Primitive schema definition for string fields.
+*/
+const StringSchemaSchema = z.object({
+	type: z.literal("string"),
+	title: z.string().optional(),
+	description: z.string().optional(),
+	minLength: z.number().optional(),
+	maxLength: z.number().optional(),
+	format: z.enum([
+		"email",
+		"uri",
+		"date",
+		"date-time"
+	]).optional(),
+	default: z.string().optional()
+});
+/**
+* Primitive schema definition for number fields.
+*/
+const NumberSchemaSchema = z.object({
+	type: z.enum(["number", "integer"]),
+	title: z.string().optional(),
+	description: z.string().optional(),
+	minimum: z.number().optional(),
+	maximum: z.number().optional(),
+	default: z.number().optional()
+});
+/**
+* Schema for single-selection enumeration without display titles for options.
+*/
+const UntitledSingleSelectEnumSchemaSchema = z.object({
+	type: z.literal("string"),
+	title: z.string().optional(),
+	description: z.string().optional(),
+	enum: z.array(z.string()),
+	default: z.string().optional()
+});
+/**
+* Schema for single-selection enumeration with display titles for each option.
+*/
+const TitledSingleSelectEnumSchemaSchema = z.object({
+	type: z.literal("string"),
+	title: z.string().optional(),
+	description: z.string().optional(),
+	oneOf: z.array(z.object({
+		const: z.string(),
+		title: z.string()
+	})),
+	default: z.string().optional()
+});
+/**
+* Use TitledSingleSelectEnumSchema instead.
+* This interface will be removed in a future version.
+*/
+const LegacyTitledEnumSchemaSchema = z.object({
+	type: z.literal("string"),
+	title: z.string().optional(),
+	description: z.string().optional(),
+	enum: z.array(z.string()),
+	enumNames: z.array(z.string()).optional(),
+	default: z.string().optional()
+});
+const SingleSelectEnumSchemaSchema = z.union([UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema]);
+/**
+* Schema for multiple-selection enumeration without display titles for options.
+*/
+const UntitledMultiSelectEnumSchemaSchema = z.object({
+	type: z.literal("array"),
+	title: z.string().optional(),
+	description: z.string().optional(),
+	minItems: z.number().optional(),
+	maxItems: z.number().optional(),
+	items: z.object({
+		type: z.literal("string"),
+		enum: z.array(z.string())
+	}),
+	default: z.array(z.string()).optional()
+});
+/**
+* Schema for multiple-selection enumeration with display titles for each option.
+*/
+const TitledMultiSelectEnumSchemaSchema = z.object({
+	type: z.literal("array"),
+	title: z.string().optional(),
+	description: z.string().optional(),
+	minItems: z.number().optional(),
+	maxItems: z.number().optional(),
+	items: z.object({ anyOf: z.array(z.object({
+		const: z.string(),
+		title: z.string()
+	})) }),
+	default: z.array(z.string()).optional()
+});
+/**
+* Combined schema for multiple-selection enumeration
+*/
+const MultiSelectEnumSchemaSchema = z.union([UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema]);
+/**
+* Primitive schema definition for enum fields.
+*/
+const EnumSchemaSchema = z.union([
+	LegacyTitledEnumSchemaSchema,
+	SingleSelectEnumSchemaSchema,
+	MultiSelectEnumSchemaSchema
+]);
+/**
+* Union of all primitive schema definitions.
+*/
+const PrimitiveSchemaDefinitionSchema = z.union([
+	EnumSchemaSchema,
+	BooleanSchemaSchema,
+	StringSchemaSchema,
+	NumberSchemaSchema
+]);
+/**
+* Parameters for an `elicitation/create` request for form-based elicitation.
+*/
+const ElicitRequestFormParamsSchema = TaskAugmentedRequestParamsSchema.extend({
+	mode: z.literal("form").optional(),
+	message: z.string(),
+	requestedSchema: z.object({
+		type: z.literal("object"),
+		properties: z.record(z.string(), PrimitiveSchemaDefinitionSchema),
+		required: z.array(z.string()).optional()
+	})
+});
+/**
+* Parameters for an `elicitation/create` request for URL-based elicitation.
+*/
+const ElicitRequestURLParamsSchema = TaskAugmentedRequestParamsSchema.extend({
+	mode: z.literal("url"),
+	message: z.string(),
+	elicitationId: z.string(),
+	url: z.string().url()
+});
+/**
+* The parameters for a request to elicit additional information from the user via the client.
+*/
+const ElicitRequestParamsSchema = z.union([ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema]);
+/**
+* A request from the server to elicit user input via the client.
+* The client should present the message and form fields to the user (form mode)
+* or navigate to a URL (URL mode).
+*/
+const ElicitRequestSchema = RequestSchema.extend({
+	method: z.literal("elicitation/create"),
+	params: ElicitRequestParamsSchema
+});
+/**
+* Parameters for a `notifications/elicitation/complete` notification.
+*
+* @category notifications/elicitation/complete
+*/
+const ElicitationCompleteNotificationParamsSchema = NotificationsParamsSchema.extend({ elicitationId: z.string() });
+/**
+* A notification from the server to the client, informing it of a completion of an out-of-band elicitation request.
+*
+* @category notifications/elicitation/complete
+*/
+const ElicitationCompleteNotificationSchema = NotificationSchema.extend({
+	method: z.literal("notifications/elicitation/complete"),
+	params: ElicitationCompleteNotificationParamsSchema
+});
+/**
+* The client's response to an elicitation/create request from the server.
+*/
+const ElicitResultSchema = ResultSchema.extend({
+	action: z.enum([
+		"accept",
+		"decline",
+		"cancel"
+	]),
+	content: z.preprocess((val) => val === null ? void 0 : val, z.record(z.string(), z.union([
+		z.string(),
+		z.number(),
+		z.boolean(),
+		z.array(z.string())
+	])).optional())
+});
+/**
+* A reference to a resource or resource template definition.
+*/
+const ResourceTemplateReferenceSchema = z.object({
+	type: z.literal("ref/resource"),
+	uri: z.string()
+});
+/**
+* Identifies a prompt.
+*/
+const PromptReferenceSchema = z.object({
+	type: z.literal("ref/prompt"),
+	name: z.string()
+});
+/**
+* Parameters for a `completion/complete` request.
+*/
+const CompleteRequestParamsSchema = BaseRequestParamsSchema.extend({
+	ref: z.union([PromptReferenceSchema, ResourceTemplateReferenceSchema]),
+	argument: z.object({
+		name: z.string(),
+		value: z.string()
+	}),
+	context: z.object({ arguments: z.record(z.string(), z.string()).optional() }).optional()
+});
+/**
+* A request from the client to the server, to ask for completion options.
+*/
+const CompleteRequestSchema = RequestSchema.extend({
+	method: z.literal("completion/complete"),
+	params: CompleteRequestParamsSchema
+});
+function assertCompleteRequestPrompt(request) {
+	if (request.params.ref.type !== "ref/prompt") throw new TypeError(`Expected CompleteRequestPrompt, but got ${request.params.ref.type}`);
+}
+function assertCompleteRequestResourceTemplate(request) {
+	if (request.params.ref.type !== "ref/resource") throw new TypeError(`Expected CompleteRequestResourceTemplate, but got ${request.params.ref.type}`);
+}
+/**
+* The server's response to a completion/complete request
+*/
+const CompleteResultSchema = ResultSchema.extend({ completion: z.looseObject({
+	values: z.array(z.string()).max(100),
+	total: z.optional(z.number().int()),
+	hasMore: z.optional(z.boolean())
+}) });
+/**
+* Represents a root directory or file that the server can operate on.
+*/
+const RootSchema = z.object({
+	uri: z.string().startsWith("file://"),
+	name: z.string().optional(),
+	_meta: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* Sent from the server to request a list of root URIs from the client.
+*/
+const ListRootsRequestSchema = RequestSchema.extend({
+	method: z.literal("roots/list"),
+	params: BaseRequestParamsSchema.optional()
+});
+/**
+* The client's response to a roots/list request from the server.
+*/
+const ListRootsResultSchema = ResultSchema.extend({ roots: z.array(RootSchema) });
+/**
+* A notification from the client to the server, informing it that the list of roots has changed.
+*/
+const RootsListChangedNotificationSchema = NotificationSchema.extend({
+	method: z.literal("notifications/roots/list_changed"),
+	params: NotificationsParamsSchema.optional()
+});
+const ClientRequestSchema = z.union([
+	PingRequestSchema,
+	InitializeRequestSchema,
+	CompleteRequestSchema,
+	SetLevelRequestSchema,
+	GetPromptRequestSchema,
+	ListPromptsRequestSchema,
+	ListResourcesRequestSchema,
+	ListResourceTemplatesRequestSchema,
+	ReadResourceRequestSchema,
+	SubscribeRequestSchema,
+	UnsubscribeRequestSchema,
+	CallToolRequestSchema,
+	ListToolsRequestSchema,
+	GetTaskRequestSchema,
+	GetTaskPayloadRequestSchema,
+	ListTasksRequestSchema,
+	CancelTaskRequestSchema
+]);
+const ClientNotificationSchema = z.union([
+	CancelledNotificationSchema,
+	ProgressNotificationSchema,
+	InitializedNotificationSchema,
+	RootsListChangedNotificationSchema,
+	TaskStatusNotificationSchema
+]);
+const ClientResultSchema = z.union([
+	EmptyResultSchema,
+	CreateMessageResultSchema,
+	CreateMessageResultWithToolsSchema,
+	ElicitResultSchema,
+	ListRootsResultSchema,
+	GetTaskResultSchema,
+	ListTasksResultSchema,
+	CreateTaskResultSchema
+]);
+const ServerRequestSchema = z.union([
+	PingRequestSchema,
+	CreateMessageRequestSchema,
+	ElicitRequestSchema,
+	ListRootsRequestSchema,
+	GetTaskRequestSchema,
+	GetTaskPayloadRequestSchema,
+	ListTasksRequestSchema,
+	CancelTaskRequestSchema
+]);
+const ServerNotificationSchema = z.union([
+	CancelledNotificationSchema,
+	ProgressNotificationSchema,
+	LoggingMessageNotificationSchema,
+	ResourceUpdatedNotificationSchema,
+	ResourceListChangedNotificationSchema,
+	ToolListChangedNotificationSchema,
+	PromptListChangedNotificationSchema,
+	TaskStatusNotificationSchema,
+	ElicitationCompleteNotificationSchema
+]);
+const ServerResultSchema = z.union([
+	EmptyResultSchema,
+	InitializeResultSchema,
+	CompleteResultSchema,
+	GetPromptResultSchema,
+	ListPromptsResultSchema,
+	ListResourcesResultSchema,
+	ListResourceTemplatesResultSchema,
+	ReadResourceResultSchema,
+	CallToolResultSchema,
+	ListToolsResultSchema,
+	GetTaskResultSchema,
+	ListTasksResultSchema,
+	CreateTaskResultSchema
+]);
+var McpError = class McpError extends Error {
+	constructor(code, message, data) {
+		super(`MCP error ${code}: ${message}`);
+		this.code = code;
+		this.data = data;
+		this.name = "McpError";
+	}
+	/**
+	* Factory method to create the appropriate error type based on the error code and data
+	*/
+	static fromError(code, message, data) {
+		if (code === ErrorCode.UrlElicitationRequired && data) {
+			const errorData = data;
+			if (errorData.elicitations) return new UrlElicitationRequiredError(errorData.elicitations, message);
+		}
+		return new McpError(code, message, data);
+	}
+};
+/**
+* Specialized error type when a tool requires a URL mode elicitation.
+* This makes it nicer for the client to handle since there is specific data to work with instead of just a code to check against.
+*/
+var UrlElicitationRequiredError = class extends McpError {
+	constructor(elicitations, message = `URL elicitation${elicitations.length > 1 ? "s" : ""} required`) {
+		super(ErrorCode.UrlElicitationRequired, message, { elicitations });
+	}
+	get elicitations() {
+		return this.data?.elicitations ?? [];
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
+/**
+* Experimental task interfaces for MCP SDK.
+* WARNING: These APIs are experimental and may change without notice.
+*/
+/**
+* Checks if a task status represents a terminal state.
+* Terminal states are those where the task has finished and will not change.
+*
+* @param status - The task status to check
+* @returns True if the status is terminal (completed, failed, or cancelled)
+* @experimental
+*/
+function isTerminal(status) {
+	return status === "completed" || status === "failed" || status === "cancelled";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
+function mapMiniTarget(t) {
+	if (!t) return "draft-7";
+	if (t === "jsonSchema7" || t === "draft-7") return "draft-7";
+	if (t === "jsonSchema2019-09" || t === "draft-2020-12") return "draft-2020-12";
+	return "draft-7";
+}
+function toJsonSchemaCompat(schema, opts) {
+	if (isZ4Schema(schema)) return z4mini.toJSONSchema(schema, {
+		target: mapMiniTarget(opts?.target),
+		io: opts?.pipeStrategy ?? "input"
+	});
+	return zodToJsonSchema(schema, {
+		strictUnions: opts?.strictUnions ?? true,
+		pipeStrategy: opts?.pipeStrategy ?? "input"
+	});
+}
+function getMethodLiteral(schema) {
+	const methodSchema = getObjectShape(schema)?.method;
+	if (!methodSchema) throw new Error("Schema is missing a method literal");
+	const value = getLiteralValue(methodSchema);
+	if (typeof value !== "string") throw new Error("Schema method literal must be a string");
+	return value;
+}
+function parseWithCompat(schema, data) {
+	const result = safeParse(schema, data);
+	if (!result.success) throw result.error;
+	return result.data;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
+/**
+* The default request timeout, in miliseconds.
+*/
+const DEFAULT_REQUEST_TIMEOUT_MSEC = 6e4;
+/**
+* Implements MCP protocol framing on top of a pluggable transport, including
+* features like request/response linking, notifications, and progress.
+*/
+var Protocol = class {
+	constructor(_options) {
+		this._options = _options;
+		this._requestMessageId = 0;
+		this._requestHandlers = /* @__PURE__ */ new Map();
+		this._requestHandlerAbortControllers = /* @__PURE__ */ new Map();
+		this._notificationHandlers = /* @__PURE__ */ new Map();
+		this._responseHandlers = /* @__PURE__ */ new Map();
+		this._progressHandlers = /* @__PURE__ */ new Map();
+		this._timeoutInfo = /* @__PURE__ */ new Map();
+		this._pendingDebouncedNotifications = /* @__PURE__ */ new Set();
+		this._taskProgressTokens = /* @__PURE__ */ new Map();
+		this._requestResolvers = /* @__PURE__ */ new Map();
+		this.setNotificationHandler(CancelledNotificationSchema, (notification) => {
+			this._oncancel(notification);
+		});
+		this.setNotificationHandler(ProgressNotificationSchema, (notification) => {
+			this._onprogress(notification);
+		});
+		this.setRequestHandler(PingRequestSchema, (_request) => ({}));
+		this._taskStore = _options?.taskStore;
+		this._taskMessageQueue = _options?.taskMessageQueue;
+		if (this._taskStore) {
+			this.setRequestHandler(GetTaskRequestSchema, async (request, extra) => {
+				const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+				if (!task) throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
+				return { ...task };
+			});
+			this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
+				const handleTaskResult = async () => {
+					const taskId = request.params.taskId;
+					if (this._taskMessageQueue) {
+						let queuedMessage;
+						while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
+							if (queuedMessage.type === "response" || queuedMessage.type === "error") {
+								const message = queuedMessage.message;
+								const requestId = message.id;
+								const resolver = this._requestResolvers.get(requestId);
+								if (resolver) {
+									this._requestResolvers.delete(requestId);
+									if (queuedMessage.type === "response") resolver(message);
+									else {
+										const errorMessage = message;
+										resolver(new McpError(errorMessage.error.code, errorMessage.error.message, errorMessage.error.data));
+									}
+								} else {
+									const messageType = queuedMessage.type === "response" ? "Response" : "Error";
+									this._onerror(/* @__PURE__ */ new Error(`${messageType} handler missing for request ${requestId}`));
+								}
+								continue;
+							}
+							await this._transport?.send(queuedMessage.message, { relatedRequestId: extra.requestId });
+						}
+					}
+					const task = await this._taskStore.getTask(taskId, extra.sessionId);
+					if (!task) throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
+					if (!isTerminal(task.status)) {
+						await this._waitForTaskUpdate(taskId, extra.signal);
+						return await handleTaskResult();
+					}
+					if (isTerminal(task.status)) {
+						const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
+						this._clearTaskQueue(taskId);
+						return {
+							...result,
+							_meta: {
+								...result._meta,
+								[RELATED_TASK_META_KEY]: { taskId }
+							}
+						};
+					}
+					return await handleTaskResult();
+				};
+				return await handleTaskResult();
+			});
+			this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => {
+				try {
+					const { tasks, nextCursor } = await this._taskStore.listTasks(request.params?.cursor, extra.sessionId);
+					return {
+						tasks,
+						nextCursor,
+						_meta: {}
+					};
+				} catch (error) {
+					throw new McpError(ErrorCode.InvalidParams, `Failed to list tasks: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			});
+			this.setRequestHandler(CancelTaskRequestSchema, async (request, extra) => {
+				try {
+					const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+					if (!task) throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request.params.taskId}`);
+					if (isTerminal(task.status)) throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
+					await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
+					this._clearTaskQueue(request.params.taskId);
+					const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+					if (!cancelledTask) throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
+					return {
+						_meta: {},
+						...cancelledTask
+					};
+				} catch (error) {
+					if (error instanceof McpError) throw error;
+					throw new McpError(ErrorCode.InvalidRequest, `Failed to cancel task: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			});
+		}
+	}
+	async _oncancel(notification) {
+		if (!notification.params.requestId) return;
+		this._requestHandlerAbortControllers.get(notification.params.requestId)?.abort(notification.params.reason);
+	}
+	_setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
+		this._timeoutInfo.set(messageId, {
+			timeoutId: setTimeout(onTimeout, timeout),
+			startTime: Date.now(),
+			timeout,
+			maxTotalTimeout,
+			resetTimeoutOnProgress,
+			onTimeout
+		});
+	}
+	_resetTimeout(messageId) {
+		const info = this._timeoutInfo.get(messageId);
+		if (!info) return false;
+		const totalElapsed = Date.now() - info.startTime;
+		if (info.maxTotalTimeout && totalElapsed >= info.maxTotalTimeout) {
+			this._timeoutInfo.delete(messageId);
+			throw McpError.fromError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", {
+				maxTotalTimeout: info.maxTotalTimeout,
+				totalElapsed
+			});
+		}
+		clearTimeout(info.timeoutId);
+		info.timeoutId = setTimeout(info.onTimeout, info.timeout);
+		return true;
+	}
+	_cleanupTimeout(messageId) {
+		const info = this._timeoutInfo.get(messageId);
+		if (info) {
+			clearTimeout(info.timeoutId);
+			this._timeoutInfo.delete(messageId);
+		}
+	}
+	/**
+	* Attaches to the given transport, starts it, and starts listening for messages.
+	*
+	* The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
+	*/
+	async connect(transport) {
+		if (this._transport) throw new Error("Already connected to a transport. Call close() before connecting to a new transport, or use a separate Protocol instance per connection.");
+		this._transport = transport;
+		const _onclose = this.transport?.onclose;
+		this._transport.onclose = () => {
+			_onclose?.();
+			this._onclose();
+		};
+		const _onerror = this.transport?.onerror;
+		this._transport.onerror = (error) => {
+			_onerror?.(error);
+			this._onerror(error);
+		};
+		const _onmessage = this._transport?.onmessage;
+		this._transport.onmessage = (message, extra) => {
+			_onmessage?.(message, extra);
+			if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) this._onresponse(message);
+			else if (isJSONRPCRequest(message)) this._onrequest(message, extra);
+			else if (isJSONRPCNotification(message)) this._onnotification(message);
+			else this._onerror(/* @__PURE__ */ new Error(`Unknown message type: ${JSON.stringify(message)}`));
+		};
+		await this._transport.start();
+	}
+	_onclose() {
+		const responseHandlers = this._responseHandlers;
+		this._responseHandlers = /* @__PURE__ */ new Map();
+		this._progressHandlers.clear();
+		this._taskProgressTokens.clear();
+		this._pendingDebouncedNotifications.clear();
+		for (const controller of this._requestHandlerAbortControllers.values()) controller.abort();
+		this._requestHandlerAbortControllers.clear();
+		const error = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed");
+		this._transport = void 0;
+		this.onclose?.();
+		for (const handler of responseHandlers.values()) handler(error);
+	}
+	_onerror(error) {
+		this.onerror?.(error);
+	}
+	_onnotification(notification) {
+		const handler = this._notificationHandlers.get(notification.method) ?? this.fallbackNotificationHandler;
+		if (handler === void 0) return;
+		Promise.resolve().then(() => handler(notification)).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Uncaught error in notification handler: ${error}`)));
+	}
+	_onrequest(request, extra) {
+		const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
+		const capturedTransport = this._transport;
+		const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
+		if (handler === void 0) {
+			const errorResponse = {
+				jsonrpc: "2.0",
+				id: request.id,
+				error: {
+					code: ErrorCode.MethodNotFound,
+					message: "Method not found"
+				}
+			};
+			if (relatedTaskId && this._taskMessageQueue) this._enqueueTaskMessage(relatedTaskId, {
+				type: "error",
+				message: errorResponse,
+				timestamp: Date.now()
+			}, capturedTransport?.sessionId).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Failed to enqueue error response: ${error}`)));
+			else capturedTransport?.send(errorResponse).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Failed to send an error response: ${error}`)));
+			return;
+		}
+		const abortController = new AbortController();
+		this._requestHandlerAbortControllers.set(request.id, abortController);
+		const taskCreationParams = isTaskAugmentedRequestParams(request.params) ? request.params.task : void 0;
+		const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport?.sessionId) : void 0;
+		const fullExtra = {
+			signal: abortController.signal,
+			sessionId: capturedTransport?.sessionId,
+			_meta: request.params?._meta,
+			sendNotification: async (notification) => {
+				if (abortController.signal.aborted) return;
+				const notificationOptions = { relatedRequestId: request.id };
+				if (relatedTaskId) notificationOptions.relatedTask = { taskId: relatedTaskId };
+				await this.notification(notification, notificationOptions);
+			},
+			sendRequest: async (r, resultSchema, options) => {
+				if (abortController.signal.aborted) throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
+				const requestOptions = {
+					...options,
+					relatedRequestId: request.id
+				};
+				if (relatedTaskId && !requestOptions.relatedTask) requestOptions.relatedTask = { taskId: relatedTaskId };
+				const effectiveTaskId = requestOptions.relatedTask?.taskId ?? relatedTaskId;
+				if (effectiveTaskId && taskStore) await taskStore.updateTaskStatus(effectiveTaskId, "input_required");
+				return await this.request(r, resultSchema, requestOptions);
+			},
+			authInfo: extra?.authInfo,
+			requestId: request.id,
+			requestInfo: extra?.requestInfo,
+			taskId: relatedTaskId,
+			taskStore,
+			taskRequestedTtl: taskCreationParams?.ttl,
+			closeSSEStream: extra?.closeSSEStream,
+			closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
+		};
+		Promise.resolve().then(() => {
+			if (taskCreationParams) this.assertTaskHandlerCapability(request.method);
+		}).then(() => handler(request, fullExtra)).then(async (result) => {
+			if (abortController.signal.aborted) return;
+			const response = {
+				result,
+				jsonrpc: "2.0",
+				id: request.id
+			};
+			if (relatedTaskId && this._taskMessageQueue) await this._enqueueTaskMessage(relatedTaskId, {
+				type: "response",
+				message: response,
+				timestamp: Date.now()
+			}, capturedTransport?.sessionId);
+			else await capturedTransport?.send(response);
+		}, async (error) => {
+			if (abortController.signal.aborted) return;
+			const errorResponse = {
+				jsonrpc: "2.0",
+				id: request.id,
+				error: {
+					code: Number.isSafeInteger(error["code"]) ? error["code"] : ErrorCode.InternalError,
+					message: error.message ?? "Internal error",
+					...error["data"] !== void 0 && { data: error["data"] }
+				}
+			};
+			if (relatedTaskId && this._taskMessageQueue) await this._enqueueTaskMessage(relatedTaskId, {
+				type: "error",
+				message: errorResponse,
+				timestamp: Date.now()
+			}, capturedTransport?.sessionId);
+			else await capturedTransport?.send(errorResponse);
+		}).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Failed to send response: ${error}`))).finally(() => {
+			this._requestHandlerAbortControllers.delete(request.id);
+		});
+	}
+	_onprogress(notification) {
+		const { progressToken,...params } = notification.params;
+		const messageId = Number(progressToken);
+		const handler = this._progressHandlers.get(messageId);
+		if (!handler) {
+			this._onerror(/* @__PURE__ */ new Error(`Received a progress notification for an unknown token: ${JSON.stringify(notification)}`));
+			return;
+		}
+		const responseHandler = this._responseHandlers.get(messageId);
+		const timeoutInfo = this._timeoutInfo.get(messageId);
+		if (timeoutInfo && responseHandler && timeoutInfo.resetTimeoutOnProgress) try {
+			this._resetTimeout(messageId);
+		} catch (error) {
+			this._responseHandlers.delete(messageId);
+			this._progressHandlers.delete(messageId);
+			this._cleanupTimeout(messageId);
+			responseHandler(error);
+			return;
+		}
+		handler(params);
+	}
+	_onresponse(response) {
+		const messageId = Number(response.id);
+		const resolver = this._requestResolvers.get(messageId);
+		if (resolver) {
+			this._requestResolvers.delete(messageId);
+			if (isJSONRPCResultResponse(response)) resolver(response);
+			else resolver(new McpError(response.error.code, response.error.message, response.error.data));
+			return;
+		}
+		const handler = this._responseHandlers.get(messageId);
+		if (handler === void 0) {
+			this._onerror(/* @__PURE__ */ new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`));
+			return;
+		}
+		this._responseHandlers.delete(messageId);
+		this._cleanupTimeout(messageId);
+		let isTaskResponse = false;
+		if (isJSONRPCResultResponse(response) && response.result && typeof response.result === "object") {
+			const result = response.result;
+			if (result.task && typeof result.task === "object") {
+				const task = result.task;
+				if (typeof task.taskId === "string") {
+					isTaskResponse = true;
+					this._taskProgressTokens.set(task.taskId, messageId);
+				}
+			}
+		}
+		if (!isTaskResponse) this._progressHandlers.delete(messageId);
+		if (isJSONRPCResultResponse(response)) handler(response);
+		else handler(McpError.fromError(response.error.code, response.error.message, response.error.data));
+	}
+	get transport() {
+		return this._transport;
+	}
+	/**
+	* Closes the connection.
+	*/
+	async close() {
+		await this._transport?.close();
+	}
+	/**
+	* Sends a request and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* @example
+	* ```typescript
+	* const stream = protocol.requestStream(request, resultSchema, options);
+	* for await (const message of stream) {
+	*   switch (message.type) {
+	*     case 'taskCreated':
+	*       console.log('Task created:', message.task.taskId);
+	*       break;
+	*     case 'taskStatus':
+	*       console.log('Task status:', message.task.status);
+	*       break;
+	*     case 'result':
+	*       console.log('Final result:', message.result);
+	*       break;
+	*     case 'error':
+	*       console.error('Error:', message.error);
+	*       break;
+	*   }
+	* }
+	* ```
+	*
+	* @experimental Use `client.experimental.tasks.requestStream()` to access this method.
+	*/
+	async *requestStream(request, resultSchema, options) {
+		const { task } = options ?? {};
+		if (!task) {
+			try {
+				yield {
+					type: "result",
+					result: await this.request(request, resultSchema, options)
+				};
+			} catch (error) {
+				yield {
+					type: "error",
+					error: error instanceof McpError ? error : new McpError(ErrorCode.InternalError, String(error))
+				};
+			}
+			return;
+		}
+		let taskId;
+		try {
+			const createResult = await this.request(request, CreateTaskResultSchema, options);
+			if (createResult.task) {
+				taskId = createResult.task.taskId;
+				yield {
+					type: "taskCreated",
+					task: createResult.task
+				};
+			} else throw new McpError(ErrorCode.InternalError, "Task creation did not return a task");
+			while (true) {
+				const task$1 = await this.getTask({ taskId }, options);
+				yield {
+					type: "taskStatus",
+					task: task$1
+				};
+				if (isTerminal(task$1.status)) {
+					if (task$1.status === "completed") yield {
+						type: "result",
+						result: await this.getTaskResult({ taskId }, resultSchema, options)
+					};
+					else if (task$1.status === "failed") yield {
+						type: "error",
+						error: new McpError(ErrorCode.InternalError, `Task ${taskId} failed`)
+					};
+					else if (task$1.status === "cancelled") yield {
+						type: "error",
+						error: new McpError(ErrorCode.InternalError, `Task ${taskId} was cancelled`)
+					};
+					return;
+				}
+				if (task$1.status === "input_required") {
+					yield {
+						type: "result",
+						result: await this.getTaskResult({ taskId }, resultSchema, options)
+					};
+					return;
+				}
+				const pollInterval = task$1.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
+				await new Promise((resolve) => setTimeout(resolve, pollInterval));
+				options?.signal?.throwIfAborted();
+			}
+		} catch (error) {
+			yield {
+				type: "error",
+				error: error instanceof McpError ? error : new McpError(ErrorCode.InternalError, String(error))
+			};
+		}
+	}
+	/**
+	* Sends a request and waits for a response.
+	*
+	* Do not use this method to emit notifications! Use notification() instead.
+	*/
+	request(request, resultSchema, options) {
+		const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
+		return new Promise((resolve, reject) => {
+			const earlyReject = (error) => {
+				reject(error);
+			};
+			if (!this._transport) {
+				earlyReject(/* @__PURE__ */ new Error("Not connected"));
+				return;
+			}
+			if (this._options?.enforceStrictCapabilities === true) try {
+				this.assertCapabilityForMethod(request.method);
+				if (task) this.assertTaskCapability(request.method);
+			} catch (e) {
+				earlyReject(e);
+				return;
+			}
+			options?.signal?.throwIfAborted();
+			const messageId = this._requestMessageId++;
+			const jsonrpcRequest = {
+				...request,
+				jsonrpc: "2.0",
+				id: messageId
+			};
+			if (options?.onprogress) {
+				this._progressHandlers.set(messageId, options.onprogress);
+				jsonrpcRequest.params = {
+					...request.params,
+					_meta: {
+						...request.params?._meta || {},
+						progressToken: messageId
+					}
+				};
+			}
+			if (task) jsonrpcRequest.params = {
+				...jsonrpcRequest.params,
+				task
+			};
+			if (relatedTask) jsonrpcRequest.params = {
+				...jsonrpcRequest.params,
+				_meta: {
+					...jsonrpcRequest.params?._meta || {},
+					[RELATED_TASK_META_KEY]: relatedTask
+				}
+			};
+			const cancel = (reason) => {
+				this._responseHandlers.delete(messageId);
+				this._progressHandlers.delete(messageId);
+				this._cleanupTimeout(messageId);
+				this._transport?.send({
+					jsonrpc: "2.0",
+					method: "notifications/cancelled",
+					params: {
+						requestId: messageId,
+						reason: String(reason)
+					}
+				}, {
+					relatedRequestId,
+					resumptionToken,
+					onresumptiontoken
+				}).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Failed to send cancellation: ${error}`)));
+				reject(reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason)));
+			};
+			this._responseHandlers.set(messageId, (response) => {
+				if (options?.signal?.aborted) return;
+				if (response instanceof Error) return reject(response);
+				try {
+					const parseResult = safeParse(resultSchema, response.result);
+					if (!parseResult.success) reject(parseResult.error);
+					else resolve(parseResult.data);
+				} catch (error) {
+					reject(error);
+				}
+			});
+			options?.signal?.addEventListener("abort", () => {
+				cancel(options?.signal?.reason);
+			});
+			const timeout = options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
+			const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
+			this._setupTimeout(messageId, timeout, options?.maxTotalTimeout, timeoutHandler, options?.resetTimeoutOnProgress ?? false);
+			const relatedTaskId = relatedTask?.taskId;
+			if (relatedTaskId) {
+				const responseResolver = (response) => {
+					const handler = this._responseHandlers.get(messageId);
+					if (handler) handler(response);
+					else this._onerror(/* @__PURE__ */ new Error(`Response handler missing for side-channeled request ${messageId}`));
+				};
+				this._requestResolvers.set(messageId, responseResolver);
+				this._enqueueTaskMessage(relatedTaskId, {
+					type: "request",
+					message: jsonrpcRequest,
+					timestamp: Date.now()
+				}).catch((error) => {
+					this._cleanupTimeout(messageId);
+					reject(error);
+				});
+			} else this._transport.send(jsonrpcRequest, {
+				relatedRequestId,
+				resumptionToken,
+				onresumptiontoken
+			}).catch((error) => {
+				this._cleanupTimeout(messageId);
+				reject(error);
+			});
+		});
+	}
+	/**
+	* Gets the current status of a task.
+	*
+	* @experimental Use `client.experimental.tasks.getTask()` to access this method.
+	*/
+	async getTask(params, options) {
+		return this.request({
+			method: "tasks/get",
+			params
+		}, GetTaskResultSchema, options);
+	}
+	/**
+	* Retrieves the result of a completed task.
+	*
+	* @experimental Use `client.experimental.tasks.getTaskResult()` to access this method.
+	*/
+	async getTaskResult(params, resultSchema, options) {
+		return this.request({
+			method: "tasks/result",
+			params
+		}, resultSchema, options);
+	}
+	/**
+	* Lists tasks, optionally starting from a pagination cursor.
+	*
+	* @experimental Use `client.experimental.tasks.listTasks()` to access this method.
+	*/
+	async listTasks(params, options) {
+		return this.request({
+			method: "tasks/list",
+			params
+		}, ListTasksResultSchema, options);
+	}
+	/**
+	* Cancels a specific task.
+	*
+	* @experimental Use `client.experimental.tasks.cancelTask()` to access this method.
+	*/
+	async cancelTask(params, options) {
+		return this.request({
+			method: "tasks/cancel",
+			params
+		}, CancelTaskResultSchema, options);
+	}
+	/**
+	* Emits a notification, which is a one-way message that does not expect a response.
+	*/
+	async notification(notification, options) {
+		if (!this._transport) throw new Error("Not connected");
+		this.assertNotificationCapability(notification.method);
+		const relatedTaskId = options?.relatedTask?.taskId;
+		if (relatedTaskId) {
+			const jsonrpcNotification$1 = {
+				...notification,
+				jsonrpc: "2.0",
+				params: {
+					...notification.params,
+					_meta: {
+						...notification.params?._meta || {},
+						[RELATED_TASK_META_KEY]: options.relatedTask
+					}
+				}
+			};
+			await this._enqueueTaskMessage(relatedTaskId, {
+				type: "notification",
+				message: jsonrpcNotification$1,
+				timestamp: Date.now()
+			});
+			return;
+		}
+		if ((this._options?.debouncedNotificationMethods ?? []).includes(notification.method) && !notification.params && !options?.relatedRequestId && !options?.relatedTask) {
+			if (this._pendingDebouncedNotifications.has(notification.method)) return;
+			this._pendingDebouncedNotifications.add(notification.method);
+			Promise.resolve().then(() => {
+				this._pendingDebouncedNotifications.delete(notification.method);
+				if (!this._transport) return;
+				let jsonrpcNotification$1 = {
+					...notification,
+					jsonrpc: "2.0"
+				};
+				if (options?.relatedTask) jsonrpcNotification$1 = {
+					...jsonrpcNotification$1,
+					params: {
+						...jsonrpcNotification$1.params,
+						_meta: {
+							...jsonrpcNotification$1.params?._meta || {},
+							[RELATED_TASK_META_KEY]: options.relatedTask
+						}
+					}
+				};
+				this._transport?.send(jsonrpcNotification$1, options).catch((error) => this._onerror(error));
+			});
+			return;
+		}
+		let jsonrpcNotification = {
+			...notification,
+			jsonrpc: "2.0"
+		};
+		if (options?.relatedTask) jsonrpcNotification = {
+			...jsonrpcNotification,
+			params: {
+				...jsonrpcNotification.params,
+				_meta: {
+					...jsonrpcNotification.params?._meta || {},
+					[RELATED_TASK_META_KEY]: options.relatedTask
+				}
+			}
+		};
+		await this._transport.send(jsonrpcNotification, options);
+	}
+	/**
+	* Registers a handler to invoke when this protocol object receives a request with the given method.
+	*
+	* Note that this will replace any previous request handler for the same method.
+	*/
+	setRequestHandler(requestSchema, handler) {
+		const method = getMethodLiteral(requestSchema);
+		this.assertRequestHandlerCapability(method);
+		this._requestHandlers.set(method, (request, extra) => {
+			const parsed = parseWithCompat(requestSchema, request);
+			return Promise.resolve(handler(parsed, extra));
+		});
+	}
+	/**
+	* Removes the request handler for the given method.
+	*/
+	removeRequestHandler(method) {
+		this._requestHandlers.delete(method);
+	}
+	/**
+	* Asserts that a request handler has not already been set for the given method, in preparation for a new one being automatically installed.
+	*/
+	assertCanSetRequestHandler(method) {
+		if (this._requestHandlers.has(method)) throw new Error(`A request handler for ${method} already exists, which would be overridden`);
+	}
+	/**
+	* Registers a handler to invoke when this protocol object receives a notification with the given method.
+	*
+	* Note that this will replace any previous notification handler for the same method.
+	*/
+	setNotificationHandler(notificationSchema, handler) {
+		const method = getMethodLiteral(notificationSchema);
+		this._notificationHandlers.set(method, (notification) => {
+			const parsed = parseWithCompat(notificationSchema, notification);
+			return Promise.resolve(handler(parsed));
+		});
+	}
+	/**
+	* Removes the notification handler for the given method.
+	*/
+	removeNotificationHandler(method) {
+		this._notificationHandlers.delete(method);
+	}
+	/**
+	* Cleans up the progress handler associated with a task.
+	* This should be called when a task reaches a terminal status.
+	*/
+	_cleanupTaskProgressHandler(taskId) {
+		const progressToken = this._taskProgressTokens.get(taskId);
+		if (progressToken !== void 0) {
+			this._progressHandlers.delete(progressToken);
+			this._taskProgressTokens.delete(taskId);
+		}
+	}
+	/**
+	* Enqueues a task-related message for side-channel delivery via tasks/result.
+	* @param taskId The task ID to associate the message with
+	* @param message The message to enqueue
+	* @param sessionId Optional session ID for binding the operation to a specific session
+	* @throws Error if taskStore is not configured or if enqueue fails (e.g., queue overflow)
+	*
+	* Note: If enqueue fails, it's the TaskMessageQueue implementation's responsibility to handle
+	* the error appropriately (e.g., by failing the task, logging, etc.). The Protocol layer
+	* simply propagates the error.
+	*/
+	async _enqueueTaskMessage(taskId, message, sessionId) {
+		if (!this._taskStore || !this._taskMessageQueue) throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
+		const maxQueueSize = this._options?.maxTaskQueueSize;
+		await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
+	}
+	/**
+	* Clears the message queue for a task and rejects any pending request resolvers.
+	* @param taskId The task ID whose queue should be cleared
+	* @param sessionId Optional session ID for binding the operation to a specific session
+	*/
+	async _clearTaskQueue(taskId, sessionId) {
+		if (this._taskMessageQueue) {
+			const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId);
+			for (const message of messages) if (message.type === "request" && isJSONRPCRequest(message.message)) {
+				const requestId = message.message.id;
+				const resolver = this._requestResolvers.get(requestId);
+				if (resolver) {
+					resolver(new McpError(ErrorCode.InternalError, "Task cancelled or completed"));
+					this._requestResolvers.delete(requestId);
+				} else this._onerror(/* @__PURE__ */ new Error(`Resolver missing for request ${requestId} during task ${taskId} cleanup`));
+			}
+		}
+	}
+	/**
+	* Waits for a task update (new messages or status change) with abort signal support.
+	* Uses polling to check for updates at the task's configured poll interval.
+	* @param taskId The task ID to wait for
+	* @param signal Abort signal to cancel the wait
+	* @returns Promise that resolves when an update occurs or rejects if aborted
+	*/
+	async _waitForTaskUpdate(taskId, signal) {
+		let interval = this._options?.defaultTaskPollInterval ?? 1e3;
+		try {
+			const task = await this._taskStore?.getTask(taskId);
+			if (task?.pollInterval) interval = task.pollInterval;
+		} catch {}
+		return new Promise((resolve, reject) => {
+			if (signal.aborted) {
+				reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
+				return;
+			}
+			const timeoutId = setTimeout(resolve, interval);
+			signal.addEventListener("abort", () => {
+				clearTimeout(timeoutId);
+				reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
+			}, { once: true });
+		});
+	}
+	requestTaskStore(request, sessionId) {
+		const taskStore = this._taskStore;
+		if (!taskStore) throw new Error("No task store configured");
+		return {
+			createTask: async (taskParams) => {
+				if (!request) throw new Error("No request provided");
+				return await taskStore.createTask(taskParams, request.id, {
+					method: request.method,
+					params: request.params
+				}, sessionId);
+			},
+			getTask: async (taskId) => {
+				const task = await taskStore.getTask(taskId, sessionId);
+				if (!task) throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
+				return task;
+			},
+			storeTaskResult: async (taskId, status, result) => {
+				await taskStore.storeTaskResult(taskId, status, result, sessionId);
+				const task = await taskStore.getTask(taskId, sessionId);
+				if (task) {
+					const notification = TaskStatusNotificationSchema.parse({
+						method: "notifications/tasks/status",
+						params: task
+					});
+					await this.notification(notification);
+					if (isTerminal(task.status)) this._cleanupTaskProgressHandler(taskId);
+				}
+			},
+			getTaskResult: (taskId) => {
+				return taskStore.getTaskResult(taskId, sessionId);
+			},
+			updateTaskStatus: async (taskId, status, statusMessage) => {
+				const task = await taskStore.getTask(taskId, sessionId);
+				if (!task) throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
+				if (isTerminal(task.status)) throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
+				await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId);
+				const updatedTask = await taskStore.getTask(taskId, sessionId);
+				if (updatedTask) {
+					const notification = TaskStatusNotificationSchema.parse({
+						method: "notifications/tasks/status",
+						params: updatedTask
+					});
+					await this.notification(notification);
+					if (isTerminal(updatedTask.status)) this._cleanupTaskProgressHandler(taskId);
+				}
+			},
+			listTasks: (cursor) => {
+				return taskStore.listTasks(cursor, sessionId);
+			}
+		};
+	}
+};
+function isPlainObject$2(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function mergeCapabilities(base, additional) {
+	const result = { ...base };
+	for (const key in additional) {
+		const k = key;
+		const addValue = additional[k];
+		if (addValue === void 0) continue;
+		const baseValue = result[k];
+		if (isPlainObject$2(baseValue) && isPlainObject$2(addValue)) result[k] = {
+			...baseValue,
+			...addValue
+		};
+		else result[k] = addValue;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/stubs/ajv.ts
+/**
+* Throwing ajv stub for browser environments.
+*
+* The MCP SDK's Server class statically imports AjvJsonSchemaValidator as a
+* default fallback. BrowserMcpServer always passes PolyfillJsonSchemaValidator,
+* so ajv is never actually used — but the static import still resolves. This
+* stub satisfies that import without pulling in the real ajv (CJS-only, breaks
+* in browsers).
+*
+* If any code path unexpectedly reaches this stub, it throws immediately so the
+* issue is surfaced rather than silently passing all validation.
+*/
+var Ajv = class {
+	compile(_schema) {
+		throw new Error("[WebMCP] Ajv stub was invoked. This indicates the MCP SDK is bypassing PolyfillJsonSchemaValidator. Please report this as a bug.");
+	}
+	getSchema(_id) {}
+	errorsText(_errors) {
+		return "";
+	}
+};
+var ajv_default = Ajv;
+
+//#endregion
+//#region src/stubs/ajv-formats.ts
+/**
+* No-op ajv-formats stub for browser environments.
+* See ./ajv.ts for rationale.
+*/
+function addFormats(_ajv) {}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
+function createDefaultAjvInstance() {
+	const ajv = new ajv_default({
+		strict: false,
+		validateFormats: true,
+		validateSchema: false,
+		allErrors: true
+	});
+	addFormats(ajv);
+	return ajv;
+}
+/**
+* @example
+* ```typescript
+* // Use with default AJV instance (recommended)
+* import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv';
+* const validator = new AjvJsonSchemaValidator();
+*
+* // Use with custom AJV instance
+* import { Ajv } from 'ajv';
+* const ajv = new Ajv({ strict: true, allErrors: true });
+* const validator = new AjvJsonSchemaValidator(ajv);
+* ```
+*/
+var AjvJsonSchemaValidator = class {
+	/**
+	* Create an AJV validator
+	*
+	* @param ajv - Optional pre-configured AJV instance. If not provided, a default instance will be created.
+	*
+	* @example
+	* ```typescript
+	* // Use default configuration (recommended for most cases)
+	* import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv';
+	* const validator = new AjvJsonSchemaValidator();
+	*
+	* // Or provide custom AJV instance for advanced configuration
+	* import { Ajv } from 'ajv';
+	* import addFormats from 'ajv-formats';
+	*
+	* const ajv = new Ajv({ validateFormats: true });
+	* addFormats(ajv);
+	* const validator = new AjvJsonSchemaValidator(ajv);
+	* ```
+	*/
+	constructor(ajv) {
+		this._ajv = ajv ?? createDefaultAjvInstance();
+	}
+	/**
+	* Create a validator for the given JSON Schema
+	*
+	* The validator is compiled once and can be reused multiple times.
+	* If the schema has an $id, it will be cached by AJV automatically.
+	*
+	* @param schema - Standard JSON Schema object
+	* @returns A validator function that validates input data
+	*/
+	getValidator(schema) {
+		const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? this._ajv.getSchema(schema.$id) ?? this._ajv.compile(schema) : this._ajv.compile(schema);
+		return (input) => {
+			if (ajvValidator(input)) return {
+				valid: true,
+				data: input,
+				errorMessage: void 0
+			};
+			else return {
+				valid: false,
+				data: void 0,
+				errorMessage: this._ajv.errorsText(ajvValidator.errors)
+			};
+		};
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/client.js
+/**
+* Experimental task features for MCP clients.
+*
+* Access via `client.experimental.tasks`:
+* ```typescript
+* const stream = client.experimental.tasks.callToolStream({ name: 'tool', arguments: {} });
+* const task = await client.experimental.tasks.getTask(taskId);
+* ```
+*
+* @experimental
+*/
+var ExperimentalClientTasks = class {
+	constructor(_client) {
+		this._client = _client;
+	}
+	/**
+	* Calls a tool and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* This method provides streaming access to tool execution, allowing you to
+	* observe intermediate task status updates for long-running tool calls.
+	* Automatically validates structured output if the tool has an outputSchema.
+	*
+	* @example
+	* ```typescript
+	* const stream = client.experimental.tasks.callToolStream({ name: 'myTool', arguments: {} });
+	* for await (const message of stream) {
+	*   switch (message.type) {
+	*     case 'taskCreated':
+	*       console.log('Tool execution started:', message.task.taskId);
+	*       break;
+	*     case 'taskStatus':
+	*       console.log('Tool status:', message.task.status);
+	*       break;
+	*     case 'result':
+	*       console.log('Tool result:', message.result);
+	*       break;
+	*     case 'error':
+	*       console.error('Tool error:', message.error);
+	*       break;
+	*   }
+	* }
+	* ```
+	*
+	* @param params - Tool call parameters (name and arguments)
+	* @param resultSchema - Zod schema for validating the result (defaults to CallToolResultSchema)
+	* @param options - Optional request options (timeout, signal, task creation params, etc.)
+	* @returns AsyncGenerator that yields ResponseMessage objects
+	*
+	* @experimental
+	*/
+	async *callToolStream(params, resultSchema = CallToolResultSchema, options) {
+		const clientInternal = this._client;
+		const optionsWithTask = {
+			...options,
+			task: options?.task ?? (clientInternal.isToolTask(params.name) ? {} : void 0)
+		};
+		const stream = clientInternal.requestStream({
+			method: "tools/call",
+			params
+		}, resultSchema, optionsWithTask);
+		const validator = clientInternal.getToolOutputValidator(params.name);
+		for await (const message of stream) {
+			if (message.type === "result" && validator) {
+				const result = message.result;
+				if (!result.structuredContent && !result.isError) {
+					yield {
+						type: "error",
+						error: new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`)
+					};
+					return;
+				}
+				if (result.structuredContent) try {
+					const validationResult = validator(result.structuredContent);
+					if (!validationResult.valid) {
+						yield {
+							type: "error",
+							error: new McpError(ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`)
+						};
+						return;
+					}
+				} catch (error) {
+					if (error instanceof McpError) {
+						yield {
+							type: "error",
+							error
+						};
+						return;
+					}
+					yield {
+						type: "error",
+						error: new McpError(ErrorCode.InvalidParams, `Failed to validate structured content: ${error instanceof Error ? error.message : String(error)}`)
+					};
+					return;
+				}
+			}
+			yield message;
+		}
+	}
+	/**
+	* Gets the current status of a task.
+	*
+	* @param taskId - The task identifier
+	* @param options - Optional request options
+	* @returns The task status
+	*
+	* @experimental
+	*/
+	async getTask(taskId, options) {
+		return this._client.getTask({ taskId }, options);
+	}
+	/**
+	* Retrieves the result of a completed task.
+	*
+	* @param taskId - The task identifier
+	* @param resultSchema - Zod schema for validating the result
+	* @param options - Optional request options
+	* @returns The task result
+	*
+	* @experimental
+	*/
+	async getTaskResult(taskId, resultSchema, options) {
+		return this._client.getTaskResult({ taskId }, resultSchema, options);
+	}
+	/**
+	* Lists tasks with optional pagination.
+	*
+	* @param cursor - Optional pagination cursor
+	* @param options - Optional request options
+	* @returns List of tasks with optional next cursor
+	*
+	* @experimental
+	*/
+	async listTasks(cursor, options) {
+		return this._client.listTasks(cursor ? { cursor } : void 0, options);
+	}
+	/**
+	* Cancels a running task.
+	*
+	* @param taskId - The task identifier
+	* @param options - Optional request options
+	*
+	* @experimental
+	*/
+	async cancelTask(taskId, options) {
+		return this._client.cancelTask({ taskId }, options);
+	}
+	/**
+	* Sends a request and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* This method provides streaming access to request processing, allowing you to
+	* observe intermediate task status updates for task-augmented requests.
+	*
+	* @param request - The request to send
+	* @param resultSchema - Zod schema for validating the result
+	* @param options - Optional request options (timeout, signal, task creation params, etc.)
+	* @returns AsyncGenerator that yields ResponseMessage objects
+	*
+	* @experimental
+	*/
+	requestStream(request, resultSchema, options) {
+		return this._client.requestStream(request, resultSchema, options);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
+/**
+* Experimental task capability assertion helpers.
+* WARNING: These APIs are experimental and may change without notice.
+*
+* @experimental
+*/
+/**
+* Asserts that task creation is supported for tools/call.
+* Used by Client.assertTaskCapability and Server.assertTaskHandlerCapability.
+*
+* @param requests - The task requests capability object
+* @param method - The method being checked
+* @param entityName - 'Server' or 'Client' for error messages
+* @throws Error if the capability is not supported
+*
+* @experimental
+*/
+function assertToolsCallTaskCapability(requests, method, entityName) {
+	if (!requests) throw new Error(`${entityName} does not support task creation (required for ${method})`);
+	switch (method) {
+		case "tools/call":
+			if (!requests.tools?.call) throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
+			break;
+		default: break;
+	}
+}
+/**
+* Asserts that task creation is supported for sampling/createMessage or elicitation/create.
+* Used by Server.assertTaskCapability and Client.assertTaskHandlerCapability.
+*
+* @param requests - The task requests capability object
+* @param method - The method being checked
+* @param entityName - 'Server' or 'Client' for error messages
+* @throws Error if the capability is not supported
+*
+* @experimental
+*/
+function assertClientRequestTaskCapability(requests, method, entityName) {
+	if (!requests) throw new Error(`${entityName} does not support task creation (required for ${method})`);
+	switch (method) {
+		case "sampling/createMessage":
+			if (!requests.sampling?.createMessage) throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
+			break;
+		case "elicitation/create":
+			if (!requests.elicitation?.create) throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
+			break;
+		default: break;
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/client/index.js
+/**
+* Elicitation default application helper. Applies defaults to the data based on the schema.
+*
+* @param schema - The schema to apply defaults to.
+* @param data - The data to apply defaults to.
+*/
+function applyElicitationDefaults(schema, data) {
+	if (!schema || data === null || typeof data !== "object") return;
+	if (schema.type === "object" && schema.properties && typeof schema.properties === "object") {
+		const obj = data;
+		const props = schema.properties;
+		for (const key of Object.keys(props)) {
+			const propSchema = props[key];
+			if (obj[key] === void 0 && Object.prototype.hasOwnProperty.call(propSchema, "default")) obj[key] = propSchema.default;
+			if (obj[key] !== void 0) applyElicitationDefaults(propSchema, obj[key]);
+		}
+	}
+	if (Array.isArray(schema.anyOf)) {
+		for (const sub of schema.anyOf) if (typeof sub !== "boolean") applyElicitationDefaults(sub, data);
+	}
+	if (Array.isArray(schema.oneOf)) {
+		for (const sub of schema.oneOf) if (typeof sub !== "boolean") applyElicitationDefaults(sub, data);
+	}
+}
+/**
+* Determines which elicitation modes are supported based on declared client capabilities.
+*
+* According to the spec:
+* - An empty elicitation capability object defaults to form mode support (backwards compatibility)
+* - URL mode is only supported if explicitly declared
+*
+* @param capabilities - The client's elicitation capabilities
+* @returns An object indicating which modes are supported
+*/
+function getSupportedElicitationModes(capabilities) {
+	if (!capabilities) return {
+		supportsFormMode: false,
+		supportsUrlMode: false
+	};
+	const hasFormCapability = capabilities.form !== void 0;
+	const hasUrlCapability = capabilities.url !== void 0;
+	return {
+		supportsFormMode: hasFormCapability || !hasFormCapability && !hasUrlCapability,
+		supportsUrlMode: hasUrlCapability
+	};
+}
+/**
+* An MCP client on top of a pluggable transport.
+*
+* The client will automatically begin the initialization flow with the server when connect() is called.
+*
+* To use with custom types, extend the base Request/Notification/Result types and pass them as type parameters:
+*
+* ```typescript
+* // Custom schemas
+* const CustomRequestSchema = RequestSchema.extend({...})
+* const CustomNotificationSchema = NotificationSchema.extend({...})
+* const CustomResultSchema = ResultSchema.extend({...})
+*
+* // Type aliases
+* type CustomRequest = z.infer<typeof CustomRequestSchema>
+* type CustomNotification = z.infer<typeof CustomNotificationSchema>
+* type CustomResult = z.infer<typeof CustomResultSchema>
+*
+* // Create typed client
+* const client = new Client<CustomRequest, CustomNotification, CustomResult>({
+*   name: "CustomClient",
+*   version: "1.0.0"
+* })
+* ```
+*/
+var Client = class extends Protocol {
+	/**
+	* Initializes this client with the given name and version information.
+	*/
+	constructor(_clientInfo, options) {
+		super(options);
+		this._clientInfo = _clientInfo;
+		this._cachedToolOutputValidators = /* @__PURE__ */ new Map();
+		this._cachedKnownTaskTools = /* @__PURE__ */ new Set();
+		this._cachedRequiredTaskTools = /* @__PURE__ */ new Set();
+		this._listChangedDebounceTimers = /* @__PURE__ */ new Map();
+		this._capabilities = options?.capabilities ?? {};
+		this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
+		if (options?.listChanged) this._pendingListChangedConfig = options.listChanged;
+	}
+	/**
+	* Set up handlers for list changed notifications based on config and server capabilities.
+	* This should only be called after initialization when server capabilities are known.
+	* Handlers are silently skipped if the server doesn't advertise the corresponding listChanged capability.
+	* @internal
+	*/
+	_setupListChangedHandlers(config) {
+		if (config.tools && this._serverCapabilities?.tools?.listChanged) this._setupListChangedHandler("tools", ToolListChangedNotificationSchema, config.tools, async () => {
+			return (await this.listTools()).tools;
+		});
+		if (config.prompts && this._serverCapabilities?.prompts?.listChanged) this._setupListChangedHandler("prompts", PromptListChangedNotificationSchema, config.prompts, async () => {
+			return (await this.listPrompts()).prompts;
+		});
+		if (config.resources && this._serverCapabilities?.resources?.listChanged) this._setupListChangedHandler("resources", ResourceListChangedNotificationSchema, config.resources, async () => {
+			return (await this.listResources()).resources;
+		});
+	}
+	/**
+	* Access experimental features.
+	*
+	* WARNING: These APIs are experimental and may change without notice.
+	*
+	* @experimental
+	*/
+	get experimental() {
+		if (!this._experimental) this._experimental = { tasks: new ExperimentalClientTasks(this) };
+		return this._experimental;
+	}
+	/**
+	* Registers new capabilities. This can only be called before connecting to a transport.
+	*
+	* The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
+	*/
+	registerCapabilities(capabilities) {
+		if (this.transport) throw new Error("Cannot register capabilities after connecting to transport");
+		this._capabilities = mergeCapabilities(this._capabilities, capabilities);
+	}
+	/**
+	* Override request handler registration to enforce client-side validation for elicitation.
+	*/
+	setRequestHandler(requestSchema, handler) {
+		const methodSchema = getObjectShape(requestSchema)?.method;
+		if (!methodSchema) throw new Error("Schema is missing a method literal");
+		let methodValue;
+		if (isZ4Schema(methodSchema)) {
+			const v4Schema = methodSchema;
+			methodValue = (v4Schema._zod?.def)?.value ?? v4Schema.value;
+		} else {
+			const v3Schema = methodSchema;
+			methodValue = v3Schema._def?.value ?? v3Schema.value;
+		}
+		if (typeof methodValue !== "string") throw new Error("Schema method literal must be a string");
+		const method = methodValue;
+		if (method === "elicitation/create") {
+			const wrappedHandler = async (request, extra) => {
+				const validatedRequest = safeParse(ElicitRequestSchema, request);
+				if (!validatedRequest.success) {
+					const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+					throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation request: ${errorMessage}`);
+				}
+				const { params } = validatedRequest.data;
+				params.mode = params.mode ?? "form";
+				const { supportsFormMode, supportsUrlMode } = getSupportedElicitationModes(this._capabilities.elicitation);
+				if (params.mode === "form" && !supportsFormMode) throw new McpError(ErrorCode.InvalidParams, "Client does not support form-mode elicitation requests");
+				if (params.mode === "url" && !supportsUrlMode) throw new McpError(ErrorCode.InvalidParams, "Client does not support URL-mode elicitation requests");
+				const result = await Promise.resolve(handler(request, extra));
+				if (params.task) {
+					const taskValidationResult = safeParse(CreateTaskResultSchema, result);
+					if (!taskValidationResult.success) {
+						const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+						throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+					}
+					return taskValidationResult.data;
+				}
+				const validationResult = safeParse(ElicitResultSchema, result);
+				if (!validationResult.success) {
+					const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+					throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation result: ${errorMessage}`);
+				}
+				const validatedResult = validationResult.data;
+				const requestedSchema = params.mode === "form" ? params.requestedSchema : void 0;
+				if (params.mode === "form" && validatedResult.action === "accept" && validatedResult.content && requestedSchema) {
+					if (this._capabilities.elicitation?.form?.applyDefaults) try {
+						applyElicitationDefaults(requestedSchema, validatedResult.content);
+					} catch {}
+				}
+				return validatedResult;
+			};
+			return super.setRequestHandler(requestSchema, wrappedHandler);
+		}
+		if (method === "sampling/createMessage") {
+			const wrappedHandler = async (request, extra) => {
+				const validatedRequest = safeParse(CreateMessageRequestSchema, request);
+				if (!validatedRequest.success) {
+					const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+					throw new McpError(ErrorCode.InvalidParams, `Invalid sampling request: ${errorMessage}`);
+				}
+				const { params } = validatedRequest.data;
+				const result = await Promise.resolve(handler(request, extra));
+				if (params.task) {
+					const taskValidationResult = safeParse(CreateTaskResultSchema, result);
+					if (!taskValidationResult.success) {
+						const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+						throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+					}
+					return taskValidationResult.data;
+				}
+				const validationResult = safeParse(params.tools || params.toolChoice ? CreateMessageResultWithToolsSchema : CreateMessageResultSchema, result);
+				if (!validationResult.success) {
+					const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+					throw new McpError(ErrorCode.InvalidParams, `Invalid sampling result: ${errorMessage}`);
+				}
+				return validationResult.data;
+			};
+			return super.setRequestHandler(requestSchema, wrappedHandler);
+		}
+		return super.setRequestHandler(requestSchema, handler);
+	}
+	assertCapability(capability, method) {
+		if (!this._serverCapabilities?.[capability]) throw new Error(`Server does not support ${capability} (required for ${method})`);
+	}
+	async connect(transport, options) {
+		await super.connect(transport);
+		if (transport.sessionId !== void 0) return;
+		try {
+			const result = await this.request({
+				method: "initialize",
+				params: {
+					protocolVersion: LATEST_PROTOCOL_VERSION,
+					capabilities: this._capabilities,
+					clientInfo: this._clientInfo
+				}
+			}, InitializeResultSchema, options);
+			if (result === void 0) throw new Error(`Server sent invalid initialize result: ${result}`);
+			if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion)) throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`);
+			this._serverCapabilities = result.capabilities;
+			this._serverVersion = result.serverInfo;
+			if (transport.setProtocolVersion) transport.setProtocolVersion(result.protocolVersion);
+			this._instructions = result.instructions;
+			await this.notification({ method: "notifications/initialized" });
+			if (this._pendingListChangedConfig) {
+				this._setupListChangedHandlers(this._pendingListChangedConfig);
+				this._pendingListChangedConfig = void 0;
+			}
+		} catch (error) {
+			this.close();
+			throw error;
+		}
+	}
+	/**
+	* After initialization has completed, this will be populated with the server's reported capabilities.
+	*/
+	getServerCapabilities() {
+		return this._serverCapabilities;
+	}
+	/**
+	* After initialization has completed, this will be populated with information about the server's name and version.
+	*/
+	getServerVersion() {
+		return this._serverVersion;
+	}
+	/**
+	* After initialization has completed, this may be populated with information about the server's instructions.
+	*/
+	getInstructions() {
+		return this._instructions;
+	}
+	assertCapabilityForMethod(method) {
+		switch (method) {
+			case "logging/setLevel":
+				if (!this._serverCapabilities?.logging) throw new Error(`Server does not support logging (required for ${method})`);
+				break;
+			case "prompts/get":
+			case "prompts/list":
+				if (!this._serverCapabilities?.prompts) throw new Error(`Server does not support prompts (required for ${method})`);
+				break;
+			case "resources/list":
+			case "resources/templates/list":
+			case "resources/read":
+			case "resources/subscribe":
+			case "resources/unsubscribe":
+				if (!this._serverCapabilities?.resources) throw new Error(`Server does not support resources (required for ${method})`);
+				if (method === "resources/subscribe" && !this._serverCapabilities.resources.subscribe) throw new Error(`Server does not support resource subscriptions (required for ${method})`);
+				break;
+			case "tools/call":
+			case "tools/list":
+				if (!this._serverCapabilities?.tools) throw new Error(`Server does not support tools (required for ${method})`);
+				break;
+			case "completion/complete":
+				if (!this._serverCapabilities?.completions) throw new Error(`Server does not support completions (required for ${method})`);
+				break;
+			case "initialize": break;
+			case "ping": break;
+		}
+	}
+	assertNotificationCapability(method) {
+		switch (method) {
+			case "notifications/roots/list_changed":
+				if (!this._capabilities.roots?.listChanged) throw new Error(`Client does not support roots list changed notifications (required for ${method})`);
+				break;
+			case "notifications/initialized": break;
+			case "notifications/cancelled": break;
+			case "notifications/progress": break;
+		}
+	}
+	assertRequestHandlerCapability(method) {
+		if (!this._capabilities) return;
+		switch (method) {
+			case "sampling/createMessage":
+				if (!this._capabilities.sampling) throw new Error(`Client does not support sampling capability (required for ${method})`);
+				break;
+			case "elicitation/create":
+				if (!this._capabilities.elicitation) throw new Error(`Client does not support elicitation capability (required for ${method})`);
+				break;
+			case "roots/list":
+				if (!this._capabilities.roots) throw new Error(`Client does not support roots capability (required for ${method})`);
+				break;
+			case "tasks/get":
+			case "tasks/list":
+			case "tasks/result":
+			case "tasks/cancel":
+				if (!this._capabilities.tasks) throw new Error(`Client does not support tasks capability (required for ${method})`);
+				break;
+			case "ping": break;
+		}
+	}
+	assertTaskCapability(method) {
+		assertToolsCallTaskCapability(this._serverCapabilities?.tasks?.requests, method, "Server");
+	}
+	assertTaskHandlerCapability(method) {
+		if (!this._capabilities) return;
+		assertClientRequestTaskCapability(this._capabilities.tasks?.requests, method, "Client");
+	}
+	async ping(options) {
+		return this.request({ method: "ping" }, EmptyResultSchema, options);
+	}
+	async complete(params, options) {
+		return this.request({
+			method: "completion/complete",
+			params
+		}, CompleteResultSchema, options);
+	}
+	async setLoggingLevel(level, options) {
+		return this.request({
+			method: "logging/setLevel",
+			params: { level }
+		}, EmptyResultSchema, options);
+	}
+	async getPrompt(params, options) {
+		return this.request({
+			method: "prompts/get",
+			params
+		}, GetPromptResultSchema, options);
+	}
+	async listPrompts(params, options) {
+		return this.request({
+			method: "prompts/list",
+			params
+		}, ListPromptsResultSchema, options);
+	}
+	async listResources(params, options) {
+		return this.request({
+			method: "resources/list",
+			params
+		}, ListResourcesResultSchema, options);
+	}
+	async listResourceTemplates(params, options) {
+		return this.request({
+			method: "resources/templates/list",
+			params
+		}, ListResourceTemplatesResultSchema, options);
+	}
+	async readResource(params, options) {
+		return this.request({
+			method: "resources/read",
+			params
+		}, ReadResourceResultSchema, options);
+	}
+	async subscribeResource(params, options) {
+		return this.request({
+			method: "resources/subscribe",
+			params
+		}, EmptyResultSchema, options);
+	}
+	async unsubscribeResource(params, options) {
+		return this.request({
+			method: "resources/unsubscribe",
+			params
+		}, EmptyResultSchema, options);
+	}
+	/**
+	* Calls a tool and waits for the result. Automatically validates structured output if the tool has an outputSchema.
+	*
+	* For task-based execution with streaming behavior, use client.experimental.tasks.callToolStream() instead.
+	*/
+	async callTool(params, resultSchema = CallToolResultSchema, options) {
+		if (this.isToolTaskRequired(params.name)) throw new McpError(ErrorCode.InvalidRequest, `Tool "${params.name}" requires task-based execution. Use client.experimental.tasks.callToolStream() instead.`);
+		const result = await this.request({
+			method: "tools/call",
+			params
+		}, resultSchema, options);
+		const validator = this.getToolOutputValidator(params.name);
+		if (validator) {
+			if (!result.structuredContent && !result.isError) throw new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`);
+			if (result.structuredContent) try {
+				const validationResult = validator(result.structuredContent);
+				if (!validationResult.valid) throw new McpError(ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`);
+			} catch (error) {
+				if (error instanceof McpError) throw error;
+				throw new McpError(ErrorCode.InvalidParams, `Failed to validate structured content: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+		return result;
+	}
+	isToolTask(toolName) {
+		if (!this._serverCapabilities?.tasks?.requests?.tools?.call) return false;
+		return this._cachedKnownTaskTools.has(toolName);
+	}
+	/**
+	* Check if a tool requires task-based execution.
+	* Unlike isToolTask which includes 'optional' tools, this only checks for 'required'.
+	*/
+	isToolTaskRequired(toolName) {
+		return this._cachedRequiredTaskTools.has(toolName);
+	}
+	/**
+	* Cache validators for tool output schemas.
+	* Called after listTools() to pre-compile validators for better performance.
+	*/
+	cacheToolMetadata(tools) {
+		this._cachedToolOutputValidators.clear();
+		this._cachedKnownTaskTools.clear();
+		this._cachedRequiredTaskTools.clear();
+		for (const tool of tools) {
+			if (tool.outputSchema) {
+				const toolValidator = this._jsonSchemaValidator.getValidator(tool.outputSchema);
+				this._cachedToolOutputValidators.set(tool.name, toolValidator);
+			}
+			const taskSupport = tool.execution?.taskSupport;
+			if (taskSupport === "required" || taskSupport === "optional") this._cachedKnownTaskTools.add(tool.name);
+			if (taskSupport === "required") this._cachedRequiredTaskTools.add(tool.name);
+		}
+	}
+	/**
+	* Get cached validator for a tool
+	*/
+	getToolOutputValidator(toolName) {
+		return this._cachedToolOutputValidators.get(toolName);
+	}
+	async listTools(params, options) {
+		const result = await this.request({
+			method: "tools/list",
+			params
+		}, ListToolsResultSchema, options);
+		this.cacheToolMetadata(result.tools);
+		return result;
+	}
+	/**
+	* Set up a single list changed handler.
+	* @internal
+	*/
+	_setupListChangedHandler(listType, notificationSchema, options, fetcher) {
+		const parseResult = ListChangedOptionsBaseSchema.safeParse(options);
+		if (!parseResult.success) throw new Error(`Invalid ${listType} listChanged options: ${parseResult.error.message}`);
+		if (typeof options.onChanged !== "function") throw new Error(`Invalid ${listType} listChanged options: onChanged must be a function`);
+		const { autoRefresh, debounceMs } = parseResult.data;
+		const { onChanged } = options;
+		const refresh = async () => {
+			if (!autoRefresh) {
+				onChanged(null, null);
+				return;
+			}
+			try {
+				onChanged(null, await fetcher());
+			} catch (e) {
+				onChanged(e instanceof Error ? e : new Error(String(e)), null);
+			}
+		};
+		const handler = () => {
+			if (debounceMs) {
+				const existingTimer = this._listChangedDebounceTimers.get(listType);
+				if (existingTimer) clearTimeout(existingTimer);
+				const timer = setTimeout(refresh, debounceMs);
+				this._listChangedDebounceTimers.set(listType, timer);
+			} else refresh();
+		};
+		this.setNotificationHandler(notificationSchema, handler);
+	}
+	async sendRootsListChanged() {
+		return this.notification({ method: "notifications/roots/list_changed" });
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
+/**
+* Buffers a continuous stdio stream into discrete JSON-RPC messages.
+*/
+var ReadBuffer = class {
+	append(chunk) {
+		this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
+	}
+	readMessage() {
+		if (!this._buffer) return null;
+		const index = this._buffer.indexOf("\n");
+		if (index === -1) return null;
+		const line = this._buffer.toString("utf8", 0, index).replace(/\r$/, "");
+		this._buffer = this._buffer.subarray(index + 1);
+		return deserializeMessage(line);
+	}
+	clear() {
+		this._buffer = void 0;
+	}
+};
+function deserializeMessage(line) {
+	return JSONRPCMessageSchema.parse(JSON.parse(line));
+}
+function serializeMessage(message) {
+	return JSON.stringify(message) + "\n";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/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.
+*
+* @experimental
+*/
+/**
+* Experimental task features for low-level MCP servers.
+*
+* Access via `server.experimental.tasks`:
+* ```typescript
+* const stream = server.experimental.tasks.requestStream(request, schema, options);
+* ```
+*
+* For high-level server usage with task-based tools, use `McpServer.experimental.tasks` instead.
+*
+* @experimental
+*/
+var ExperimentalServerTasks = class {
+	constructor(_server) {
+		this._server = _server;
+	}
+	/**
+	* Sends a request and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* This method provides streaming access to request processing, allowing you to
+	* observe intermediate task status updates for task-augmented requests.
+	*
+	* @param request - The request to send
+	* @param resultSchema - Zod schema for validating the result
+	* @param options - Optional request options (timeout, signal, task creation params, etc.)
+	* @returns AsyncGenerator that yields ResponseMessage objects
+	*
+	* @experimental
+	*/
+	requestStream(request, resultSchema, options) {
+		return this._server.requestStream(request, resultSchema, options);
+	}
+	/**
+	* Gets the current status of a task.
+	*
+	* @param taskId - The task identifier
+	* @param options - Optional request options
+	* @returns The task status
+	*
+	* @experimental
+	*/
+	async getTask(taskId, options) {
+		return this._server.getTask({ taskId }, options);
+	}
+	/**
+	* Retrieves the result of a completed task.
+	*
+	* @param taskId - The task identifier
+	* @param resultSchema - Zod schema for validating the result
+	* @param options - Optional request options
+	* @returns The task result
+	*
+	* @experimental
+	*/
+	async getTaskResult(taskId, resultSchema, options) {
+		return this._server.getTaskResult({ taskId }, resultSchema, options);
+	}
+	/**
+	* Lists tasks with optional pagination.
+	*
+	* @param cursor - Optional pagination cursor
+	* @param options - Optional request options
+	* @returns List of tasks with optional next cursor
+	*
+	* @experimental
+	*/
+	async listTasks(cursor, options) {
+		return this._server.listTasks(cursor ? { cursor } : void 0, options);
+	}
+	/**
+	* Cancels a running task.
+	*
+	* @param taskId - The task identifier
+	* @param options - Optional request options
+	*
+	* @experimental
+	*/
+	async cancelTask(taskId, options) {
+		return this._server.cancelTask({ taskId }, options);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
+/**
+* An MCP server on top of a pluggable transport.
+*
+* This server will automatically respond to the initialization flow as initiated from the client.
+*
+* To use with custom types, extend the base Request/Notification/Result types and pass them as type parameters:
+*
+* ```typescript
+* // Custom schemas
+* const CustomRequestSchema = RequestSchema.extend({...})
+* const CustomNotificationSchema = NotificationSchema.extend({...})
+* const CustomResultSchema = ResultSchema.extend({...})
+*
+* // Type aliases
+* type CustomRequest = z.infer<typeof CustomRequestSchema>
+* type CustomNotification = z.infer<typeof CustomNotificationSchema>
+* type CustomResult = z.infer<typeof CustomResultSchema>
+*
+* // Create typed server
+* const server = new Server<CustomRequest, CustomNotification, CustomResult>({
+*   name: "CustomServer",
+*   version: "1.0.0"
+* })
+* ```
+* @deprecated Use `McpServer` instead for the high-level API. Only use `Server` for advanced use cases.
+*/
+var Server = class extends Protocol {
+	/**
+	* Initializes this server with the given name and version information.
+	*/
+	constructor(_serverInfo, options) {
+		super(options);
+		this._serverInfo = _serverInfo;
+		this._loggingLevels = /* @__PURE__ */ new Map();
+		this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
+		this.isMessageIgnored = (level, sessionId) => {
+			const currentLevel = this._loggingLevels.get(sessionId);
+			return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
+		};
+		this._capabilities = options?.capabilities ?? {};
+		this._instructions = options?.instructions;
+		this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
+		this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request));
+		this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.());
+		if (this._capabilities.logging) this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
+			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);
+			return {};
+		});
+	}
+	/**
+	* Access experimental features.
+	*
+	* WARNING: These APIs are experimental and may change without notice.
+	*
+	* @experimental
+	*/
+	get experimental() {
+		if (!this._experimental) this._experimental = { tasks: new ExperimentalServerTasks(this) };
+		return this._experimental;
+	}
+	/**
+	* Registers new capabilities. This can only be called before connecting to a transport.
+	*
+	* The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
+	*/
+	registerCapabilities(capabilities) {
+		if (this.transport) throw new Error("Cannot register capabilities after connecting to transport");
+		this._capabilities = mergeCapabilities(this._capabilities, capabilities);
+	}
+	/**
+	* Override request handler registration to enforce server-side validation for tools/call.
+	*/
+	setRequestHandler(requestSchema, handler) {
+		const methodSchema = getObjectShape(requestSchema)?.method;
+		if (!methodSchema) throw new Error("Schema is missing a method literal");
+		let methodValue;
+		if (isZ4Schema(methodSchema)) {
+			const v4Schema = methodSchema;
+			methodValue = (v4Schema._zod?.def)?.value ?? v4Schema.value;
+		} else {
+			const v3Schema = methodSchema;
+			methodValue = v3Schema._def?.value ?? v3Schema.value;
+		}
+		if (typeof methodValue !== "string") throw new Error("Schema method literal must be a string");
+		if (methodValue === "tools/call") {
+			const wrappedHandler = async (request, extra) => {
+				const validatedRequest = safeParse(CallToolRequestSchema, request);
+				if (!validatedRequest.success) {
+					const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+					throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
+				}
+				const { params } = validatedRequest.data;
+				const result = await Promise.resolve(handler(request, extra));
+				if (params.task) {
+					const taskValidationResult = safeParse(CreateTaskResultSchema, result);
+					if (!taskValidationResult.success) {
+						const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+						throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+					}
+					return taskValidationResult.data;
+				}
+				const validationResult = safeParse(CallToolResultSchema, result);
+				if (!validationResult.success) {
+					const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+					throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
+				}
+				return validationResult.data;
+			};
+			return super.setRequestHandler(requestSchema, wrappedHandler);
+		}
+		return super.setRequestHandler(requestSchema, handler);
+	}
+	assertCapabilityForMethod(method) {
+		switch (method) {
+			case "sampling/createMessage":
+				if (!this._clientCapabilities?.sampling) throw new Error(`Client does not support sampling (required for ${method})`);
+				break;
+			case "elicitation/create":
+				if (!this._clientCapabilities?.elicitation) throw new Error(`Client does not support elicitation (required for ${method})`);
+				break;
+			case "roots/list":
+				if (!this._clientCapabilities?.roots) throw new Error(`Client does not support listing roots (required for ${method})`);
+				break;
+			case "ping": break;
+		}
+	}
+	assertNotificationCapability(method) {
+		switch (method) {
+			case "notifications/message":
+				if (!this._capabilities.logging) throw new Error(`Server does not support logging (required for ${method})`);
+				break;
+			case "notifications/resources/updated":
+			case "notifications/resources/list_changed":
+				if (!this._capabilities.resources) throw new Error(`Server does not support notifying about resources (required for ${method})`);
+				break;
+			case "notifications/tools/list_changed":
+				if (!this._capabilities.tools) throw new Error(`Server does not support notifying of tool list changes (required for ${method})`);
+				break;
+			case "notifications/prompts/list_changed":
+				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 (!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;
+		}
+	}
+	assertRequestHandlerCapability(method) {
+		if (!this._capabilities) return;
+		switch (method) {
+			case "completion/complete":
+				if (!this._capabilities.completions) throw new Error(`Server does not support completions (required for ${method})`);
+				break;
+			case "logging/setLevel":
+				if (!this._capabilities.logging) throw new Error(`Server does not support logging (required for ${method})`);
+				break;
+			case "prompts/get":
+			case "prompts/list":
+				if (!this._capabilities.prompts) throw new Error(`Server does not support prompts (required for ${method})`);
+				break;
+			case "resources/list":
+			case "resources/templates/list":
+			case "resources/read":
+				if (!this._capabilities.resources) throw new Error(`Server does not support resources (required for ${method})`);
+				break;
+			case "tools/call":
+			case "tools/list":
+				if (!this._capabilities.tools) throw new Error(`Server does not support tools (required for ${method})`);
+				break;
+			case "tasks/get":
+			case "tasks/list":
+			case "tasks/result":
+			case "tasks/cancel":
+				if (!this._capabilities.tasks) throw new Error(`Server does not support tasks capability (required for ${method})`);
+				break;
+			case "ping":
+			case "initialize": break;
+		}
+	}
+	assertTaskCapability(method) {
+		assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, "Client");
+	}
+	assertTaskHandlerCapability(method) {
+		if (!this._capabilities) return;
+		assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, "Server");
+	}
+	async _oninitialize(request) {
+		const requestedVersion = request.params.protocolVersion;
+		this._clientCapabilities = request.params.capabilities;
+		this._clientVersion = request.params.clientInfo;
+		return {
+			protocolVersion: SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION,
+			capabilities: this.getCapabilities(),
+			serverInfo: this._serverInfo,
+			...this._instructions && { instructions: this._instructions }
+		};
+	}
+	/**
+	* After initialization has completed, this will be populated with the client's reported capabilities.
+	*/
+	getClientCapabilities() {
+		return this._clientCapabilities;
+	}
+	/**
+	* After initialization has completed, this will be populated with information about the client's name and version.
+	*/
+	getClientVersion() {
+		return this._clientVersion;
+	}
+	getCapabilities() {
+		return this._capabilities;
+	}
+	async ping() {
+		return this.request({ method: "ping" }, EmptyResultSchema);
+	}
+	async createMessage(params, options) {
+		if (params.tools || params.toolChoice) {
+			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];
+			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");
+			}
+		}
+		if (params.tools) return this.request({
+			method: "sampling/createMessage",
+			params
+		}, CreateMessageResultWithToolsSchema, options);
+		return this.request({
+			method: "sampling/createMessage",
+			params
+		}, CreateMessageResultSchema, options);
+	}
+	/**
+	* Creates an elicitation request for the given parameters.
+	* For backwards compatibility, `mode` may be omitted for form requests and will default to `'form'`.
+	* @param params The parameters for the elicitation request.
+	* @param options Optional request options.
+	* @returns The result of the elicitation request.
+	*/
+	async elicitInput(params, options) {
+		switch (params.mode ?? "form") {
+			case "url": {
+				if (!this._clientCapabilities?.elicitation?.url) throw new Error("Client does not support url elicitation.");
+				const urlParams = params;
+				return this.request({
+					method: "elicitation/create",
+					params: urlParams
+				}, ElicitResultSchema, options);
+			}
+			case "form": {
+				if (!this._clientCapabilities?.elicitation?.form) throw new Error("Client does not support form elicitation.");
+				const formParams = params.mode === "form" ? params : {
+					...params,
+					mode: "form"
+				};
+				const result = await this.request({
+					method: "elicitation/create",
+					params: formParams
+				}, ElicitResultSchema, options);
+				if (result.action === "accept" && result.content && formParams.requestedSchema) try {
+					const validationResult = this._jsonSchemaValidator.getValidator(formParams.requestedSchema)(result.content);
+					if (!validationResult.valid) throw new McpError(ErrorCode.InvalidParams, `Elicitation response content does not match requested schema: ${validationResult.errorMessage}`);
+				} catch (error) {
+					if (error instanceof McpError) throw error;
+					throw new McpError(ErrorCode.InternalError, `Error validating elicitation response: ${error instanceof Error ? error.message : String(error)}`);
+				}
+				return result;
+			}
+		}
+	}
+	/**
+	* Creates a reusable callback that, when invoked, will send a `notifications/elicitation/complete`
+	* notification for the specified elicitation ID.
+	*
+	* @param elicitationId The ID of the elicitation to mark as complete.
+	* @param options Optional notification options. Useful when the completion notification should be related to a prior request.
+	* @returns A function that emits the completion notification when awaited.
+	*/
+	createElicitationCompletionNotifier(elicitationId, options) {
+		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 }
+		}, options);
+	}
+	async listRoots(params, options) {
+		return this.request({
+			method: "roots/list",
+			params
+		}, ListRootsResultSchema, options);
+	}
+	/**
+	* Sends a logging message to the client, if connected.
+	* Note: You only need to send the parameters object, not the entire JSON RPC message
+	* @see LoggingMessageNotification
+	* @param params
+	* @param sessionId optional for stateless and backward compatibility
+	*/
+	async sendLoggingMessage(params, sessionId) {
+		if (this._capabilities.logging) {
+			if (!this.isMessageIgnored(params.level, sessionId)) return this.notification({
+				method: "notifications/message",
+				params
+			});
+		}
+	}
+	async sendResourceUpdated(params) {
+		return this.notification({
+			method: "notifications/resources/updated",
+			params
+		});
+	}
+	async sendResourceListChanged() {
+		return this.notification({ method: "notifications/resources/list_changed" });
+	}
+	async sendToolListChanged() {
+		return this.notification({ method: "notifications/tools/list_changed" });
+	}
+	async sendPromptListChanged() {
+		return this.notification({ method: "notifications/prompts/list_changed" });
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js
+const COMPLETABLE_SYMBOL = Symbol.for("mcp.completable");
 /**
-* A no-op JSON Schema validator that always returns valid.
+* Checks if a schema is completable (has completion metadata).
+*/
+function isCompletable(schema) {
+	return !!schema && typeof schema === "object" && COMPLETABLE_SYMBOL in schema;
+}
+/**
+* Gets the completer callback from a completable schema, if it exists.
+*/
+function getCompleter(schema) {
+	return schema[COMPLETABLE_SYMBOL]?.complete;
+}
+var McpZodTypeKind;
+(function(McpZodTypeKind$1) {
+	McpZodTypeKind$1["Completable"] = "McpCompletable";
+})(McpZodTypeKind || (McpZodTypeKind = {}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/toolNameValidation.js
+/**
+* Tool name validation utilities according to SEP: Specify Format for Tool Names
 *
-* Use this in browser environments where:
-* - ajv causes "Error compiling schema" errors
-* - Validation is already handled elsewhere (e.g., by Zod)
-* - You need to avoid eval/Function constructor restrictions
+* Tool names SHOULD be between 1 and 128 characters in length (inclusive).
+* Tool names are case-sensitive.
+* Allowed characters: uppercase and lowercase ASCII letters (A-Z, a-z), digits
+* (0-9), underscore (_), dash (-), and dot (.).
+* Tool names SHOULD NOT contain spaces, commas, or other special characters.
+*/
+/**
+* Regular expression for valid tool names according to SEP-986 specification
+*/
+const TOOL_NAME_REGEX = /^[A-Za-z0-9._-]{1,128}$/;
+/**
+* Validates a tool name according to the SEP specification
+* @param name - The tool name to validate
+* @returns An object containing validation result and any warnings
+*/
+function validateToolName(name) {
+	const warnings = [];
+	if (name.length === 0) return {
+		isValid: false,
+		warnings: ["Tool name cannot be empty"]
+	};
+	if (name.length > 128) return {
+		isValid: false,
+		warnings: [`Tool name exceeds maximum length of 128 characters (current: ${name.length})`]
+	};
+	if (name.includes(" ")) warnings.push("Tool name contains spaces, which may cause parsing issues");
+	if (name.includes(",")) warnings.push("Tool name contains commas, which may cause parsing issues");
+	if (name.startsWith("-") || name.endsWith("-")) warnings.push("Tool name starts or ends with a dash, which may cause parsing issues in some contexts");
+	if (name.startsWith(".") || name.endsWith(".")) warnings.push("Tool name starts or ends with a dot, which may cause parsing issues in some contexts");
+	if (!TOOL_NAME_REGEX.test(name)) {
+		const invalidChars = name.split("").filter((char) => !/[A-Za-z0-9._-]/.test(char)).filter((char, index, arr) => arr.indexOf(char) === index);
+		warnings.push(`Tool name contains invalid characters: ${invalidChars.map((c) => `"${c}"`).join(", ")}`, "Allowed characters are: A-Z, a-z, 0-9, underscore (_), dash (-), and dot (.)");
+		return {
+			isValid: false,
+			warnings
+		};
+	}
+	return {
+		isValid: true,
+		warnings
+	};
+}
+/**
+* Issues warnings for non-conforming tool names
+* @param name - The tool name that triggered the warnings
+* @param warnings - Array of warning messages
+*/
+function issueToolNameWarning(name, warnings) {
+	if (warnings.length > 0) {
+		console.warn(`Tool name validation warning for "${name}":`);
+		for (const warning of warnings) console.warn(`  - ${warning}`);
+		console.warn("Tool registration will proceed, but this may cause compatibility issues.");
+		console.warn("Consider updating the tool name to conform to the MCP tool naming standard.");
+		console.warn("See SEP: Specify Format for Tool Names (https://github.com/modelcontextprotocol/modelcontextprotocol/issues/986) for more details.");
+	}
+}
+/**
+* Validates a tool name and issues warnings for non-conforming names
+* @param name - The tool name to validate
+* @returns true if the name is valid, false otherwise
+*/
+function validateAndWarnToolName(name) {
+	const result = validateToolName(name);
+	issueToolNameWarning(name, result.warnings);
+	return result.isValid;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.js
+/**
+* Experimental McpServer task features for MCP SDK.
+* WARNING: These APIs are experimental and may change without notice.
 *
-* @example
-* ```typescript
-* import { BrowserMcpServer } from '@mcp-b/webmcp-ts-sdk';
-* import { NoOpJsonSchemaValidator } from '@mcp-b/webmcp-ts-sdk/no-op-validator';
+* @experimental
+*/
+/**
+* Experimental task features for McpServer.
 *
-* const server = new BrowserMcpServer(
-*   { name: 'my-server', version: '1.0.0' },
-*   { jsonSchemaValidator: new NoOpJsonSchemaValidator() }
-* );
+* Access via `server.experimental.tasks`:
+* ```typescript
+* server.experimental.tasks.registerToolTask('long-running', config, handler);
 * ```
+*
+* @experimental
 */
-var NoOpJsonSchemaValidator = class {
+var ExperimentalMcpServerTasks = class {
+	constructor(_mcpServer) {
+		this._mcpServer = _mcpServer;
+	}
+	registerToolTask(name, config, handler) {
+		const execution = {
+			taskSupport: "required",
+			...config.execution
+		};
+		if (execution.taskSupport === "forbidden") throw new Error(`Cannot register task-based tool '${name}' with taskSupport 'forbidden'. Use registerTool() instead.`);
+		return this._mcpServer._createRegisteredTool(name, config.title, config.description, config.inputSchema, config.outputSchema, config.annotations, execution, config._meta, handler);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js
+/**
+* High-level MCP server that provides a simpler API for working with resources, tools, and prompts.
+* For advanced usage (like sending notifications or setting custom request handlers), use the underlying
+* Server instance available via the `server` property.
+*/
+var McpServer = class {
+	constructor(serverInfo, options) {
+		this._registeredResources = {};
+		this._registeredResourceTemplates = {};
+		this._registeredTools = {};
+		this._registeredPrompts = {};
+		this._toolHandlersInitialized = false;
+		this._completionHandlerInitialized = false;
+		this._resourceHandlersInitialized = false;
+		this._promptHandlersInitialized = false;
+		this.server = new Server(serverInfo, options);
+	}
 	/**
-	* Returns a validator function that always passes.
-	* The input data is passed through unchanged.
+	* Access experimental features.
 	*
-	* @param _schema - The JSON Schema (ignored)
-	* @returns A validator function that always returns valid
+	* WARNING: These APIs are experimental and may change without notice.
+	*
+	* @experimental
 	*/
-	getValidator(_schema) {
-		return (input) => ({
-			valid: true,
-			data: input,
-			errorMessage: void 0
+	get experimental() {
+		if (!this._experimental) this._experimental = { tasks: new ExperimentalMcpServerTasks(this) };
+		return this._experimental;
+	}
+	/**
+	* Attaches to the given transport, starts it, and starts listening for messages.
+	*
+	* The `server` 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) {
+		return await this.server.connect(transport);
+	}
+	/**
+	* Closes the connection.
+	*/
+	async close() {
+		await this.server.close();
+	}
+	setToolRequestHandlers() {
+		if (this._toolHandlersInitialized) return;
+		this.server.assertCanSetRequestHandler(getMethodValue(ListToolsRequestSchema));
+		this.server.assertCanSetRequestHandler(getMethodValue(CallToolRequestSchema));
+		this.server.registerCapabilities({ tools: { listChanged: true } });
+		this.server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: Object.entries(this._registeredTools).filter(([, tool]) => tool.enabled).map(([name, tool]) => {
+			const toolDefinition = {
+				name,
+				title: tool.title,
+				description: tool.description,
+				inputSchema: (() => {
+					const obj = normalizeObjectSchema(tool.inputSchema);
+					return obj ? toJsonSchemaCompat(obj, {
+						strictUnions: true,
+						pipeStrategy: "input"
+					}) : EMPTY_OBJECT_JSON_SCHEMA;
+				})(),
+				annotations: tool.annotations,
+				execution: tool.execution,
+				_meta: tool._meta
+			};
+			if (tool.outputSchema) {
+				const obj = normalizeObjectSchema(tool.outputSchema);
+				if (obj) toolDefinition.outputSchema = toJsonSchemaCompat(obj, {
+					strictUnions: true,
+					pipeStrategy: "output"
+				});
+			}
+			return toolDefinition;
+		}) }));
+		this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+			try {
+				const tool = this._registeredTools[request.params.name];
+				if (!tool) throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
+				if (!tool.enabled) throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} disabled`);
+				const isTaskRequest = !!request.params.task;
+				const taskSupport = tool.execution?.taskSupport;
+				const isTaskHandler = "createTask" in tool.handler;
+				if ((taskSupport === "required" || taskSupport === "optional") && !isTaskHandler) throw new McpError(ErrorCode.InternalError, `Tool ${request.params.name} has taskSupport '${taskSupport}' but was not registered with registerToolTask`);
+				if (taskSupport === "required" && !isTaskRequest) throw new McpError(ErrorCode.MethodNotFound, `Tool ${request.params.name} requires task augmentation (taskSupport: 'required')`);
+				if (taskSupport === "optional" && !isTaskRequest && isTaskHandler) return await this.handleAutomaticTaskPolling(tool, request, extra);
+				const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
+				const result = await this.executeToolHandler(tool, args, extra);
+				if (isTaskRequest) return result;
+				await this.validateToolOutput(tool, result, request.params.name);
+				return result;
+			} catch (error) {
+				if (error instanceof McpError) {
+					if (error.code === ErrorCode.UrlElicitationRequired) throw error;
+				}
+				return this.createToolError(error instanceof Error ? error.message : String(error));
+			}
+		});
+		this._toolHandlersInitialized = true;
+	}
+	/**
+	* Creates a tool error result.
+	*
+	* @param errorMessage - The error message.
+	* @returns The tool error result.
+	*/
+	createToolError(errorMessage) {
+		return {
+			content: [{
+				type: "text",
+				text: errorMessage
+			}],
+			isError: true
+		};
+	}
+	/**
+	* Validates tool input arguments against the tool's input schema.
+	*/
+	async validateToolInput(tool, args, toolName) {
+		if (!tool.inputSchema) return;
+		const parseResult = await safeParseAsync(normalizeObjectSchema(tool.inputSchema) ?? tool.inputSchema, args);
+		if (!parseResult.success) {
+			const errorMessage = getParseErrorMessage("error" in parseResult ? parseResult.error : "Unknown error");
+			throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage}`);
+		}
+		return parseResult.data;
+	}
+	/**
+	* Validates tool output against the tool's output schema.
+	*/
+	async validateToolOutput(tool, result, toolName) {
+		if (!tool.outputSchema) return;
+		if (!("content" in result)) return;
+		if (result.isError) return;
+		if (!result.structuredContent) throw new McpError(ErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`);
+		const parseResult = await safeParseAsync(normalizeObjectSchema(tool.outputSchema), result.structuredContent);
+		if (!parseResult.success) {
+			const errorMessage = getParseErrorMessage("error" in parseResult ? parseResult.error : "Unknown error");
+			throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage}`);
+		}
+	}
+	/**
+	* Executes a tool handler (either regular or task-based).
+	*/
+	async executeToolHandler(tool, args, extra) {
+		const handler = tool.handler;
+		if ("createTask" in handler) {
+			if (!extra.taskStore) throw new Error("No task store provided.");
+			const taskExtra = {
+				...extra,
+				taskStore: extra.taskStore
+			};
+			if (tool.inputSchema) {
+				const typedHandler = handler;
+				return await Promise.resolve(typedHandler.createTask(args, taskExtra));
+			} else {
+				const typedHandler = handler;
+				return await Promise.resolve(typedHandler.createTask(taskExtra));
+			}
+		}
+		if (tool.inputSchema) {
+			const typedHandler = handler;
+			return await Promise.resolve(typedHandler(args, extra));
+		} else {
+			const typedHandler = handler;
+			return await Promise.resolve(typedHandler(extra));
+		}
+	}
+	/**
+	* Handles automatic task polling for tools with taskSupport 'optional'.
+	*/
+	async handleAutomaticTaskPolling(tool, request, extra) {
+		if (!extra.taskStore) throw new Error("No task store provided for task-capable tool.");
+		const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
+		const handler = tool.handler;
+		const taskExtra = {
+			...extra,
+			taskStore: extra.taskStore
+		};
+		const createTaskResult = args ? await Promise.resolve(handler.createTask(args, taskExtra)) : await Promise.resolve(handler.createTask(taskExtra));
+		const taskId = createTaskResult.task.taskId;
+		let task = createTaskResult.task;
+		const pollInterval = task.pollInterval ?? 5e3;
+		while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
+			await new Promise((resolve) => setTimeout(resolve, pollInterval));
+			const updatedTask = await extra.taskStore.getTask(taskId);
+			if (!updatedTask) throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
+			task = updatedTask;
+		}
+		return await extra.taskStore.getTaskResult(taskId);
+	}
+	setCompletionRequestHandler() {
+		if (this._completionHandlerInitialized) return;
+		this.server.assertCanSetRequestHandler(getMethodValue(CompleteRequestSchema));
+		this.server.registerCapabilities({ completions: {} });
+		this.server.setRequestHandler(CompleteRequestSchema, async (request) => {
+			switch (request.params.ref.type) {
+				case "ref/prompt":
+					assertCompleteRequestPrompt(request);
+					return this.handlePromptCompletion(request, request.params.ref);
+				case "ref/resource":
+					assertCompleteRequestResourceTemplate(request);
+					return this.handleResourceCompletion(request, request.params.ref);
+				default: throw new McpError(ErrorCode.InvalidParams, `Invalid completion reference: ${request.params.ref}`);
+			}
+		});
+		this._completionHandlerInitialized = true;
+	}
+	async handlePromptCompletion(request, ref) {
+		const prompt = this._registeredPrompts[ref.name];
+		if (!prompt) throw new McpError(ErrorCode.InvalidParams, `Prompt ${ref.name} not found`);
+		if (!prompt.enabled) throw new McpError(ErrorCode.InvalidParams, `Prompt ${ref.name} disabled`);
+		if (!prompt.argsSchema) return EMPTY_COMPLETION_RESULT;
+		const field = getObjectShape(prompt.argsSchema)?.[request.params.argument.name];
+		if (!isCompletable(field)) return EMPTY_COMPLETION_RESULT;
+		const completer = getCompleter(field);
+		if (!completer) return EMPTY_COMPLETION_RESULT;
+		return createCompletionResult(await completer(request.params.argument.value, request.params.context));
+	}
+	async handleResourceCompletion(request, ref) {
+		const template = Object.values(this._registeredResourceTemplates).find((t) => t.resourceTemplate.uriTemplate.toString() === ref.uri);
+		if (!template) {
+			if (this._registeredResources[ref.uri]) return EMPTY_COMPLETION_RESULT;
+			throw new McpError(ErrorCode.InvalidParams, `Resource template ${request.params.ref.uri} not found`);
+		}
+		const completer = template.resourceTemplate.completeCallback(request.params.argument.name);
+		if (!completer) return EMPTY_COMPLETION_RESULT;
+		return createCompletionResult(await completer(request.params.argument.value, request.params.context));
+	}
+	setResourceRequestHandlers() {
+		if (this._resourceHandlersInitialized) return;
+		this.server.assertCanSetRequestHandler(getMethodValue(ListResourcesRequestSchema));
+		this.server.assertCanSetRequestHandler(getMethodValue(ListResourceTemplatesRequestSchema));
+		this.server.assertCanSetRequestHandler(getMethodValue(ReadResourceRequestSchema));
+		this.server.registerCapabilities({ resources: { listChanged: true } });
+		this.server.setRequestHandler(ListResourcesRequestSchema, async (request, extra) => {
+			const resources = Object.entries(this._registeredResources).filter(([_, resource]) => resource.enabled).map(([uri, resource]) => ({
+				uri,
+				name: resource.name,
+				...resource.metadata
+			}));
+			const templateResources = [];
+			for (const template of Object.values(this._registeredResourceTemplates)) {
+				if (!template.resourceTemplate.listCallback) continue;
+				const result = await template.resourceTemplate.listCallback(extra);
+				for (const resource of result.resources) templateResources.push({
+					...template.metadata,
+					...resource
+				});
+			}
+			return { resources: [...resources, ...templateResources] };
+		});
+		this.server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
+			return { resourceTemplates: Object.entries(this._registeredResourceTemplates).map(([name, template]) => ({
+				name,
+				uriTemplate: template.resourceTemplate.uriTemplate.toString(),
+				...template.metadata
+			})) };
+		});
+		this.server.setRequestHandler(ReadResourceRequestSchema, async (request, extra) => {
+			const uri = new URL(request.params.uri);
+			const resource = this._registeredResources[uri.toString()];
+			if (resource) {
+				if (!resource.enabled) throw new McpError(ErrorCode.InvalidParams, `Resource ${uri} disabled`);
+				return resource.readCallback(uri, extra);
+			}
+			for (const template of Object.values(this._registeredResourceTemplates)) {
+				const variables = template.resourceTemplate.uriTemplate.match(uri.toString());
+				if (variables) return template.readCallback(uri, variables, extra);
+			}
+			throw new McpError(ErrorCode.InvalidParams, `Resource ${uri} not found`);
 		});
+		this._resourceHandlersInitialized = true;
+	}
+	setPromptRequestHandlers() {
+		if (this._promptHandlersInitialized) return;
+		this.server.assertCanSetRequestHandler(getMethodValue(ListPromptsRequestSchema));
+		this.server.assertCanSetRequestHandler(getMethodValue(GetPromptRequestSchema));
+		this.server.registerCapabilities({ prompts: { listChanged: true } });
+		this.server.setRequestHandler(ListPromptsRequestSchema, () => ({ prompts: Object.entries(this._registeredPrompts).filter(([, prompt]) => prompt.enabled).map(([name, prompt]) => {
+			return {
+				name,
+				title: prompt.title,
+				description: prompt.description,
+				arguments: prompt.argsSchema ? promptArgumentsFromSchema(prompt.argsSchema) : void 0
+			};
+		}) }));
+		this.server.setRequestHandler(GetPromptRequestSchema, async (request, extra) => {
+			const prompt = this._registeredPrompts[request.params.name];
+			if (!prompt) throw new McpError(ErrorCode.InvalidParams, `Prompt ${request.params.name} not found`);
+			if (!prompt.enabled) throw new McpError(ErrorCode.InvalidParams, `Prompt ${request.params.name} disabled`);
+			if (prompt.argsSchema) {
+				const parseResult = await safeParseAsync(normalizeObjectSchema(prompt.argsSchema), request.params.arguments);
+				if (!parseResult.success) {
+					const errorMessage = getParseErrorMessage("error" in parseResult ? parseResult.error : "Unknown error");
+					throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${errorMessage}`);
+				}
+				const args = parseResult.data;
+				const cb = prompt.callback;
+				return await Promise.resolve(cb(args, extra));
+			} else {
+				const cb = prompt.callback;
+				return await Promise.resolve(cb(extra));
+			}
+		});
+		this._promptHandlersInitialized = true;
+	}
+	resource(name, uriOrTemplate, ...rest) {
+		let metadata;
+		if (typeof rest[0] === "object") metadata = rest.shift();
+		const readCallback = rest[0];
+		if (typeof uriOrTemplate === "string") {
+			if (this._registeredResources[uriOrTemplate]) throw new Error(`Resource ${uriOrTemplate} is already registered`);
+			const registeredResource = this._createRegisteredResource(name, void 0, uriOrTemplate, metadata, readCallback);
+			this.setResourceRequestHandlers();
+			this.sendResourceListChanged();
+			return registeredResource;
+		} else {
+			if (this._registeredResourceTemplates[name]) throw new Error(`Resource template ${name} is already registered`);
+			const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, void 0, uriOrTemplate, metadata, readCallback);
+			this.setResourceRequestHandlers();
+			this.sendResourceListChanged();
+			return registeredResourceTemplate;
+		}
+	}
+	registerResource(name, uriOrTemplate, config, readCallback) {
+		if (typeof uriOrTemplate === "string") {
+			if (this._registeredResources[uriOrTemplate]) throw new Error(`Resource ${uriOrTemplate} is already registered`);
+			const registeredResource = this._createRegisteredResource(name, config.title, uriOrTemplate, config, readCallback);
+			this.setResourceRequestHandlers();
+			this.sendResourceListChanged();
+			return registeredResource;
+		} else {
+			if (this._registeredResourceTemplates[name]) throw new Error(`Resource template ${name} is already registered`);
+			const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, config.title, uriOrTemplate, config, readCallback);
+			this.setResourceRequestHandlers();
+			this.sendResourceListChanged();
+			return registeredResourceTemplate;
+		}
+	}
+	_createRegisteredResource(name, title, uri, metadata, readCallback) {
+		const registeredResource = {
+			name,
+			title,
+			metadata,
+			readCallback,
+			enabled: true,
+			disable: () => registeredResource.update({ enabled: false }),
+			enable: () => registeredResource.update({ enabled: true }),
+			remove: () => registeredResource.update({ uri: null }),
+			update: (updates) => {
+				if (typeof updates.uri !== "undefined" && updates.uri !== uri) {
+					delete this._registeredResources[uri];
+					if (updates.uri) this._registeredResources[updates.uri] = registeredResource;
+				}
+				if (typeof updates.name !== "undefined") registeredResource.name = updates.name;
+				if (typeof updates.title !== "undefined") registeredResource.title = updates.title;
+				if (typeof updates.metadata !== "undefined") registeredResource.metadata = updates.metadata;
+				if (typeof updates.callback !== "undefined") registeredResource.readCallback = updates.callback;
+				if (typeof updates.enabled !== "undefined") registeredResource.enabled = updates.enabled;
+				this.sendResourceListChanged();
+			}
+		};
+		this._registeredResources[uri] = registeredResource;
+		return registeredResource;
+	}
+	_createRegisteredResourceTemplate(name, title, template, metadata, readCallback) {
+		const registeredResourceTemplate = {
+			resourceTemplate: template,
+			title,
+			metadata,
+			readCallback,
+			enabled: true,
+			disable: () => registeredResourceTemplate.update({ enabled: false }),
+			enable: () => registeredResourceTemplate.update({ enabled: true }),
+			remove: () => registeredResourceTemplate.update({ name: null }),
+			update: (updates) => {
+				if (typeof updates.name !== "undefined" && updates.name !== name) {
+					delete this._registeredResourceTemplates[name];
+					if (updates.name) this._registeredResourceTemplates[updates.name] = registeredResourceTemplate;
+				}
+				if (typeof updates.title !== "undefined") registeredResourceTemplate.title = updates.title;
+				if (typeof updates.template !== "undefined") registeredResourceTemplate.resourceTemplate = updates.template;
+				if (typeof updates.metadata !== "undefined") registeredResourceTemplate.metadata = updates.metadata;
+				if (typeof updates.callback !== "undefined") registeredResourceTemplate.readCallback = updates.callback;
+				if (typeof updates.enabled !== "undefined") registeredResourceTemplate.enabled = updates.enabled;
+				this.sendResourceListChanged();
+			}
+		};
+		this._registeredResourceTemplates[name] = registeredResourceTemplate;
+		const variableNames = template.uriTemplate.variableNames;
+		if (Array.isArray(variableNames) && variableNames.some((v) => !!template.completeCallback(v))) this.setCompletionRequestHandler();
+		return registeredResourceTemplate;
+	}
+	_createRegisteredPrompt(name, title, description, argsSchema, callback) {
+		const registeredPrompt = {
+			title,
+			description,
+			argsSchema: argsSchema === void 0 ? void 0 : objectFromShape(argsSchema),
+			callback,
+			enabled: true,
+			disable: () => registeredPrompt.update({ enabled: false }),
+			enable: () => registeredPrompt.update({ enabled: true }),
+			remove: () => registeredPrompt.update({ name: null }),
+			update: (updates) => {
+				if (typeof updates.name !== "undefined" && updates.name !== name) {
+					delete this._registeredPrompts[name];
+					if (updates.name) this._registeredPrompts[updates.name] = registeredPrompt;
+				}
+				if (typeof updates.title !== "undefined") registeredPrompt.title = updates.title;
+				if (typeof updates.description !== "undefined") registeredPrompt.description = updates.description;
+				if (typeof updates.argsSchema !== "undefined") registeredPrompt.argsSchema = objectFromShape(updates.argsSchema);
+				if (typeof updates.callback !== "undefined") registeredPrompt.callback = updates.callback;
+				if (typeof updates.enabled !== "undefined") registeredPrompt.enabled = updates.enabled;
+				this.sendPromptListChanged();
+			}
+		};
+		this._registeredPrompts[name] = registeredPrompt;
+		if (argsSchema) {
+			if (Object.values(argsSchema).some((field) => {
+				return isCompletable(field instanceof ZodOptional ? field._def?.innerType : field);
+			})) this.setCompletionRequestHandler();
+		}
+		return registeredPrompt;
+	}
+	_createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, execution, _meta, handler) {
+		validateAndWarnToolName(name);
+		const registeredTool = {
+			title,
+			description,
+			inputSchema: getZodSchemaObject(inputSchema),
+			outputSchema: getZodSchemaObject(outputSchema),
+			annotations,
+			execution,
+			_meta,
+			handler,
+			enabled: true,
+			disable: () => registeredTool.update({ enabled: false }),
+			enable: () => registeredTool.update({ enabled: true }),
+			remove: () => registeredTool.update({ name: null }),
+			update: (updates) => {
+				if (typeof updates.name !== "undefined" && updates.name !== name) {
+					if (typeof updates.name === "string") validateAndWarnToolName(updates.name);
+					delete this._registeredTools[name];
+					if (updates.name) this._registeredTools[updates.name] = registeredTool;
+				}
+				if (typeof updates.title !== "undefined") registeredTool.title = updates.title;
+				if (typeof updates.description !== "undefined") registeredTool.description = updates.description;
+				if (typeof updates.paramsSchema !== "undefined") registeredTool.inputSchema = objectFromShape(updates.paramsSchema);
+				if (typeof updates.outputSchema !== "undefined") registeredTool.outputSchema = objectFromShape(updates.outputSchema);
+				if (typeof updates.callback !== "undefined") registeredTool.handler = updates.callback;
+				if (typeof updates.annotations !== "undefined") registeredTool.annotations = updates.annotations;
+				if (typeof updates._meta !== "undefined") registeredTool._meta = updates._meta;
+				if (typeof updates.enabled !== "undefined") registeredTool.enabled = updates.enabled;
+				this.sendToolListChanged();
+			}
+		};
+		this._registeredTools[name] = registeredTool;
+		this.setToolRequestHandlers();
+		this.sendToolListChanged();
+		return registeredTool;
+	}
+	/**
+	* tool() implementation. Parses arguments passed to overrides defined above.
+	*/
+	tool(name, ...rest) {
+		if (this._registeredTools[name]) throw new Error(`Tool ${name} is already registered`);
+		let description;
+		let inputSchema;
+		let outputSchema;
+		let annotations;
+		if (typeof rest[0] === "string") description = rest.shift();
+		if (rest.length > 1) {
+			const firstArg = rest[0];
+			if (isZodRawShapeCompat(firstArg)) {
+				inputSchema = rest.shift();
+				if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShapeCompat(rest[0])) annotations = rest.shift();
+			} else if (typeof firstArg === "object" && firstArg !== null) annotations = rest.shift();
+		}
+		const callback = rest[0];
+		return this._createRegisteredTool(name, void 0, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, void 0, callback);
+	}
+	/**
+	* Registers a tool with a config object and callback.
+	*/
+	registerTool(name, config, cb) {
+		if (this._registeredTools[name]) throw new Error(`Tool ${name} is already registered`);
+		const { title, description, inputSchema, outputSchema, annotations, _meta } = config;
+		return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, _meta, cb);
+	}
+	prompt(name, ...rest) {
+		if (this._registeredPrompts[name]) throw new Error(`Prompt ${name} is already registered`);
+		let description;
+		if (typeof rest[0] === "string") description = rest.shift();
+		let argsSchema;
+		if (rest.length > 1) argsSchema = rest.shift();
+		const cb = rest[0];
+		const registeredPrompt = this._createRegisteredPrompt(name, void 0, description, argsSchema, cb);
+		this.setPromptRequestHandlers();
+		this.sendPromptListChanged();
+		return registeredPrompt;
+	}
+	/**
+	* Registers a prompt with a config object and callback.
+	*/
+	registerPrompt(name, config, cb) {
+		if (this._registeredPrompts[name]) throw new Error(`Prompt ${name} is already registered`);
+		const { title, description, argsSchema } = config;
+		const registeredPrompt = this._createRegisteredPrompt(name, title, description, argsSchema, cb);
+		this.setPromptRequestHandlers();
+		this.sendPromptListChanged();
+		return registeredPrompt;
+	}
+	/**
+	* Checks if the server is connected to a transport.
+	* @returns True if the server is connected
+	*/
+	isConnected() {
+		return this.server.transport !== void 0;
+	}
+	/**
+	* Sends a logging message to the client, if connected.
+	* Note: You only need to send the parameters object, not the entire JSON RPC message
+	* @see LoggingMessageNotification
+	* @param params
+	* @param sessionId optional for stateless and backward compatibility
+	*/
+	async sendLoggingMessage(params, sessionId) {
+		return this.server.sendLoggingMessage(params, sessionId);
+	}
+	/**
+	* Sends a resource list changed event to the client, if connected.
+	*/
+	sendResourceListChanged() {
+		if (this.isConnected()) this.server.sendResourceListChanged();
+	}
+	/**
+	* Sends a tool list changed event to the client, if connected.
+	*/
+	sendToolListChanged() {
+		if (this.isConnected()) this.server.sendToolListChanged();
+	}
+	/**
+	* Sends a prompt list changed event to the client, if connected.
+	*/
+	sendPromptListChanged() {
+		if (this.isConnected()) this.server.sendPromptListChanged();
+	}
+};
+const EMPTY_OBJECT_JSON_SCHEMA = {
+	type: "object",
+	properties: {}
+};
+/**
+* Checks if a value looks like a Zod schema by checking for parse/safeParse methods.
+*/
+function isZodTypeLike(value) {
+	return value !== null && typeof value === "object" && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
+}
+/**
+* Checks if an object is a Zod schema instance (v3 or v4).
+*
+* Zod schemas have internal markers:
+* - v3: `_def` property
+* - v4: `_zod` property
+*
+* This includes transformed schemas like z.preprocess(), z.transform(), z.pipe().
+*/
+function isZodSchemaInstance(obj) {
+	return "_def" in obj || "_zod" in obj || isZodTypeLike(obj);
+}
+/**
+* Checks if an object is a "raw shape" - a plain object where values are Zod schemas.
+*
+* Raw shapes are used as shorthand: `{ name: z.string() }` instead of `z.object({ name: z.string() })`.
+*
+* IMPORTANT: This must NOT match actual Zod schema instances (like z.preprocess, z.pipe),
+* which have internal properties that could be mistaken for schema values.
+*/
+function isZodRawShapeCompat(obj) {
+	if (typeof obj !== "object" || obj === null) return false;
+	if (isZodSchemaInstance(obj)) return false;
+	if (Object.keys(obj).length === 0) return true;
+	return Object.values(obj).some(isZodTypeLike);
+}
+/**
+* Converts a provided Zod schema to a Zod object if it is a ZodRawShapeCompat,
+* otherwise returns the schema as is.
+*/
+function getZodSchemaObject(schema) {
+	if (!schema) return;
+	if (isZodRawShapeCompat(schema)) return objectFromShape(schema);
+	return schema;
+}
+function promptArgumentsFromSchema(schema) {
+	const shape = getObjectShape(schema);
+	if (!shape) return [];
+	return Object.entries(shape).map(([name, field]) => {
+		return {
+			name,
+			description: getSchemaDescription(field),
+			required: !isSchemaOptional(field)
+		};
+	});
+}
+function getMethodValue(schema) {
+	const methodSchema = getObjectShape(schema)?.method;
+	if (!methodSchema) throw new Error("Schema is missing a method literal");
+	const value = getLiteralValue(methodSchema);
+	if (typeof value === "string") return value;
+	throw new Error("Schema method literal must be a string");
+}
+function createCompletionResult(suggestions) {
+	return { completion: {
+		values: suggestions.slice(0, 100),
+		total: suggestions.length,
+		hasMore: suggestions.length > 100
+	} };
+}
+const EMPTY_COMPLETION_RESULT = { completion: {
+	values: [],
+	hasMore: false
+} };
+
+//#endregion
+//#region src/polyfill-validator.ts
+var PolyfillJsonSchemaValidator = class {
+	getValidator(schema) {
+		return (input) => {
+			if (!isPlainObject(input)) return {
+				valid: false,
+				data: void 0,
+				errorMessage: "expected object arguments"
+			};
+			const issue = validateArgsWithSchema(input, schema);
+			if (issue) return {
+				valid: false,
+				data: void 0,
+				errorMessage: issue.message
+			};
+			return {
+				valid: true,
+				data: input,
+				errorMessage: void 0
+			};
+		};
 	}
 };
 
 //#endregion
 //#region src/browser-server.ts
+const DEFAULT_INPUT_SCHEMA = {
+	type: "object",
+	properties: {}
+};
+const DEFAULT_CLIENT_REQUEST_TIMEOUT = 1e4;
+function isPlainObject$1(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isCallToolResult(value) {
+	return isPlainObject$1(value) && Array.isArray(value.content);
+}
+function isJsonPrimitive(value) {
+	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isJsonValue(value) {
+	if (isJsonPrimitive(value)) return Number.isFinite(value) || typeof value !== "number";
+	if (Array.isArray(value)) return value.every((entry) => isJsonValue(entry));
+	if (!isPlainObject$1(value)) return false;
+	return Object.values(value).every((entry) => isJsonValue(entry));
+}
+function toStructuredContent(value) {
+	if (!isPlainObject$1(value) || !isJsonValue(value)) return;
+	return value;
+}
+function serializeTextContent(value) {
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+function normalizeToolResponse(value) {
+	if (isCallToolResult(value)) return value;
+	const structuredContent = toStructuredContent(value);
+	return {
+		content: [{
+			type: "text",
+			text: serializeTextContent(value)
+		}],
+		...structuredContent ? { structuredContent } : {},
+		isError: false
+	};
+}
+function withDefaultTimeout(options) {
+	if (options?.signal) return options;
+	return {
+		...options,
+		signal: AbortSignal.timeout(DEFAULT_CLIENT_REQUEST_TIMEOUT)
+	};
+}
 /**
-* Browser-optimized MCP Server for Web Model Context API (navigator.modelContext).
+* Browser-optimized MCP Server that speaks WebMCP natively.
 *
-* This class extends McpServer to support dynamic registration of tools, resources,
-* and prompts after transport connection, which is required for the Web Model Context API
-* where items are registered via navigator.modelContext.provideContext() at any time.
+* This server IS navigator.modelContext — it implements the WebMCP standard API
+* (provideContext, registerTool, unregisterTool, clearContext) while retaining
+* full MCP protocol capabilities (resources, prompts, elicitation, sampling)
+* via the inherited BaseMcpServer surface.
 *
-* Key differences from base McpServer:
-* - Pre-registers tool, resource, and prompt capabilities before connection
-* - Allows items to be registered after transport is connected
-* - Uses no-op JSON Schema validator to avoid ajv errors in browser environments
-* - Designed for browser environments where items arrive asynchronously
+* When `native` is provided, all tool operations are mirrored to it so that
+* navigator.modelContextTesting (polyfill testing shim) stays in sync.
 */
 var BrowserMcpServer = class extends McpServer {
+	native;
+	_promptSchemas = /* @__PURE__ */ new Map();
+	_jsonValidator;
+	_publicMethodsBound = false;
 	constructor(serverInfo, options) {
+		const validator = new PolyfillJsonSchemaValidator();
 		const enhancedOptions = {
-			...options,
-			capabilities: mergeCapabilities$1(options?.capabilities || {}, {
+			capabilities: mergeCapabilities(options?.capabilities || {}, {
 				tools: { listChanged: true },
 				resources: { listChanged: true },
 				prompts: { listChanged: true }
 			}),
-			jsonSchemaValidator: options?.jsonSchemaValidator ?? new NoOpJsonSchemaValidator()
+			jsonSchemaValidator: options?.jsonSchemaValidator ?? validator
 		};
 		super(serverInfo, enhancedOptions);
+		this._jsonValidator = validator;
+		this.native = options?.native;
+		this.bindPublicApiMethods();
+	}
+	/**
+	* navigator.modelContext consumers may destructure methods (e.g. const { registerTool } = ...).
+	* Bind methods once so they remain callable outside instance-method invocation syntax.
+	*/
+	bindPublicApiMethods() {
+		if (this._publicMethodsBound) return;
+		this.registerTool = this.registerTool.bind(this);
+		this.unregisterTool = this.unregisterTool.bind(this);
+		this.provideContext = this.provideContext.bind(this);
+		this.clearContext = this.clearContext.bind(this);
+		this.listTools = this.listTools.bind(this);
+		this.callTool = this.callTool.bind(this);
+		this.executeTool = this.executeTool.bind(this);
+		this.registerResource = this.registerResource.bind(this);
+		this.listResources = this.listResources.bind(this);
+		this.readResource = this.readResource.bind(this);
+		this.registerPrompt = this.registerPrompt.bind(this);
+		this.listPrompts = this.listPrompts.bind(this);
+		this.getPrompt = this.getPrompt.bind(this);
+		this.createMessage = this.createMessage.bind(this);
+		this.elicitInput = this.elicitInput.bind(this);
+		this._publicMethodsBound = true;
+	}
+	get _parentTools() {
+		return this._registeredTools;
+	}
+	get _parentResources() {
+		return this._registeredResources;
+	}
+	get _parentPrompts() {
+		return this._registeredPrompts;
+	}
+	/**
+	* Converts a schema (Zod or plain JSON Schema) to a transport-ready JSON Schema.
+	* When `requireObjectType` is true (the default, for inputSchema), empty `{}` schemas
+	* are normalized to `{ type: "object", properties: {} }` and schemas missing a root
+	* `type` get `type: "object"` prepended — per MCP spec requirements.
+	* When false (for outputSchema), no object-type normalization is applied.
+	*/
+	toTransportSchema(schema, requireObjectType = true) {
+		if (!schema || typeof schema !== "object") {
+			if (requireObjectType) {
+				console.warn(`[BrowserMcpServer] toTransportSchema received non-object schema (${typeof schema}), using default`);
+				return DEFAULT_INPUT_SCHEMA;
+			}
+			return {};
+		}
+		const normalized = normalizeObjectSchema(schema);
+		const jsonSchema = normalized ? toJsonSchemaCompat(normalized, {
+			strictUnions: true,
+			pipeStrategy: "input"
+		}) : schema;
+		if (Object.keys(jsonSchema).length === 0) {
+			if (requireObjectType) {
+				console.warn("[BrowserMcpServer] toTransportSchema received empty {} schema, normalizing to default object schema");
+				return DEFAULT_INPUT_SCHEMA;
+			}
+			return jsonSchema;
+		}
+		if (requireObjectType && jsonSchema.type === void 0) {
+			console.warn("[BrowserMcpServer] toTransportSchema received schema without root type, prepending type:\"object\"");
+			return {
+				type: "object",
+				...jsonSchema
+			};
+		}
+		return jsonSchema;
+	}
+	isZodSchema(schema) {
+		if (!schema || typeof schema !== "object") return false;
+		const s = schema;
+		return "_zod" in s || "_def" in s;
+	}
+	getNativeToolsApi() {
+		if (!this.native) return;
+		const candidate = this.native;
+		if (typeof candidate.listTools !== "function" || typeof candidate.callTool !== "function") return;
+		return candidate;
+	}
+	registerToolInServer(tool) {
+		const inputSchema = this.toTransportSchema(tool.inputSchema);
+		super.registerTool(tool.name, {
+			description: tool.description,
+			inputSchema,
+			...tool.outputSchema ? { outputSchema: tool.outputSchema } : {},
+			...tool.annotations ? { annotations: tool.annotations } : {}
+		}, async (args) => {
+			return normalizeToolResponse(await tool.execute(args, { requestUserInteraction: async (cb) => cb() }));
+		});
+		return { unregister: () => this.unregisterTool(tool.name) };
+	}
+	backfillTools(tools, execute) {
+		let synced = 0;
+		for (const sourceTool of tools) {
+			if (!sourceTool?.name || this._parentTools[sourceTool.name]) continue;
+			const toolDescriptor = {
+				name: sourceTool.name,
+				description: sourceTool.description ?? "",
+				inputSchema: sourceTool.inputSchema ?? DEFAULT_INPUT_SCHEMA,
+				execute: async (args) => execute(sourceTool.name, args)
+			};
+			if (sourceTool.outputSchema) toolDescriptor.outputSchema = sourceTool.outputSchema;
+			if (sourceTool.annotations) toolDescriptor.annotations = sourceTool.annotations;
+			this.registerToolInServer(toolDescriptor);
+			synced++;
+		}
+		return synced;
+	}
+	registerTool(tool) {
+		if (this.native) this.native.registerTool(tool);
+		try {
+			return this.registerToolInServer(tool);
+		} catch (error) {
+			if (this.native) try {
+				this.native.unregisterTool(tool.name);
+			} catch (rollbackError) {
+				console.error("[BrowserMcpServer] Rollback of native tool registration failed:", rollbackError);
+			}
+			throw error;
+		}
+	}
+	/**
+	* Backfill tools that were already registered on the native/polyfill context
+	* before this BrowserMcpServer wrapper was installed.
+	*/
+	syncNativeTools() {
+		const nativeToolsApi = this.getNativeToolsApi();
+		if (!nativeToolsApi) return 0;
+		const nativeCallTool = nativeToolsApi.callTool.bind(nativeToolsApi);
+		return this.backfillTools(nativeToolsApi.listTools(), async (name, args) => nativeCallTool({
+			name,
+			arguments: args
+		}));
+	}
+	unregisterTool(name) {
+		this._parentTools[name]?.remove();
+		if (this.native) this.native.unregisterTool(name);
+	}
+	registerResource(descriptor) {
+		const registered = super.registerResource(descriptor.name, descriptor.uri, {
+			...descriptor.description !== void 0 && { description: descriptor.description },
+			...descriptor.mimeType !== void 0 && { mimeType: descriptor.mimeType }
+		}, async (uri) => ({ contents: (await descriptor.read(uri)).contents }));
+		return { unregister: () => registered.remove() };
+	}
+	registerPrompt(descriptor) {
+		if (descriptor.argsSchema) this._promptSchemas.set(descriptor.name, descriptor.argsSchema);
+		const registered = super.registerPrompt(descriptor.name, { ...descriptor.description !== void 0 && { description: descriptor.description } }, async (args) => ({ messages: (await descriptor.get(args)).messages }));
+		return { unregister: () => {
+			this._promptSchemas.delete(descriptor.name);
+			registered.remove();
+		} };
+	}
+	provideContext(options) {
+		for (const tool of Object.values(this._parentTools)) tool.remove();
+		if (this.native) this.native.clearContext();
+		for (const tool of options?.tools ?? []) this.registerTool(tool);
+	}
+	clearContext() {
+		for (const tool of Object.values(this._parentTools)) tool.remove();
+		if (this.native) this.native.clearContext();
+	}
+	listResources() {
+		return Object.entries(this._parentResources).filter(([, resource]) => resource.enabled).map(([uri, resource]) => ({
+			uri,
+			name: resource.name,
+			...resource.metadata
+		}));
+	}
+	async readResource(uri) {
+		const resource = this._parentResources[uri];
+		if (!resource) throw new Error(`Resource not found: ${uri}`);
+		return resource.readCallback(new URL(uri), {});
+	}
+	listPrompts() {
+		return Object.entries(this._parentPrompts).filter(([, prompt]) => prompt.enabled).map(([name, prompt]) => {
+			const schema = this._promptSchemas.get(name);
+			return {
+				name,
+				...prompt.description !== void 0 && { description: prompt.description },
+				...schema?.properties ? { arguments: Object.entries(schema.properties).map(([argName, prop]) => ({
+					name: argName,
+					...typeof prop === "object" && prop !== null && "description" in prop ? { description: prop.description } : {},
+					...schema.required?.includes(argName) ? { required: true } : {}
+				})) } : {}
+			};
+		});
+	}
+	async getPrompt(name, args = {}) {
+		const prompt = this._parentPrompts[name];
+		if (!prompt) throw new Error(`Prompt not found: ${name}`);
+		const schema = this._promptSchemas.get(name);
+		if (schema) {
+			const result = this._jsonValidator.getValidator(schema)(args);
+			if (!result.valid) throw new Error(`Invalid arguments for prompt ${name}: ${result.errorMessage}`);
+		}
+		return prompt.callback(args, {});
+	}
+	listTools() {
+		return Object.entries(this._parentTools).filter(([, tool]) => tool.enabled).map(([name, tool]) => {
+			const item = {
+				name,
+				description: tool.description ?? "",
+				inputSchema: this.toTransportSchema(tool.inputSchema ?? DEFAULT_INPUT_SCHEMA)
+			};
+			if (tool.outputSchema) item.outputSchema = this.toTransportSchema(tool.outputSchema, false);
+			if (tool.annotations) item.annotations = tool.annotations;
+			return item;
+		});
+	}
+	/**
+	* Override SDK's validateToolInput to handle both Zod schemas and plain JSON Schema.
+	* Zod schemas use the SDK's safeParseAsync; plain JSON Schema uses PolyfillJsonSchemaValidator.
+	*/
+	async validateToolInput(tool, args, toolName) {
+		if (!tool.inputSchema) return void 0;
+		if (this.isZodSchema(tool.inputSchema)) {
+			const result$1 = await safeParseAsync(tool.inputSchema, args ?? {});
+			if (!result$1.success) throw new Error(`Invalid arguments for tool ${toolName}: ${getParseErrorMessage(result$1.error)}`);
+			return result$1.data;
+		}
+		const result = this._jsonValidator.getValidator(tool.inputSchema)(args ?? {});
+		if (!result.valid) throw new Error(`Invalid arguments for tool ${toolName}: ${result.errorMessage}`);
+		return result.data;
+	}
+	/**
+	* Override SDK's validateToolOutput to handle both Zod schemas and plain JSON Schema.
+	*/
+	async validateToolOutput(tool, result, toolName) {
+		if (!tool.outputSchema) return;
+		const r = result;
+		if (!("content" in r) || r.isError || !r.structuredContent) return;
+		if (this.isZodSchema(tool.outputSchema)) {
+			const parseResult = await safeParseAsync(tool.outputSchema, r.structuredContent);
+			if (!parseResult.success) throw new Error(`Output validation error: Invalid structured content for tool ${toolName}: ${getParseErrorMessage(parseResult.error)}`);
+			return;
+		}
+		const validationResult = this._jsonValidator.getValidator(tool.outputSchema)(r.structuredContent);
+		if (!validationResult.valid) throw new Error(`Output validation error: Invalid structured content for tool ${toolName}: ${validationResult.errorMessage}`);
+	}
+	async callTool(params) {
+		const tool = this._parentTools[params.name];
+		if (!tool) throw new Error(`Tool not found: ${params.name}`);
+		return tool.handler(params.arguments ?? {}, {});
+	}
+	async executeTool(name, args = {}) {
+		return this.callTool({
+			name,
+			arguments: args
+		});
 	}
 	/**
-	* Override connect to ensure request handlers are initialized
-	* BEFORE the transport connection is established.
+	* Override connect to initialize request handlers BEFORE the transport connection.
+	* This prevents "Cannot register capabilities after connecting to transport" errors
+	* when tools are registered dynamically after connection.
 	*
-	* This prevents the "Cannot register capabilities after connecting to transport"
-	* error when items are registered dynamically after connection.
+	* After the parent sets up its Zod-based handlers, we replace the ones that break
+	* with plain JSON Schema objects (ListTools, ListPrompts, GetPrompt).
 	*/
 	async connect(transport) {
 		this.setToolRequestHandlers();
+		this.setResourceRequestHandlers();
+		this.setPromptRequestHandlers();
+		this.server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: this.listTools() }));
+		this.server.setRequestHandler(ListPromptsRequestSchema, () => ({ prompts: this.listPrompts() }));
+		this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+			const prompt = this._parentPrompts[request.params.name];
+			if (!prompt) throw new Error(`Prompt ${request.params.name} not found`);
+			if (!prompt.enabled) throw new Error(`Prompt ${request.params.name} disabled`);
+			const schema = this._promptSchemas.get(request.params.name);
+			if (schema) {
+				const result = this._jsonValidator.getValidator(schema)(request.params.arguments ?? {});
+				if (!result.valid) throw new Error(`Invalid arguments for prompt ${request.params.name}: ${result.errorMessage}`);
+				return prompt.callback(request.params.arguments, {});
+			}
+			return prompt.callback({}, {});
+		});
 		return super.connect(transport);
 	}
+	async createMessage(params, options) {
+		return this.server.createMessage(params, withDefaultTimeout(options));
+	}
+	async elicitInput(params, options) {
+		return this.server.elicitInput(params, withDefaultTimeout(options));
+	}
+};
+
+//#endregion
+//#region src/no-op-validator.ts
+/**
+* A no-op JSON Schema validator that always returns valid.
+*
+* Use this in browser environments where:
+* - ajv causes "Error compiling schema" errors
+* - Validation is already handled elsewhere (e.g., by Zod)
+* - You need to avoid eval/Function constructor restrictions
+*
+* @example
+* ```typescript
+* import { BrowserMcpServer } from '@mcp-b/webmcp-ts-sdk';
+* import { NoOpJsonSchemaValidator } from '@mcp-b/webmcp-ts-sdk/no-op-validator';
+*
+* const server = new BrowserMcpServer(
+*   { name: 'my-server', version: '1.0.0' },
+*   { jsonSchemaValidator: new NoOpJsonSchemaValidator() }
+* );
+* ```
+*/
+var NoOpJsonSchemaValidator = class {
+	/**
+	* Returns a validator function that always passes.
+	* The input data is passed through unchanged.
+	*
+	* @param _schema - The JSON Schema (ignored)
+	* @returns A validator function that always returns valid
+	*/
+	getValidator(_schema) {
+		return (input) => ({
+			valid: true,
+			data: input,
+			errorMessage: void 0
+		});
+	}
 };
 
 //#endregion
-export { BrowserMcpServer, BrowserMcpServer as McpServer, CallToolRequestSchema, CallToolResultSchema, Client, CreateMessageRequestSchema, CreateMessageResultSchema, ElicitRequestSchema, ElicitResultSchema, ErrorCode, GetPromptRequestSchema, GetPromptResultSchema, InitializeRequestSchema, InitializeResultSchema, JSONRPCMessageSchema, LATEST_PROTOCOL_VERSION, ListPromptsRequestSchema, ListPromptsResultSchema, ListResourcesRequestSchema, ListResourcesResultSchema, ListToolsRequestSchema, ListToolsResultSchema, LoggingLevelSchema, NoOpJsonSchemaValidator, ReadBuffer, ReadResourceRequestSchema, ReadResourceResultSchema, ResourceListChangedNotificationSchema, SUPPORTED_PROTOCOL_VERSIONS, Server, ToolListChangedNotificationSchema, mergeCapabilities, serializeMessage };
+export { BrowserMcpServer, BrowserMcpServer as McpServer, CallToolRequestSchema, CallToolResultSchema, Client, CreateMessageRequestSchema, CreateMessageResultSchema, ElicitRequestSchema, ElicitResultSchema, ErrorCode, GetPromptRequestSchema, GetPromptResultSchema, InitializeRequestSchema, InitializeResultSchema, JSONRPCMessageSchema, LATEST_PROTOCOL_VERSION, ListPromptsRequestSchema, ListPromptsResultSchema, ListResourcesRequestSchema, ListResourcesResultSchema, ListToolsRequestSchema, ListToolsResultSchema, LoggingLevelSchema, NoOpJsonSchemaValidator, PolyfillJsonSchemaValidator, ReadBuffer, ReadResourceRequestSchema, ReadResourceResultSchema, ResourceListChangedNotificationSchema, SUPPORTED_PROTOCOL_VERSIONS, ToolListChangedNotificationSchema, mergeCapabilities, serializeMessage };
 //# sourceMappingURL=index.js.map