sunpeak 0.16.29 → 0.17.2

package/template/node_modules/.vite-mcp/deps/protocol-CTflwIfG.js

@@ -0,0 +1,2090 @@
+import { Cn as object, In as string, It as custom, Jn as union, On as preprocess, Sn as number, Tt as array, Yn as unknown, jn as record, kt as boolean, ln as literal, mi as safeParse$1, tn as intersection, un as looseObject, vt as _enum, wn as optional, xr as datetime, xt as _null, zt as discriminatedUnion } from "./schemas-NsgmY9QV.js";
+//#region ../../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
+function isZ4Schema(s) {
+	return !!s._zod;
+}
+function safeParse(schema, data) {
+	if (isZ4Schema(schema)) return safeParse$1(schema, data);
+	return schema.safeParse(data);
+}
+function getObjectShape(schema) {
+	if (!schema) return void 0;
+	let rawShape;
+	if (isZ4Schema(schema)) rawShape = schema._zod?.def?.shape;
+	else rawShape = schema.shape;
+	if (!rawShape) return void 0;
+	if (typeof rawShape === "function") try {
+		return rawShape();
+	} catch {
+		return;
+	}
+	return rawShape;
+}
+/**
+* Gets the literal value from a schema, if it's a literal schema.
+* Works with both Zod v3 and v4.
+* Returns undefined if the schema is not a literal or the value cannot be determined.
+*/
+function getLiteralValue(schema) {
+	if (isZ4Schema(schema)) {
+		const def = schema._zod?.def;
+		if (def) {
+			if (def.value !== void 0) return def.value;
+			if (Array.isArray(def.values) && def.values.length > 0) return def.values[0];
+		}
+	}
+	const def = schema._def;
+	if (def) {
+		if (def.value !== void 0) return def.value;
+		if (Array.isArray(def.values) && def.values.length > 0) return def.values[0];
+	}
+	const directValue = schema.value;
+	if (directValue !== void 0) return directValue;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
+var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
+/**
+* Assert 'object' type schema.
+*
+* @internal
+*/
+var AssertObjectSchema = custom((v) => v !== null && (typeof v === "object" || typeof v === "function"));
+/**
+* A progress token, used to associate progress notifications with the original request.
+*/
+var ProgressTokenSchema = union([string(), number().int()]);
+/**
+* An opaque token used to represent a cursor for pagination.
+*/
+var CursorSchema = string();
+looseObject({
+	ttl: union([number(), _null()]).optional(),
+	pollInterval: number().optional()
+});
+var TaskMetadataSchema = object({ ttl: number().optional() });
+/**
+* Metadata for associating messages with a task.
+* Include this in the `_meta` field under the key `io.modelcontextprotocol/related-task`.
+*/
+var RelatedTaskMetadataSchema = object({ taskId: string() });
+var RequestMetaSchema = looseObject({
+	progressToken: ProgressTokenSchema.optional(),
+	[RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
+});
+/**
+* Common params for any request.
+*/
+var BaseRequestParamsSchema = object({ _meta: RequestMetaSchema.optional() });
+/**
+* Common params for any task-augmented request.
+*/
+var 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.
+*/
+var isTaskAugmentedRequestParams = (value) => TaskAugmentedRequestParamsSchema.safeParse(value).success;
+var RequestSchema = object({
+	method: string(),
+	params: BaseRequestParamsSchema.loose().optional()
+});
+var NotificationsParamsSchema = object({ _meta: RequestMetaSchema.optional() });
+var NotificationSchema = object({
+	method: string(),
+	params: NotificationsParamsSchema.loose().optional()
+});
+var ResultSchema = looseObject({ _meta: RequestMetaSchema.optional() });
+/**
+* A uniquely identifying ID for a request in JSON-RPC.
+*/
+var RequestIdSchema = union([string(), number().int()]);
+/**
+* A request that expects a response.
+*/
+var JSONRPCRequestSchema = object({
+	jsonrpc: literal("2.0"),
+	id: RequestIdSchema,
+	...RequestSchema.shape
+}).strict();
+var isJSONRPCRequest = (value) => JSONRPCRequestSchema.safeParse(value).success;
+/**
+* A notification which does not expect a response.
+*/
+var JSONRPCNotificationSchema = object({
+	jsonrpc: literal("2.0"),
+	...NotificationSchema.shape
+}).strict();
+var isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value).success;
+/**
+* A successful (non-error) response to a request.
+*/
+var JSONRPCResultResponseSchema = object({
+	jsonrpc: literal("2.0"),
+	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.
+*/
+var isJSONRPCResultResponse = (value) => JSONRPCResultResponseSchema.safeParse(value).success;
+/**
+* Error codes defined by the JSON-RPC specification.
+*/
+var ErrorCode;
+(function(ErrorCode) {
+	ErrorCode[ErrorCode["ConnectionClosed"] = -32e3] = "ConnectionClosed";
+	ErrorCode[ErrorCode["RequestTimeout"] = -32001] = "RequestTimeout";
+	ErrorCode[ErrorCode["ParseError"] = -32700] = "ParseError";
+	ErrorCode[ErrorCode["InvalidRequest"] = -32600] = "InvalidRequest";
+	ErrorCode[ErrorCode["MethodNotFound"] = -32601] = "MethodNotFound";
+	ErrorCode[ErrorCode["InvalidParams"] = -32602] = "InvalidParams";
+	ErrorCode[ErrorCode["InternalError"] = -32603] = "InternalError";
+	ErrorCode[ErrorCode["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired";
+})(ErrorCode || (ErrorCode = {}));
+/**
+* A response to a request that indicates an error occurred.
+*/
+var JSONRPCErrorResponseSchema = object({
+	jsonrpc: literal("2.0"),
+	id: RequestIdSchema.optional(),
+	error: object({
+		code: number().int(),
+		message: string(),
+		data: 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.
+*/
+var isJSONRPCErrorResponse = (value) => JSONRPCErrorResponseSchema.safeParse(value).success;
+var JSONRPCMessageSchema = union([
+	JSONRPCRequestSchema,
+	JSONRPCNotificationSchema,
+	JSONRPCResultResponseSchema,
+	JSONRPCErrorResponseSchema
+]);
+union([JSONRPCResultResponseSchema, JSONRPCErrorResponseSchema]);
+/**
+* A response that indicates success but carries no data.
+*/
+var EmptyResultSchema = ResultSchema.strict();
+var CancelledNotificationParamsSchema = NotificationsParamsSchema.extend({
+	requestId: RequestIdSchema.optional(),
+	reason: 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.
+*/
+var CancelledNotificationSchema = NotificationSchema.extend({
+	method: literal("notifications/cancelled"),
+	params: CancelledNotificationParamsSchema
+});
+/**
+* Base schema to add `icons` property.
+*
+*/
+var IconsSchema = object({ icons: array(object({
+	src: string(),
+	mimeType: string().optional(),
+	sizes: array(string()).optional(),
+	theme: _enum(["light", "dark"]).optional()
+})).optional() });
+/**
+* Base metadata interface for common properties across resources, tools, prompts, and implementations.
+*/
+var BaseMetadataSchema = object({
+	name: string(),
+	title: string().optional()
+});
+/**
+* Describes the name and version of an MCP implementation.
+*/
+var ImplementationSchema = BaseMetadataSchema.extend({
+	...BaseMetadataSchema.shape,
+	...IconsSchema.shape,
+	version: string(),
+	websiteUrl: string().optional(),
+	description: string().optional()
+});
+var ElicitationCapabilitySchema = preprocess((value) => {
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		if (Object.keys(value).length === 0) return { form: {} };
+	}
+	return value;
+}, intersection(object({
+	form: intersection(object({ applyDefaults: boolean().optional() }), record(string(), unknown())).optional(),
+	url: AssertObjectSchema.optional()
+}), record(string(), unknown()).optional()));
+/**
+* Task capabilities for clients, indicating which request types support task creation.
+*/
+var ClientTasksCapabilitySchema = looseObject({
+	list: AssertObjectSchema.optional(),
+	cancel: AssertObjectSchema.optional(),
+	requests: looseObject({
+		sampling: looseObject({ createMessage: AssertObjectSchema.optional() }).optional(),
+		elicitation: looseObject({ create: AssertObjectSchema.optional() }).optional()
+	}).optional()
+});
+/**
+* Task capabilities for servers, indicating which request types support task creation.
+*/
+var ServerTasksCapabilitySchema = looseObject({
+	list: AssertObjectSchema.optional(),
+	cancel: AssertObjectSchema.optional(),
+	requests: looseObject({ tools: looseObject({ call: AssertObjectSchema.optional() }).optional() }).optional()
+});
+/**
+* Capabilities a client may support. Known capabilities are defined here, in this schema, but this is not a closed set: any client can define its own, additional capabilities.
+*/
+var ClientCapabilitiesSchema = object({
+	experimental: record(string(), AssertObjectSchema).optional(),
+	sampling: object({
+		context: AssertObjectSchema.optional(),
+		tools: AssertObjectSchema.optional()
+	}).optional(),
+	elicitation: ElicitationCapabilitySchema.optional(),
+	roots: object({ listChanged: boolean().optional() }).optional(),
+	tasks: ClientTasksCapabilitySchema.optional()
+});
+var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
+	protocolVersion: string(),
+	capabilities: ClientCapabilitiesSchema,
+	clientInfo: ImplementationSchema
+});
+/**
+* This request is sent from the client to the server when it first connects, asking it to begin initialization.
+*/
+var InitializeRequestSchema = RequestSchema.extend({
+	method: 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.
+*/
+var ServerCapabilitiesSchema = object({
+	experimental: record(string(), AssertObjectSchema).optional(),
+	logging: AssertObjectSchema.optional(),
+	completions: AssertObjectSchema.optional(),
+	prompts: object({ listChanged: boolean().optional() }).optional(),
+	resources: object({
+		subscribe: boolean().optional(),
+		listChanged: boolean().optional()
+	}).optional(),
+	tools: object({ listChanged: boolean().optional() }).optional(),
+	tasks: ServerTasksCapabilitySchema.optional()
+});
+/**
+* After receiving an initialize request from the client, the server sends this response.
+*/
+var InitializeResultSchema = ResultSchema.extend({
+	protocolVersion: string(),
+	capabilities: ServerCapabilitiesSchema,
+	serverInfo: ImplementationSchema,
+	instructions: string().optional()
+});
+/**
+* This notification is sent from the client to the server after initialization has finished.
+*/
+var InitializedNotificationSchema = NotificationSchema.extend({
+	method: 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.
+*/
+var PingRequestSchema = RequestSchema.extend({
+	method: literal("ping"),
+	params: BaseRequestParamsSchema.optional()
+});
+var ProgressSchema = object({
+	progress: number(),
+	total: optional(number()),
+	message: optional(string())
+});
+var ProgressNotificationParamsSchema = 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
+*/
+var ProgressNotificationSchema = NotificationSchema.extend({
+	method: literal("notifications/progress"),
+	params: ProgressNotificationParamsSchema
+});
+var PaginatedRequestParamsSchema = BaseRequestParamsSchema.extend({ cursor: CursorSchema.optional() });
+var PaginatedRequestSchema = RequestSchema.extend({ params: PaginatedRequestParamsSchema.optional() });
+var PaginatedResultSchema = ResultSchema.extend({ nextCursor: CursorSchema.optional() });
+/**
+* The status of a task.
+* */
+var TaskStatusSchema = _enum([
+	"working",
+	"input_required",
+	"completed",
+	"failed",
+	"cancelled"
+]);
+/**
+* A pollable state object associated with a request.
+*/
+var TaskSchema = object({
+	taskId: string(),
+	status: TaskStatusSchema,
+	ttl: union([number(), _null()]),
+	createdAt: string(),
+	lastUpdatedAt: string(),
+	pollInterval: optional(number()),
+	statusMessage: optional(string())
+});
+/**
+* Result returned when a task is created, containing the task data wrapped in a task field.
+*/
+var CreateTaskResultSchema = ResultSchema.extend({ task: TaskSchema });
+/**
+* Parameters for task status notification.
+*/
+var TaskStatusNotificationParamsSchema = NotificationsParamsSchema.merge(TaskSchema);
+/**
+* A notification sent when a task's status changes.
+*/
+var TaskStatusNotificationSchema = NotificationSchema.extend({
+	method: literal("notifications/tasks/status"),
+	params: TaskStatusNotificationParamsSchema
+});
+/**
+* A request to get the state of a specific task.
+*/
+var GetTaskRequestSchema = RequestSchema.extend({
+	method: literal("tasks/get"),
+	params: BaseRequestParamsSchema.extend({ taskId: string() })
+});
+/**
+* The response to a tasks/get request.
+*/
+var GetTaskResultSchema = ResultSchema.merge(TaskSchema);
+/**
+* A request to get the result of a specific task.
+*/
+var GetTaskPayloadRequestSchema = RequestSchema.extend({
+	method: literal("tasks/result"),
+	params: BaseRequestParamsSchema.extend({ taskId: string() })
+});
+ResultSchema.loose();
+/**
+* A request to list tasks.
+*/
+var ListTasksRequestSchema = PaginatedRequestSchema.extend({ method: literal("tasks/list") });
+/**
+* The response to a tasks/list request.
+*/
+var ListTasksResultSchema = PaginatedResultSchema.extend({ tasks: array(TaskSchema) });
+/**
+* A request to cancel a specific task.
+*/
+var CancelTaskRequestSchema = RequestSchema.extend({
+	method: literal("tasks/cancel"),
+	params: BaseRequestParamsSchema.extend({ taskId: string() })
+});
+/**
+* The response to a tasks/cancel request.
+*/
+var CancelTaskResultSchema = ResultSchema.merge(TaskSchema);
+/**
+* The contents of a specific resource or sub-resource.
+*/
+var ResourceContentsSchema = object({
+	uri: string(),
+	mimeType: optional(string()),
+	_meta: record(string(), unknown()).optional()
+});
+var TextResourceContentsSchema = ResourceContentsSchema.extend({ text: 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.
+*/
+var Base64Schema = string().refine((val) => {
+	try {
+		atob(val);
+		return true;
+	} catch {
+		return false;
+	}
+}, { message: "Invalid Base64 string" });
+var BlobResourceContentsSchema = ResourceContentsSchema.extend({ blob: Base64Schema });
+/**
+* The sender or recipient of messages and data in a conversation.
+*/
+var RoleSchema = _enum(["user", "assistant"]);
+/**
+* Optional annotations providing clients additional context about a resource.
+*/
+var AnnotationsSchema = object({
+	audience: array(RoleSchema).optional(),
+	priority: number().min(0).max(1).optional(),
+	lastModified: datetime({ offset: true }).optional()
+});
+/**
+* A known resource that the server is capable of reading.
+*/
+var ResourceSchema = object({
+	...BaseMetadataSchema.shape,
+	...IconsSchema.shape,
+	uri: string(),
+	description: optional(string()),
+	mimeType: optional(string()),
+	annotations: AnnotationsSchema.optional(),
+	_meta: optional(looseObject({}))
+});
+/**
+* A template description for resources available on the server.
+*/
+var ResourceTemplateSchema = object({
+	...BaseMetadataSchema.shape,
+	...IconsSchema.shape,
+	uriTemplate: string(),
+	description: optional(string()),
+	mimeType: optional(string()),
+	annotations: AnnotationsSchema.optional(),
+	_meta: optional(looseObject({}))
+});
+/**
+* Sent from the client to request a list of resources the server has.
+*/
+var ListResourcesRequestSchema = PaginatedRequestSchema.extend({ method: literal("resources/list") });
+/**
+* The server's response to a resources/list request from the client.
+*/
+var ListResourcesResultSchema = PaginatedResultSchema.extend({ resources: array(ResourceSchema) });
+/**
+* Sent from the client to request a list of resource templates the server has.
+*/
+var ListResourceTemplatesRequestSchema = PaginatedRequestSchema.extend({ method: literal("resources/templates/list") });
+/**
+* The server's response to a resources/templates/list request from the client.
+*/
+var ListResourceTemplatesResultSchema = PaginatedResultSchema.extend({ resourceTemplates: array(ResourceTemplateSchema) });
+var ResourceRequestParamsSchema = BaseRequestParamsSchema.extend({ uri: string() });
+/**
+* Parameters for a `resources/read` request.
+*/
+var ReadResourceRequestParamsSchema = ResourceRequestParamsSchema;
+/**
+* Sent from the client to the server, to read a specific resource URI.
+*/
+var ReadResourceRequestSchema = RequestSchema.extend({
+	method: literal("resources/read"),
+	params: ReadResourceRequestParamsSchema
+});
+/**
+* The server's response to a resources/read request from the client.
+*/
+var ReadResourceResultSchema = ResultSchema.extend({ contents: array(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.
+*/
+var ResourceListChangedNotificationSchema = NotificationSchema.extend({
+	method: literal("notifications/resources/list_changed"),
+	params: NotificationsParamsSchema.optional()
+});
+var SubscribeRequestParamsSchema = ResourceRequestParamsSchema;
+/**
+* Sent from the client to request resources/updated notifications from the server whenever a particular resource changes.
+*/
+var SubscribeRequestSchema = RequestSchema.extend({
+	method: literal("resources/subscribe"),
+	params: SubscribeRequestParamsSchema
+});
+var UnsubscribeRequestParamsSchema = ResourceRequestParamsSchema;
+/**
+* Sent from the client to request cancellation of resources/updated notifications from the server. This should follow a previous resources/subscribe request.
+*/
+var UnsubscribeRequestSchema = RequestSchema.extend({
+	method: literal("resources/unsubscribe"),
+	params: UnsubscribeRequestParamsSchema
+});
+/**
+* Parameters for a `notifications/resources/updated` notification.
+*/
+var ResourceUpdatedNotificationParamsSchema = NotificationsParamsSchema.extend({ uri: 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.
+*/
+var ResourceUpdatedNotificationSchema = NotificationSchema.extend({
+	method: literal("notifications/resources/updated"),
+	params: ResourceUpdatedNotificationParamsSchema
+});
+/**
+* Describes an argument that a prompt can accept.
+*/
+var PromptArgumentSchema = object({
+	name: string(),
+	description: optional(string()),
+	required: optional(boolean())
+});
+/**
+* A prompt or prompt template that the server offers.
+*/
+var PromptSchema = object({
+	...BaseMetadataSchema.shape,
+	...IconsSchema.shape,
+	description: optional(string()),
+	arguments: optional(array(PromptArgumentSchema)),
+	_meta: optional(looseObject({}))
+});
+/**
+* Sent from the client to request a list of prompts and prompt templates the server has.
+*/
+var ListPromptsRequestSchema = PaginatedRequestSchema.extend({ method: literal("prompts/list") });
+/**
+* The server's response to a prompts/list request from the client.
+*/
+var ListPromptsResultSchema = PaginatedResultSchema.extend({ prompts: array(PromptSchema) });
+/**
+* Parameters for a `prompts/get` request.
+*/
+var GetPromptRequestParamsSchema = BaseRequestParamsSchema.extend({
+	name: string(),
+	arguments: record(string(), string()).optional()
+});
+/**
+* Used by the client to get a prompt provided by the server.
+*/
+var GetPromptRequestSchema = RequestSchema.extend({
+	method: literal("prompts/get"),
+	params: GetPromptRequestParamsSchema
+});
+/**
+* Text provided to or from an LLM.
+*/
+var TextContentSchema = object({
+	type: literal("text"),
+	text: string(),
+	annotations: AnnotationsSchema.optional(),
+	_meta: record(string(), unknown()).optional()
+});
+/**
+* An image provided to or from an LLM.
+*/
+var ImageContentSchema = object({
+	type: literal("image"),
+	data: Base64Schema,
+	mimeType: string(),
+	annotations: AnnotationsSchema.optional(),
+	_meta: record(string(), unknown()).optional()
+});
+/**
+* An Audio provided to or from an LLM.
+*/
+var AudioContentSchema = object({
+	type: literal("audio"),
+	data: Base64Schema,
+	mimeType: string(),
+	annotations: AnnotationsSchema.optional(),
+	_meta: record(string(), unknown()).optional()
+});
+/**
+* A tool call request from an assistant (LLM).
+* Represents the assistant's request to use a tool.
+*/
+var ToolUseContentSchema = object({
+	type: literal("tool_use"),
+	name: string(),
+	id: string(),
+	input: record(string(), unknown()),
+	_meta: record(string(), unknown()).optional()
+});
+/**
+* The contents of a resource, embedded into a prompt or tool call result.
+*/
+var EmbeddedResourceSchema = object({
+	type: literal("resource"),
+	resource: union([TextResourceContentsSchema, BlobResourceContentsSchema]),
+	annotations: AnnotationsSchema.optional(),
+	_meta: record(string(), 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.
+*/
+var ResourceLinkSchema = ResourceSchema.extend({ type: literal("resource_link") });
+/**
+* A content block that can be used in prompts and tool results.
+*/
+var ContentBlockSchema = union([
+	TextContentSchema,
+	ImageContentSchema,
+	AudioContentSchema,
+	ResourceLinkSchema,
+	EmbeddedResourceSchema
+]);
+/**
+* Describes a message returned as part of a prompt.
+*/
+var PromptMessageSchema = object({
+	role: RoleSchema,
+	content: ContentBlockSchema
+});
+/**
+* The server's response to a prompts/get request from the client.
+*/
+var GetPromptResultSchema = ResultSchema.extend({
+	description: string().optional(),
+	messages: array(PromptMessageSchema)
+});
+/**
+* An optional notification from the server to the client, informing it that the list of prompts it offers has changed. This may be issued by servers without any previous subscription from the client.
+*/
+var PromptListChangedNotificationSchema = NotificationSchema.extend({
+	method: 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.
+*/
+var ToolAnnotationsSchema = object({
+	title: string().optional(),
+	readOnlyHint: boolean().optional(),
+	destructiveHint: boolean().optional(),
+	idempotentHint: boolean().optional(),
+	openWorldHint: boolean().optional()
+});
+/**
+* Execution-related properties for a tool.
+*/
+var ToolExecutionSchema = object({ taskSupport: _enum([
+	"required",
+	"optional",
+	"forbidden"
+]).optional() });
+/**
+* Definition for a tool the client can call.
+*/
+var ToolSchema = object({
+	...BaseMetadataSchema.shape,
+	...IconsSchema.shape,
+	description: string().optional(),
+	inputSchema: object({
+		type: literal("object"),
+		properties: record(string(), AssertObjectSchema).optional(),
+		required: array(string()).optional()
+	}).catchall(unknown()),
+	outputSchema: object({
+		type: literal("object"),
+		properties: record(string(), AssertObjectSchema).optional(),
+		required: array(string()).optional()
+	}).catchall(unknown()).optional(),
+	annotations: ToolAnnotationsSchema.optional(),
+	execution: ToolExecutionSchema.optional(),
+	_meta: record(string(), unknown()).optional()
+});
+/**
+* Sent from the client to request a list of tools the server has.
+*/
+var ListToolsRequestSchema = PaginatedRequestSchema.extend({ method: literal("tools/list") });
+/**
+* The server's response to a tools/list request from the client.
+*/
+var ListToolsResultSchema = PaginatedResultSchema.extend({ tools: array(ToolSchema) });
+/**
+* The server's response to a tool call.
+*/
+var CallToolResultSchema = ResultSchema.extend({
+	content: array(ContentBlockSchema).default([]),
+	structuredContent: record(string(), unknown()).optional(),
+	isError: boolean().optional()
+});
+CallToolResultSchema.or(ResultSchema.extend({ toolResult: unknown() }));
+/**
+* Parameters for a `tools/call` request.
+*/
+var CallToolRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
+	name: string(),
+	arguments: record(string(), unknown()).optional()
+});
+/**
+* Used by the client to invoke a tool provided by the server.
+*/
+var CallToolRequestSchema = RequestSchema.extend({
+	method: 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.
+*/
+var ToolListChangedNotificationSchema = NotificationSchema.extend({
+	method: literal("notifications/tools/list_changed"),
+	params: NotificationsParamsSchema.optional()
+});
+object({
+	autoRefresh: boolean().default(true),
+	debounceMs: number().int().nonnegative().default(300)
+});
+/**
+* The severity of a log message.
+*/
+var LoggingLevelSchema = _enum([
+	"debug",
+	"info",
+	"notice",
+	"warning",
+	"error",
+	"critical",
+	"alert",
+	"emergency"
+]);
+/**
+* Parameters for a `logging/setLevel` request.
+*/
+var SetLevelRequestParamsSchema = BaseRequestParamsSchema.extend({ level: LoggingLevelSchema });
+/**
+* A request from the client to the server, to enable or adjust logging.
+*/
+var SetLevelRequestSchema = RequestSchema.extend({
+	method: literal("logging/setLevel"),
+	params: SetLevelRequestParamsSchema
+});
+/**
+* Parameters for a `notifications/message` notification.
+*/
+var LoggingMessageNotificationParamsSchema = NotificationsParamsSchema.extend({
+	level: LoggingLevelSchema,
+	logger: string().optional(),
+	data: 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.
+*/
+var LoggingMessageNotificationSchema = NotificationSchema.extend({
+	method: literal("notifications/message"),
+	params: LoggingMessageNotificationParamsSchema
+});
+/**
+* The server's preferences for model selection, requested of the client during sampling.
+*/
+var ModelPreferencesSchema = object({
+	hints: array(object({ name: string().optional() })).optional(),
+	costPriority: number().min(0).max(1).optional(),
+	speedPriority: number().min(0).max(1).optional(),
+	intelligencePriority: number().min(0).max(1).optional()
+});
+/**
+* Controls tool usage behavior in sampling requests.
+*/
+var ToolChoiceSchema = object({ mode: _enum([
+	"auto",
+	"required",
+	"none"
+]).optional() });
+/**
+* The result of a tool execution, provided by the user (server).
+* Represents the outcome of invoking a tool requested via ToolUseContent.
+*/
+var ToolResultContentSchema = object({
+	type: literal("tool_result"),
+	toolUseId: string().describe("The unique identifier for the corresponding tool call."),
+	content: array(ContentBlockSchema).default([]),
+	structuredContent: object({}).loose().optional(),
+	isError: boolean().optional(),
+	_meta: record(string(), unknown()).optional()
+});
+/**
+* Basic content types for sampling responses (without tool use).
+* Used for backwards-compatible CreateMessageResult when tools are not used.
+*/
+var SamplingContentSchema = discriminatedUnion("type", [
+	TextContentSchema,
+	ImageContentSchema,
+	AudioContentSchema
+]);
+/**
+* Content block types allowed in sampling messages.
+* This includes text, image, audio, tool use requests, and tool results.
+*/
+var SamplingMessageContentBlockSchema = discriminatedUnion("type", [
+	TextContentSchema,
+	ImageContentSchema,
+	AudioContentSchema,
+	ToolUseContentSchema,
+	ToolResultContentSchema
+]);
+/**
+* Describes a message issued to or received from an LLM API.
+*/
+var SamplingMessageSchema = object({
+	role: RoleSchema,
+	content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)]),
+	_meta: record(string(), unknown()).optional()
+});
+/**
+* Parameters for a `sampling/createMessage` request.
+*/
+var CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
+	messages: array(SamplingMessageSchema),
+	modelPreferences: ModelPreferencesSchema.optional(),
+	systemPrompt: string().optional(),
+	includeContext: _enum([
+		"none",
+		"thisServer",
+		"allServers"
+	]).optional(),
+	temperature: number().optional(),
+	maxTokens: number().int(),
+	stopSequences: array(string()).optional(),
+	metadata: AssertObjectSchema.optional(),
+	tools: array(ToolSchema).optional(),
+	toolChoice: ToolChoiceSchema.optional()
+});
+/**
+* A request from the server to sample an LLM via the client. The client has full discretion over which model to select. The client should also inform the user before beginning sampling, to allow them to inspect the request (human in the loop) and decide whether to approve it.
+*/
+var CreateMessageRequestSchema = RequestSchema.extend({
+	method: 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.
+*/
+var CreateMessageResultSchema = ResultSchema.extend({
+	model: string(),
+	stopReason: optional(_enum([
+		"endTurn",
+		"stopSequence",
+		"maxTokens"
+	]).or(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.
+*/
+var CreateMessageResultWithToolsSchema = ResultSchema.extend({
+	model: string(),
+	stopReason: optional(_enum([
+		"endTurn",
+		"stopSequence",
+		"maxTokens",
+		"toolUse"
+	]).or(string())),
+	role: RoleSchema,
+	content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)])
+});
+/**
+* Primitive schema definition for boolean fields.
+*/
+var BooleanSchemaSchema = object({
+	type: literal("boolean"),
+	title: string().optional(),
+	description: string().optional(),
+	default: boolean().optional()
+});
+/**
+* Primitive schema definition for string fields.
+*/
+var StringSchemaSchema = object({
+	type: literal("string"),
+	title: string().optional(),
+	description: string().optional(),
+	minLength: number().optional(),
+	maxLength: number().optional(),
+	format: _enum([
+		"email",
+		"uri",
+		"date",
+		"date-time"
+	]).optional(),
+	default: string().optional()
+});
+/**
+* Primitive schema definition for number fields.
+*/
+var NumberSchemaSchema = object({
+	type: _enum(["number", "integer"]),
+	title: string().optional(),
+	description: string().optional(),
+	minimum: number().optional(),
+	maximum: number().optional(),
+	default: number().optional()
+});
+/**
+* Schema for single-selection enumeration without display titles for options.
+*/
+var UntitledSingleSelectEnumSchemaSchema = object({
+	type: literal("string"),
+	title: string().optional(),
+	description: string().optional(),
+	enum: array(string()),
+	default: string().optional()
+});
+/**
+* Schema for single-selection enumeration with display titles for each option.
+*/
+var TitledSingleSelectEnumSchemaSchema = object({
+	type: literal("string"),
+	title: string().optional(),
+	description: string().optional(),
+	oneOf: array(object({
+		const: string(),
+		title: string()
+	})),
+	default: string().optional()
+});
+/**
+* Union of all primitive schema definitions.
+*/
+var PrimitiveSchemaDefinitionSchema = union([
+	union([
+		object({
+			type: literal("string"),
+			title: string().optional(),
+			description: string().optional(),
+			enum: array(string()),
+			enumNames: array(string()).optional(),
+			default: string().optional()
+		}),
+		union([UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema]),
+		union([object({
+			type: literal("array"),
+			title: string().optional(),
+			description: string().optional(),
+			minItems: number().optional(),
+			maxItems: number().optional(),
+			items: object({
+				type: literal("string"),
+				enum: array(string())
+			}),
+			default: array(string()).optional()
+		}), object({
+			type: literal("array"),
+			title: string().optional(),
+			description: string().optional(),
+			minItems: number().optional(),
+			maxItems: number().optional(),
+			items: object({ anyOf: array(object({
+				const: string(),
+				title: string()
+			})) }),
+			default: array(string()).optional()
+		})])
+	]),
+	BooleanSchemaSchema,
+	StringSchemaSchema,
+	NumberSchemaSchema
+]);
+/**
+* The parameters for a request to elicit additional information from the user via the client.
+*/
+var ElicitRequestParamsSchema = union([TaskAugmentedRequestParamsSchema.extend({
+	mode: literal("form").optional(),
+	message: string(),
+	requestedSchema: object({
+		type: literal("object"),
+		properties: record(string(), PrimitiveSchemaDefinitionSchema),
+		required: array(string()).optional()
+	})
+}), TaskAugmentedRequestParamsSchema.extend({
+	mode: literal("url"),
+	message: string(),
+	elicitationId: string(),
+	url: string().url()
+})]);
+/**
+* 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).
+*/
+var ElicitRequestSchema = RequestSchema.extend({
+	method: literal("elicitation/create"),
+	params: ElicitRequestParamsSchema
+});
+/**
+* Parameters for a `notifications/elicitation/complete` notification.
+*
+* @category notifications/elicitation/complete
+*/
+var ElicitationCompleteNotificationParamsSchema = NotificationsParamsSchema.extend({ elicitationId: 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
+*/
+var ElicitationCompleteNotificationSchema = NotificationSchema.extend({
+	method: literal("notifications/elicitation/complete"),
+	params: ElicitationCompleteNotificationParamsSchema
+});
+/**
+* The client's response to an elicitation/create request from the server.
+*/
+var ElicitResultSchema = ResultSchema.extend({
+	action: _enum([
+		"accept",
+		"decline",
+		"cancel"
+	]),
+	content: preprocess((val) => val === null ? void 0 : val, record(string(), union([
+		string(),
+		number(),
+		boolean(),
+		array(string())
+	])).optional())
+});
+/**
+* A reference to a resource or resource template definition.
+*/
+var ResourceTemplateReferenceSchema = object({
+	type: literal("ref/resource"),
+	uri: string()
+});
+/**
+* Identifies a prompt.
+*/
+var PromptReferenceSchema = object({
+	type: literal("ref/prompt"),
+	name: string()
+});
+/**
+* Parameters for a `completion/complete` request.
+*/
+var CompleteRequestParamsSchema = BaseRequestParamsSchema.extend({
+	ref: union([PromptReferenceSchema, ResourceTemplateReferenceSchema]),
+	argument: object({
+		name: string(),
+		value: string()
+	}),
+	context: object({ arguments: record(string(), string()).optional() }).optional()
+});
+/**
+* A request from the client to the server, to ask for completion options.
+*/
+var CompleteRequestSchema = RequestSchema.extend({
+	method: literal("completion/complete"),
+	params: CompleteRequestParamsSchema
+});
+/**
+* The server's response to a completion/complete request
+*/
+var CompleteResultSchema = ResultSchema.extend({ completion: looseObject({
+	values: array(string()).max(100),
+	total: optional(number().int()),
+	hasMore: optional(boolean())
+}) });
+/**
+* Represents a root directory or file that the server can operate on.
+*/
+var RootSchema = object({
+	uri: string().startsWith("file://"),
+	name: string().optional(),
+	_meta: record(string(), unknown()).optional()
+});
+/**
+* Sent from the server to request a list of root URIs from the client.
+*/
+var ListRootsRequestSchema = RequestSchema.extend({
+	method: literal("roots/list"),
+	params: BaseRequestParamsSchema.optional()
+});
+/**
+* The client's response to a roots/list request from the server.
+*/
+var ListRootsResultSchema = ResultSchema.extend({ roots: array(RootSchema) });
+/**
+* A notification from the client to the server, informing it that the list of roots has changed.
+*/
+var RootsListChangedNotificationSchema = NotificationSchema.extend({
+	method: literal("notifications/roots/list_changed"),
+	params: NotificationsParamsSchema.optional()
+});
+union([
+	PingRequestSchema,
+	InitializeRequestSchema,
+	CompleteRequestSchema,
+	SetLevelRequestSchema,
+	GetPromptRequestSchema,
+	ListPromptsRequestSchema,
+	ListResourcesRequestSchema,
+	ListResourceTemplatesRequestSchema,
+	ReadResourceRequestSchema,
+	SubscribeRequestSchema,
+	UnsubscribeRequestSchema,
+	CallToolRequestSchema,
+	ListToolsRequestSchema,
+	GetTaskRequestSchema,
+	GetTaskPayloadRequestSchema,
+	ListTasksRequestSchema,
+	CancelTaskRequestSchema
+]);
+union([
+	CancelledNotificationSchema,
+	ProgressNotificationSchema,
+	InitializedNotificationSchema,
+	RootsListChangedNotificationSchema,
+	TaskStatusNotificationSchema
+]);
+union([
+	EmptyResultSchema,
+	CreateMessageResultSchema,
+	CreateMessageResultWithToolsSchema,
+	ElicitResultSchema,
+	ListRootsResultSchema,
+	GetTaskResultSchema,
+	ListTasksResultSchema,
+	CreateTaskResultSchema
+]);
+union([
+	PingRequestSchema,
+	CreateMessageRequestSchema,
+	ElicitRequestSchema,
+	ListRootsRequestSchema,
+	GetTaskRequestSchema,
+	GetTaskPayloadRequestSchema,
+	ListTasksRequestSchema,
+	CancelTaskRequestSchema
+]);
+union([
+	CancelledNotificationSchema,
+	ProgressNotificationSchema,
+	LoggingMessageNotificationSchema,
+	ResourceUpdatedNotificationSchema,
+	ResourceListChangedNotificationSchema,
+	ToolListChangedNotificationSchema,
+	PromptListChangedNotificationSchema,
+	TaskStatusNotificationSchema,
+	ElicitationCompleteNotificationSchema
+]);
+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.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
+/**
+* Experimental task interfaces for MCP SDK.
+* WARNING: These APIs are experimental and may change without notice.
+*/
+/**
+* Checks if a task status represents a terminal state.
+* Terminal states are those where the task has finished and will not change.
+*
+* @param status - The task status to check
+* @returns True if the status is terminal (completed, failed, or cancelled)
+* @experimental
+*/
+function isTerminal(status) {
+	return status === "completed" || status === "failed" || status === "cancelled";
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
+function getMethodLiteral(schema) {
+	const methodSchema = getObjectShape(schema)?.method;
+	if (!methodSchema) throw new Error("Schema is missing a method literal");
+	const value = getLiteralValue(methodSchema);
+	if (typeof value !== "string") throw new Error("Schema method literal must be a string");
+	return value;
+}
+function parseWithCompat(schema, data) {
+	const result = safeParse(schema, data);
+	if (!result.success) throw result.error;
+	return result.data;
+}
+/**
+* Implements MCP protocol framing on top of a pluggable transport, including
+* features like request/response linking, notifications, and progress.
+*/
+var Protocol = class {
+	constructor(_options) {
+		this._options = _options;
+		this._requestMessageId = 0;
+		this._requestHandlers = /* @__PURE__ */ new Map();
+		this._requestHandlerAbortControllers = /* @__PURE__ */ new Map();
+		this._notificationHandlers = /* @__PURE__ */ new Map();
+		this._responseHandlers = /* @__PURE__ */ new Map();
+		this._progressHandlers = /* @__PURE__ */ new Map();
+		this._timeoutInfo = /* @__PURE__ */ new Map();
+		this._pendingDebouncedNotifications = /* @__PURE__ */ new Set();
+		this._taskProgressTokens = /* @__PURE__ */ new Map();
+		this._requestResolvers = /* @__PURE__ */ new Map();
+		this.setNotificationHandler(CancelledNotificationSchema, (notification) => {
+			this._oncancel(notification);
+		});
+		this.setNotificationHandler(ProgressNotificationSchema, (notification) => {
+			this._onprogress(notification);
+		});
+		this.setRequestHandler(PingRequestSchema, (_request) => ({}));
+		this._taskStore = _options?.taskStore;
+		this._taskMessageQueue = _options?.taskMessageQueue;
+		if (this._taskStore) {
+			this.setRequestHandler(GetTaskRequestSchema, async (request, extra) => {
+				const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+				if (!task) throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
+				return { ...task };
+			});
+			this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
+				const handleTaskResult = async () => {
+					const taskId = request.params.taskId;
+					if (this._taskMessageQueue) {
+						let queuedMessage;
+						while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
+							if (queuedMessage.type === "response" || queuedMessage.type === "error") {
+								const message = queuedMessage.message;
+								const requestId = message.id;
+								const resolver = this._requestResolvers.get(requestId);
+								if (resolver) {
+									this._requestResolvers.delete(requestId);
+									if (queuedMessage.type === "response") resolver(message);
+									else {
+										const errorMessage = message;
+										resolver(new McpError(errorMessage.error.code, errorMessage.error.message, errorMessage.error.data));
+									}
+								} else {
+									const messageType = queuedMessage.type === "response" ? "Response" : "Error";
+									this._onerror(/* @__PURE__ */ new Error(`${messageType} handler missing for request ${requestId}`));
+								}
+								continue;
+							}
+							await this._transport?.send(queuedMessage.message, { relatedRequestId: extra.requestId });
+						}
+					}
+					const task = await this._taskStore.getTask(taskId, extra.sessionId);
+					if (!task) throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
+					if (!isTerminal(task.status)) {
+						await this._waitForTaskUpdate(taskId, extra.signal);
+						return await handleTaskResult();
+					}
+					if (isTerminal(task.status)) {
+						const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
+						this._clearTaskQueue(taskId);
+						return {
+							...result,
+							_meta: {
+								...result._meta,
+								[RELATED_TASK_META_KEY]: { taskId }
+							}
+						};
+					}
+					return await handleTaskResult();
+				};
+				return await handleTaskResult();
+			});
+			this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => {
+				try {
+					const { tasks, nextCursor } = await this._taskStore.listTasks(request.params?.cursor, extra.sessionId);
+					return {
+						tasks,
+						nextCursor,
+						_meta: {}
+					};
+				} catch (error) {
+					throw new McpError(ErrorCode.InvalidParams, `Failed to list tasks: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			});
+			this.setRequestHandler(CancelTaskRequestSchema, async (request, extra) => {
+				try {
+					const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+					if (!task) throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request.params.taskId}`);
+					if (isTerminal(task.status)) throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
+					await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
+					this._clearTaskQueue(request.params.taskId);
+					const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+					if (!cancelledTask) throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
+					return {
+						_meta: {},
+						...cancelledTask
+					};
+				} catch (error) {
+					if (error instanceof McpError) throw error;
+					throw new McpError(ErrorCode.InvalidRequest, `Failed to cancel task: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			});
+		}
+	}
+	async _oncancel(notification) {
+		if (!notification.params.requestId) return;
+		this._requestHandlerAbortControllers.get(notification.params.requestId)?.abort(notification.params.reason);
+	}
+	_setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
+		this._timeoutInfo.set(messageId, {
+			timeoutId: setTimeout(onTimeout, timeout),
+			startTime: Date.now(),
+			timeout,
+			maxTotalTimeout,
+			resetTimeoutOnProgress,
+			onTimeout
+		});
+	}
+	_resetTimeout(messageId) {
+		const info = this._timeoutInfo.get(messageId);
+		if (!info) return false;
+		const totalElapsed = Date.now() - info.startTime;
+		if (info.maxTotalTimeout && totalElapsed >= info.maxTotalTimeout) {
+			this._timeoutInfo.delete(messageId);
+			throw McpError.fromError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", {
+				maxTotalTimeout: info.maxTotalTimeout,
+				totalElapsed
+			});
+		}
+		clearTimeout(info.timeoutId);
+		info.timeoutId = setTimeout(info.onTimeout, info.timeout);
+		return true;
+	}
+	_cleanupTimeout(messageId) {
+		const info = this._timeoutInfo.get(messageId);
+		if (info) {
+			clearTimeout(info.timeoutId);
+			this._timeoutInfo.delete(messageId);
+		}
+	}
+	/**
+	* Attaches to the given transport, starts it, and starts listening for messages.
+	*
+	* The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
+	*/
+	async connect(transport) {
+		if (this._transport) throw new Error("Already connected to a transport. Call close() before connecting to a new transport, or use a separate Protocol instance per connection.");
+		this._transport = transport;
+		const _onclose = this.transport?.onclose;
+		this._transport.onclose = () => {
+			_onclose?.();
+			this._onclose();
+		};
+		const _onerror = this.transport?.onerror;
+		this._transport.onerror = (error) => {
+			_onerror?.(error);
+			this._onerror(error);
+		};
+		const _onmessage = this._transport?.onmessage;
+		this._transport.onmessage = (message, extra) => {
+			_onmessage?.(message, extra);
+			if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) this._onresponse(message);
+			else if (isJSONRPCRequest(message)) this._onrequest(message, extra);
+			else if (isJSONRPCNotification(message)) this._onnotification(message);
+			else this._onerror(/* @__PURE__ */ new Error(`Unknown message type: ${JSON.stringify(message)}`));
+		};
+		await this._transport.start();
+	}
+	_onclose() {
+		const responseHandlers = this._responseHandlers;
+		this._responseHandlers = /* @__PURE__ */ new Map();
+		this._progressHandlers.clear();
+		this._taskProgressTokens.clear();
+		this._pendingDebouncedNotifications.clear();
+		for (const 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 = await this.getTask({ taskId }, options);
+				yield {
+					type: "taskStatus",
+					task
+				};
+				if (isTerminal(task.status)) {
+					if (task.status === "completed") yield {
+						type: "result",
+						result: await this.getTaskResult({ taskId }, resultSchema, options)
+					};
+					else if (task.status === "failed") yield {
+						type: "error",
+						error: new McpError(ErrorCode.InternalError, `Task ${taskId} failed`)
+					};
+					else if (task.status === "cancelled") yield {
+						type: "error",
+						error: new McpError(ErrorCode.InternalError, `Task ${taskId} was cancelled`)
+					};
+					return;
+				}
+				if (task.status === "input_required") {
+					yield {
+						type: "result",
+						result: await this.getTaskResult({ taskId }, resultSchema, options)
+					};
+					return;
+				}
+				const pollInterval = task.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
+				await new Promise((resolve) => setTimeout(resolve, pollInterval));
+				options?.signal?.throwIfAborted();
+			}
+		} catch (error) {
+			yield {
+				type: "error",
+				error: error instanceof McpError ? error : new McpError(ErrorCode.InternalError, String(error))
+			};
+		}
+	}
+	/**
+	* Sends a request and waits for a response.
+	*
+	* Do not use this method to emit notifications! Use notification() instead.
+	*/
+	request(request, resultSchema, options) {
+		const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
+		return new Promise((resolve, reject) => {
+			const earlyReject = (error) => {
+				reject(error);
+			};
+			if (!this._transport) {
+				earlyReject(/* @__PURE__ */ new Error("Not connected"));
+				return;
+			}
+			if (this._options?.enforceStrictCapabilities === true) try {
+				this.assertCapabilityForMethod(request.method);
+				if (task) this.assertTaskCapability(request.method);
+			} catch (e) {
+				earlyReject(e);
+				return;
+			}
+			options?.signal?.throwIfAborted();
+			const messageId = this._requestMessageId++;
+			const jsonrpcRequest = {
+				...request,
+				jsonrpc: "2.0",
+				id: messageId
+			};
+			if (options?.onprogress) {
+				this._progressHandlers.set(messageId, options.onprogress);
+				jsonrpcRequest.params = {
+					...request.params,
+					_meta: {
+						...request.params?._meta || {},
+						progressToken: messageId
+					}
+				};
+			}
+			if (task) jsonrpcRequest.params = {
+				...jsonrpcRequest.params,
+				task
+			};
+			if (relatedTask) jsonrpcRequest.params = {
+				...jsonrpcRequest.params,
+				_meta: {
+					...jsonrpcRequest.params?._meta || {},
+					[RELATED_TASK_META_KEY]: relatedTask
+				}
+			};
+			const cancel = (reason) => {
+				this._responseHandlers.delete(messageId);
+				this._progressHandlers.delete(messageId);
+				this._cleanupTimeout(messageId);
+				this._transport?.send({
+					jsonrpc: "2.0",
+					method: "notifications/cancelled",
+					params: {
+						requestId: messageId,
+						reason: String(reason)
+					}
+				}, {
+					relatedRequestId,
+					resumptionToken,
+					onresumptiontoken
+				}).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Failed to send cancellation: ${error}`)));
+				reject(reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason)));
+			};
+			this._responseHandlers.set(messageId, (response) => {
+				if (options?.signal?.aborted) return;
+				if (response instanceof Error) return reject(response);
+				try {
+					const parseResult = safeParse(resultSchema, response.result);
+					if (!parseResult.success) reject(parseResult.error);
+					else resolve(parseResult.data);
+				} catch (error) {
+					reject(error);
+				}
+			});
+			options?.signal?.addEventListener("abort", () => {
+				cancel(options?.signal?.reason);
+			});
+			const timeout = options?.timeout ?? 6e4;
+			const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
+			this._setupTimeout(messageId, timeout, options?.maxTotalTimeout, timeoutHandler, options?.resetTimeoutOnProgress ?? false);
+			const relatedTaskId = relatedTask?.taskId;
+			if (relatedTaskId) {
+				const responseResolver = (response) => {
+					const handler = this._responseHandlers.get(messageId);
+					if (handler) handler(response);
+					else this._onerror(/* @__PURE__ */ new Error(`Response handler missing for side-channeled request ${messageId}`));
+				};
+				this._requestResolvers.set(messageId, responseResolver);
+				this._enqueueTaskMessage(relatedTaskId, {
+					type: "request",
+					message: jsonrpcRequest,
+					timestamp: Date.now()
+				}).catch((error) => {
+					this._cleanupTimeout(messageId);
+					reject(error);
+				});
+			} else this._transport.send(jsonrpcRequest, {
+				relatedRequestId,
+				resumptionToken,
+				onresumptiontoken
+			}).catch((error) => {
+				this._cleanupTimeout(messageId);
+				reject(error);
+			});
+		});
+	}
+	/**
+	* Gets the current status of a task.
+	*
+	* @experimental Use `client.experimental.tasks.getTask()` to access this method.
+	*/
+	async getTask(params, options) {
+		return this.request({
+			method: "tasks/get",
+			params
+		}, GetTaskResultSchema, options);
+	}
+	/**
+	* Retrieves the result of a completed task.
+	*
+	* @experimental Use `client.experimental.tasks.getTaskResult()` to access this method.
+	*/
+	async getTaskResult(params, resultSchema, options) {
+		return this.request({
+			method: "tasks/result",
+			params
+		}, resultSchema, options);
+	}
+	/**
+	* Lists tasks, optionally starting from a pagination cursor.
+	*
+	* @experimental Use `client.experimental.tasks.listTasks()` to access this method.
+	*/
+	async listTasks(params, options) {
+		return this.request({
+			method: "tasks/list",
+			params
+		}, ListTasksResultSchema, options);
+	}
+	/**
+	* Cancels a specific task.
+	*
+	* @experimental Use `client.experimental.tasks.cancelTask()` to access this method.
+	*/
+	async cancelTask(params, options) {
+		return this.request({
+			method: "tasks/cancel",
+			params
+		}, CancelTaskResultSchema, options);
+	}
+	/**
+	* Emits a notification, which is a one-way message that does not expect a response.
+	*/
+	async notification(notification, options) {
+		if (!this._transport) throw new Error("Not connected");
+		this.assertNotificationCapability(notification.method);
+		const relatedTaskId = options?.relatedTask?.taskId;
+		if (relatedTaskId) {
+			const jsonrpcNotification = {
+				...notification,
+				jsonrpc: "2.0",
+				params: {
+					...notification.params,
+					_meta: {
+						...notification.params?._meta || {},
+						[RELATED_TASK_META_KEY]: options.relatedTask
+					}
+				}
+			};
+			await this._enqueueTaskMessage(relatedTaskId, {
+				type: "notification",
+				message: jsonrpcNotification,
+				timestamp: Date.now()
+			});
+			return;
+		}
+		if ((this._options?.debouncedNotificationMethods ?? []).includes(notification.method) && !notification.params && !options?.relatedRequestId && !options?.relatedTask) {
+			if (this._pendingDebouncedNotifications.has(notification.method)) return;
+			this._pendingDebouncedNotifications.add(notification.method);
+			Promise.resolve().then(() => {
+				this._pendingDebouncedNotifications.delete(notification.method);
+				if (!this._transport) return;
+				let jsonrpcNotification = {
+					...notification,
+					jsonrpc: "2.0"
+				};
+				if (options?.relatedTask) jsonrpcNotification = {
+					...jsonrpcNotification,
+					params: {
+						...jsonrpcNotification.params,
+						_meta: {
+							...jsonrpcNotification.params?._meta || {},
+							[RELATED_TASK_META_KEY]: options.relatedTask
+						}
+					}
+				};
+				this._transport?.send(jsonrpcNotification, options).catch((error) => this._onerror(error));
+			});
+			return;
+		}
+		let jsonrpcNotification = {
+			...notification,
+			jsonrpc: "2.0"
+		};
+		if (options?.relatedTask) jsonrpcNotification = {
+			...jsonrpcNotification,
+			params: {
+				...jsonrpcNotification.params,
+				_meta: {
+					...jsonrpcNotification.params?._meta || {},
+					[RELATED_TASK_META_KEY]: options.relatedTask
+				}
+			}
+		};
+		await this._transport.send(jsonrpcNotification, options);
+	}
+	/**
+	* Registers a handler to invoke when this protocol object receives a request with the given method.
+	*
+	* Note that this will replace any previous request handler for the same method.
+	*/
+	setRequestHandler(requestSchema, handler) {
+		const method = getMethodLiteral(requestSchema);
+		this.assertRequestHandlerCapability(method);
+		this._requestHandlers.set(method, (request, extra) => {
+			const parsed = parseWithCompat(requestSchema, request);
+			return Promise.resolve(handler(parsed, extra));
+		});
+	}
+	/**
+	* Removes the request handler for the given method.
+	*/
+	removeRequestHandler(method) {
+		this._requestHandlers.delete(method);
+	}
+	/**
+	* Asserts that a request handler has not already been set for the given method, in preparation for a new one being automatically installed.
+	*/
+	assertCanSetRequestHandler(method) {
+		if (this._requestHandlers.has(method)) throw new Error(`A request handler for ${method} already exists, which would be overridden`);
+	}
+	/**
+	* Registers a handler to invoke when this protocol object receives a notification with the given method.
+	*
+	* Note that this will replace any previous notification handler for the same method.
+	*/
+	setNotificationHandler(notificationSchema, handler) {
+		const method = getMethodLiteral(notificationSchema);
+		this._notificationHandlers.set(method, (notification) => {
+			const parsed = parseWithCompat(notificationSchema, notification);
+			return Promise.resolve(handler(parsed));
+		});
+	}
+	/**
+	* Removes the notification handler for the given method.
+	*/
+	removeNotificationHandler(method) {
+		this._notificationHandlers.delete(method);
+	}
+	/**
+	* Cleans up the progress handler associated with a task.
+	* This should be called when a task reaches a terminal status.
+	*/
+	_cleanupTaskProgressHandler(taskId) {
+		const progressToken = this._taskProgressTokens.get(taskId);
+		if (progressToken !== void 0) {
+			this._progressHandlers.delete(progressToken);
+			this._taskProgressTokens.delete(taskId);
+		}
+	}
+	/**
+	* Enqueues a task-related message for side-channel delivery via tasks/result.
+	* @param taskId The task ID to associate the message with
+	* @param message The message to enqueue
+	* @param sessionId Optional session ID for binding the operation to a specific session
+	* @throws Error if taskStore is not configured or if enqueue fails (e.g., queue overflow)
+	*
+	* Note: If enqueue fails, it's the TaskMessageQueue implementation's responsibility to handle
+	* the error appropriately (e.g., by failing the task, logging, etc.). The Protocol layer
+	* simply propagates the error.
+	*/
+	async _enqueueTaskMessage(taskId, message, sessionId) {
+		if (!this._taskStore || !this._taskMessageQueue) throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
+		const maxQueueSize = this._options?.maxTaskQueueSize;
+		await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
+	}
+	/**
+	* Clears the message queue for a task and rejects any pending request resolvers.
+	* @param taskId The task ID whose queue should be cleared
+	* @param sessionId Optional session ID for binding the operation to a specific session
+	*/
+	async _clearTaskQueue(taskId, sessionId) {
+		if (this._taskMessageQueue) {
+			const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId);
+			for (const message of messages) if (message.type === "request" && isJSONRPCRequest(message.message)) {
+				const requestId = message.message.id;
+				const resolver = this._requestResolvers.get(requestId);
+				if (resolver) {
+					resolver(new McpError(ErrorCode.InternalError, "Task cancelled or completed"));
+					this._requestResolvers.delete(requestId);
+				} else this._onerror(/* @__PURE__ */ new Error(`Resolver missing for request ${requestId} during task ${taskId} cleanup`));
+			}
+		}
+	}
+	/**
+	* Waits for a task update (new messages or status change) with abort signal support.
+	* Uses polling to check for updates at the task's configured poll interval.
+	* @param taskId The task ID to wait for
+	* @param signal Abort signal to cancel the wait
+	* @returns Promise that resolves when an update occurs or rejects if aborted
+	*/
+	async _waitForTaskUpdate(taskId, signal) {
+		let interval = this._options?.defaultTaskPollInterval ?? 1e3;
+		try {
+			const task = await this._taskStore?.getTask(taskId);
+			if (task?.pollInterval) interval = task.pollInterval;
+		} catch {}
+		return new Promise((resolve, reject) => {
+			if (signal.aborted) {
+				reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
+				return;
+			}
+			const timeoutId = setTimeout(resolve, interval);
+			signal.addEventListener("abort", () => {
+				clearTimeout(timeoutId);
+				reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
+			}, { once: true });
+		});
+	}
+	requestTaskStore(request, sessionId) {
+		const taskStore = this._taskStore;
+		if (!taskStore) throw new Error("No task store configured");
+		return {
+			createTask: async (taskParams) => {
+				if (!request) throw new Error("No request provided");
+				return await taskStore.createTask(taskParams, request.id, {
+					method: request.method,
+					params: request.params
+				}, sessionId);
+			},
+			getTask: async (taskId) => {
+				const task = await taskStore.getTask(taskId, sessionId);
+				if (!task) throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
+				return task;
+			},
+			storeTaskResult: async (taskId, status, result) => {
+				await taskStore.storeTaskResult(taskId, status, result, sessionId);
+				const task = await taskStore.getTask(taskId, sessionId);
+				if (task) {
+					const notification = TaskStatusNotificationSchema.parse({
+						method: "notifications/tasks/status",
+						params: task
+					});
+					await this.notification(notification);
+					if (isTerminal(task.status)) this._cleanupTaskProgressHandler(taskId);
+				}
+			},
+			getTaskResult: (taskId) => {
+				return taskStore.getTaskResult(taskId, sessionId);
+			},
+			updateTaskStatus: async (taskId, status, statusMessage) => {
+				const task = await taskStore.getTask(taskId, sessionId);
+				if (!task) throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
+				if (isTerminal(task.status)) throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
+				await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId);
+				const updatedTask = await taskStore.getTask(taskId, sessionId);
+				if (updatedTask) {
+					const notification = TaskStatusNotificationSchema.parse({
+						method: "notifications/tasks/status",
+						params: updatedTask
+					});
+					await this.notification(notification);
+					if (isTerminal(updatedTask.status)) this._cleanupTaskProgressHandler(taskId);
+				}
+			},
+			listTasks: (cursor) => {
+				return taskStore.listTasks(cursor, sessionId);
+			}
+		};
+	}
+};
+//#endregion
+export { ResourceListChangedNotificationSchema as C, ResourceLinkSchema as S, ToolSchema as T, PingRequestSchema as _, EmbeddedResourceSchema as a, ReadResourceResultSchema as b, JSONRPCMessageSchema as c, ListResourceTemplatesRequestSchema as d, ListResourceTemplatesResultSchema as f, LoggingMessageNotificationSchema as g, ListToolsRequestSchema as h, ContentBlockSchema as i, ListPromptsRequestSchema as l, ListResourcesResultSchema as m, CallToolRequestSchema as n, EmptyResultSchema as o, ListResourcesRequestSchema as p, CallToolResultSchema as r, ImplementationSchema as s, Protocol as t, ListPromptsResultSchema as u, PromptListChangedNotificationSchema as v, ToolListChangedNotificationSchema as w, RequestIdSchema as x, ReadResourceRequestSchema as y };
+
+//# sourceMappingURL=protocol-CTflwIfG.js.map