@agentconnect.md/daemon 1.0.0-rc.221 → 1.0.0-rc.222

package/dist/{run-foreground-mvTzCScX.js → run-foreground-B05rDr1z.js}

@@ -1,11 +1,12 @@
 import { i as __require, o as __toESM, t as __commonJSMin } from "./rolldown-runtime-CE-6LUnI.js";
 import { n as require_ms, t as require_src$2 } from "./src-DDtlVutj.js";
 import { t as DAEMON_VERSION } from "./version-DGaRXjBK.js";
-import { a as agentChildEnv, i as selectAgent, n as findAgentFiles, o as loadConfig, r as loadAgents, s as persistDaemonId } from "./load-agents-C1m5Y9n_.js";
+import { C as _coercedNumber, T as NEVER, a as array, d as literal, f as looseObject, i as any, m as object, o as boolean, p as number$1, t as ZodNumber, v as string, x as url$4 } from "./schemas-CQkO9hC5.js";
+import { a as agentChildEnv, i as selectAgent, n as findAgentFiles, o as loadConfig, r as loadAgents, s as persistDaemonId } from "./load-agents-hq5NXMmx.js";
 import { l as resolveRoot, o as mcpSocketPath, u as statePath } from "./paths-DEcUO8lC.js";
-import { _ as cachedRuntimeVersions, a as initGitInjection, c as simpleGit, d as MAX_FRAME_BYTES, f as buildEnvelope, g as cachedRuntimeNames, h as MEMORY_INDEX, i as prepareWorkspace, m as encode, n as installedRuntimes, o as probeGitVersion, p as decodeEnvelope, r as prefetchWorkspace, s as sessionGitEnv, t as AcpHost, u as normalizeGitUrl, v as resolveRuntimes } from "./acp-host-zyZ_j0yY.js";
+import { _ as cachedRuntimeNames, a as initGitInjection, c as simpleGit, d as MAX_FRAME_BYTES, f as buildEnvelope, g as RESERVED_MCP_SERVER_NAME, h as MEMORY_INDEX, i as prepareWorkspace, m as encode, n as installedRuntimes, o as probeGitVersion, p as decodeEnvelope, r as prefetchWorkspace, s as sessionGitEnv, t as AcpHost, u as normalizeGitUrl, v as cachedRuntimeVersions, y as resolveRuntimes } from "./acp-host-DE2r7uCO.js";
 import { i as GitCredentialCache, n as gitcredSocketPath, r as writeGitcredShim, t as GitCredServer } from "./gitcred-server-Dcsq6QJe.js";
-import { n as encodeFrame, t as decodeFrames } from "./ipc-2Xbxe7uu.js";
+import { B as isInitializedNotification, C as JSONRPCMessageSchema, D as ListResourceTemplatesResultSchema, E as ListPromptsResultSchema, F as ReadResourceResultSchema, G as safeParse, H as isJSONRPCResultResponse, I as ResourceListChangedNotificationSchema, K as decodeFrames, L as SUPPORTED_PROTOCOL_VERSIONS, N as McpError, O as ListResourcesResultSchema, P as PromptListChangedNotificationSchema, T as ListChangedOptionsBaseSchema, U as getObjectShape, V as isJSONRPCRequest, W as isZ4Schema, _ as EmptyResultSchema, a as AjvJsonSchemaValidator, d as CreateMessageRequestSchema, f as CreateMessageResultSchema, g as ElicitResultSchema, h as ElicitRequestSchema, i as assertToolsCallTaskCapability, j as ListToolsResultSchema, l as CallToolResultSchema, m as CreateTaskResultSchema, n as serializeMessage, o as Protocol, p as CreateMessageResultWithToolsSchema, q as encodeFrame, r as assertClientRequestTaskCapability, s as mergeCapabilities, t as ReadBuffer, u as CompleteResultSchema, v as ErrorCode, w as LATEST_PROTOCOL_VERSION, x as InitializeResultSchema, y as GetPromptResultSchema, z as ToolListChangedNotificationSchema } from "./stdio-CwrB9yrX.js";
 import { URL as URL$1 } from "url";
 import * as tls from "tls";
 import * as net$2 from "net";
@@ -15,13 +16,38 @@ import * as http$6 from "http";
 import { Agent } from "https";
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, promises, readFileSync, rmSync, stat, unwatchFile, watch, watchFile, writeFileSync } from "node:fs";
 import { EventEmitter } from "node:events";
+import process$1 from "node:process";
 import { hostname, tmpdir, type } from "node:os";
 import { randomBytes, randomUUID } from "node:crypto";
