@amplitude/ai 0.1.0

package/dist/node_modules/.pnpm/@modelcontextprotocol_sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","names":[],"sources":["../../../../../../../../../../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js"],"sourcesContent":["/**\n * Experimental server task features for MCP SDK.\n * WARNING: These APIs are experimental and may change without notice.\n *\n * @experimental\n */\nimport { CreateMessageResultSchema, ElicitResultSchema } from '../../types.js';\n/**\n * Experimental task features for low-level MCP servers.\n *\n * Access via `server.experimental.tasks`:\n * ```typescript\n * const stream = server.experimental.tasks.requestStream(request, schema, options);\n * ```\n *\n * For high-level server usage with task-based tools, use `McpServer.experimental.tasks` instead.\n *\n * @experimental\n */\nexport class ExperimentalServerTasks {\n    constructor(_server) {\n        this._server = _server;\n    }\n    /**\n     * Sends a request and returns an AsyncGenerator that yields response messages.\n     * The generator is guaranteed to end with either a 'result' or 'error' message.\n     *\n     * This method provides streaming access to request processing, allowing you to\n     * observe intermediate task status updates for task-augmented requests.\n     *\n     * @param request - The request to send\n     * @param resultSchema - Zod schema for validating the result\n     * @param options - Optional request options (timeout, signal, task creation params, etc.)\n     * @returns AsyncGenerator that yields ResponseMessage objects\n     *\n     * @experimental\n     */\n    requestStream(request, resultSchema, options) {\n        return this._server.requestStream(request, resultSchema, options);\n    }\n    /**\n     * Sends a sampling request and returns an AsyncGenerator that yields response messages.\n     * The generator is guaranteed to end with either a 'result' or 'error' message.\n     *\n     * For task-augmented requests, yields 'taskCreated' and 'taskStatus' messages\n     * before the final result.\n     *\n     * @example\n     * ```typescript\n     * const stream = server.experimental.tasks.createMessageStream({\n     *     messages: [{ role: 'user', content: { type: 'text', text: 'Hello' } }],\n     *     maxTokens: 100\n     * }, {\n     *     onprogress: (progress) => {\n     *         // Handle streaming tokens via progress notifications\n     *         console.log('Progress:', progress.message);\n     *     }\n     * });\n     *\n     * for await (const message of stream) {\n     *     switch (message.type) {\n     *         case 'taskCreated':\n     *             console.log('Task created:', message.task.taskId);\n     *             break;\n     *         case 'taskStatus':\n     *             console.log('Task status:', message.task.status);\n     *             break;\n     *         case 'result':\n     *             console.log('Final result:', message.result);\n     *             break;\n     *         case 'error':\n     *             console.error('Error:', message.error);\n     *             break;\n     *     }\n     * }\n     * ```\n     *\n     * @param params - The sampling request parameters\n     * @param options - Optional request options (timeout, signal, task creation params, onprogress, etc.)\n     * @returns AsyncGenerator that yields ResponseMessage objects\n     *\n     * @experimental\n     */\n    createMessageStream(params, options) {\n        // Access client capabilities via the server\n        const clientCapabilities = this._server.getClientCapabilities();\n        // Capability check - only required when tools/toolChoice are provided\n        if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) {\n            throw new Error('Client does not support sampling tools capability.');\n        }\n        // Message structure validation - always validate tool_use/tool_result pairs.\n        // These may appear even without tools/toolChoice in the current request when\n        // a previous sampling request returned tool_use and this is a follow-up with results.\n        if (params.messages.length > 0) {\n            const lastMessage = params.messages[params.messages.length - 1];\n            const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];\n            const hasToolResults = lastContent.some(c => c.type === 'tool_result');\n            const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : undefined;\n            const previousContent = previousMessage\n                ? Array.isArray(previousMessage.content)\n                    ? previousMessage.content\n                    : [previousMessage.content]\n                : [];\n            const hasPreviousToolUse = previousContent.some(c => c.type === 'tool_use');\n            if (hasToolResults) {\n                if (lastContent.some(c => c.type !== 'tool_result')) {\n                    throw new Error('The last message must contain only tool_result content if any is present');\n                }\n                if (!hasPreviousToolUse) {\n                    throw new Error('tool_result blocks are not matching any tool_use from the previous message');\n                }\n            }\n            if (hasPreviousToolUse) {\n                // Extract tool_use IDs from previous message and tool_result IDs from current message\n                const toolUseIds = new Set(previousContent.filter(c => c.type === 'tool_use').map(c => c.id));\n                const toolResultIds = new Set(lastContent.filter(c => c.type === 'tool_result').map(c => c.toolUseId));\n                if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every(id => toolResultIds.has(id))) {\n                    throw new Error('ids of tool_result blocks and tool_use blocks from previous message do not match');\n                }\n            }\n        }\n        return this.requestStream({\n            method: 'sampling/createMessage',\n            params\n        }, CreateMessageResultSchema, options);\n    }\n    /**\n     * Sends an elicitation request and returns an AsyncGenerator that yields response messages.\n     * The generator is guaranteed to end with either a 'result' or 'error' message.\n     *\n     * For task-augmented requests (especially URL-based elicitation), yields 'taskCreated'\n     * and 'taskStatus' messages before the final result.\n     *\n     * @example\n     * ```typescript\n     * const stream = server.experimental.tasks.elicitInputStream({\n     *     mode: 'url',\n     *     message: 'Please authenticate',\n     *     elicitationId: 'auth-123',\n     *     url: 'https://example.com/auth'\n     * }, {\n     *     task: { ttl: 300000 } // Task-augmented for long-running auth flow\n     * });\n     *\n     * for await (const message of stream) {\n     *     switch (message.type) {\n     *         case 'taskCreated':\n     *             console.log('Task created:', message.task.taskId);\n     *             break;\n     *         case 'taskStatus':\n     *             console.log('Task status:', message.task.status);\n     *             break;\n     *         case 'result':\n     *             console.log('User action:', message.result.action);\n     *             break;\n     *         case 'error':\n     *             console.error('Error:', message.error);\n     *             break;\n     *     }\n     * }\n     * ```\n     *\n     * @param params - The elicitation request parameters\n     * @param options - Optional request options (timeout, signal, task creation params, etc.)\n     * @returns AsyncGenerator that yields ResponseMessage objects\n     *\n     * @experimental\n     */\n    elicitInputStream(params, options) {\n        // Access client capabilities via the server\n        const clientCapabilities = this._server.getClientCapabilities();\n        const mode = params.mode ?? 'form';\n        // Capability check based on mode\n        switch (mode) {\n            case 'url': {\n                if (!clientCapabilities?.elicitation?.url) {\n                    throw new Error('Client does not support url elicitation.');\n                }\n                break;\n            }\n            case 'form': {\n                if (!clientCapabilities?.elicitation?.form) {\n                    throw new Error('Client does not support form elicitation.');\n                }\n                break;\n            }\n        }\n        // Normalize params to ensure mode is set for form mode (defaults to 'form' per spec)\n        const normalizedParams = mode === 'form' && params.mode === undefined ? { ...params, mode: 'form' } : params;\n        // Cast to ServerRequest needed because TypeScript can't narrow the union type\n        // based on the discriminated 'method' field when constructing the object literal\n        return this.requestStream({\n            method: 'elicitation/create',\n            params: normalizedParams\n        }, ElicitResultSchema, options);\n    }\n    /**\n     * Gets the current status of a task.\n     *\n     * @param taskId - The task identifier\n     * @param options - Optional request options\n     * @returns The task status\n     *\n     * @experimental\n     */\n    async getTask(taskId, options) {\n        return this._server.getTask({ taskId }, options);\n    }\n    /**\n     * Retrieves the result of a completed task.\n     *\n     * @param taskId - The task identifier\n     * @param resultSchema - Zod schema for validating the result\n     * @param options - Optional request options\n     * @returns The task result\n     *\n     * @experimental\n     */\n    async getTaskResult(taskId, resultSchema, options) {\n        return this._server.getTaskResult({ taskId }, resultSchema, options);\n    }\n    /**\n     * Lists tasks with optional pagination.\n     *\n     * @param cursor - Optional pagination cursor\n     * @param options - Optional request options\n     * @returns List of tasks with optional next cursor\n     *\n     * @experimental\n     */\n    async listTasks(cursor, options) {\n        return this._server.listTasks(cursor ? { cursor } : undefined, options);\n    }\n    /**\n     * Cancels a running task.\n     *\n     * @param taskId - The task identifier\n     * @param options - Optional request options\n     *\n     * @experimental\n     */\n    async cancelTask(taskId, options) {\n        return this._server.cancelTask({ taskId }, options);\n    }\n}\n//# sourceMappingURL=server.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;AAmBA,IAAa,0BAAb,MAAqC;CACjC,YAAY,SAAS;AACjB,OAAK,UAAU;;;;;;;;;;;;;;;;CAgBnB,cAAc,SAAS,cAAc,SAAS;AAC1C,SAAO,KAAK,QAAQ,cAAc,SAAS,cAAc,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CrE,oBAAoB,QAAQ,SAAS;EAEjC,MAAM,qBAAqB,KAAK,QAAQ,uBAAuB;AAE/D,OAAK,OAAO,SAAS,OAAO,eAAe,CAAC,oBAAoB,UAAU,MACtE,OAAM,IAAI,MAAM,qDAAqD;AAKzE,MAAI,OAAO,SAAS,SAAS,GAAG;GAC5B,MAAM,cAAc,OAAO,SAAS,OAAO,SAAS,SAAS;GAC7D,MAAM,cAAc,MAAM,QAAQ,YAAY,QAAQ,GAAG,YAAY,UAAU,CAAC,YAAY,QAAQ;GACpG,MAAM,iBAAiB,YAAY,MAAK,MAAK,EAAE,SAAS,cAAc;GACtE,MAAM,kBAAkB,OAAO,SAAS,SAAS,IAAI,OAAO,SAAS,OAAO,SAAS,SAAS,KAAK;GACnG,MAAM,kBAAkB,kBAClB,MAAM,QAAQ,gBAAgB,QAAQ,GAClC,gBAAgB,UAChB,CAAC,gBAAgB,QAAQ,GAC7B,EAAE;GACR,MAAM,qBAAqB,gBAAgB,MAAK,MAAK,EAAE,SAAS,WAAW;AAC3E,OAAI,gBAAgB;AAChB,QAAI,YAAY,MAAK,MAAK,EAAE,SAAS,cAAc,CAC/C,OAAM,IAAI,MAAM,2EAA2E;AAE/F,QAAI,CAAC,mBACD,OAAM,IAAI,MAAM,6EAA6E;;AAGrG,OAAI,oBAAoB;IAEpB,MAAM,aAAa,IAAI,IAAI,gBAAgB,QAAO,MAAK,EAAE,SAAS,WAAW,CAAC,KAAI,MAAK,EAAE,GAAG,CAAC;IAC7F,MAAM,gBAAgB,IAAI,IAAI,YAAY,QAAO,MAAK,EAAE,SAAS,cAAc,CAAC,KAAI,MAAK,EAAE,UAAU,CAAC;AACtG,QAAI,WAAW,SAAS,cAAc,QAAQ,CAAC,CAAC,GAAG,WAAW,CAAC,OAAM,OAAM,cAAc,IAAI,GAAG,CAAC,CAC7F,OAAM,IAAI,MAAM,mFAAmF;;;AAI/G,SAAO,KAAK,cAAc;GACtB,QAAQ;GACR;GACH,EAAE,2BAA2B,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4C1C,kBAAkB,QAAQ,SAAS;EAE/B,MAAM,qBAAqB,KAAK,QAAQ,uBAAuB;EAC/D,MAAM,OAAO,OAAO,QAAQ;AAE5B,UAAQ,MAAR;GACI,KAAK;AACD,QAAI,CAAC,oBAAoB,aAAa,IAClC,OAAM,IAAI,MAAM,2CAA2C;AAE/D;GAEJ,KAAK;AACD,QAAI,CAAC,oBAAoB,aAAa,KAClC,OAAM,IAAI,MAAM,4CAA4C;AAEhE;;EAIR,MAAM,mBAAmB,SAAS,UAAU,OAAO,SAAS,SAAY;GAAE,GAAG;GAAQ,MAAM;GAAQ,GAAG;AAGtG,SAAO,KAAK,cAAc;GACtB,QAAQ;GACR,QAAQ;GACX,EAAE,oBAAoB,QAAQ;;;;;;;;;;;CAWnC,MAAM,QAAQ,QAAQ,SAAS;AAC3B,SAAO,KAAK,QAAQ,QAAQ,EAAE,QAAQ,EAAE,QAAQ;;;;;;;;;;;;CAYpD,MAAM,cAAc,QAAQ,cAAc,SAAS;AAC/C,SAAO,KAAK,QAAQ,cAAc,EAAE,QAAQ,EAAE,cAAc,QAAQ;;;;;;;;;;;CAWxE,MAAM,UAAU,QAAQ,SAAS;AAC7B,SAAO,KAAK,QAAQ,UAAU,SAAS,EAAE,QAAQ,GAAG,QAAW,QAAQ;;;;;;;;;;CAU3E,MAAM,WAAW,QAAQ,SAAS;AAC9B,SAAO,KAAK,QAAQ,WAAW,EAAE,QAAQ,EAAE,QAAQ"}

package/dist/node_modules/.pnpm/@modelcontextprotocol_sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js

@@ -0,0 +1,22 @@
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js
+const COMPLETABLE_SYMBOL = Symbol.for("mcp.completable");
+/**
+* Checks if a schema is completable (has completion metadata).
+*/
+function isCompletable(schema) {
+	return !!schema && typeof schema === "object" && COMPLETABLE_SYMBOL in schema;
+}
+/**
+* Gets the completer callback from a completable schema, if it exists.
+*/
+function getCompleter(schema) {
+	return schema[COMPLETABLE_SYMBOL]?.complete;
+}
+var McpZodTypeKind;
+(function(McpZodTypeKind$1) {
+	McpZodTypeKind$1["Completable"] = "McpCompletable";
+})(McpZodTypeKind || (McpZodTypeKind = {}));
+
+//#endregion
+export { getCompleter, isCompletable };
+//# sourceMappingURL=completable.js.map

package/dist/node_modules/.pnpm/@modelcontextprotocol_sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"completable.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js"],"sourcesContent":["export const COMPLETABLE_SYMBOL = Symbol.for('mcp.completable');\n/**\n * Wraps a Zod type to provide autocompletion capabilities. Useful for, e.g., prompt arguments in MCP.\n * Works with both Zod v3 and v4 schemas.\n */\nexport function completable(schema, complete) {\n    Object.defineProperty(schema, COMPLETABLE_SYMBOL, {\n        value: { complete },\n        enumerable: false,\n        writable: false,\n        configurable: false\n    });\n    return schema;\n}\n/**\n * Checks if a schema is completable (has completion metadata).\n */\nexport function isCompletable(schema) {\n    return !!schema && typeof schema === 'object' && COMPLETABLE_SYMBOL in schema;\n}\n/**\n * Gets the completer callback from a completable schema, if it exists.\n */\nexport function getCompleter(schema) {\n    const meta = schema[COMPLETABLE_SYMBOL];\n    return meta?.complete;\n}\n/**\n * Unwraps a completable schema to get the underlying schema.\n * For backward compatibility with code that called `.unwrap()`.\n */\nexport function unwrapCompletable(schema) {\n    return schema;\n}\n// Legacy exports for backward compatibility\n// These types are deprecated but kept for existing code\nexport var McpZodTypeKind;\n(function (McpZodTypeKind) {\n    McpZodTypeKind[\"Completable\"] = \"McpCompletable\";\n})(McpZodTypeKind || (McpZodTypeKind = {}));\n//# sourceMappingURL=completable.js.map"],"x_google_ignoreList":[0],"mappings":";AAAA,MAAa,qBAAqB,OAAO,IAAI,kBAAkB;;;;AAiB/D,SAAgB,cAAc,QAAQ;AAClC,QAAO,CAAC,CAAC,UAAU,OAAO,WAAW,YAAY,sBAAsB;;;;;AAK3E,SAAgB,aAAa,QAAQ;AAEjC,QADa,OAAO,qBACP;;AAWjB,IAAW;CACV,SAAU,kBAAgB;AACvB,kBAAe,iBAAiB;GACjC,mBAAmB,iBAAiB,EAAE,EAAE"}