-import { Readable } from "node:stream";
+import { PassThrough, Readable } from "node:stream";
 import net from "node:net";
 import { lstat, open, readdir, realpath, stat as stat$1 } from "node:fs/promises";
 import { DatabaseSync } from "node:sqlite";
 import assert from "assert";
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/compat.js
+/** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
+const ZodIssueCode = {
+	invalid_type: "invalid_type",
+	too_big: "too_big",
+	too_small: "too_small",
+	invalid_format: "invalid_format",
+	not_multiple_of: "not_multiple_of",
+	unrecognized_keys: "unrecognized_keys",
+	invalid_union: "invalid_union",
+	invalid_key: "invalid_key",
+	invalid_element: "invalid_element",
+	invalid_value: "invalid_value",
+	custom: "custom"
+};
+/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
+var ZodFirstPartyTypeKind;
+ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/coerce.js
+function number(params) {
+	return _coercedNumber(ZodNumber, params);
+}
+//#endregion
 //#region ../../node_modules/.pnpm/ws@8.21.0/node_modules/ws/lib/constants.js
 var require_constants$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const BINARY_TYPES = [
@@ -6031,20 +6057,20 @@ var SessionManager = class {
 			this.deps.store.upsertSession(rec);
 		} else if (host.hasSession?.(rec.acpSessionId) === false) {
 			const cwd = await prepareWorkspace(agent);
+			const mcpServers = this.deps.mcpServersFor?.({
+				agent,
+				channel: msg.channel,
+				thread
+			}) ?? [];
 			let resumed = false;
 			if (host.loadSupported?.()) {
 				this.deps.store.setSessionState(key, "resuming", Date.now());
 				try {
-					await host.loadSession(rec.acpSessionId, cwd, effortOverride);
+					await host.loadSession(rec.acpSessionId, cwd, mcpServers, effortOverride);
 					resumed = true;
 				} catch {}
 			}
 			if (!resumed) {
-				const mcpServers = this.deps.mcpServersFor?.({
-					agent,
-					channel: msg.channel,
-					thread
-				}) ?? [];
 				const acpSessionId = await host.newSession(cwd, mcpServers, effortOverride);
 				created = true;
 				rec = {
@@ -6486,7 +6512,7 @@ var McpControlServer = class {
 */
 function buildMcpServers(opts) {
 	return [{
-		name: "agentconnect",
+		name: RESERVED_MCP_SERVER_NAME,
 		command: process.execPath,
 		args: [
 			...process.execArgv,
@@ -6503,6 +6529,3363 @@ function buildMcpServers(opts) {
 	}];
 }
 //#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/client.js
+/**
+* Experimental client task features for MCP SDK.
+* WARNING: These APIs are experimental and may change without notice.
+*
+* @experimental
+*/
+/**
+* Experimental task features for MCP clients.
+*
+* Access via `client.experimental.tasks`:
+* ```typescript
+* const stream = client.experimental.tasks.callToolStream({ name: 'tool', arguments: {} });
+* const task = await client.experimental.tasks.getTask(taskId);
+* ```
+*
+* @experimental
+*/
+var ExperimentalClientTasks = class {
+	constructor(_client) {
+		this._client = _client;
+	}
+	/**
+	* Calls a tool and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* This method provides streaming access to tool execution, allowing you to
+	* observe intermediate task status updates for long-running tool calls.
+	* Automatically validates structured output if the tool has an outputSchema.
+	*
+	* @example
+	* ```typescript
+	* const stream = client.experimental.tasks.callToolStream({ name: 'myTool', arguments: {} });
+	* for await (const message of stream) {
+	*   switch (message.type) {
+	*     case 'taskCreated':
+	*       console.log('Tool execution started:', message.task.taskId);
+	*       break;
+	*     case 'taskStatus':
+	*       console.log('Tool status:', message.task.status);
+	*       break;
+	*     case 'result':
+	*       console.log('Tool result:', message.result);
+	*       break;
+	*     case 'error':
+	*       console.error('Tool error:', message.error);
+	*       break;
+	*   }
+	* }
+	* ```
+	*
+	* @param params - Tool call parameters (name and arguments)
+	* @param resultSchema - Zod schema for validating the result (defaults to CallToolResultSchema)
+	* @param options - Optional request options (timeout, signal, task creation params, etc.)
+	* @returns AsyncGenerator that yields ResponseMessage objects
+	*
+	* @experimental
+	*/
+	async *callToolStream(params, resultSchema = CallToolResultSchema, options) {
+		const clientInternal = this._client;
+		const optionsWithTask = {
+			...options,
+			task: options?.task ?? (clientInternal.isToolTask(params.name) ? {} : void 0)
+		};
+		const stream = clientInternal.requestStream({
+			method: "tools/call",
+			params
+		}, resultSchema, optionsWithTask);
+		const validator = clientInternal.getToolOutputValidator(params.name);
+		for await (const message of stream) {
+			if (message.type === "result" && validator) {
+				const result = message.result;
+				if (!result.structuredContent && !result.isError) {
+					yield {
+						type: "error",
+						error: new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`)
+					};
+					return;
+				}
+				if (result.structuredContent) try {
+					const validationResult = validator(result.structuredContent);
+					if (!validationResult.valid) {
+						yield {
+							type: "error",
+							error: new McpError(ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`)
+						};
+						return;
+					}
+				} catch (error) {
+					if (error instanceof McpError) {
+						yield {
+							type: "error",
+							error
+						};
+						return;
+					}
+					yield {
+						type: "error",
+						error: new McpError(ErrorCode.InvalidParams, `Failed to validate structured content: ${error instanceof Error ? error.message : String(error)}`)
+					};
+					return;
+				}
+			}
+			yield message;
+		}
+	}
+	/**
+	* Gets the current status of a task.
+	*
+	* @param taskId - The task identifier
+	* @param options - Optional request options
+	* @returns The task status
+	*
+	* @experimental
+	*/
+	async getTask(taskId, options) {
+		return this._client.getTask({ taskId }, options);
+	}
+	/**
+	* Retrieves the result of a completed task.
+	*
+	* @param taskId - The task identifier
+	* @param resultSchema - Zod schema for validating the result
+	* @param options - Optional request options
+	* @returns The task result
+	*
+	* @experimental
+	*/
+	async getTaskResult(taskId, resultSchema, options) {
+		return this._client.getTaskResult({ taskId }, resultSchema, options);
+	}
+	/**
+	* Lists tasks with optional pagination.
+	*
+	* @param cursor - Optional pagination cursor
+	* @param options - Optional request options
+	* @returns List of tasks with optional next cursor
+	*
+	* @experimental
+	*/
+	async listTasks(cursor, options) {
+		return this._client.listTasks(cursor ? { cursor } : void 0, options);
+	}
+	/**
+	* Cancels a running task.
+	*
+	* @param taskId - The task identifier
+	* @param options - Optional request options
+	*
+	* @experimental
+	*/
+	async cancelTask(taskId, options) {
+		return this._client.cancelTask({ taskId }, options);
+	}
+	/**
+	* Sends a request and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* This method provides streaming access to request processing, allowing you to
+	* observe intermediate task status updates for task-augmented requests.
+	*
+	* @param request - The request to send
+	* @param resultSchema - Zod schema for validating the result
+	* @param options - Optional request options (timeout, signal, task creation params, etc.)
+	* @returns AsyncGenerator that yields ResponseMessage objects
+	*
+	* @experimental
+	*/
+	requestStream(request, resultSchema, options) {
+		return this._client.requestStream(request, resultSchema, options);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/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 {
+				const items = await fetcher();
+				onChanged(null, items);
+			} catch (e) {
+				const error = e instanceof Error ? e : new Error(String(e));
+				onChanged(error, 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/isexe@2.0.0/node_modules/isexe/windows.js
+var require_windows = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = isexe;
+	isexe.sync = sync;
+	var fs$17 = __require("fs");
+	function checkPathExt(path, options) {
+		var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+		if (!pathext) return true;
+		pathext = pathext.split(";");
+		if (pathext.indexOf("") !== -1) return true;
+		for (var i = 0; i < pathext.length; i++) {
+			var p = pathext[i].toLowerCase();
+			if (p && path.substr(-p.length).toLowerCase() === p) return true;
+		}
+		return false;
+	}
+	function checkStat(stat, path, options) {
+		if (!stat.isSymbolicLink() && !stat.isFile()) return false;
+		return checkPathExt(path, options);
+	}
+	function isexe(path, options, cb) {
+		fs$17.stat(path, function(er, stat) {
+			cb(er, er ? false : checkStat(stat, path, options));
+		});
+	}
+	function sync(path, options) {
+		return checkStat(fs$17.statSync(path), path, options);
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js
+var require_mode = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = isexe;
+	isexe.sync = sync;
+	var fs$16 = __require("fs");
+	function isexe(path, options, cb) {
+		fs$16.stat(path, function(er, stat) {
+			cb(er, er ? false : checkStat(stat, options));
+		});
+	}
+	function sync(path, options) {
+		return checkStat(fs$16.statSync(path), options);
+	}
+	function checkStat(stat, options) {
+		return stat.isFile() && checkMode(stat, options);
+	}
+	function checkMode(stat, options) {
+		var mod = stat.mode;
+		var uid = stat.uid;
+		var gid = stat.gid;
+		var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+		var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+		var u = parseInt("100", 8);
+		var g = parseInt("010", 8);
+		var o = parseInt("001", 8);
+		var ug = u | g;
+		return mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
+var require_isexe = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	__require("fs");
+	var core;
+	if (process.platform === "win32" || global.TESTING_WINDOWS) core = require_windows();
+	else core = require_mode();
+	module.exports = isexe;
+	isexe.sync = sync;
+	function isexe(path, options, cb) {
+		if (typeof options === "function") {
+			cb = options;
+			options = {};
+		}
+		if (!cb) {
+			if (typeof Promise !== "function") throw new TypeError("callback not provided");
+			return new Promise(function(resolve, reject) {
+				isexe(path, options || {}, function(er, is) {
+					if (er) reject(er);
+					else resolve(is);
+				});
+			});
+		}
+		core(path, options || {}, function(er, is) {
+			if (er) {
+				if (er.code === "EACCES" || options && options.ignoreErrors) {
+					er = null;
+					is = false;
+				}
+			}
+			cb(er, is);
+		});
+	}
+	function sync(path, options) {
+		try {
+			return core.sync(path, options || {});
+		} catch (er) {
+			if (options && options.ignoreErrors || er.code === "EACCES") return false;
+			else throw er;
+		}
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
+var require_which = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+	const path$12 = __require("path");
+	const COLON = isWindows ? ";" : ":";
+	const isexe = require_isexe();
+	const getNotFoundError = (cmd) => Object.assign(/* @__PURE__ */ new Error(`not found: ${cmd}`), { code: "ENOENT" });
+	const getPathInfo = (cmd, opt) => {
+		const colon = opt.colon || COLON;
+		const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [...isWindows ? [process.cwd()] : [], ...(opt.path || process.env.PATH || "").split(colon)];
+		const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+		const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+		if (isWindows) {
+			if (cmd.indexOf(".") !== -1 && pathExt[0] !== "") pathExt.unshift("");
+		}
+		return {
+			pathEnv,
+			pathExt,
+			pathExtExe
+		};
+	};
+	const which = (cmd, opt, cb) => {
+		if (typeof opt === "function") {
+			cb = opt;
+			opt = {};
+		}
+		if (!opt) opt = {};
+		const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+		const found = [];
+		const step = (i) => new Promise((resolve, reject) => {
+			if (i === pathEnv.length) return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+			const ppRaw = pathEnv[i];
+			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+			const pCmd = path$12.join(pathPart, cmd);
+			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+			resolve(subStep(p, i, 0));
+		});
+		const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+			if (ii === pathExt.length) return resolve(step(i + 1));
+			const ext = pathExt[ii];
+			isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+				if (!er && is) if (opt.all) found.push(p + ext);
+				else return resolve(p + ext);
+				return resolve(subStep(p, i, ii + 1));
+			});
+		});
+		return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+	};
+	const whichSync = (cmd, opt) => {
+		opt = opt || {};
+		const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+		const found = [];
+		for (let i = 0; i < pathEnv.length; i++) {
+			const ppRaw = pathEnv[i];
+			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+			const pCmd = path$12.join(pathPart, cmd);
+			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+			for (let j = 0; j < pathExt.length; j++) {
+				const cur = p + pathExt[j];
+				try {
+					if (isexe.sync(cur, { pathExt: pathExtExe })) if (opt.all) found.push(cur);
+					else return cur;
+				} catch (ex) {}
+			}
+		}
+		if (opt.all && found.length) return found;
+		if (opt.nothrow) return null;
+		throw getNotFoundError(cmd);
+	};
+	module.exports = which;
+	which.sync = whichSync;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js
+var require_path_key = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const pathKey = (options = {}) => {
+		const environment = options.env || process.env;
+		if ((options.platform || process.platform) !== "win32") return "PATH";
+		return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+	};
+	module.exports = pathKey;
+	module.exports.default = pathKey;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$11 = __require("path");
+	const which = require_which();
+	const getPathKey = require_path_key();
+	function resolveCommandAttempt(parsed, withoutPathExt) {
+		const env = parsed.options.env || process.env;
+		const cwd = process.cwd();
+		const hasCustomCwd = parsed.options.cwd != null;
+		const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+		if (shouldSwitchCwd) try {
+			process.chdir(parsed.options.cwd);
+		} catch (err) {}
+		let resolved;
+		try {
+			resolved = which.sync(parsed.command, {
+				path: env[getPathKey({ env })],
+				pathExt: withoutPathExt ? path$11.delimiter : void 0
+			});
+		} catch (e) {} finally {
+			if (shouldSwitchCwd) process.chdir(cwd);
+		}
+		if (resolved) resolved = path$11.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+		return resolved;
+	}
+	function resolveCommand(parsed) {
+		return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+	}
+	module.exports = resolveCommand;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js
+var require_escape = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+	function escapeCommand(arg) {
+		arg = arg.replace(metaCharsRegExp, "^$1");
+		return arg;
+	}
+	function escapeArgument(arg, doubleEscapeMetaChars) {
+		arg = `${arg}`;
+		arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+		arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+		arg = `"${arg}"`;
+		arg = arg.replace(metaCharsRegExp, "^$1");
+		if (doubleEscapeMetaChars) arg = arg.replace(metaCharsRegExp, "^$1");
+		return arg;
+	}
+	module.exports.command = escapeCommand;
+	module.exports.argument = escapeArgument;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = /^#!(.*)/;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js
+var require_shebang_command = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const shebangRegex = require_shebang_regex();
+	module.exports = (string = "") => {
+		const match = string.match(shebangRegex);
+		if (!match) return null;
+		const [path, argument] = match[0].replace(/#! ?/, "").split(" ");
+		const binary = path.split("/").pop();
+		if (binary === "env") return argument;
+		return argument ? `${binary} ${argument}` : binary;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs$15 = __require("fs");
+	const shebangCommand = require_shebang_command();
+	function readShebang(command) {
+		const size = 150;
+		const buffer = Buffer.alloc(size);
+		let fd;
+		try {
+			fd = fs$15.openSync(command, "r");
+			fs$15.readSync(fd, buffer, 0, size, 0);
+			fs$15.closeSync(fd);
+		} catch (e) {}
+		return shebangCommand(buffer.toString());
+	}
+	module.exports = readShebang;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
+var require_parse$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$10 = __require("path");
+	const resolveCommand = require_resolveCommand();
+	const escape = require_escape();
+	const readShebang = require_readShebang();
+	const isWin = process.platform === "win32";
+	const isExecutableRegExp = /\.(?:com|exe)$/i;
+	const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+	function detectShebang(parsed) {
+		parsed.file = resolveCommand(parsed);
+		const shebang = parsed.file && readShebang(parsed.file);
+		if (shebang) {
+			parsed.args.unshift(parsed.file);
+			parsed.command = shebang;
+			return resolveCommand(parsed);
+		}
+		return parsed.file;
+	}
+	function parseNonShell(parsed) {
+		if (!isWin) return parsed;
+		const commandFile = detectShebang(parsed);
+		const needsShell = !isExecutableRegExp.test(commandFile);
+		if (parsed.options.forceShell || needsShell) {
+			const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+			parsed.command = path$10.normalize(parsed.command);
+			parsed.command = escape.command(parsed.command);
+			parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+			parsed.args = [
+				"/d",
+				"/s",
+				"/c",
+				`"${[parsed.command].concat(parsed.args).join(" ")}"`
+			];
+			parsed.command = process.env.comspec || "cmd.exe";
+			parsed.options.windowsVerbatimArguments = true;
+		}
+		return parsed;
+	}
+	function parse(command, args, options) {
+		if (args && !Array.isArray(args)) {
+			options = args;
+			args = null;
+		}
+		args = args ? args.slice(0) : [];
+		options = Object.assign({}, options);
+		const parsed = {
+			command,
+			args,
+			options,
+			file: void 0,
+			original: {
+				command,
+				args
+			}
+		};
+		return options.shell ? parsed : parseNonShell(parsed);
+	}
+	module.exports = parse;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isWin = process.platform === "win32";
+	function notFoundError(original, syscall) {
+		return Object.assign(/* @__PURE__ */ new Error(`${syscall} ${original.command} ENOENT`), {
+			code: "ENOENT",
+			errno: "ENOENT",
+			syscall: `${syscall} ${original.command}`,
+			path: original.command,
+			spawnargs: original.args
+		});
+	}
+	function hookChildProcess(cp, parsed) {
+		if (!isWin) return;
+		const originalEmit = cp.emit;
+		cp.emit = function(name, arg1) {
+			if (name === "exit") {
+				const err = verifyENOENT(arg1, parsed);
+				if (err) return originalEmit.call(cp, "error", err);
+			}
+			return originalEmit.apply(cp, arguments);
+		};
+	}
+	function verifyENOENT(status, parsed) {
+		if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawn");
+		return null;
+	}
+	function verifyENOENTSync(status, parsed) {
+		if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawnSync");
+		return null;
+	}
+	module.exports = {
+		hookChildProcess,
+		verifyENOENT,
+		verifyENOENTSync,
+		notFoundError
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/client/stdio.js
+var import_cross_spawn = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const cp = __require("child_process");
+	const parse = require_parse$2();
+	const enoent = require_enoent();
+	function spawn(command, args, options) {
+		const parsed = parse(command, args, options);
+		const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+		enoent.hookChildProcess(spawned, parsed);
+		return spawned;
+	}
+	function spawnSync(command, args, options) {
+		const parsed = parse(command, args, options);
+		const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+		result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+		return result;
+	}
+	module.exports = spawn;
+	module.exports.spawn = spawn;
+	module.exports.sync = spawnSync;
+	module.exports._parse = parse;
+	module.exports._enoent = enoent;
+})))(), 1);
+/**
+* Environment variables to inherit by default, if an environment is not explicitly given.
+*/
+const DEFAULT_INHERITED_ENV_VARS = process$1.platform === "win32" ? [
+	"APPDATA",
+	"HOMEDRIVE",
+	"HOMEPATH",
+	"LOCALAPPDATA",
+	"PATH",
+	"PROCESSOR_ARCHITECTURE",
+	"SYSTEMDRIVE",
+	"SYSTEMROOT",
+	"TEMP",
+	"USERNAME",
+	"USERPROFILE",
+	"PROGRAMFILES"
+] : [
+	"HOME",
+	"LOGNAME",
+	"PATH",
+	"SHELL",
+	"TERM",
+	"USER"
+];
+/**
+* Returns a default environment object including only environment variables deemed safe to inherit.
+*/
+function getDefaultEnvironment() {
+	const env = {};
+	for (const key of DEFAULT_INHERITED_ENV_VARS) {
+		const value = process$1.env[key];
+		if (value === void 0) continue;
+		if (value.startsWith("()")) continue;
+		env[key] = value;
+	}
+	return env;
+}
+/**
+* Client transport for stdio: this will connect to a server by spawning a process and communicating with it over stdin/stdout.
+*
+* This transport is only available in Node.js environments.
+*/
+var StdioClientTransport = class {
+	constructor(server) {
+		this._readBuffer = new ReadBuffer();
+		this._stderrStream = null;
+		this._serverParams = server;
+		if (server.stderr === "pipe" || server.stderr === "overlapped") this._stderrStream = new PassThrough();
+	}
+	/**
+	* Starts the server process and prepares to communicate with it.
+	*/
+	async start() {
+		if (this._process) throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+		return new Promise((resolve, reject) => {
+			this._process = (0, import_cross_spawn.default)(this._serverParams.command, this._serverParams.args ?? [], {
+				env: {
+					...getDefaultEnvironment(),
+					...this._serverParams.env
+				},
+				stdio: [
+					"pipe",
+					"pipe",
+					this._serverParams.stderr ?? "inherit"
+				],
+				shell: false,
+				windowsHide: process$1.platform === "win32",
+				cwd: this._serverParams.cwd
+			});
+			this._process.on("error", (error) => {
+				reject(error);
+				this.onerror?.(error);
+			});
+			this._process.on("spawn", () => {
+				resolve();
+			});
+			this._process.on("close", (_code) => {
+				this._process = void 0;
+				this.onclose?.();
+			});
+			this._process.stdin?.on("error", (error) => {
+				this.onerror?.(error);
+			});
+			this._process.stdout?.on("data", (chunk) => {
+				this._readBuffer.append(chunk);
+				this.processReadBuffer();
+			});
+			this._process.stdout?.on("error", (error) => {
+				this.onerror?.(error);
+			});
+			if (this._stderrStream && this._process.stderr) this._process.stderr.pipe(this._stderrStream);
+		});
+	}
+	/**
+	* The stderr stream of the child process, if `StdioServerParameters.stderr` was set to "pipe" or "overlapped".
+	*
+	* If stderr piping was requested, a PassThrough stream is returned _immediately_, allowing callers to
+	* attach listeners before the start method is invoked. This prevents loss of any early
+	* error output emitted by the child process.
+	*/
+	get stderr() {
+		if (this._stderrStream) return this._stderrStream;
+		return this._process?.stderr ?? null;
+	}
+	/**
+	* The child process pid spawned by this transport.
+	*
+	* This is only available after the transport has been started.
+	*/
+	get pid() {
+		return this._process?.pid ?? null;
+	}
+	processReadBuffer() {
+		while (true) try {
+			const message = this._readBuffer.readMessage();
+			if (message === null) break;
+			this.onmessage?.(message);
+		} catch (error) {
+			this.onerror?.(error);
+		}
+	}
+	async close() {
+		if (this._process) {
+			const processToClose = this._process;
+			this._process = void 0;
+			const closePromise = new Promise((resolve) => {
+				processToClose.once("close", () => {
+					resolve();
+				});
+			});
+			try {
+				processToClose.stdin?.end();
+			} catch {}
+			await Promise.race([closePromise, new Promise((resolve) => setTimeout(resolve, 2e3).unref())]);
+			if (processToClose.exitCode === null) {
+				try {
+					processToClose.kill("SIGTERM");
+				} catch {}
+				await Promise.race([closePromise, new Promise((resolve) => setTimeout(resolve, 2e3).unref())]);
+			}
+			if (processToClose.exitCode === null) try {
+				processToClose.kill("SIGKILL");
+			} catch {}
+		}
+		this._readBuffer.clear();
+	}
+	send(message) {
+		return new Promise((resolve) => {
+			if (!this._process?.stdin) throw new Error("Not connected");
+			const json = serializeMessage(message);
+			if (this._process.stdin.write(json)) resolve();
+			else this._process.stdin.once("drain", resolve);
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/transport.js
+/**
+* Normalizes HeadersInit to a plain Record<string, string> for manipulation.
+* Handles Headers objects, arrays of tuples, and plain objects.
+*/
+function normalizeHeaders(headers) {
+	if (!headers) return {};
+	if (headers instanceof Headers) return Object.fromEntries(headers.entries());
+	if (Array.isArray(headers)) return Object.fromEntries(headers);
+	return { ...headers };
+}
+/**
+* Creates a fetch function that includes base RequestInit options.
+* This ensures requests inherit settings like credentials, mode, headers, etc. from the base init.
+*
+* @param baseFetch - The base fetch function to wrap (defaults to global fetch)
+* @param baseInit - The base RequestInit to merge with each request
+* @returns A wrapped fetch function that merges base options with call-specific options
+*/
+function createFetchWithInit(baseFetch = fetch, baseInit) {
+	if (!baseInit) return baseFetch;
+	return async (url, init) => {
+		return baseFetch(url, {
+			...baseInit,
+			...init,
+			headers: init?.headers ? {
+				...normalizeHeaders(baseInit.headers),
+				...normalizeHeaders(init.headers)
+			} : baseInit.headers
+		});
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/pkce-challenge@5.0.1/node_modules/pkce-challenge/dist/index.node.js
+let crypto$6;
+crypto$6 = globalThis.crypto?.webcrypto ?? globalThis.crypto ?? import("node:crypto").then((m) => m.webcrypto);
+/**
+* Creates an array of length `size` of random bytes
+* @param size
+* @returns Array of random ints (0 to 255)
+*/
+async function getRandomValues(size) {
+	return (await crypto$6).getRandomValues(new Uint8Array(size));
+}
+/** Generate cryptographically strong random string
+* @param size The desired length of the string
+* @returns The random string
+*/
+async function random(size) {
+	const mask = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";
+	const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % 66;
+	let result = "";
+	while (result.length < size) {
+		const randomBytes = await getRandomValues(size - result.length);
+		for (const randomByte of randomBytes) if (randomByte < evenDistCutoff) result += mask[randomByte % 66];
+	}
+	return result;
+}
+/** Generate a PKCE challenge verifier
+* @param length Length of the verifier
+* @returns A random verifier `length` characters long
+*/
+async function generateVerifier(length) {
+	return await random(length);
+}
+/** Generate a PKCE code challenge from a code verifier
+* @param code_verifier
+* @returns The base64 url encoded code challenge
+*/
+async function generateChallenge(code_verifier) {
+	const buffer = await (await crypto$6).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier));
+	return btoa(String.fromCharCode(...new Uint8Array(buffer))).replace(/\//g, "_").replace(/\+/g, "-").replace(/=/g, "");
+}
+/** Generate a PKCE challenge pair
+* @param length Length of the verifer (between 43-128). Defaults to 43.
+* @returns PKCE challenge pair
+*/
+async function pkceChallenge(length) {
+	if (!length) length = 43;
+	if (length < 43 || length > 128) throw `Expected a length between 43 and 128. Received ${length}.`;
+	const verifier = await generateVerifier(length);
+	return {
+		code_verifier: verifier,
+		code_challenge: await generateChallenge(verifier)
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth.js
+/**
+* Reusable URL validation that disallows javascript: scheme
+*/
+const SafeUrlSchema = url$4().superRefine((val, ctx) => {
+	if (!URL.canParse(val)) {
+		ctx.addIssue({
+			code: ZodIssueCode.custom,
+			message: "URL must be parseable",
+			fatal: true
+		});
+		return NEVER;
+	}
+}).refine((url) => {
+	const u = new URL(url);
+	return u.protocol !== "javascript:" && u.protocol !== "data:" && u.protocol !== "vbscript:";
+}, { message: "URL cannot use javascript:, data:, or vbscript: scheme" });
+/**
+* RFC 9728 OAuth Protected Resource Metadata
+*/
+const OAuthProtectedResourceMetadataSchema = looseObject({
+	resource: string().url(),
+	authorization_servers: array(SafeUrlSchema).optional(),
+	jwks_uri: string().url().optional(),
+	scopes_supported: array(string()).optional(),
+	bearer_methods_supported: array(string()).optional(),
+	resource_signing_alg_values_supported: array(string()).optional(),
+	resource_name: string().optional(),
+	resource_documentation: string().optional(),
+	resource_policy_uri: string().url().optional(),
+	resource_tos_uri: string().url().optional(),
+	tls_client_certificate_bound_access_tokens: boolean().optional(),
+	authorization_details_types_supported: array(string()).optional(),
+	dpop_signing_alg_values_supported: array(string()).optional(),
+	dpop_bound_access_tokens_required: boolean().optional()
+});
+/**
+* RFC 8414 OAuth 2.0 Authorization Server Metadata
+*/
+const OAuthMetadataSchema = looseObject({
+	issuer: string(),
+	authorization_endpoint: SafeUrlSchema,
+	token_endpoint: SafeUrlSchema,
+	registration_endpoint: SafeUrlSchema.optional(),
+	scopes_supported: array(string()).optional(),
+	response_types_supported: array(string()),
+	response_modes_supported: array(string()).optional(),
+	grant_types_supported: array(string()).optional(),
+	token_endpoint_auth_methods_supported: array(string()).optional(),
+	token_endpoint_auth_signing_alg_values_supported: array(string()).optional(),
+	service_documentation: SafeUrlSchema.optional(),
+	revocation_endpoint: SafeUrlSchema.optional(),
+	revocation_endpoint_auth_methods_supported: array(string()).optional(),
+	revocation_endpoint_auth_signing_alg_values_supported: array(string()).optional(),
+	introspection_endpoint: string().optional(),
+	introspection_endpoint_auth_methods_supported: array(string()).optional(),
+	introspection_endpoint_auth_signing_alg_values_supported: array(string()).optional(),
+	code_challenge_methods_supported: array(string()).optional(),
+	client_id_metadata_document_supported: boolean().optional()
+});
+/**
+* OpenID Connect Discovery metadata that may include OAuth 2.0 fields
+* This schema represents the real-world scenario where OIDC providers
+* return a mix of OpenID Connect and OAuth 2.0 metadata fields
+*/
+const OpenIdProviderDiscoveryMetadataSchema = object({
+	...looseObject({
+		issuer: string(),
+		authorization_endpoint: SafeUrlSchema,
+		token_endpoint: SafeUrlSchema,
+		userinfo_endpoint: SafeUrlSchema.optional(),
+		jwks_uri: SafeUrlSchema,
+		registration_endpoint: SafeUrlSchema.optional(),
+		scopes_supported: array(string()).optional(),
+		response_types_supported: array(string()),
+		response_modes_supported: array(string()).optional(),
+		grant_types_supported: array(string()).optional(),
+		acr_values_supported: array(string()).optional(),
+		subject_types_supported: array(string()),
+		id_token_signing_alg_values_supported: array(string()),
+		id_token_encryption_alg_values_supported: array(string()).optional(),
+		id_token_encryption_enc_values_supported: array(string()).optional(),
+		userinfo_signing_alg_values_supported: array(string()).optional(),
+		userinfo_encryption_alg_values_supported: array(string()).optional(),
+		userinfo_encryption_enc_values_supported: array(string()).optional(),
+		request_object_signing_alg_values_supported: array(string()).optional(),
+		request_object_encryption_alg_values_supported: array(string()).optional(),
+		request_object_encryption_enc_values_supported: array(string()).optional(),
+		token_endpoint_auth_methods_supported: array(string()).optional(),
+		token_endpoint_auth_signing_alg_values_supported: array(string()).optional(),
+		display_values_supported: array(string()).optional(),
+		claim_types_supported: array(string()).optional(),
+		claims_supported: array(string()).optional(),
+		service_documentation: string().optional(),
+		claims_locales_supported: array(string()).optional(),
+		ui_locales_supported: array(string()).optional(),
+		claims_parameter_supported: boolean().optional(),
+		request_parameter_supported: boolean().optional(),
+		request_uri_parameter_supported: boolean().optional(),
+		require_request_uri_registration: boolean().optional(),
+		op_policy_uri: SafeUrlSchema.optional(),
+		op_tos_uri: SafeUrlSchema.optional(),
+		client_id_metadata_document_supported: boolean().optional()
+	}).shape,
+	...OAuthMetadataSchema.pick({ code_challenge_methods_supported: true }).shape
+});
+/**
+* OAuth 2.1 token response
+*/
+const OAuthTokensSchema = object({
+	access_token: string(),
+	id_token: string().optional(),
+	token_type: string(),
+	expires_in: number().optional(),
+	scope: string().optional(),
+	refresh_token: string().optional()
+}).strip();
+/**
+* OAuth 2.1 error response
+*/
+const OAuthErrorResponseSchema = object({
+	error: string(),
+	error_description: string().optional(),
+	error_uri: string().optional()
+});
+/**
+* Optional version of SafeUrlSchema that allows empty string for retrocompatibility on tos_uri and logo_uri
+*/
+const OptionalSafeUrlSchema = SafeUrlSchema.optional().or(literal("").transform(() => void 0));
+/**
+* RFC 7591 OAuth 2.0 Dynamic Client Registration metadata
+*/
+const OAuthClientMetadataSchema = object({
+	redirect_uris: array(SafeUrlSchema),
+	token_endpoint_auth_method: string().optional(),
+	grant_types: array(string()).optional(),
+	response_types: array(string()).optional(),
+	client_name: string().optional(),
+	client_uri: SafeUrlSchema.optional(),
+	logo_uri: OptionalSafeUrlSchema,
+	scope: string().optional(),
+	contacts: array(string()).optional(),
+	tos_uri: OptionalSafeUrlSchema,
+	policy_uri: string().optional(),
+	jwks_uri: SafeUrlSchema.optional(),
+	jwks: any().optional(),
+	software_id: string().optional(),
+	software_version: string().optional(),
+	software_statement: string().optional()
+}).strip();
+/**
+* RFC 7591 OAuth 2.0 Dynamic Client Registration client information
+*/
+const OAuthClientInformationSchema = object({
+	client_id: string(),
+	client_secret: string().optional(),
+	client_id_issued_at: number$1().optional(),
+	client_secret_expires_at: number$1().optional()
+}).strip();
+/**
+* RFC 7591 OAuth 2.0 Dynamic Client Registration full response (client information plus metadata)
+*/
+const OAuthClientInformationFullSchema = OAuthClientMetadataSchema.merge(OAuthClientInformationSchema);
+object({
+	error: string(),
+	error_description: string().optional()
+}).strip();
+object({
+	token: string(),
+	token_type_hint: string().optional()
+}).strip();
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth-utils.js
+/**
+* Utilities for handling OAuth resource URIs.
+*/
+/**
+* Converts a server URL to a resource URL by removing the fragment.
+* RFC 8707 section 2 states that resource URIs "MUST NOT include a fragment component".
+* Keeps everything else unchanged (scheme, domain, port, path, query).
+*/
+function resourceUrlFromServerUrl(url) {
+	const resourceURL = typeof url === "string" ? new URL(url) : new URL(url.href);
+	resourceURL.hash = "";
+	return resourceURL;
+}
+/**
+* Checks if a requested resource URL matches a configured resource URL.
+* A requested resource matches if it has the same scheme, domain, port,
+* and its path starts with the configured resource's path.
+*
+* @param requestedResource The resource URL being requested
+* @param configuredResource The resource URL that has been configured
+* @returns true if the requested resource matches the configured resource, false otherwise
+*/
+function checkResourceAllowed({ requestedResource, configuredResource }) {
+	const requested = typeof requestedResource === "string" ? new URL(requestedResource) : new URL(requestedResource.href);
+	const configured = typeof configuredResource === "string" ? new URL(configuredResource) : new URL(configuredResource.href);
+	if (requested.origin !== configured.origin) return false;
+	if (requested.pathname.length < configured.pathname.length) return false;
+	const requestedPath = requested.pathname.endsWith("/") ? requested.pathname : requested.pathname + "/";
+	const configuredPath = configured.pathname.endsWith("/") ? configured.pathname : configured.pathname + "/";
+	return requestedPath.startsWith(configuredPath);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/server/auth/errors.js
+/**
+* Base class for all OAuth errors
+*/
+var OAuthError = class extends Error {
+	constructor(message, errorUri) {
+		super(message);
+		this.errorUri = errorUri;
+		this.name = this.constructor.name;
+	}
+	/**
+	* Converts the error to a standard OAuth error response object
+	*/
+	toResponseObject() {
+		const response = {
+			error: this.errorCode,
+			error_description: this.message
+		};
+		if (this.errorUri) response.error_uri = this.errorUri;
+		return response;
+	}
+	get errorCode() {
+		return this.constructor.errorCode;
+	}
+};
+/**
+* Invalid request error - The request is missing a required parameter,
+* includes an invalid parameter value, includes a parameter more than once,
+* or is otherwise malformed.
+*/
+var InvalidRequestError = class extends OAuthError {};
+InvalidRequestError.errorCode = "invalid_request";
+/**
+* Invalid client error - Client authentication failed (e.g., unknown client, no client
+* authentication included, or unsupported authentication method).
+*/
+var InvalidClientError = class extends OAuthError {};
+InvalidClientError.errorCode = "invalid_client";
+/**
+* Invalid grant error - The provided authorization grant or refresh token is
+* invalid, expired, revoked, does not match the redirection URI used in the
+* authorization request, or was issued to another client.
+*/
+var InvalidGrantError = class extends OAuthError {};
+InvalidGrantError.errorCode = "invalid_grant";
+/**
+* Unauthorized client error - The authenticated client is not authorized to use
+* this authorization grant type.
+*/
+var UnauthorizedClientError = class extends OAuthError {};
+UnauthorizedClientError.errorCode = "unauthorized_client";
+/**
+* Unsupported grant type error - The authorization grant type is not supported
+* by the authorization server.
+*/
+var UnsupportedGrantTypeError = class extends OAuthError {};
+UnsupportedGrantTypeError.errorCode = "unsupported_grant_type";
+/**
+* Invalid scope error - The requested scope is invalid, unknown, malformed, or
+* exceeds the scope granted by the resource owner.
+*/
+var InvalidScopeError = class extends OAuthError {};
+InvalidScopeError.errorCode = "invalid_scope";
+/**
+* Access denied error - The resource owner or authorization server denied the request.
+*/
+var AccessDeniedError = class extends OAuthError {};
+AccessDeniedError.errorCode = "access_denied";
+/**
+* Server error - The authorization server encountered an unexpected condition
+* that prevented it from fulfilling the request.
+*/
+var ServerError = class extends OAuthError {};
+ServerError.errorCode = "server_error";
+/**
+* Temporarily unavailable error - The authorization server is currently unable to
+* handle the request due to a temporary overloading or maintenance of the server.
+*/
+var TemporarilyUnavailableError = class extends OAuthError {};
+TemporarilyUnavailableError.errorCode = "temporarily_unavailable";
+/**
+* Unsupported response type error - The authorization server does not support
+* obtaining an authorization code using this method.
+*/
+var UnsupportedResponseTypeError = class extends OAuthError {};
+UnsupportedResponseTypeError.errorCode = "unsupported_response_type";
+/**
+* Unsupported token type error - The authorization server does not support
+* the requested token type.
+*/
+var UnsupportedTokenTypeError = class extends OAuthError {};
+UnsupportedTokenTypeError.errorCode = "unsupported_token_type";
+/**
+* Invalid token error - The access token provided is expired, revoked, malformed,
+* or invalid for other reasons.
+*/
+var InvalidTokenError = class extends OAuthError {};
+InvalidTokenError.errorCode = "invalid_token";
+/**
+* Method not allowed error - The HTTP method used is not allowed for this endpoint.
+* (Custom, non-standard error)
+*/
+var MethodNotAllowedError = class extends OAuthError {};
+MethodNotAllowedError.errorCode = "method_not_allowed";
+/**
+* Too many requests error - Rate limit exceeded.
+* (Custom, non-standard error based on RFC 6585)
+*/
+var TooManyRequestsError = class extends OAuthError {};
+TooManyRequestsError.errorCode = "too_many_requests";
+/**
+* Invalid client metadata error - The client metadata is invalid.
+* (Custom error for dynamic client registration - RFC 7591)
+*/
+var InvalidClientMetadataError = class extends OAuthError {};
+InvalidClientMetadataError.errorCode = "invalid_client_metadata";
+/**
+* Insufficient scope error - The request requires higher privileges than provided by the access token.
+*/
+var InsufficientScopeError = class extends OAuthError {};
+InsufficientScopeError.errorCode = "insufficient_scope";
+/**
+* Invalid target error - The requested resource is invalid, missing, unknown, or malformed.
+* (Custom error for resource indicators - RFC 8707)
+*/
+var InvalidTargetError = class extends OAuthError {};
+InvalidTargetError.errorCode = "invalid_target";
+/**
+* A full list of all OAuthErrors, enabling parsing from error responses
+*/
+const OAUTH_ERRORS = {
+	[InvalidRequestError.errorCode]: InvalidRequestError,
+	[InvalidClientError.errorCode]: InvalidClientError,
+	[InvalidGrantError.errorCode]: InvalidGrantError,
+	[UnauthorizedClientError.errorCode]: UnauthorizedClientError,
+	[UnsupportedGrantTypeError.errorCode]: UnsupportedGrantTypeError,
+	[InvalidScopeError.errorCode]: InvalidScopeError,
+	[AccessDeniedError.errorCode]: AccessDeniedError,
+	[ServerError.errorCode]: ServerError,
+	[TemporarilyUnavailableError.errorCode]: TemporarilyUnavailableError,
+	[UnsupportedResponseTypeError.errorCode]: UnsupportedResponseTypeError,
+	[UnsupportedTokenTypeError.errorCode]: UnsupportedTokenTypeError,
+	[InvalidTokenError.errorCode]: InvalidTokenError,
+	[MethodNotAllowedError.errorCode]: MethodNotAllowedError,
+	[TooManyRequestsError.errorCode]: TooManyRequestsError,
+	[InvalidClientMetadataError.errorCode]: InvalidClientMetadataError,
+	[InsufficientScopeError.errorCode]: InsufficientScopeError,
+	[InvalidTargetError.errorCode]: InvalidTargetError
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/client/auth.js
+var UnauthorizedError = class extends Error {
+	constructor(message) {
+		super(message ?? "Unauthorized");
+	}
+};
+function isClientAuthMethod(method) {
+	return [
+		"client_secret_basic",
+		"client_secret_post",
+		"none"
+	].includes(method);
+}
+const AUTHORIZATION_CODE_RESPONSE_TYPE = "code";
+const AUTHORIZATION_CODE_CHALLENGE_METHOD = "S256";
+/**
+* Determines the best client authentication method to use based on server support and client configuration.
+*
+* Priority order (highest to lowest):
+* 1. client_secret_basic (if client secret is available)
+* 2. client_secret_post (if client secret is available)
+* 3. none (for public clients)
+*
+* @param clientInformation - OAuth client information containing credentials
+* @param supportedMethods - Authentication methods supported by the authorization server
+* @returns The selected authentication method
+*/
+function selectClientAuthMethod(clientInformation, supportedMethods) {
+	const hasClientSecret = clientInformation.client_secret !== void 0;
+	if ("token_endpoint_auth_method" in clientInformation && clientInformation.token_endpoint_auth_method && isClientAuthMethod(clientInformation.token_endpoint_auth_method) && (supportedMethods.length === 0 || supportedMethods.includes(clientInformation.token_endpoint_auth_method))) return clientInformation.token_endpoint_auth_method;
+	if (supportedMethods.length === 0) return hasClientSecret ? "client_secret_basic" : "none";
+	if (hasClientSecret && supportedMethods.includes("client_secret_basic")) return "client_secret_basic";
+	if (hasClientSecret && supportedMethods.includes("client_secret_post")) return "client_secret_post";
+	if (supportedMethods.includes("none")) return "none";
+	return hasClientSecret ? "client_secret_post" : "none";
+}
+/**
+* Applies client authentication to the request based on the specified method.
+*
+* Implements OAuth 2.1 client authentication methods:
+* - client_secret_basic: HTTP Basic authentication (RFC 6749 Section 2.3.1)
+* - client_secret_post: Credentials in request body (RFC 6749 Section 2.3.1)
+* - none: Public client authentication (RFC 6749 Section 2.1)
+*
+* @param method - The authentication method to use
+* @param clientInformation - OAuth client information containing credentials
+* @param headers - HTTP headers object to modify
+* @param params - URL search parameters to modify
+* @throws {Error} When required credentials are missing
+*/
+function applyClientAuthentication(method, clientInformation, headers, params) {
+	const { client_id, client_secret } = clientInformation;
+	switch (method) {
+		case "client_secret_basic":
+			applyBasicAuth(client_id, client_secret, headers);
+			return;
+		case "client_secret_post":
+			applyPostAuth(client_id, client_secret, params);
+			return;
+		case "none":
+			applyPublicAuth(client_id, params);
+			return;
+		default: throw new Error(`Unsupported client authentication method: ${method}`);
+	}
+}
+/**
+* Applies HTTP Basic authentication (RFC 6749 Section 2.3.1)
+*/
+function applyBasicAuth(clientId, clientSecret, headers) {
+	if (!clientSecret) throw new Error("client_secret_basic authentication requires a client_secret");
+	const credentials = btoa(`${clientId}:${clientSecret}`);
+	headers.set("Authorization", `Basic ${credentials}`);
+}
+/**
+* Applies POST body authentication (RFC 6749 Section 2.3.1)
+*/
+function applyPostAuth(clientId, clientSecret, params) {
+	params.set("client_id", clientId);
+	if (clientSecret) params.set("client_secret", clientSecret);
+}
+/**
+* Applies public client authentication (RFC 6749 Section 2.1)
+*/
+function applyPublicAuth(clientId, params) {
+	params.set("client_id", clientId);
+}
+/**
+* Parses an OAuth error response from a string or Response object.
+*
+* If the input is a standard OAuth2.0 error response, it will be parsed according to the spec
+* and an instance of the appropriate OAuthError subclass will be returned.
+* If parsing fails, it falls back to a generic ServerError that includes
+* the response status (if available) and original content.
+*
+* @param input - A Response object or string containing the error response
+* @returns A Promise that resolves to an OAuthError instance
+*/
+async function parseErrorResponse(input) {
+	const statusCode = input instanceof Response ? input.status : void 0;
+	const body = input instanceof Response ? await input.text() : input;
+	try {
+		const { error, error_description, error_uri } = OAuthErrorResponseSchema.parse(JSON.parse(body));
+		return new (OAUTH_ERRORS[error] || ServerError)(error_description || "", error_uri);
+	} catch (error) {
+		return new ServerError(`${statusCode ? `HTTP ${statusCode}: ` : ""}Invalid OAuth error response: ${error}. Raw body: ${body}`);
+	}
+}
+/**
+* Orchestrates the full auth flow with a server.
+*
+* This can be used as a single entry point for all authorization functionality,
+* instead of linking together the other lower-level functions in this module.
+*/
+async function auth(provider, options) {
+	try {
+		return await authInternal(provider, options);
+	} catch (error) {
+		if (error instanceof InvalidClientError || error instanceof UnauthorizedClientError) {
+			await provider.invalidateCredentials?.("all");
+			return await authInternal(provider, options);
+		} else if (error instanceof InvalidGrantError) {
+			await provider.invalidateCredentials?.("tokens");
+			return await authInternal(provider, options);
+		}
+		throw error;
+	}
+}
+async function authInternal(provider, { serverUrl, authorizationCode, scope, resourceMetadataUrl, fetchFn }) {
+	const cachedState = await provider.discoveryState?.();
+	let resourceMetadata;
+	let authorizationServerUrl;
+	let metadata;
+	let effectiveResourceMetadataUrl = resourceMetadataUrl;
+	if (!effectiveResourceMetadataUrl && cachedState?.resourceMetadataUrl) effectiveResourceMetadataUrl = new URL(cachedState.resourceMetadataUrl);
+	if (cachedState?.authorizationServerUrl) {
+		authorizationServerUrl = cachedState.authorizationServerUrl;
+		resourceMetadata = cachedState.resourceMetadata;
+		metadata = cachedState.authorizationServerMetadata ?? await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn });
+		if (!resourceMetadata) try {
+			resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl }, fetchFn);
+		} catch {}
+		if (metadata !== cachedState.authorizationServerMetadata || resourceMetadata !== cachedState.resourceMetadata) await provider.saveDiscoveryState?.({
+			authorizationServerUrl: String(authorizationServerUrl),
+			resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
+			resourceMetadata,
+			authorizationServerMetadata: metadata
+		});
+	} else {
+		const serverInfo = await discoverOAuthServerInfo(serverUrl, {
+			resourceMetadataUrl: effectiveResourceMetadataUrl,
+			fetchFn
+		});
+		authorizationServerUrl = serverInfo.authorizationServerUrl;
+		metadata = serverInfo.authorizationServerMetadata;
+		resourceMetadata = serverInfo.resourceMetadata;
+		await provider.saveDiscoveryState?.({
+			authorizationServerUrl: String(authorizationServerUrl),
+			resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
+			resourceMetadata,
+			authorizationServerMetadata: metadata
+		});
+	}
+	const resource = await selectResourceURL(serverUrl, provider, resourceMetadata);
+	const resolvedScope = scope || resourceMetadata?.scopes_supported?.join(" ") || provider.clientMetadata.scope;
+	let clientInformation = await Promise.resolve(provider.clientInformation());
+	if (!clientInformation) {
+		if (authorizationCode !== void 0) throw new Error("Existing OAuth client information is required when exchanging an authorization code");
+		const supportsUrlBasedClientId = metadata?.client_id_metadata_document_supported === true;
+		const clientMetadataUrl = provider.clientMetadataUrl;
+		if (clientMetadataUrl && !isHttpsUrl(clientMetadataUrl)) throw new InvalidClientMetadataError(`clientMetadataUrl must be a valid HTTPS URL with a non-root pathname, got: ${clientMetadataUrl}`);
+		if (supportsUrlBasedClientId && clientMetadataUrl) {
+			clientInformation = { client_id: clientMetadataUrl };
+			await provider.saveClientInformation?.(clientInformation);
+		} else {
+			if (!provider.saveClientInformation) throw new Error("OAuth client information must be saveable for dynamic registration");
+			const fullInformation = await registerClient(authorizationServerUrl, {
+				metadata,
+				clientMetadata: provider.clientMetadata,
+				scope: resolvedScope,
+				fetchFn
+			});
+			await provider.saveClientInformation(fullInformation);
+			clientInformation = fullInformation;
+		}
+	}
+	const nonInteractiveFlow = !provider.redirectUrl;
+	if (authorizationCode !== void 0 || nonInteractiveFlow) {
+		const tokens = await fetchToken(provider, authorizationServerUrl, {
+			metadata,
+			resource,
+			authorizationCode,
+			fetchFn
+		});
+		await provider.saveTokens(tokens);
+		return "AUTHORIZED";
+	}
+	const tokens = await provider.tokens();
+	if (tokens?.refresh_token) try {
+		const newTokens = await refreshAuthorization(authorizationServerUrl, {
+			metadata,
+			clientInformation,
+			refreshToken: tokens.refresh_token,
+			resource,
+			addClientAuthentication: provider.addClientAuthentication,
+			fetchFn
+		});
+		await provider.saveTokens(newTokens);
+		return "AUTHORIZED";
+	} catch (error) {
+		if (!(error instanceof OAuthError) || error instanceof ServerError) {} else throw error;
+	}
+	const state = provider.state ? await provider.state() : void 0;
+	const { authorizationUrl, codeVerifier } = await startAuthorization(authorizationServerUrl, {
+		metadata,
+		clientInformation,
+		state,
+		redirectUrl: provider.redirectUrl,
+		scope: resolvedScope,
+		resource
+	});
+	await provider.saveCodeVerifier(codeVerifier);
+	await provider.redirectToAuthorization(authorizationUrl);
+	return "REDIRECT";
+}
+/**
+* SEP-991: URL-based Client IDs
+* Validate that the client_id is a valid URL with https scheme
+*/
+function isHttpsUrl(value) {
+	if (!value) return false;
+	try {
+		const url = new URL(value);
+		return url.protocol === "https:" && url.pathname !== "/";
+	} catch {
+		return false;
+	}
+}
+async function selectResourceURL(serverUrl, provider, resourceMetadata) {
+	const defaultResource = resourceUrlFromServerUrl(serverUrl);
+	if (provider.validateResourceURL) return await provider.validateResourceURL(defaultResource, resourceMetadata?.resource);
+	if (!resourceMetadata) return;
+	if (!checkResourceAllowed({
+		requestedResource: defaultResource,
+		configuredResource: resourceMetadata.resource
+	})) throw new Error(`Protected resource ${resourceMetadata.resource} does not match expected ${defaultResource} (or origin)`);
+	return new URL(resourceMetadata.resource);
+}
+/**
+* Extract resource_metadata, scope, and error from WWW-Authenticate header.
+*/
+function extractWWWAuthenticateParams(res) {
+	const authenticateHeader = res.headers.get("WWW-Authenticate");
+	if (!authenticateHeader) return {};
+	const [type, scheme] = authenticateHeader.split(" ");
+	if (type.toLowerCase() !== "bearer" || !scheme) return {};
+	const resourceMetadataMatch = extractFieldFromWwwAuth(res, "resource_metadata") || void 0;
+	let resourceMetadataUrl;
+	if (resourceMetadataMatch) try {
+		resourceMetadataUrl = new URL(resourceMetadataMatch);
+	} catch {}
+	const scope = extractFieldFromWwwAuth(res, "scope") || void 0;
+	const error = extractFieldFromWwwAuth(res, "error") || void 0;
+	return {
+		resourceMetadataUrl,
+		scope,
+		error
+	};
+}
+/**
+* Extracts a specific field's value from the WWW-Authenticate header string.
+*
+* @param response The HTTP response object containing the headers.
+* @param fieldName The name of the field to extract (e.g., "realm", "nonce").
+* @returns The field value
+*/
+function extractFieldFromWwwAuth(response, fieldName) {
+	const wwwAuthHeader = response.headers.get("WWW-Authenticate");
+	if (!wwwAuthHeader) return null;
+	const pattern = new RegExp(`${fieldName}=(?:"([^"]+)"|([^\\s,]+))`);
+	const match = wwwAuthHeader.match(pattern);
+	if (match) return match[1] || match[2];
+	return null;
+}
+/**
+* Looks up RFC 9728 OAuth 2.0 Protected Resource Metadata.
+*
+* If the server returns a 404 for the well-known endpoint, this function will
+* return `undefined`. Any other errors will be thrown as exceptions.
+*/
+async function discoverOAuthProtectedResourceMetadata(serverUrl, opts, fetchFn = fetch) {
+	const response = await discoverMetadataWithFallback(serverUrl, "oauth-protected-resource", fetchFn, {
+		protocolVersion: opts?.protocolVersion,
+		metadataUrl: opts?.resourceMetadataUrl
+	});
+	if (!response || response.status === 404) {
+		await response?.body?.cancel();
+		throw new Error(`Resource server does not implement OAuth 2.0 Protected Resource Metadata.`);
+	}
+	if (!response.ok) {
+		await response.body?.cancel();
+		throw new Error(`HTTP ${response.status} trying to load well-known OAuth protected resource metadata.`);
+	}
+	return OAuthProtectedResourceMetadataSchema.parse(await response.json());
+}
+/**
+* Helper function to handle fetch with CORS retry logic
+*/
+async function fetchWithCorsRetry(url, headers, fetchFn = fetch) {
+	try {
+		return await fetchFn(url, { headers });
+	} catch (error) {
+		if (error instanceof TypeError) if (headers) return fetchWithCorsRetry(url, void 0, fetchFn);
+		else return;
+		throw error;
+	}
+}
+/**
+* Constructs the well-known path for auth-related metadata discovery
+*/
+function buildWellKnownPath(wellKnownPrefix, pathname = "", options = {}) {
+	if (pathname.endsWith("/")) pathname = pathname.slice(0, -1);
+	return options.prependPathname ? `${pathname}/.well-known/${wellKnownPrefix}` : `/.well-known/${wellKnownPrefix}${pathname}`;
+}
+/**
+* Tries to discover OAuth metadata at a specific URL
+*/
+async function tryMetadataDiscovery(url, protocolVersion, fetchFn = fetch) {
+	return await fetchWithCorsRetry(url, { "MCP-Protocol-Version": protocolVersion }, fetchFn);
+}
+/**
+* Determines if fallback to root discovery should be attempted
+*/
+function shouldAttemptFallback(response, pathname) {
+	return !response || response.status >= 400 && response.status < 500 && pathname !== "/";
+}
+/**
+* Generic function for discovering OAuth metadata with fallback support
+*/
+async function discoverMetadataWithFallback(serverUrl, wellKnownType, fetchFn, opts) {
+	const issuer = new URL(serverUrl);
+	const protocolVersion = opts?.protocolVersion ?? "2025-11-25";
+	let url;
+	if (opts?.metadataUrl) url = new URL(opts.metadataUrl);
+	else {
+		const wellKnownPath = buildWellKnownPath(wellKnownType, issuer.pathname);
+		url = new URL(wellKnownPath, opts?.metadataServerUrl ?? issuer);
+		url.search = issuer.search;
+	}
+	let response = await tryMetadataDiscovery(url, protocolVersion, fetchFn);
+	if (!opts?.metadataUrl && shouldAttemptFallback(response, issuer.pathname)) response = await tryMetadataDiscovery(new URL(`/.well-known/${wellKnownType}`, issuer), protocolVersion, fetchFn);
+	return response;
+}
+/**
+* Builds a list of discovery URLs to try for authorization server metadata.
+* URLs are returned in priority order:
+* 1. OAuth metadata at the given URL
+* 2. OIDC metadata endpoints at the given URL
+*/
+function buildDiscoveryUrls(authorizationServerUrl) {
+	const url = typeof authorizationServerUrl === "string" ? new URL(authorizationServerUrl) : authorizationServerUrl;
+	const hasPath = url.pathname !== "/";
+	const urlsToTry = [];
+	if (!hasPath) {
+		urlsToTry.push({
+			url: new URL("/.well-known/oauth-authorization-server", url.origin),
+			type: "oauth"
+		});
+		urlsToTry.push({
+			url: new URL(`/.well-known/openid-configuration`, url.origin),
+			type: "oidc"
+		});
+		return urlsToTry;
+	}
+	let pathname = url.pathname;
+	if (pathname.endsWith("/")) pathname = pathname.slice(0, -1);
+	urlsToTry.push({
+		url: new URL(`/.well-known/oauth-authorization-server${pathname}`, url.origin),
+		type: "oauth"
+	});
+	urlsToTry.push({
+		url: new URL(`/.well-known/openid-configuration${pathname}`, url.origin),
+		type: "oidc"
+	});
+	urlsToTry.push({
+		url: new URL(`${pathname}/.well-known/openid-configuration`, url.origin),
+		type: "oidc"
+	});
+	return urlsToTry;
+}
+/**
+* Discovers authorization server metadata with support for RFC 8414 OAuth 2.0 Authorization Server Metadata
+* and OpenID Connect Discovery 1.0 specifications.
+*
+* This function implements a fallback strategy for authorization server discovery:
+* 1. Attempts RFC 8414 OAuth metadata discovery first
+* 2. If OAuth discovery fails, falls back to OpenID Connect Discovery
+*
+* @param authorizationServerUrl - The authorization server URL obtained from the MCP Server's
+*                                 protected resource metadata, or the MCP server's URL if the
+*                                 metadata was not found.
+* @param options - Configuration options
+* @param options.fetchFn - Optional fetch function for making HTTP requests, defaults to global fetch
+* @param options.protocolVersion - MCP protocol version to use, defaults to LATEST_PROTOCOL_VERSION
+* @returns Promise resolving to authorization server metadata, or undefined if discovery fails
+*/
+async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn = fetch, protocolVersion = LATEST_PROTOCOL_VERSION } = {}) {
+	const headers = {
+		"MCP-Protocol-Version": protocolVersion,
+		Accept: "application/json"
+	};
+	const urlsToTry = buildDiscoveryUrls(authorizationServerUrl);
+	for (const { url: endpointUrl, type } of urlsToTry) {
+		const response = await fetchWithCorsRetry(endpointUrl, headers, fetchFn);
+		if (!response)
+ /**
+		* CORS error occurred - don't throw as the endpoint may not allow CORS,
+		* continue trying other possible endpoints
+		*/
+		continue;
+		if (!response.ok) {
+			await response.body?.cancel();
+			if (response.status >= 400 && response.status < 500) continue;
+			throw new Error(`HTTP ${response.status} trying to load ${type === "oauth" ? "OAuth" : "OpenID provider"} metadata from ${endpointUrl}`);
+		}
+		if (type === "oauth") return OAuthMetadataSchema.parse(await response.json());
+		else return OpenIdProviderDiscoveryMetadataSchema.parse(await response.json());
+	}
+}
+/**
+* Discovers the authorization server for an MCP server following
+* {@link https://datatracker.ietf.org/doc/html/rfc9728 | RFC 9728} (OAuth 2.0 Protected
+* Resource Metadata), with fallback to treating the server URL as the
+* authorization server.
+*
+* This function combines two discovery steps into one call:
+* 1. Probes `/.well-known/oauth-protected-resource` on the MCP server to find the
+*    authorization server URL (RFC 9728).
+* 2. Fetches authorization server metadata from that URL (RFC 8414 / OpenID Connect Discovery).
+*
+* Use this when you need the authorization server metadata for operations outside the
+* {@linkcode auth} orchestrator, such as token refresh or token revocation.
+*
+* @param serverUrl - The MCP resource server URL
+* @param opts - Optional configuration
+* @param opts.resourceMetadataUrl - Override URL for the protected resource metadata endpoint
+* @param opts.fetchFn - Custom fetch function for HTTP requests
+* @returns Authorization server URL, metadata, and resource metadata (if available)
+*/
+async function discoverOAuthServerInfo(serverUrl, opts) {
+	let resourceMetadata;
+	let authorizationServerUrl;
+	try {
+		resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: opts?.resourceMetadataUrl }, opts?.fetchFn);
+		if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) authorizationServerUrl = resourceMetadata.authorization_servers[0];
+	} catch {}
+	if (!authorizationServerUrl) authorizationServerUrl = String(new URL("/", serverUrl));
+	const authorizationServerMetadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn: opts?.fetchFn });
+	return {
+		authorizationServerUrl,
+		authorizationServerMetadata,
+		resourceMetadata
+	};
+}
+/**
+* Begins the authorization flow with the given server, by generating a PKCE challenge and constructing the authorization URL.
+*/
+async function startAuthorization(authorizationServerUrl, { metadata, clientInformation, redirectUrl, scope, state, resource }) {
+	let authorizationUrl;
+	if (metadata) {
+		authorizationUrl = new URL(metadata.authorization_endpoint);
+		if (!metadata.response_types_supported.includes(AUTHORIZATION_CODE_RESPONSE_TYPE)) throw new Error(`Incompatible auth server: does not support response type ${AUTHORIZATION_CODE_RESPONSE_TYPE}`);
+		if (metadata.code_challenge_methods_supported && !metadata.code_challenge_methods_supported.includes(AUTHORIZATION_CODE_CHALLENGE_METHOD)) throw new Error(`Incompatible auth server: does not support code challenge method ${AUTHORIZATION_CODE_CHALLENGE_METHOD}`);
+	} else authorizationUrl = new URL("/authorize", authorizationServerUrl);
+	const challenge = await pkceChallenge();
+	const codeVerifier = challenge.code_verifier;
+	const codeChallenge = challenge.code_challenge;
+	authorizationUrl.searchParams.set("response_type", AUTHORIZATION_CODE_RESPONSE_TYPE);
+	authorizationUrl.searchParams.set("client_id", clientInformation.client_id);
+	authorizationUrl.searchParams.set("code_challenge", codeChallenge);
+	authorizationUrl.searchParams.set("code_challenge_method", AUTHORIZATION_CODE_CHALLENGE_METHOD);
+	authorizationUrl.searchParams.set("redirect_uri", String(redirectUrl));
+	if (state) authorizationUrl.searchParams.set("state", state);
+	if (scope) authorizationUrl.searchParams.set("scope", scope);
+	if (scope?.includes("offline_access")) authorizationUrl.searchParams.append("prompt", "consent");
+	if (resource) authorizationUrl.searchParams.set("resource", resource.href);
+	return {
+		authorizationUrl,
+		codeVerifier
+	};
+}
+/**
+* Prepares token request parameters for an authorization code exchange.
+*
+* This is the default implementation used by fetchToken when the provider
+* doesn't implement prepareTokenRequest.
+*
+* @param authorizationCode - The authorization code received from the authorization endpoint
+* @param codeVerifier - The PKCE code verifier
+* @param redirectUri - The redirect URI used in the authorization request
+* @returns URLSearchParams for the authorization_code grant
+*/
+function prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, redirectUri) {
+	return new URLSearchParams({
+		grant_type: "authorization_code",
+		code: authorizationCode,
+		code_verifier: codeVerifier,
+		redirect_uri: String(redirectUri)
+	});
+}
+/**
+* Internal helper to execute a token request with the given parameters.
+* Used by exchangeAuthorization, refreshAuthorization, and fetchToken.
+*/
+async function executeTokenRequest(authorizationServerUrl, { metadata, tokenRequestParams, clientInformation, addClientAuthentication, resource, fetchFn }) {
+	const tokenUrl = metadata?.token_endpoint ? new URL(metadata.token_endpoint) : new URL("/token", authorizationServerUrl);
+	const headers = new Headers({
+		"Content-Type": "application/x-www-form-urlencoded",
+		Accept: "application/json"
+	});
+	if (resource) tokenRequestParams.set("resource", resource.href);
+	if (addClientAuthentication) await addClientAuthentication(headers, tokenRequestParams, tokenUrl, metadata);
+	else if (clientInformation) applyClientAuthentication(selectClientAuthMethod(clientInformation, metadata?.token_endpoint_auth_methods_supported ?? []), clientInformation, headers, tokenRequestParams);
+	const response = await (fetchFn ?? fetch)(tokenUrl, {
+		method: "POST",
+		headers,
+		body: tokenRequestParams
+	});
+	if (!response.ok) throw await parseErrorResponse(response);
+	return OAuthTokensSchema.parse(await response.json());
+}
+/**
+* Exchange a refresh token for an updated access token.
+*
+* Supports multiple client authentication methods as specified in OAuth 2.1:
+* - Automatically selects the best authentication method based on server support
+* - Preserves the original refresh token if a new one is not returned
+*
+* @param authorizationServerUrl - The authorization server's base URL
+* @param options - Configuration object containing client info, refresh token, etc.
+* @returns Promise resolving to OAuth tokens (preserves original refresh_token if not replaced)
+* @throws {Error} When token refresh fails or authentication is invalid
+*/
+async function refreshAuthorization(authorizationServerUrl, { metadata, clientInformation, refreshToken, resource, addClientAuthentication, fetchFn }) {
+	return {
+		refresh_token: refreshToken,
+		...await executeTokenRequest(authorizationServerUrl, {
+			metadata,
+			tokenRequestParams: new URLSearchParams({
+				grant_type: "refresh_token",
+				refresh_token: refreshToken
+			}),
+			clientInformation,
+			addClientAuthentication,
+			resource,
+			fetchFn
+		})
+	};
+}
+/**
+* Unified token fetching that works with any grant type via provider.prepareTokenRequest().
+*
+* This function provides a single entry point for obtaining tokens regardless of the
+* OAuth grant type. The provider's prepareTokenRequest() method determines which grant
+* to use and supplies the grant-specific parameters.
+*
+* @param provider - OAuth client provider that implements prepareTokenRequest()
+* @param authorizationServerUrl - The authorization server's base URL
+* @param options - Configuration for the token request
+* @returns Promise resolving to OAuth tokens
+* @throws {Error} When provider doesn't implement prepareTokenRequest or token fetch fails
+*
+* @example
+* // Provider for client_credentials:
+* class MyProvider implements OAuthClientProvider {
+*   prepareTokenRequest(scope) {
+*     const params = new URLSearchParams({ grant_type: 'client_credentials' });
+*     if (scope) params.set('scope', scope);
+*     return params;
+*   }
+*   // ... other methods
+* }
+*
+* const tokens = await fetchToken(provider, authServerUrl, { metadata });
+*/
+async function fetchToken(provider, authorizationServerUrl, { metadata, resource, authorizationCode, fetchFn } = {}) {
+	const scope = provider.clientMetadata.scope;
+	let tokenRequestParams;
+	if (provider.prepareTokenRequest) tokenRequestParams = await provider.prepareTokenRequest(scope);
+	if (!tokenRequestParams) {
+		if (!authorizationCode) throw new Error("Either provider.prepareTokenRequest() or authorizationCode is required");
+		if (!provider.redirectUrl) throw new Error("redirectUrl is required for authorization_code flow");
+		tokenRequestParams = prepareAuthorizationCodeRequest(authorizationCode, await provider.codeVerifier(), provider.redirectUrl);
+	}
+	const clientInformation = await provider.clientInformation();
+	return executeTokenRequest(authorizationServerUrl, {
+		metadata,
+		tokenRequestParams,
+		clientInformation: clientInformation ?? void 0,
+		addClientAuthentication: provider.addClientAuthentication,
+		resource,
+		fetchFn
+	});
+}
+/**
+* Performs OAuth 2.0 Dynamic Client Registration according to RFC 7591.
+*
+* If `scope` is provided, it overrides `clientMetadata.scope` in the registration
+* request body. This allows callers to apply the Scope Selection Strategy (SEP-835)
+* consistently across both DCR and the subsequent authorization request.
+*/
+async function registerClient(authorizationServerUrl, { metadata, clientMetadata, scope, fetchFn }) {
+	let registrationUrl;
+	if (metadata) {
+		if (!metadata.registration_endpoint) throw new Error("Incompatible auth server: does not support dynamic client registration");
+		registrationUrl = new URL(metadata.registration_endpoint);
+	} else registrationUrl = new URL("/register", authorizationServerUrl);
+	const response = await (fetchFn ?? fetch)(registrationUrl, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			...clientMetadata,
+			...scope !== void 0 ? { scope } : {}
+		})
+	});
+	if (!response.ok) throw await parseErrorResponse(response);
+	return OAuthClientInformationFullSchema.parse(await response.json());
+}
+//#endregion
+//#region ../../node_modules/.pnpm/eventsource-parser@3.1.0/node_modules/eventsource-parser/dist/index.js
+var ParseError = class extends Error {
+	constructor(message, options) {
+		super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+	}
+};
+const LF = 10, CR = 13, SPACE = 32;
+function noop(_arg) {}
+function createParser(config) {
+	if (typeof config == "function") throw new TypeError("`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?");
+	const { onEvent = noop, onError = noop, onRetry = noop, onComment, maxBufferSize } = config, pendingFragments = [];
+	let pendingFragmentsLength = 0, isFirstChunk = !0, id, data = "", dataLines = 0, eventType, terminated = !1;
+	function feed(chunk) {
+		if (terminated) throw new Error("Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing.");
+		if (isFirstChunk && (isFirstChunk = !1, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
+			const trailing2 = processLines(chunk);
+			trailing2 !== "" && (pendingFragments.push(trailing2), pendingFragmentsLength = trailing2.length), checkBufferSize();
+			return;
+		}
+		if (chunk.indexOf(`
+`) === -1 && chunk.indexOf("\r") === -1) {
+			pendingFragments.push(chunk), pendingFragmentsLength += chunk.length, checkBufferSize();
+			return;
+		}
+		pendingFragments.push(chunk);
+		const input = pendingFragments.join("");
+		pendingFragments.length = 0, pendingFragmentsLength = 0;
+		const trailing = processLines(input);
+		trailing !== "" && (pendingFragments.push(trailing), pendingFragmentsLength = trailing.length), checkBufferSize();
+	}
+	function checkBufferSize() {
+		maxBufferSize !== void 0 && (pendingFragmentsLength + data.length <= maxBufferSize || (terminated = !0, pendingFragments.length = 0, pendingFragmentsLength = 0, id = void 0, data = "", dataLines = 0, eventType = void 0, onError(new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, { type: "max-buffer-size-exceeded" }))));
+	}
+	function processLines(chunk) {
+		let searchIndex = 0;
+		if (chunk.indexOf("\r") === -1) {
+			let lfIndex = chunk.indexOf(`
+`, searchIndex);
+			for (; lfIndex !== -1;) {
+				if (searchIndex === lfIndex) {
+					dataLines > 0 && onEvent({
+						id,
+						event: eventType,
+						data
+					}), id = void 0, data = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+					continue;
+				}
+				const firstCharCode = chunk.charCodeAt(searchIndex);
+				if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+					const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5, value = chunk.slice(valueStart, lfIndex);
+					if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+						onEvent({
+							id,
+							event: eventType,
+							data: value
+						}), id = void 0, data = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
+`, searchIndex);
+						continue;
+					}
+					data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+				} else isEventPrefix(chunk, searchIndex, firstCharCode) ? eventType = chunk.slice(chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6, lfIndex) || void 0 : parseLine(chunk, searchIndex, lfIndex);
+				searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+			}
+			return chunk.slice(searchIndex);
+		}
+		for (; searchIndex < chunk.length;) {
+			const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+			let lineEnd = -1;
+			if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = crIndex < lfIndex ? crIndex : lfIndex : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) break;
+			parseLine(chunk, searchIndex, lineEnd), searchIndex = lineEnd + 1, chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF && searchIndex++;
+		}
+		return chunk.slice(searchIndex);
+	}
+	function parseLine(chunk, start, end) {
+		if (start === end) {
+			dispatchEvent();
+			return;
+		}
+		const firstCharCode = chunk.charCodeAt(start);
+		if (isDataPrefix(chunk, start, firstCharCode)) {
+			const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5, value2 = chunk.slice(valueStart, end);
+			data = dataLines === 0 ? value2 : `${data}
+${value2}`, dataLines++;
+			return;
+		}
+		if (isEventPrefix(chunk, start, firstCharCode)) {
+			eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
+			return;
+		}
+		if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+			const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+			id = value2.includes("\0") ? void 0 : value2;
+			return;
+		}
+		if (firstCharCode === 58) {
+			if (onComment) {
+				const line2 = chunk.slice(start, end);
+				onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+			}
+			return;
+		}
+		const line = chunk.slice(start, end), fieldSeparatorIndex = line.indexOf(":");
+		if (fieldSeparatorIndex === -1) {
+			processField(line, "", line);
+			return;
+		}
+		const field = line.slice(0, fieldSeparatorIndex), offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1;
+		processField(field, line.slice(fieldSeparatorIndex + offset), line);
+	}
+	function processField(field, value, line) {
+		switch (field) {
+			case "event":
+				eventType = value || void 0;
+				break;
+			case "data":
+				data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+				break;
+			case "id":
+				id = value.includes("\0") ? void 0 : value;
+				break;
+			case "retry":
+				/^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(new ParseError(`Invalid \`retry\` value: "${value}"`, {
+					type: "invalid-retry",
+					value,
+					line
+				}));
+				break;
+			default:
+				onError(new ParseError(`Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`, {
+					type: "unknown-field",
+					field,
+					value,
+					line
+				}));
+				break;
+		}
+	}
+	function dispatchEvent() {
+		dataLines > 0 && onEvent({
+			id,
+			event: eventType,
+			data
+		}), id = void 0, data = "", dataLines = 0, eventType = void 0;
+	}
+	function reset(options = {}) {
+		if (options.consume && pendingFragments.length > 0) {
+			const incompleteLine = pendingFragments.join("");
+			parseLine(incompleteLine, 0, incompleteLine.length);
+		}
+		isFirstChunk = !0, id = void 0, data = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0, pendingFragmentsLength = 0, terminated = !1;
+	}
+	return {
+		feed,
+		reset
+	};
+}
+function isDataPrefix(chunk, i, firstCharCode) {
+	return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+function isEventPrefix(chunk, i, firstCharCode) {
+	return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/eventsource-parser@3.1.0/node_modules/eventsource-parser/dist/stream.js
+var EventSourceParserStream = class extends TransformStream {
+	constructor({ onError, onRetry, onComment, maxBufferSize } = {}) {
+		let parser;
+		super({
+			start(controller) {
+				parser = createParser({
+					onEvent: (event) => {
+						controller.enqueue(event);
+					},
+					onError(error) {
+						typeof onError == "function" && onError(error), (onError === "terminate" || error.type === "max-buffer-size-exceeded") && controller.error(error);
+					},
+					onRetry,
+					onComment,
+					maxBufferSize
+				});
+			},
+			transform(chunk) {
+				parser.feed(chunk);
+			}
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/client/streamableHttp.js
+const DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS = {
+	initialReconnectionDelay: 1e3,
+	maxReconnectionDelay: 3e4,
+	reconnectionDelayGrowFactor: 1.5,
+	maxRetries: 2
+};
+var StreamableHTTPError = class extends Error {
+	constructor(code, message) {
+		super(`Streamable HTTP error: ${message}`);
+		this.code = code;
+	}
+};
+/**
+* Client transport for Streamable HTTP: this implements the MCP Streamable HTTP transport specification.
+* It will connect to a server using HTTP POST for sending messages and HTTP GET with Server-Sent Events
+* for receiving messages.
+*/
+var StreamableHTTPClientTransport = class {
+	constructor(url, opts) {
+		this._hasCompletedAuthFlow = false;
+		this._url = url;
+		this._resourceMetadataUrl = void 0;
+		this._scope = void 0;
+		this._requestInit = opts?.requestInit;
+		this._authProvider = opts?.authProvider;
+		this._fetch = opts?.fetch;
+		this._fetchWithInit = createFetchWithInit(opts?.fetch, opts?.requestInit);
+		this._sessionId = opts?.sessionId;
+		this._reconnectionOptions = opts?.reconnectionOptions ?? DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS;
+	}
+	async _authThenStart() {
+		if (!this._authProvider) throw new UnauthorizedError("No auth provider");
+		let result;
+		try {
+			result = await auth(this._authProvider, {
+				serverUrl: this._url,
+				resourceMetadataUrl: this._resourceMetadataUrl,
+				scope: this._scope,
+				fetchFn: this._fetchWithInit
+			});
+		} catch (error) {
+			this.onerror?.(error);
+			throw error;
+		}
+		if (result !== "AUTHORIZED") throw new UnauthorizedError();
+		return await this._startOrAuthSse({ resumptionToken: void 0 });
+	}
+	async _commonHeaders() {
+		const headers = {};
+		if (this._authProvider) {
+			const tokens = await this._authProvider.tokens();
+			if (tokens) headers["Authorization"] = `Bearer ${tokens.access_token}`;
+		}
+		if (this._sessionId) headers["mcp-session-id"] = this._sessionId;
+		if (this._protocolVersion) headers["mcp-protocol-version"] = this._protocolVersion;
+		const extraHeaders = normalizeHeaders(this._requestInit?.headers);
+		return new Headers({
+			...headers,
+			...extraHeaders
+		});
+	}
+	async _startOrAuthSse(options) {
+		const { resumptionToken } = options;
+		try {
+			const headers = await this._commonHeaders();
+			headers.set("Accept", "text/event-stream");
+			if (resumptionToken) headers.set("last-event-id", resumptionToken);
+			const response = await (this._fetch ?? fetch)(this._url, {
+				method: "GET",
+				headers,
+				signal: this._abortController?.signal
+			});
+			if (!response.ok) {
+				await response.body?.cancel();
+				if (response.status === 401 && this._authProvider) return await this._authThenStart();
+				if (response.status === 405) return;
+				throw new StreamableHTTPError(response.status, `Failed to open SSE stream: ${response.statusText}`);
+			}
+			this._handleSseStream(response.body, options, true);
+		} catch (error) {
+			this.onerror?.(error);
+			throw error;
+		}
+	}
+	/**
+	* Calculates the next reconnection delay using  backoff algorithm
+	*
+	* @param attempt Current reconnection attempt count for the specific stream
+	* @returns Time to wait in milliseconds before next reconnection attempt
+	*/
+	_getNextReconnectionDelay(attempt) {
+		if (this._serverRetryMs !== void 0) return this._serverRetryMs;
+		const initialDelay = this._reconnectionOptions.initialReconnectionDelay;
+		const growFactor = this._reconnectionOptions.reconnectionDelayGrowFactor;
+		const maxDelay = this._reconnectionOptions.maxReconnectionDelay;
+		return Math.min(initialDelay * Math.pow(growFactor, attempt), maxDelay);
+	}
+	/**
+	* Schedule a reconnection attempt using server-provided retry interval or backoff
+	*
+	* @param lastEventId The ID of the last received event for resumability
+	* @param attemptCount Current reconnection attempt count for this specific stream
+	*/
+	_scheduleReconnection(options, attemptCount = 0) {
+		const maxRetries = this._reconnectionOptions.maxRetries;
+		if (attemptCount >= maxRetries) {
+			this.onerror?.(/* @__PURE__ */ new Error(`Maximum reconnection attempts (${maxRetries}) exceeded.`));
+			return;
+		}
+		const delay = this._getNextReconnectionDelay(attemptCount);
+		this._reconnectionTimeout = setTimeout(() => {
+			this._startOrAuthSse(options).catch((error) => {
+				this.onerror?.(/* @__PURE__ */ new Error(`Failed to reconnect SSE stream: ${error instanceof Error ? error.message : String(error)}`));
+				this._scheduleReconnection(options, attemptCount + 1);
+			});
+		}, delay);
+	}
+	_handleSseStream(stream, options, isReconnectable) {
+		if (!stream) return;
+		const { onresumptiontoken, replayMessageId } = options;
+		let lastEventId;
+		let hasPrimingEvent = false;
+		let receivedResponse = false;
+		const processStream = async () => {
+			try {
+				const reader = stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream({ onRetry: (retryMs) => {
+					this._serverRetryMs = retryMs;
+				} })).getReader();
+				while (true) {
+					const { value: event, done } = await reader.read();
+					if (done) break;
+					if (event.id) {
+						lastEventId = event.id;
+						hasPrimingEvent = true;
+						onresumptiontoken?.(event.id);
+					}
+					if (!event.data) continue;
+					if (!event.event || event.event === "message") try {
+						const message = JSONRPCMessageSchema.parse(JSON.parse(event.data));
+						if (isJSONRPCResultResponse(message)) {
+							receivedResponse = true;
+							if (replayMessageId !== void 0) message.id = replayMessageId;
+						}
+						this.onmessage?.(message);
+					} catch (error) {
+						this.onerror?.(error);
+					}
+				}
+				if ((isReconnectable || hasPrimingEvent) && !receivedResponse && this._abortController && !this._abortController.signal.aborted) this._scheduleReconnection({
+					resumptionToken: lastEventId,
+					onresumptiontoken,
+					replayMessageId
+				}, 0);
+			} catch (error) {
+				this.onerror?.(/* @__PURE__ */ new Error(`SSE stream disconnected: ${error}`));
+				if ((isReconnectable || hasPrimingEvent) && !receivedResponse && this._abortController && !this._abortController.signal.aborted) try {
+					this._scheduleReconnection({
+						resumptionToken: lastEventId,
+						onresumptiontoken,
+						replayMessageId
+					}, 0);
+				} catch (error) {
+					this.onerror?.(/* @__PURE__ */ new Error(`Failed to reconnect: ${error instanceof Error ? error.message : String(error)}`));
+				}
+			}
+		};
+		processStream();
+	}
+	async start() {
+		if (this._abortController) throw new Error("StreamableHTTPClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+		this._abortController = new AbortController();
+	}
+	/**
+	* Call this method after the user has finished authorizing via their user agent and is redirected back to the MCP client application. This will exchange the authorization code for an access token, enabling the next connection attempt to successfully auth.
+	*/
+	async finishAuth(authorizationCode) {
+		if (!this._authProvider) throw new UnauthorizedError("No auth provider");
+		if (await auth(this._authProvider, {
+			serverUrl: this._url,
+			authorizationCode,
+			resourceMetadataUrl: this._resourceMetadataUrl,
+			scope: this._scope,
+			fetchFn: this._fetchWithInit
+		}) !== "AUTHORIZED") throw new UnauthorizedError("Failed to authorize");
+	}
+	async close() {
+		if (this._reconnectionTimeout) {
+			clearTimeout(this._reconnectionTimeout);
+			this._reconnectionTimeout = void 0;
+		}
+		this._abortController?.abort();
+		this.onclose?.();
+	}
+	async send(message, options) {
+		try {
+			const { resumptionToken, onresumptiontoken } = options || {};
+			if (resumptionToken) {
+				this._startOrAuthSse({
+					resumptionToken,
+					replayMessageId: isJSONRPCRequest(message) ? message.id : void 0
+				}).catch((err) => this.onerror?.(err));
+				return;
+			}
+			const headers = await this._commonHeaders();
+			headers.set("content-type", "application/json");
+			headers.set("accept", "application/json, text/event-stream");
+			const init = {
+				...this._requestInit,
+				method: "POST",
+				headers,
+				body: JSON.stringify(message),
+				signal: this._abortController?.signal
+			};
+			const response = await (this._fetch ?? fetch)(this._url, init);
+			const sessionId = response.headers.get("mcp-session-id");
+			if (sessionId) this._sessionId = sessionId;
+			if (!response.ok) {
+				const text = await response.text().catch(() => null);
+				if (response.status === 401 && this._authProvider) {
+					if (this._hasCompletedAuthFlow) throw new StreamableHTTPError(401, "Server returned 401 after successful authentication");
+					const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
+					this._resourceMetadataUrl = resourceMetadataUrl;
+					this._scope = scope;
+					if (await auth(this._authProvider, {
+						serverUrl: this._url,
+						resourceMetadataUrl: this._resourceMetadataUrl,
+						scope: this._scope,
+						fetchFn: this._fetchWithInit
+					}) !== "AUTHORIZED") throw new UnauthorizedError();
+					this._hasCompletedAuthFlow = true;
+					return this.send(message);
+				}
+				if (response.status === 403 && this._authProvider) {
+					const { resourceMetadataUrl, scope, error } = extractWWWAuthenticateParams(response);
+					if (error === "insufficient_scope") {
+						const wwwAuthHeader = response.headers.get("WWW-Authenticate");
+						if (this._lastUpscopingHeader === wwwAuthHeader) throw new StreamableHTTPError(403, "Server returned 403 after trying upscoping");
+						if (scope) this._scope = scope;
+						if (resourceMetadataUrl) this._resourceMetadataUrl = resourceMetadataUrl;
+						this._lastUpscopingHeader = wwwAuthHeader ?? void 0;
+						if (await auth(this._authProvider, {
+							serverUrl: this._url,
+							resourceMetadataUrl: this._resourceMetadataUrl,
+							scope: this._scope,
+							fetchFn: this._fetch
+						}) !== "AUTHORIZED") throw new UnauthorizedError();
+						return this.send(message);
+					}
+				}
+				throw new StreamableHTTPError(response.status, `Error POSTing to endpoint: ${text}`);
+			}
+			this._hasCompletedAuthFlow = false;
+			this._lastUpscopingHeader = void 0;
+			if (response.status === 202) {
+				await response.body?.cancel();
+				if (isInitializedNotification(message)) this._startOrAuthSse({ resumptionToken: void 0 }).catch((err) => this.onerror?.(err));
+				return;
+			}
+			const hasRequests = (Array.isArray(message) ? message : [message]).filter((msg) => "method" in msg && "id" in msg && msg.id !== void 0).length > 0;
+			const contentType = response.headers.get("content-type");
+			if (hasRequests) if (contentType?.includes("text/event-stream")) this._handleSseStream(response.body, { onresumptiontoken }, false);
+			else if (contentType?.includes("application/json")) {
+				const data = await response.json();
+				const responseMessages = Array.isArray(data) ? data.map((msg) => JSONRPCMessageSchema.parse(msg)) : [JSONRPCMessageSchema.parse(data)];
+				for (const msg of responseMessages) this.onmessage?.(msg);
+			} else {
+				await response.body?.cancel();
+				throw new StreamableHTTPError(-1, `Unexpected content type: ${contentType}`);
+			}
+			else await response.body?.cancel();
+		} catch (error) {
+			this.onerror?.(error);
+			throw error;
+		}
+	}
+	get sessionId() {
+		return this._sessionId;
+	}
+	/**
+	* Terminates the current session by sending a DELETE request to the server.
+	*
+	* Clients that no longer need a particular session
+	* (e.g., because the user is leaving the client application) SHOULD send an
+	* HTTP DELETE to the MCP endpoint with the Mcp-Session-Id header to explicitly
+	* terminate the session.
+	*
+	* The server MAY respond with HTTP 405 Method Not Allowed, indicating that
+	* the server does not allow clients to terminate sessions.
+	*/
+	async terminateSession() {
+		if (!this._sessionId) return;
+		try {
+			const headers = await this._commonHeaders();
+			const init = {
+				...this._requestInit,
+				method: "DELETE",
+				headers,
+				signal: this._abortController?.signal
+			};
+			const response = await (this._fetch ?? fetch)(this._url, init);
+			await response.body?.cancel();
+			if (!response.ok && response.status !== 405) throw new StreamableHTTPError(response.status, `Failed to terminate session: ${response.statusText}`);
+			this._sessionId = void 0;
+		} catch (error) {
+			this.onerror?.(error);
+			throw error;
+		}
+	}
+	setProtocolVersion(version) {
+		this._protocolVersion = version;
+	}
+	get protocolVersion() {
+		return this._protocolVersion;
+	}
+	/**
+	* Resume an SSE stream from a previous event ID.
+	* Opens a GET SSE connection with Last-Event-ID header to replay missed events.
+	*
+	* @param lastEventId The event ID to resume from
+	* @param options Optional callback to receive new resumption tokens
+	*/
+	async resumeStream(lastEventId, options) {
+		await this._startOrAuthSse({
+			resumptionToken: lastEventId,
+			onresumptiontoken: options?.onresumptiontoken
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/eventsource@3.0.7/node_modules/eventsource/dist/index.js
+var ErrorEvent = class extends Event {
+	/**
+	* Constructs a new `ErrorEvent` instance. This is typically not called directly,
+	* but rather emitted by the `EventSource` object when an error occurs.
+	*
+	* @param type - The type of the event (should be "error")
+	* @param errorEventInitDict - Optional properties to include in the error event
+	*/
+	constructor(type, errorEventInitDict) {
+		var _a, _b;
+		super(type), this.code = (_a = errorEventInitDict == null ? void 0 : errorEventInitDict.code) != null ? _a : void 0, this.message = (_b = errorEventInitDict == null ? void 0 : errorEventInitDict.message) != null ? _b : void 0;
+	}
+	/**
+	* Node.js "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+	* when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+	* we explicitly include the properties in the `inspect` method.
+	*
+	* This is automatically called by Node.js when you `console.log` an instance of this class.
+	*
+	* @param _depth - The current depth
+	* @param options - The options passed to `util.inspect`
+	* @param inspect - The inspect function to use (prevents having to import it from `util`)
+	* @returns A string representation of the error
+	*/
+	[Symbol.for("nodejs.util.inspect.custom")](_depth, options, inspect) {
+		return inspect(inspectableError(this), options);
+	}
+	/**
+	* Deno "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+	* when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+	* we explicitly include the properties in the `inspect` method.
+	*
+	* This is automatically called by Deno when you `console.log` an instance of this class.
+	*
+	* @param inspect - The inspect function to use (prevents having to import it from `util`)
+	* @param options - The options passed to `Deno.inspect`
+	* @returns A string representation of the error
+	*/
+	[Symbol.for("Deno.customInspect")](inspect, options) {
+		return inspect(inspectableError(this), options);
+	}
+};
+function syntaxError(message) {
+	const DomException = globalThis.DOMException;
+	return typeof DomException == "function" ? new DomException(message, "SyntaxError") : new SyntaxError(message);
+}
+function flattenError(err) {
+	return err instanceof Error ? "errors" in err && Array.isArray(err.errors) ? err.errors.map(flattenError).join(", ") : "cause" in err && err.cause instanceof Error ? `${err}: ${flattenError(err.cause)}` : err.message : `${err}`;
+}
+function inspectableError(err) {
+	return {
+		type: err.type,
+		message: err.message,
+		code: err.code,
+		defaultPrevented: err.defaultPrevented,
+		cancelable: err.cancelable,
+		timeStamp: err.timeStamp
+	};
+}
+var __typeError = (msg) => {
+	throw TypeError(msg);
+}, __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg), __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj)), __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value), __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value), __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method), _readyState, _url, _redirectUrl, _withCredentials, _fetch, _reconnectInterval, _reconnectTimer, _lastEventId, _controller, _parser, _onError, _onMessage, _onOpen, _EventSource_instances, connect_fn, _onFetchResponse, _onFetchError, getRequestOptions_fn, _onEvent, _onRetryChange, failConnection_fn, scheduleReconnect_fn, _reconnect;
+var EventSource = class extends EventTarget {
+	constructor(url, eventSourceInitDict) {
+		var _a, _b;
+		super(), __privateAdd(this, _EventSource_instances), this.CONNECTING = 0, this.OPEN = 1, this.CLOSED = 2, __privateAdd(this, _readyState), __privateAdd(this, _url), __privateAdd(this, _redirectUrl), __privateAdd(this, _withCredentials), __privateAdd(this, _fetch), __privateAdd(this, _reconnectInterval), __privateAdd(this, _reconnectTimer), __privateAdd(this, _lastEventId, null), __privateAdd(this, _controller), __privateAdd(this, _parser), __privateAdd(this, _onError, null), __privateAdd(this, _onMessage, null), __privateAdd(this, _onOpen, null), __privateAdd(this, _onFetchResponse, async (response) => {
+			var _a2;
+			__privateGet(this, _parser).reset();
+			const { body, redirected, status, headers } = response;
+			if (status === 204) {
+				__privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Server sent HTTP 204, not reconnecting", 204), this.close();
+				return;
+			}
+			if (redirected ? __privateSet(this, _redirectUrl, new URL(response.url)) : __privateSet(this, _redirectUrl, void 0), status !== 200) {
+				__privateMethod(this, _EventSource_instances, failConnection_fn).call(this, `Non-200 status code (${status})`, status);
+				return;
+			}
+			if (!(headers.get("content-type") || "").startsWith("text/event-stream")) {
+				__privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Invalid content type, expected \"text/event-stream\"", status);
+				return;
+			}
+			if (__privateGet(this, _readyState) === this.CLOSED) return;
+			__privateSet(this, _readyState, this.OPEN);
+			const openEvent = new Event("open");
+			if ((_a2 = __privateGet(this, _onOpen)) == null || _a2.call(this, openEvent), this.dispatchEvent(openEvent), typeof body != "object" || !body || !("getReader" in body)) {
+				__privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Invalid response body, expected a web ReadableStream", status), this.close();
+				return;
+			}
+			const decoder = new TextDecoder(), reader = body.getReader();
+			let open = !0;
+			do {
+				const { done, value } = await reader.read();
+				value && __privateGet(this, _parser).feed(decoder.decode(value, { stream: !done })), done && (open = !1, __privateGet(this, _parser).reset(), __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this));
+			} while (open);
+		}), __privateAdd(this, _onFetchError, (err) => {
+			__privateSet(this, _controller, void 0), !(err.name === "AbortError" || err.type === "aborted") && __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this, flattenError(err));
+		}), __privateAdd(this, _onEvent, (event) => {
+			typeof event.id == "string" && __privateSet(this, _lastEventId, event.id);
+			const messageEvent = new MessageEvent(event.event || "message", {
+				data: event.data,
+				origin: __privateGet(this, _redirectUrl) ? __privateGet(this, _redirectUrl).origin : __privateGet(this, _url).origin,
+				lastEventId: event.id || ""
+			});
+			__privateGet(this, _onMessage) && (!event.event || event.event === "message") && __privateGet(this, _onMessage).call(this, messageEvent), this.dispatchEvent(messageEvent);
+		}), __privateAdd(this, _onRetryChange, (value) => {
+			__privateSet(this, _reconnectInterval, value);
+		}), __privateAdd(this, _reconnect, () => {
+			__privateSet(this, _reconnectTimer, void 0), __privateGet(this, _readyState) === this.CONNECTING && __privateMethod(this, _EventSource_instances, connect_fn).call(this);
+		});
+		try {
+			if (url instanceof URL) __privateSet(this, _url, url);
+			else if (typeof url == "string") __privateSet(this, _url, new URL(url, getBaseURL()));
+			else throw new Error("Invalid URL");
+		} catch {
+			throw syntaxError("An invalid or illegal string was specified");
+		}
+		__privateSet(this, _parser, createParser({
+			onEvent: __privateGet(this, _onEvent),
+			onRetry: __privateGet(this, _onRetryChange)
+		})), __privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _reconnectInterval, 3e3), __privateSet(this, _fetch, (_a = eventSourceInitDict == null ? void 0 : eventSourceInitDict.fetch) != null ? _a : globalThis.fetch), __privateSet(this, _withCredentials, (_b = eventSourceInitDict == null ? void 0 : eventSourceInitDict.withCredentials) != null ? _b : !1), __privateMethod(this, _EventSource_instances, connect_fn).call(this);
+	}
+	/**
+	* Returns the state of this EventSource object's connection. It can have the values described below.
+	*
+	* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/readyState)
+	*
+	* Note: typed as `number` instead of `0 | 1 | 2` for compatibility with the `EventSource` interface,
+	* defined in the TypeScript `dom` library.
+	*
+	* @public
+	*/
+	get readyState() {
+		return __privateGet(this, _readyState);
+	}
+	/**
+	* Returns the URL providing the event stream.
+	*
+	* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/url)
+	*
+	* @public
+	*/
+	get url() {
+		return __privateGet(this, _url).href;
+	}
+	/**
+	* Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
+	*
+	* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/withCredentials)
+	*/
+	get withCredentials() {
+		return __privateGet(this, _withCredentials);
+	}
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/error_event) */
+	get onerror() {
+		return __privateGet(this, _onError);
+	}
+	set onerror(value) {
+		__privateSet(this, _onError, value);
+	}
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/message_event) */
+	get onmessage() {
+		return __privateGet(this, _onMessage);
+	}
+	set onmessage(value) {
+		__privateSet(this, _onMessage, value);
+	}
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/open_event) */
+	get onopen() {
+		return __privateGet(this, _onOpen);
+	}
+	set onopen(value) {
+		__privateSet(this, _onOpen, value);
+	}
+	addEventListener(type, listener, options) {
+		const listen = listener;
+		super.addEventListener(type, listen, options);
+	}
+	removeEventListener(type, listener, options) {
+		const listen = listener;
+		super.removeEventListener(type, listen, options);
+	}
+	/**
+	* Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
+	*
+	* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/close)
+	*
+	* @public
+	*/
+	close() {
+		__privateGet(this, _reconnectTimer) && clearTimeout(__privateGet(this, _reconnectTimer)), __privateGet(this, _readyState) !== this.CLOSED && (__privateGet(this, _controller) && __privateGet(this, _controller).abort(), __privateSet(this, _readyState, this.CLOSED), __privateSet(this, _controller, void 0));
+	}
+};
+_readyState = /* @__PURE__ */ new WeakMap(), _url = /* @__PURE__ */ new WeakMap(), _redirectUrl = /* @__PURE__ */ new WeakMap(), _withCredentials = /* @__PURE__ */ new WeakMap(), _fetch = /* @__PURE__ */ new WeakMap(), _reconnectInterval = /* @__PURE__ */ new WeakMap(), _reconnectTimer = /* @__PURE__ */ new WeakMap(), _lastEventId = /* @__PURE__ */ new WeakMap(), _controller = /* @__PURE__ */ new WeakMap(), _parser = /* @__PURE__ */ new WeakMap(), _onError = /* @__PURE__ */ new WeakMap(), _onMessage = /* @__PURE__ */ new WeakMap(), _onOpen = /* @__PURE__ */ new WeakMap(), _EventSource_instances = /* @__PURE__ */ new WeakSet(), connect_fn = function() {
+	__privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _controller, new AbortController()), __privateGet(this, _fetch)(__privateGet(this, _url), __privateMethod(this, _EventSource_instances, getRequestOptions_fn).call(this)).then(__privateGet(this, _onFetchResponse)).catch(__privateGet(this, _onFetchError));
+}, _onFetchResponse = /* @__PURE__ */ new WeakMap(), _onFetchError = /* @__PURE__ */ new WeakMap(), getRequestOptions_fn = function() {
+	var _a;
+	const init = {
+		mode: "cors",
+		redirect: "follow",
+		headers: {
+			Accept: "text/event-stream",
+			...__privateGet(this, _lastEventId) ? { "Last-Event-ID": __privateGet(this, _lastEventId) } : void 0
+		},
+		cache: "no-store",
+		signal: (_a = __privateGet(this, _controller)) == null ? void 0 : _a.signal
+	};
+	return "window" in globalThis && (init.credentials = this.withCredentials ? "include" : "same-origin"), init;
+}, _onEvent = /* @__PURE__ */ new WeakMap(), _onRetryChange = /* @__PURE__ */ new WeakMap(), failConnection_fn = function(message, code) {
+	var _a;
+	__privateGet(this, _readyState) !== this.CLOSED && __privateSet(this, _readyState, this.CLOSED);
+	const errorEvent = new ErrorEvent("error", {
+		code,
+		message
+	});
+	(_a = __privateGet(this, _onError)) == null || _a.call(this, errorEvent), this.dispatchEvent(errorEvent);
+}, scheduleReconnect_fn = function(message, code) {
+	var _a;
+	if (__privateGet(this, _readyState) === this.CLOSED) return;
+	__privateSet(this, _readyState, this.CONNECTING);
+	const errorEvent = new ErrorEvent("error", {
+		code,
+		message
+	});
+	(_a = __privateGet(this, _onError)) == null || _a.call(this, errorEvent), this.dispatchEvent(errorEvent), __privateSet(this, _reconnectTimer, setTimeout(__privateGet(this, _reconnect), __privateGet(this, _reconnectInterval)));
+}, _reconnect = /* @__PURE__ */ new WeakMap(), EventSource.CONNECTING = 0, EventSource.OPEN = 1, EventSource.CLOSED = 2;
+function getBaseURL() {
+	const doc = "document" in globalThis ? globalThis.document : void 0;
+	return doc && typeof doc == "object" && "baseURI" in doc && typeof doc.baseURI == "string" ? doc.baseURI : void 0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/client/sse.js
+var SseError = class extends Error {
+	constructor(code, message, event) {
+		super(`SSE error: ${message}`);
+		this.code = code;
+		this.event = event;
+	}
+};
+/**
+* Client transport for SSE: this will connect to a server using Server-Sent Events for receiving
+* messages and make separate POST requests for sending messages.
+* @deprecated SSEClientTransport is deprecated. Prefer to use StreamableHTTPClientTransport where possible instead. Note that because some servers are still using SSE, clients may need to support both transports during the migration period.
+*/
+var SSEClientTransport = class {
+	constructor(url, opts) {
+		this._url = url;
+		this._resourceMetadataUrl = void 0;
+		this._scope = void 0;
+		this._eventSourceInit = opts?.eventSourceInit;
+		this._requestInit = opts?.requestInit;
+		this._authProvider = opts?.authProvider;
+		this._fetch = opts?.fetch;
+		this._fetchWithInit = createFetchWithInit(opts?.fetch, opts?.requestInit);
+	}
+	async _authThenStart() {
+		if (!this._authProvider) throw new UnauthorizedError("No auth provider");
+		let result;
+		try {
+			result = await auth(this._authProvider, {
+				serverUrl: this._url,
+				resourceMetadataUrl: this._resourceMetadataUrl,
+				scope: this._scope,
+				fetchFn: this._fetchWithInit
+			});
+		} catch (error) {
+			this.onerror?.(error);
+			throw error;
+		}
+		if (result !== "AUTHORIZED") throw new UnauthorizedError();
+		return await this._startOrAuth();
+	}
+	async _commonHeaders() {
+		const headers = {};
+		if (this._authProvider) {
+			const tokens = await this._authProvider.tokens();
+			if (tokens) headers["Authorization"] = `Bearer ${tokens.access_token}`;
+		}
+		if (this._protocolVersion) headers["mcp-protocol-version"] = this._protocolVersion;
+		const extraHeaders = normalizeHeaders(this._requestInit?.headers);
+		return new Headers({
+			...headers,
+			...extraHeaders
+		});
+	}
+	_startOrAuth() {
+		const fetchImpl = this?._eventSourceInit?.fetch ?? this._fetch ?? fetch;
+		return new Promise((resolve, reject) => {
+			this._eventSource = new EventSource(this._url.href, {
+				...this._eventSourceInit,
+				fetch: async (url, init) => {
+					const headers = await this._commonHeaders();
+					headers.set("Accept", "text/event-stream");
+					const response = await fetchImpl(url, {
+						...init,
+						headers
+					});
+					if (response.status === 401 && response.headers.has("www-authenticate")) {
+						const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
+						this._resourceMetadataUrl = resourceMetadataUrl;
+						this._scope = scope;
+					}
+					return response;
+				}
+			});
+			this._abortController = new AbortController();
+			this._eventSource.onerror = (event) => {
+				if (event.code === 401 && this._authProvider) {
+					this._authThenStart().then(resolve, reject);
+					return;
+				}
+				const error = new SseError(event.code, event.message, event);
+				reject(error);
+				this.onerror?.(error);
+			};
+			this._eventSource.onopen = () => {};
+			this._eventSource.addEventListener("endpoint", (event) => {
+				const messageEvent = event;
+				try {
+					this._endpoint = new URL(messageEvent.data, this._url);
+					if (this._endpoint.origin !== this._url.origin) throw new Error(`Endpoint origin does not match connection origin: ${this._endpoint.origin}`);
+				} catch (error) {
+					reject(error);
+					this.onerror?.(error);
+					this.close();
+					return;
+				}
+				resolve();
+			});
+			this._eventSource.onmessage = (event) => {
+				const messageEvent = event;
+				let message;
+				try {
+					message = JSONRPCMessageSchema.parse(JSON.parse(messageEvent.data));
+				} catch (error) {
+					this.onerror?.(error);
+					return;
+				}
+				this.onmessage?.(message);
+			};
+		});
+	}
+	async start() {
+		if (this._eventSource) throw new Error("SSEClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+		return await this._startOrAuth();
+	}
+	/**
+	* Call this method after the user has finished authorizing via their user agent and is redirected back to the MCP client application. This will exchange the authorization code for an access token, enabling the next connection attempt to successfully auth.
+	*/
+	async finishAuth(authorizationCode) {
+		if (!this._authProvider) throw new UnauthorizedError("No auth provider");
+		if (await auth(this._authProvider, {
+			serverUrl: this._url,
+			authorizationCode,
+			resourceMetadataUrl: this._resourceMetadataUrl,
+			scope: this._scope,
+			fetchFn: this._fetchWithInit
+		}) !== "AUTHORIZED") throw new UnauthorizedError("Failed to authorize");
+	}
+	async close() {
+		this._abortController?.abort();
+		this._eventSource?.close();
+		this.onclose?.();
+	}
+	async send(message) {
+		if (!this._endpoint) throw new Error("Not connected");
+		try {
+			const headers = await this._commonHeaders();
+			headers.set("content-type", "application/json");
+			const init = {
+				...this._requestInit,
+				method: "POST",
+				headers,
+				body: JSON.stringify(message),
+				signal: this._abortController?.signal
+			};
+			const response = await (this._fetch ?? fetch)(this._endpoint, init);
+			if (!response.ok) {
+				const text = await response.text().catch(() => null);
+				if (response.status === 401 && this._authProvider) {
+					const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
+					this._resourceMetadataUrl = resourceMetadataUrl;
+					this._scope = scope;
+					if (await auth(this._authProvider, {
+						serverUrl: this._url,
+						resourceMetadataUrl: this._resourceMetadataUrl,
+						scope: this._scope,
+						fetchFn: this._fetchWithInit
+					}) !== "AUTHORIZED") throw new UnauthorizedError();
+					return this.send(message);
+				}
+				throw new Error(`Error POSTing to endpoint (HTTP ${response.status}): ${text}`);
+			}
+			await response.body?.cancel();
+		} catch (error) {
+			this.onerror?.(error);
+			throw error;
+		}
+	}
+	setProtocolVersion(version) {
+		this._protocolVersion = version;
+	}
+};
+//#endregion
+//#region src/mcp/mcp-prober.ts
+const DEFAULT_TIMEOUT_MS$1 = 15e3;
+const DEFAULT_CONCURRENCY$1 = 3;
+function envRecord(pairs) {
+	return Object.fromEntries(pairs.map((e) => [e.name, e.value]));
+}
+function buildTransport(def) {
+	switch (def.transport) {
+		case "stdio": return new StdioClientTransport({
+			command: def.command,
+			args: def.args,
+			env: {
+				...getDefaultEnvironment(),
+				...envRecord(def.env)
+			},
+			stderr: "ignore"
+		});
+		case "http": return new StreamableHTTPClientTransport(new URL(def.url), { requestInit: { headers: envRecord(def.headers) } });
+		case "sse": return new SSEClientTransport(new URL(def.url), { requestInit: { headers: envRecord(def.headers) } });
+	}
+}
+async function connectReal(name, def) {
+	const client = new Client({
+		name: "agentconnect",
+		version: DAEMON_VERSION
+	});
+	await client.connect(buildTransport(def));
+	return {
+		listTools: async () => (await client.listTools()).tools.map((t) => t.name),
+		serverVersion: () => client.getServerVersion()?.version,
+		close: () => client.close()
+	};
+}
+/**
+* Probe one configured MCP server. Never throws: any failure (spawn error, bad
+* URL, handshake failure, timeout) is captured in `{ ok: false, error }`. On
+* success, `tools` reflects whatever `tools/list` returned — an empty list is
+* not a failure.
+*/
+async function probeMcpServer(name, def, opts = {}) {
+	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$1;
+	let timer;
+	let timedOut = false;
+	const timeout = new Promise((_, reject) => {
+		timer = setTimeout(() => {
+			timedOut = true;
+			reject(/* @__PURE__ */ new Error(`probe timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+	});
+	let conn;
+	const run = async () => {
+		conn = await (opts.connectFactory ?? connectReal)(name, def);
+		return {
+			tools: await conn.listTools(),
+			version: conn.serverVersion()
+		};
+	};
+	const pending = run();
+	try {
+		const { tools, version } = await Promise.race([pending, timeout]);
+		opts.log?.info(`mcp-probe: ${name} ok (tools: ${tools.length ? tools.join(", ") : "none"})`);
+		return {
+			name,
+			transport: def.transport,
+			ok: true,
+			tools,
+			...version !== void 0 ? { version } : {}
+		};
+	} catch (err) {
+		const error = err.message;
+		opts.log?.warn(`mcp-probe: ${name} failed — ${error}`);
+		return {
+			name,
+			transport: def.transport,
+			ok: false,
+			tools: [],
+			error
+		};
+	} finally {
+		if (timer) clearTimeout(timer);
+		const closeConn = () => conn?.close().catch(() => {});
+		if (timedOut) pending.then(closeConn, closeConn);
+		else await closeConn();
+	}
+}
+/**
+* Probe every configured MCP server with bounded concurrency. Result order is
+* not meaningful — callers key by `result.name`.
+*/
+async function probeAllMcpServers(defs, opts = {}) {
+	const names = Object.keys(defs);
+	if (names.length === 0) return [];
+	const limit = Math.max(1, opts.concurrency ?? DEFAULT_CONCURRENCY$1);
+	const results = [];
+	let next = 0;
+	const worker = async () => {
+		for (let i = next++; i < names.length; i = next++) {
+			const name = names[i];
+			results.push(await probeMcpServer(name, defs[name], opts));
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, names.length) }, () => worker()));
+	return results;
+}
+//#endregion
+//#region src/mcp/resolve-servers.ts
+/**
+* Resolve an agent's enabled MCP-server names against the daemon's configured
+* definitions, producing the ACP `McpServer` entries to attach at
+* session/new|load (after the daemon's own bridge entry).
+*
+* Skips (with a warn) rather than fails: an unknown name, the reserved bridge
+* name, and an http/sse server the agent's runtime is KNOWN not to accept
+* (`caps` from the runtime probe). When `caps` is undefined (runtime not probed
+* yet) http/sse entries are included optimistically — the runtime rejecting an
+* unsupported transport at session/new is a clearer failure than silently
+* withholding a server the user enabled.
+*/
+function resolveAgentMcpServers(opts) {
+	const out = [];
+	for (const name of opts.enabled) {
+		if (name === "agentconnect") {
+			opts.warn?.(`mcp: server name "${name}" is reserved for the daemon bridge — skipped`);
+			continue;
+		}
+		const def = opts.defs[name];
+		if (!def) {
+			opts.warn?.(`mcp: server "${name}" is not configured on this daemon — skipped`);
+			continue;
+		}
+		if (def.transport === "stdio") {
+			out.push({
+				name,
+				command: def.command,
+				args: def.args,
+				env: def.env
+			});
+			continue;
+		}
+		if (opts.caps && !opts.caps[def.transport]) {
+			opts.warn?.(`mcp: server "${name}" needs the ${def.transport} transport, which the runtime doesn't accept — skipped`);
+			continue;
+		}
+		out.push({
+			type: def.transport,
+			name,
+			url: def.url,
+			headers: def.headers
+		});
+	}
+	return out;
+}
+//#endregion
 //#region src/mcp/tools.ts
 const obj = (properties, required = []) => ({
 	type: "object",
@@ -65068,13 +68451,15 @@ async function probeRuntime(id, rt, cwd, opts = {}) {
 		const opt = await Promise.race([run(), timeout]);
 		const models = (opt?.models ?? []).filter((m) => m !== "default");
 		const acpProtocolVersion = host.acpProtocolVersion();
+		const mcpCapabilities = host.mcpCapabilities?.() ?? void 0;
 		opts.log?.info(`probe: ${id} ok (models: ${models.length ? models.join(", ") : "none advertised"})`);
 		return {
 			runtime: id,
 			ok: true,
 			models,
 			currentModel: opt?.current,
-			acpProtocolVersion
+			acpProtocolVersion,
+			mcpCapabilities
 		};
 	} catch (err) {
 		const error = err.message;
@@ -65690,7 +69075,7 @@ var CpClient = class {
 		this.heartbeatMs = ok.heartbeatSec > 0 ? ok.heartbeatSec * 1e3 : this.deps.heartbeatDefaultMs;
 		this.armHeartbeat();
 		this.deps.log.info(`cp: READY (epoch=${this.sessionEpoch}, routingEpoch=${this.routingEpoch})`);
-		this.emitDaemonRuntimes(this.deps.runtimeProfiles());
+		this.emitDaemonRuntimes(this.deps.runtimeProfiles(), this.deps.mcpServerFacts?.() ?? []);
 		this.deps.onReady?.();
 	}
 	/**
@@ -65700,9 +69085,12 @@ var CpClient = class {
 	* runtime list to exactly this snapshot, pruning runtimes that are no longer
 	* installed. No-op unless READY/DRAINING.
 	*/
-	emitDaemonRuntimes(runtimes) {
+	emitDaemonRuntimes(runtimes, mcpServers = []) {
 		if (this.state !== "READY" && this.state !== "DRAINING") return;
-		this.transport?.send(encode(buildEnvelope("facts/daemon-runtimes", { runtimes })));
+		this.transport?.send(encode(buildEnvelope("facts/daemon-runtimes", {
+			runtimes,
+			mcpServers
+		})));
 	}
 	/**
 	* Report a session's cumulative token usage (D→C `usage/report` EVT,
@@ -66478,6 +69866,7 @@ function applySpecFields(raw, spec, opts) {
 	if (spec.executionMode !== void 0) raw.executionMode = spec.executionMode;
 	if (spec.fastMode !== void 0) raw.fastMode = spec.fastMode;
 	if (spec.permissionMode !== void 0) raw.permissionMode = spec.permissionMode;
+	if (spec.mcpServers !== void 0) raw.mcpServers = spec.mcpServers;
 	if (spec.outputMode !== void 0) {
 		const out = typeof raw.output === "object" && raw.output !== null ? raw.output : {};
 		out.mode = spec.outputMode;
@@ -82599,6 +85988,9 @@ var Daemon = class Daemon {
 	runtimeVersions = {};
 	runtimeModels = /* @__PURE__ */ new Map();
 	runtimeAcpVersions = /* @__PURE__ */ new Map();
+	runtimeMcpCaps = /* @__PURE__ */ new Map();
+	mcpServerDefs = {};
+	mcpServerFacts = [];
 	probing = false;
 	lastProbeAtMs = 0;
 	cpClient;
@@ -82674,6 +86066,10 @@ var Daemon = class Daemon {
 		this.log.info(`runtimes ready: ${Object.keys(this.runtimes).join(", ") || "(none)"}`);
 		const skipped = Object.keys(resolvedRuntimes).filter((id) => !this.runtimes[id]);
 		if (skipped.length) this.log.info(`runtimes not installed (skipped): ${skipped.join(", ")}`);
+		const { [RESERVED_MCP_SERVER_NAME]: reservedMcp, ...mcpServerDefs } = cfg.mcpServers ?? {};
+		if (reservedMcp) this.log.warn(`mcp: config server name "${RESERVED_MCP_SERVER_NAME}" is reserved for the daemon bridge — ignored`);
+		this.mcpServerDefs = mcpServerDefs;
+		if (Object.keys(mcpServerDefs).length) this.log.info(`mcp servers configured: ${Object.keys(mcpServerDefs).join(", ")}`);
 		this.store = new LocalStore(statePath(root));
 		this.nameResolver = new SlackNameResolver((id, name) => {
 			this.store.setDisplayName(id, name, Date.now());
@@ -82723,21 +86119,30 @@ var Daemon = class Daemon {
 			hostFor: (agentId) => this.ensureHostAsync(agentId),
 			agentById: (id) => this.agents.get(id),
 			mcpServersFor: ({ agent, channel, thread }) => {
+				const servers = [];
 				const tools = toolsForIntegrations(agent.integrations);
-				if (tools.length === 0) return [];
 				const integrationId = agent.integrations.find((i) => i.platform === "slack")?.id;
-				const token = this.mcp.register({
-					agentId: agent.id,
-					...integrationId ? { integrationId } : {},
-					channel,
-					thread,
-					tools
-				});
-				return buildMcpServers({
-					socketPath: mcpSocketPath(root),
-					token,
-					cliEntry
-				});
+				if (tools.length > 0) {
+					const token = this.mcp.register({
+						agentId: agent.id,
+						...integrationId ? { integrationId } : {},
+						channel,
+						thread,
+						tools
+					});
+					servers.push(...buildMcpServers({
+						socketPath: mcpSocketPath(root),
+						token,
+						cliEntry
+					}));
+				}
+				servers.push(...resolveAgentMcpServers({
+					enabled: agent.mcpServers,
+					defs: this.mcpServerDefs,
+					caps: this.runtimeMcpCaps.get(agent.runtime),
+					warn: (m) => this.log.warn(m)
+				}));
+				return servers;
 			},
 			downloadAttachment: (agentId, att) => this.replyConnFor(agentId)?.downloadFile?.(att.sourceUrl, this.cfg.limits.maxAttachmentBytes) ?? Promise.resolve(null),
 			attachmentMaxBytes: cfg.limits.maxAttachmentBytes,
@@ -84432,6 +87837,7 @@ var Daemon = class Daemon {
 				features: []
 			}),
 			runtimeProfiles: () => Object.keys(this.runtimes).map((id) => this.runtimeProfileFor(id)),
+			mcpServerFacts: () => this.mcpServerFacts,
 			onReady: () => {
 				this.probeRuntimesAndEmit();
 				for (const [integrationId, channels] of this.channelSnapshots) this.cpClient?.emitIntegrationChannels({
@@ -84491,7 +87897,8 @@ var Daemon = class Daemon {
 			models: this.runtimeModels.get(id) ?? [],
 			acpSupport: "full",
 			acpProtocolVersion: this.runtimeAcpVersions.get(id),
-			toolCalling: true
+			toolCalling: true,
+			mcpCapabilities: this.runtimeMcpCaps.get(id)
 		};
 	}
 	/** How long a completed probe sweep stays fresh — reconnects within this window
@@ -84499,8 +87906,10 @@ var Daemon = class Daemon {
 	static PROBE_TTL_MS = 5 * 6e4;
 	/**
 	* Probe every installed runtime in the background (launch → initialize →
-	* session/new → read models → tear down), then emit one `facts/daemon-runtimes`
-	* snapshot once the whole sweep completes so the CP replaces its runtime list.
+	* session/new → read models → tear down) and, concurrently, every configured
+	* MCP server (MCP handshake + tools/list), then emit one `facts/daemon-runtimes`
+	* snapshot once the whole sweep completes so the CP replaces its runtime +
+	* MCP-server lists.
 	*
 	* Triggered on each CP (re)connect. Deduped while in flight; skipped (with a
 	* cached re-emit) when the last sweep is still fresh, so a reconnect storm can't
@@ -84510,25 +87919,33 @@ var Daemon = class Daemon {
 	async probeRuntimesAndEmit() {
 		if (this.opts.hostFactory && !this.opts.probeRuntimes) return;
 		const ids = Object.keys(this.runtimes);
-		if (ids.length === 0) return;
+		const mcpNames = Object.keys(this.mcpServerDefs);
+		if (ids.length === 0 && mcpNames.length === 0) return;
 		if (this.probing) return;
 		if (this.lastProbeAtMs > 0 && Date.now() - this.lastProbeAtMs < Daemon.PROBE_TTL_MS) {
-			this.cpClient?.emitDaemonRuntimes(ids.map((id) => this.runtimeProfileFor(id)));
+			this.cpClient?.emitDaemonRuntimes(ids.map((id) => this.runtimeProfileFor(id)), this.mcpServerFacts);
 			return;
 		}
 		this.probing = true;
-		this.log.info(`probe: sweeping ${ids.length} runtime(s): ${ids.join(", ")}`);
+		this.log.info(`probe: sweeping ${ids.length} runtime(s): ${ids.join(", ") || "(none)"}`);
+		if (mcpNames.length) this.log.info(`probe: sweeping ${mcpNames.length} MCP server(s): ${mcpNames.join(", ")}`);
 		try {
-			const results = await (this.opts.probeRuntimes ?? probeAllRuntimes)(this.runtimes, { log: this.log });
+			const probe = this.opts.probeRuntimes ?? probeAllRuntimes;
+			const probeMcp = this.opts.probeMcpServers ?? probeAllMcpServers;
+			const [results, mcpFacts] = await Promise.all([probe(this.runtimes, { log: this.log }), probeMcp(this.mcpServerDefs, { log: this.log })]);
 			for (const r of results) {
 				this.runtimeModels.set(r.runtime, r.ok ? r.models : []);
 				if (r.ok && r.acpProtocolVersion !== void 0) this.runtimeAcpVersions.set(r.runtime, r.acpProtocolVersion);
 				else this.runtimeAcpVersions.delete(r.runtime);
+				if (r.ok && r.mcpCapabilities) this.runtimeMcpCaps.set(r.runtime, r.mcpCapabilities);
+				else this.runtimeMcpCaps.delete(r.runtime);
 			}
+			this.mcpServerFacts = mcpFacts;
 			this.lastProbeAtMs = Date.now();
 			const okCount = results.filter((r) => r.ok).length;
 			this.log.info(`probe: sweep complete — ${okCount}/${results.length} runtime(s) reachable`);
-			this.cpClient?.emitDaemonRuntimes(ids.map((id) => this.runtimeProfileFor(id)));
+			if (mcpFacts.length) this.log.info(`probe: ${mcpFacts.filter((s) => s.ok).length}/${mcpFacts.length} MCP server(s) reachable`);
+			this.cpClient?.emitDaemonRuntimes(ids.map((id) => this.runtimeProfileFor(id)), this.mcpServerFacts);
 		} catch (err) {
 			this.log.warn(`probe: sweep failed: ${formatErr(err)}`);
 		} finally {
@@ -84588,4 +88005,4 @@ async function runForeground(opts, deps = {}) {
 //#endregion
 export { ClientTransport as n, runForeground as t };
 
-//# sourceMappingURL=run-foreground-mvTzCScX.js.map
+//# sourceMappingURL=run-foreground-B05rDr1z.js.map