package/dist/node_modules/.pnpm/@modelcontextprotocol_sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js

@@ -0,0 +1,351 @@
+import { getObjectShape, isZ4Schema, safeParse } from "./zod-compat.js";
+import { CallToolRequestSchema, CallToolResultSchema, CreateMessageResultSchema, CreateMessageResultWithToolsSchema, CreateTaskResultSchema, ElicitResultSchema, EmptyResultSchema, ErrorCode, InitializeRequestSchema, InitializedNotificationSchema, LATEST_PROTOCOL_VERSION, ListRootsResultSchema, LoggingLevelSchema, McpError, SUPPORTED_PROTOCOL_VERSIONS, SetLevelRequestSchema } from "../types.js";
+import { Protocol, mergeCapabilities } from "../shared/protocol.js";
+import { AjvJsonSchemaValidator } from "../validation/ajv-provider.js";
+import { ExperimentalServerTasks } from "../experimental/tasks/server.js";
+import { assertClientRequestTaskCapability, assertToolsCallTaskCapability } from "../experimental/tasks/helpers.js";
+
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
+/**
+* An MCP server on top of a pluggable transport.
+*
+* This server will automatically respond to the initialization flow as initiated from the client.
+*
+* To use with custom types, extend the base Request/Notification/Result types and pass them as type parameters:
+*
+* ```typescript
+* // Custom schemas
+* const CustomRequestSchema = RequestSchema.extend({...})
+* const CustomNotificationSchema = NotificationSchema.extend({...})
+* const CustomResultSchema = ResultSchema.extend({...})
+*
+* // Type aliases
+* type CustomRequest = z.infer<typeof CustomRequestSchema>
+* type CustomNotification = z.infer<typeof CustomNotificationSchema>
+* type CustomResult = z.infer<typeof CustomResultSchema>
+*
+* // Create typed server
+* const server = new Server<CustomRequest, CustomNotification, CustomResult>({
+*   name: "CustomServer",
+*   version: "1.0.0"
+* })
+* ```
+* @deprecated Use `McpServer` instead for the high-level API. Only use `Server` for advanced use cases.
+*/
+var Server = class extends Protocol {
+	/**
+	* Initializes this server with the given name and version information.
+	*/
+	constructor(_serverInfo, options) {
+		super(options);
+		this._serverInfo = _serverInfo;
+		this._loggingLevels = /* @__PURE__ */ new Map();
+		this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
+		this.isMessageIgnored = (level, sessionId) => {
+			const currentLevel = this._loggingLevels.get(sessionId);
+			return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
+		};
+		this._capabilities = options?.capabilities ?? {};
+		this._instructions = options?.instructions;
+		this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
+		this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request));
+		this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.());
+		if (this._capabilities.logging) this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
+			const transportSessionId = extra.sessionId || extra.requestInfo?.headers["mcp-session-id"] || void 0;
+			const { level } = request.params;
+			const parseResult = LoggingLevelSchema.safeParse(level);
+			if (parseResult.success) this._loggingLevels.set(transportSessionId, parseResult.data);
+			return {};
+		});
+	}
+	/**
+	* Access experimental features.
+	*
+	* WARNING: These APIs are experimental and may change without notice.
+	*
+	* @experimental
+	*/
+	get experimental() {
+		if (!this._experimental) this._experimental = { tasks: new ExperimentalServerTasks(this) };
+		return this._experimental;
+	}
+	/**
+	* Registers new capabilities. This can only be called before connecting to a transport.
+	*
+	* The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
+	*/
+	registerCapabilities(capabilities) {
+		if (this.transport) throw new Error("Cannot register capabilities after connecting to transport");
+		this._capabilities = mergeCapabilities(this._capabilities, capabilities);
+	}
+	/**
+	* Override request handler registration to enforce server-side validation for tools/call.
+	*/
+	setRequestHandler(requestSchema, handler) {
+		const methodSchema = getObjectShape(requestSchema)?.method;
+		if (!methodSchema) throw new Error("Schema is missing a method literal");
+		let methodValue;
+		if (isZ4Schema(methodSchema)) {
+			const v4Schema = methodSchema;
+			methodValue = (v4Schema._zod?.def)?.value ?? v4Schema.value;
+		} else {
+			const v3Schema = methodSchema;
+			methodValue = v3Schema._def?.value ?? v3Schema.value;
+		}
+		if (typeof methodValue !== "string") throw new Error("Schema method literal must be a string");
+		if (methodValue === "tools/call") {
+			const wrappedHandler = async (request, extra) => {
+				const validatedRequest = safeParse(CallToolRequestSchema, request);
+				if (!validatedRequest.success) {
+					const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+					throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
+				}
+				const { params } = validatedRequest.data;
+				const result = await Promise.resolve(handler(request, extra));
+				if (params.task) {
+					const taskValidationResult = safeParse(CreateTaskResultSchema, result);
+					if (!taskValidationResult.success) {
+						const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+						throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+					}
+					return taskValidationResult.data;
+				}
+				const validationResult = safeParse(CallToolResultSchema, result);
+				if (!validationResult.success) {
+					const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+					throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
+				}
+				return validationResult.data;
+			};
+			return super.setRequestHandler(requestSchema, wrappedHandler);
+		}
+		return super.setRequestHandler(requestSchema, handler);
+	}
+	assertCapabilityForMethod(method) {
+		switch (method) {
+			case "sampling/createMessage":
+				if (!this._clientCapabilities?.sampling) throw new Error(`Client does not support sampling (required for ${method})`);
+				break;
+			case "elicitation/create":
+				if (!this._clientCapabilities?.elicitation) throw new Error(`Client does not support elicitation (required for ${method})`);
+				break;
+			case "roots/list":
+				if (!this._clientCapabilities?.roots) throw new Error(`Client does not support listing roots (required for ${method})`);
+				break;
+			case "ping": break;
+		}
+	}
+	assertNotificationCapability(method) {
+		switch (method) {
+			case "notifications/message":
+				if (!this._capabilities.logging) throw new Error(`Server does not support logging (required for ${method})`);
+				break;
+			case "notifications/resources/updated":
+			case "notifications/resources/list_changed":
+				if (!this._capabilities.resources) throw new Error(`Server does not support notifying about resources (required for ${method})`);
+				break;
+			case "notifications/tools/list_changed":
+				if (!this._capabilities.tools) throw new Error(`Server does not support notifying of tool list changes (required for ${method})`);
+				break;
+			case "notifications/prompts/list_changed":
+				if (!this._capabilities.prompts) throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`);
+				break;
+			case "notifications/elicitation/complete":
+				if (!this._clientCapabilities?.elicitation?.url) throw new Error(`Client does not support URL elicitation (required for ${method})`);
+				break;
+			case "notifications/cancelled": break;
+			case "notifications/progress": break;
+		}
+	}
+	assertRequestHandlerCapability(method) {
+		if (!this._capabilities) return;
+		switch (method) {
+			case "completion/complete":
+				if (!this._capabilities.completions) throw new Error(`Server does not support completions (required for ${method})`);
+				break;
+			case "logging/setLevel":
+				if (!this._capabilities.logging) throw new Error(`Server does not support logging (required for ${method})`);
+				break;
+			case "prompts/get":
+			case "prompts/list":
+				if (!this._capabilities.prompts) throw new Error(`Server does not support prompts (required for ${method})`);
+				break;
+			case "resources/list":
+			case "resources/templates/list":
+			case "resources/read":
+				if (!this._capabilities.resources) throw new Error(`Server does not support resources (required for ${method})`);
+				break;
+			case "tools/call":
+			case "tools/list":
+				if (!this._capabilities.tools) throw new Error(`Server does not support tools (required for ${method})`);
+				break;
+			case "tasks/get":
+			case "tasks/list":
+			case "tasks/result":
+			case "tasks/cancel":
+				if (!this._capabilities.tasks) throw new Error(`Server does not support tasks capability (required for ${method})`);
+				break;
+			case "ping":
+			case "initialize": break;
+		}
+	}
+	assertTaskCapability(method) {
+		assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, "Client");
+	}
+	assertTaskHandlerCapability(method) {
+		if (!this._capabilities) return;
+		assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, "Server");
+	}
+	async _oninitialize(request) {
+		const requestedVersion = request.params.protocolVersion;
+		this._clientCapabilities = request.params.capabilities;
+		this._clientVersion = request.params.clientInfo;
+		return {
+			protocolVersion: SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION,
+			capabilities: this.getCapabilities(),
+			serverInfo: this._serverInfo,
+			...this._instructions && { instructions: this._instructions }
+		};
+	}
+	/**
+	* After initialization has completed, this will be populated with the client's reported capabilities.
+	*/
+	getClientCapabilities() {
+		return this._clientCapabilities;
+	}
+	/**
+	* After initialization has completed, this will be populated with information about the client's name and version.
+	*/
+	getClientVersion() {
+		return this._clientVersion;
+	}
+	getCapabilities() {
+		return this._capabilities;
+	}
+	async ping() {
+		return this.request({ method: "ping" }, EmptyResultSchema);
+	}
+	async createMessage(params, options) {
+		if (params.tools || params.toolChoice) {
+			if (!this._clientCapabilities?.sampling?.tools) throw new Error("Client does not support sampling tools capability.");
+		}
+		if (params.messages.length > 0) {
+			const lastMessage = params.messages[params.messages.length - 1];
+			const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
+			const hasToolResults = lastContent.some((c) => c.type === "tool_result");
+			const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : void 0;
+			const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
+			const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
+			if (hasToolResults) {
+				if (lastContent.some((c) => c.type !== "tool_result")) throw new Error("The last message must contain only tool_result content if any is present");
+				if (!hasPreviousToolUse) throw new Error("tool_result blocks are not matching any tool_use from the previous message");
+			}
+			if (hasPreviousToolUse) {
+				const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
+				const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
+				if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
+			}
+		}
+		if (params.tools) return this.request({
+			method: "sampling/createMessage",
+			params
+		}, CreateMessageResultWithToolsSchema, options);
+		return this.request({
+			method: "sampling/createMessage",
+			params
+		}, CreateMessageResultSchema, options);
+	}
+	/**
+	* Creates an elicitation request for the given parameters.
+	* For backwards compatibility, `mode` may be omitted for form requests and will default to `'form'`.
+	* @param params The parameters for the elicitation request.
+	* @param options Optional request options.
+	* @returns The result of the elicitation request.
+	*/
+	async elicitInput(params, options) {
+		switch (params.mode ?? "form") {
+			case "url": {
+				if (!this._clientCapabilities?.elicitation?.url) throw new Error("Client does not support url elicitation.");
+				const urlParams = params;
+				return this.request({
+					method: "elicitation/create",
+					params: urlParams
+				}, ElicitResultSchema, options);
+			}
+			case "form": {
+				if (!this._clientCapabilities?.elicitation?.form) throw new Error("Client does not support form elicitation.");
+				const formParams = params.mode === "form" ? params : {
+					...params,
+					mode: "form"
+				};
+				const result = await this.request({
+					method: "elicitation/create",
+					params: formParams
+				}, ElicitResultSchema, options);
+				if (result.action === "accept" && result.content && formParams.requestedSchema) try {
+					const validationResult = this._jsonSchemaValidator.getValidator(formParams.requestedSchema)(result.content);
+					if (!validationResult.valid) throw new McpError(ErrorCode.InvalidParams, `Elicitation response content does not match requested schema: ${validationResult.errorMessage}`);
+				} catch (error) {
+					if (error instanceof McpError) throw error;
+					throw new McpError(ErrorCode.InternalError, `Error validating elicitation response: ${error instanceof Error ? error.message : String(error)}`);
+				}
+				return result;
+			}
+		}
+	}
+	/**
+	* Creates a reusable callback that, when invoked, will send a `notifications/elicitation/complete`
+	* notification for the specified elicitation ID.
+	*
+	* @param elicitationId The ID of the elicitation to mark as complete.
+	* @param options Optional notification options. Useful when the completion notification should be related to a prior request.
+	* @returns A function that emits the completion notification when awaited.
+	*/
+	createElicitationCompletionNotifier(elicitationId, options) {
+		if (!this._clientCapabilities?.elicitation?.url) throw new Error("Client does not support URL elicitation (required for notifications/elicitation/complete)");
+		return () => this.notification({
+			method: "notifications/elicitation/complete",
+			params: { elicitationId }
+		}, options);
+	}
+	async listRoots(params, options) {
+		return this.request({
+			method: "roots/list",
+			params
+		}, ListRootsResultSchema, options);
+	}
+	/**
+	* Sends a logging message to the client, if connected.
+	* Note: You only need to send the parameters object, not the entire JSON RPC message
+	* @see LoggingMessageNotification
+	* @param params
+	* @param sessionId optional for stateless and backward compatibility
+	*/
+	async sendLoggingMessage(params, sessionId) {
+		if (this._capabilities.logging) {
+			if (!this.isMessageIgnored(params.level, sessionId)) return this.notification({
+				method: "notifications/message",
+				params
+			});
+		}
+	}
+	async sendResourceUpdated(params) {
+		return this.notification({
+			method: "notifications/resources/updated",
+			params
+		});
+	}
+	async sendResourceListChanged() {
+		return this.notification({ method: "notifications/resources/list_changed" });
+	}
+	async sendToolListChanged() {
+		return this.notification({ method: "notifications/tools/list_changed" });
+	}
+	async sendPromptListChanged() {
+		return this.notification({ method: "notifications/prompts/list_changed" });
+	}
+};
+
+//#endregion
+export { Server };
+//# sourceMappingURL=index.js.map

package/dist/node_modules/.pnpm/@modelcontextprotocol_sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js"],"sourcesContent":["import { mergeCapabilities, Protocol } from '../shared/protocol.js';\nimport { CreateMessageResultSchema, CreateMessageResultWithToolsSchema, ElicitResultSchema, EmptyResultSchema, ErrorCode, InitializedNotificationSchema, InitializeRequestSchema, LATEST_PROTOCOL_VERSION, ListRootsResultSchema, LoggingLevelSchema, McpError, SetLevelRequestSchema, SUPPORTED_PROTOCOL_VERSIONS, CallToolRequestSchema, CallToolResultSchema, CreateTaskResultSchema } from '../types.js';\nimport { AjvJsonSchemaValidator } from '../validation/ajv-provider.js';\nimport { getObjectShape, isZ4Schema, safeParse } from './zod-compat.js';\nimport { ExperimentalServerTasks } from '../experimental/tasks/server.js';\nimport { assertToolsCallTaskCapability, assertClientRequestTaskCapability } from '../experimental/tasks/helpers.js';\n/**\n * An MCP server on top of a pluggable transport.\n *\n * This server will automatically respond to the initialization flow as initiated from the client.\n *\n * To use with custom types, extend the base Request/Notification/Result types and pass them as type parameters:\n *\n * ```typescript\n * // Custom schemas\n * const CustomRequestSchema = RequestSchema.extend({...})\n * const CustomNotificationSchema = NotificationSchema.extend({...})\n * const CustomResultSchema = ResultSchema.extend({...})\n *\n * // Type aliases\n * type CustomRequest = z.infer<typeof CustomRequestSchema>\n * type CustomNotification = z.infer<typeof CustomNotificationSchema>\n * type CustomResult = z.infer<typeof CustomResultSchema>\n *\n * // Create typed server\n * const server = new Server<CustomRequest, CustomNotification, CustomResult>({\n *   name: \"CustomServer\",\n *   version: \"1.0.0\"\n * })\n * ```\n * @deprecated Use `McpServer` instead for the high-level API. Only use `Server` for advanced use cases.\n */\nexport class Server extends Protocol {\n    /**\n     * Initializes this server with the given name and version information.\n     */\n    constructor(_serverInfo, options) {\n        super(options);\n        this._serverInfo = _serverInfo;\n        // Map log levels by session id\n        this._loggingLevels = new Map();\n        // Map LogLevelSchema to severity index\n        this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));\n        // Is a message with the given level ignored in the log level set for the given session id?\n        this.isMessageIgnored = (level, sessionId) => {\n            const currentLevel = this._loggingLevels.get(sessionId);\n            return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;\n        };\n        this._capabilities = options?.capabilities ?? {};\n        this._instructions = options?.instructions;\n        this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();\n        this.setRequestHandler(InitializeRequestSchema, request => this._oninitialize(request));\n        this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.());\n        if (this._capabilities.logging) {\n            this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {\n                const transportSessionId = extra.sessionId || extra.requestInfo?.headers['mcp-session-id'] || undefined;\n                const { level } = request.params;\n                const parseResult = LoggingLevelSchema.safeParse(level);\n                if (parseResult.success) {\n                    this._loggingLevels.set(transportSessionId, parseResult.data);\n                }\n                return {};\n            });\n        }\n    }\n    /**\n     * Access experimental features.\n     *\n     * WARNING: These APIs are experimental and may change without notice.\n     *\n     * @experimental\n     */\n    get experimental() {\n        if (!this._experimental) {\n            this._experimental = {\n                tasks: new ExperimentalServerTasks(this)\n            };\n        }\n        return this._experimental;\n    }\n    /**\n     * Registers new capabilities. This can only be called before connecting to a transport.\n     *\n     * The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).\n     */\n    registerCapabilities(capabilities) {\n        if (this.transport) {\n            throw new Error('Cannot register capabilities after connecting to transport');\n        }\n        this._capabilities = mergeCapabilities(this._capabilities, capabilities);\n    }\n    /**\n     * Override request handler registration to enforce server-side validation for tools/call.\n     */\n    setRequestHandler(requestSchema, handler) {\n        const shape = getObjectShape(requestSchema);\n        const methodSchema = shape?.method;\n        if (!methodSchema) {\n            throw new Error('Schema is missing a method literal');\n        }\n        // Extract literal value using type-safe property access\n        let methodValue;\n        if (isZ4Schema(methodSchema)) {\n            const v4Schema = methodSchema;\n            const v4Def = v4Schema._zod?.def;\n            methodValue = v4Def?.value ?? v4Schema.value;\n        }\n        else {\n            const v3Schema = methodSchema;\n            const legacyDef = v3Schema._def;\n            methodValue = legacyDef?.value ?? v3Schema.value;\n        }\n        if (typeof methodValue !== 'string') {\n            throw new Error('Schema method literal must be a string');\n        }\n        const method = methodValue;\n        if (method === 'tools/call') {\n            const wrappedHandler = async (request, extra) => {\n                const validatedRequest = safeParse(CallToolRequestSchema, request);\n                if (!validatedRequest.success) {\n                    const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);\n                    throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);\n                }\n                const { params } = validatedRequest.data;\n                const result = await Promise.resolve(handler(request, extra));\n                // When task creation is requested, validate and return CreateTaskResult\n                if (params.task) {\n                    const taskValidationResult = safeParse(CreateTaskResultSchema, result);\n                    if (!taskValidationResult.success) {\n                        const errorMessage = taskValidationResult.error instanceof Error\n                            ? taskValidationResult.error.message\n                            : String(taskValidationResult.error);\n                        throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);\n                    }\n                    return taskValidationResult.data;\n                }\n                // For non-task requests, validate against CallToolResultSchema\n                const validationResult = safeParse(CallToolResultSchema, result);\n                if (!validationResult.success) {\n                    const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);\n                    throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);\n                }\n                return validationResult.data;\n            };\n            // Install the wrapped handler\n            return super.setRequestHandler(requestSchema, wrappedHandler);\n        }\n        // Other handlers use default behavior\n        return super.setRequestHandler(requestSchema, handler);\n    }\n    assertCapabilityForMethod(method) {\n        switch (method) {\n            case 'sampling/createMessage':\n                if (!this._clientCapabilities?.sampling) {\n                    throw new Error(`Client does not support sampling (required for ${method})`);\n                }\n                break;\n            case 'elicitation/create':\n                if (!this._clientCapabilities?.elicitation) {\n                    throw new Error(`Client does not support elicitation (required for ${method})`);\n                }\n                break;\n            case 'roots/list':\n                if (!this._clientCapabilities?.roots) {\n                    throw new Error(`Client does not support listing roots (required for ${method})`);\n                }\n                break;\n            case 'ping':\n                // No specific capability required for ping\n                break;\n        }\n    }\n    assertNotificationCapability(method) {\n        switch (method) {\n            case 'notifications/message':\n                if (!this._capabilities.logging) {\n                    throw new Error(`Server does not support logging (required for ${method})`);\n                }\n                break;\n            case 'notifications/resources/updated':\n            case 'notifications/resources/list_changed':\n                if (!this._capabilities.resources) {\n                    throw new Error(`Server does not support notifying about resources (required for ${method})`);\n                }\n                break;\n            case 'notifications/tools/list_changed':\n                if (!this._capabilities.tools) {\n                    throw new Error(`Server does not support notifying of tool list changes (required for ${method})`);\n                }\n                break;\n            case 'notifications/prompts/list_changed':\n                if (!this._capabilities.prompts) {\n                    throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`);\n                }\n                break;\n            case 'notifications/elicitation/complete':\n                if (!this._clientCapabilities?.elicitation?.url) {\n                    throw new Error(`Client does not support URL elicitation (required for ${method})`);\n                }\n                break;\n            case 'notifications/cancelled':\n                // Cancellation notifications are always allowed\n                break;\n            case 'notifications/progress':\n                // Progress notifications are always allowed\n                break;\n        }\n    }\n    assertRequestHandlerCapability(method) {\n        // Task handlers are registered in Protocol constructor before _capabilities is initialized\n        // Skip capability check for task methods during initialization\n        if (!this._capabilities) {\n            return;\n        }\n        switch (method) {\n            case 'completion/complete':\n                if (!this._capabilities.completions) {\n                    throw new Error(`Server does not support completions (required for ${method})`);\n                }\n                break;\n            case 'logging/setLevel':\n                if (!this._capabilities.logging) {\n                    throw new Error(`Server does not support logging (required for ${method})`);\n                }\n                break;\n            case 'prompts/get':\n            case 'prompts/list':\n                if (!this._capabilities.prompts) {\n                    throw new Error(`Server does not support prompts (required for ${method})`);\n                }\n                break;\n            case 'resources/list':\n            case 'resources/templates/list':\n            case 'resources/read':\n                if (!this._capabilities.resources) {\n                    throw new Error(`Server does not support resources (required for ${method})`);\n                }\n                break;\n            case 'tools/call':\n            case 'tools/list':\n                if (!this._capabilities.tools) {\n                    throw new Error(`Server does not support tools (required for ${method})`);\n                }\n                break;\n            case 'tasks/get':\n            case 'tasks/list':\n            case 'tasks/result':\n            case 'tasks/cancel':\n                if (!this._capabilities.tasks) {\n                    throw new Error(`Server does not support tasks capability (required for ${method})`);\n                }\n                break;\n            case 'ping':\n            case 'initialize':\n                // No specific capability required for these methods\n                break;\n        }\n    }\n    assertTaskCapability(method) {\n        assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, 'Client');\n    }\n    assertTaskHandlerCapability(method) {\n        // Task handlers are registered in Protocol constructor before _capabilities is initialized\n        // Skip capability check for task methods during initialization\n        if (!this._capabilities) {\n            return;\n        }\n        assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, 'Server');\n    }\n    async _oninitialize(request) {\n        const requestedVersion = request.params.protocolVersion;\n        this._clientCapabilities = request.params.capabilities;\n        this._clientVersion = request.params.clientInfo;\n        const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION;\n        return {\n            protocolVersion,\n            capabilities: this.getCapabilities(),\n            serverInfo: this._serverInfo,\n            ...(this._instructions && { instructions: this._instructions })\n        };\n    }\n    /**\n     * After initialization has completed, this will be populated with the client's reported capabilities.\n     */\n    getClientCapabilities() {\n        return this._clientCapabilities;\n    }\n    /**\n     * After initialization has completed, this will be populated with information about the client's name and version.\n     */\n    getClientVersion() {\n        return this._clientVersion;\n    }\n    getCapabilities() {\n        return this._capabilities;\n    }\n    async ping() {\n        return this.request({ method: 'ping' }, EmptyResultSchema);\n    }\n    // Implementation\n    async createMessage(params, options) {\n        // Capability check - only required when tools/toolChoice are provided\n        if (params.tools || params.toolChoice) {\n            if (!this._clientCapabilities?.sampling?.tools) {\n                throw new Error('Client does not support sampling tools capability.');\n            }\n        }\n        // Message structure validation - always validate tool_use/tool_result pairs.\n        // These may appear even without tools/toolChoice in the current request when\n        // a previous sampling request returned tool_use and this is a follow-up with results.\n        if (params.messages.length > 0) {\n            const lastMessage = params.messages[params.messages.length - 1];\n            const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];\n            const hasToolResults = lastContent.some(c => c.type === 'tool_result');\n            const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : undefined;\n            const previousContent = previousMessage\n                ? Array.isArray(previousMessage.content)\n                    ? previousMessage.content\n                    : [previousMessage.content]\n                : [];\n            const hasPreviousToolUse = previousContent.some(c => c.type === 'tool_use');\n            if (hasToolResults) {\n                if (lastContent.some(c => c.type !== 'tool_result')) {\n                    throw new Error('The last message must contain only tool_result content if any is present');\n                }\n                if (!hasPreviousToolUse) {\n                    throw new Error('tool_result blocks are not matching any tool_use from the previous message');\n                }\n            }\n            if (hasPreviousToolUse) {\n                const toolUseIds = new Set(previousContent.filter(c => c.type === 'tool_use').map(c => c.id));\n                const toolResultIds = new Set(lastContent.filter(c => c.type === 'tool_result').map(c => c.toolUseId));\n                if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every(id => toolResultIds.has(id))) {\n                    throw new Error('ids of tool_result blocks and tool_use blocks from previous message do not match');\n                }\n            }\n        }\n        // Use different schemas based on whether tools are provided\n        if (params.tools) {\n            return this.request({ method: 'sampling/createMessage', params }, CreateMessageResultWithToolsSchema, options);\n        }\n        return this.request({ method: 'sampling/createMessage', params }, CreateMessageResultSchema, options);\n    }\n    /**\n     * Creates an elicitation request for the given parameters.\n     * For backwards compatibility, `mode` may be omitted for form requests and will default to `'form'`.\n     * @param params The parameters for the elicitation request.\n     * @param options Optional request options.\n     * @returns The result of the elicitation request.\n     */\n    async elicitInput(params, options) {\n        const mode = (params.mode ?? 'form');\n        switch (mode) {\n            case 'url': {\n                if (!this._clientCapabilities?.elicitation?.url) {\n                    throw new Error('Client does not support url elicitation.');\n                }\n                const urlParams = params;\n                return this.request({ method: 'elicitation/create', params: urlParams }, ElicitResultSchema, options);\n            }\n            case 'form': {\n                if (!this._clientCapabilities?.elicitation?.form) {\n                    throw new Error('Client does not support form elicitation.');\n                }\n                const formParams = params.mode === 'form' ? params : { ...params, mode: 'form' };\n                const result = await this.request({ method: 'elicitation/create', params: formParams }, ElicitResultSchema, options);\n                if (result.action === 'accept' && result.content && formParams.requestedSchema) {\n                    try {\n                        const validator = this._jsonSchemaValidator.getValidator(formParams.requestedSchema);\n                        const validationResult = validator(result.content);\n                        if (!validationResult.valid) {\n                            throw new McpError(ErrorCode.InvalidParams, `Elicitation response content does not match requested schema: ${validationResult.errorMessage}`);\n                        }\n                    }\n                    catch (error) {\n                        if (error instanceof McpError) {\n                            throw error;\n                        }\n                        throw new McpError(ErrorCode.InternalError, `Error validating elicitation response: ${error instanceof Error ? error.message : String(error)}`);\n                    }\n                }\n                return result;\n            }\n        }\n    }\n    /**\n     * Creates a reusable callback that, when invoked, will send a `notifications/elicitation/complete`\n     * notification for the specified elicitation ID.\n     *\n     * @param elicitationId The ID of the elicitation to mark as complete.\n     * @param options Optional notification options. Useful when the completion notification should be related to a prior request.\n     * @returns A function that emits the completion notification when awaited.\n     */\n    createElicitationCompletionNotifier(elicitationId, options) {\n        if (!this._clientCapabilities?.elicitation?.url) {\n            throw new Error('Client does not support URL elicitation (required for notifications/elicitation/complete)');\n        }\n        return () => this.notification({\n            method: 'notifications/elicitation/complete',\n            params: {\n                elicitationId\n            }\n        }, options);\n    }\n    async listRoots(params, options) {\n        return this.request({ method: 'roots/list', params }, ListRootsResultSchema, options);\n    }\n    /**\n     * Sends a logging message to the client, if connected.\n     * Note: You only need to send the parameters object, not the entire JSON RPC message\n     * @see LoggingMessageNotification\n     * @param params\n     * @param sessionId optional for stateless and backward compatibility\n     */\n    async sendLoggingMessage(params, sessionId) {\n        if (this._capabilities.logging) {\n            if (!this.isMessageIgnored(params.level, sessionId)) {\n                return this.notification({ method: 'notifications/message', params });\n            }\n        }\n    }\n    async sendResourceUpdated(params) {\n        return this.notification({\n            method: 'notifications/resources/updated',\n            params\n        });\n    }\n    async sendResourceListChanged() {\n        return this.notification({\n            method: 'notifications/resources/list_changed'\n        });\n    }\n    async sendToolListChanged() {\n        return this.notification({ method: 'notifications/tools/list_changed' });\n    }\n    async sendPromptListChanged() {\n        return this.notification({ method: 'notifications/prompts/list_changed' });\n    }\n}\n//# sourceMappingURL=index.js.map"],"x_google_ignoreList":[0],"mappings":"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"}