@silkweave/mcp 1.8.0 → 1.9.1

package/build/index.mjs

@@ -2,22 +2,21 @@ import { intro } from "@clack/prompts";
 import { Client } from "@modelcontextprotocol/sdk/client";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { LoggingMessageNotificationSchema, ProgressNotificationSchema, isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
-import { SilkweaveError, unwrap } from "@silkweave/core";
 import { createCLILogger, createLogger } from "@silkweave/logger";
 import { capitalCase, kebabCase, pascalCase } from "change-case";
 import { Command } from "commander";
 import { randomUUID } from "crypto";
-import { z } from "zod/v4";
+import { SilkweaveError, createContext, isStreamingAction, runStreamingAction } from "@silkweave/core";
 import { randomUUID as randomUUID$1 } from "node:crypto";
-import { InMemoryEventStore } from "@modelcontextprotocol/sdk/examples/shared/inMemoryEventStore.js";
 import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import express from "express";
 import { generateProtectedResourceMetadata, validateToken } from "@silkweave/auth";
+import { AsyncLocalStorage } from "node:async_hooks";
 import cors from "cors";
-import express from "express";
 import { readFile, writeFile } from "fs/promises";
-import { AsyncLocalStorage } from "node:async_hooks";
+import { InMemoryEventStore } from "@modelcontextprotocol/sdk/examples/shared/inMemoryEventStore.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 //#region src/util/result.ts
 function smartToolResult(data) {
@@ -91,16 +90,37 @@ function parseResourceMessage({ resource }) {
 }
 //#endregion
 //#region src/adapter/cliProxy.ts
-function addCliOption(command, key, type, defaultValue) {
-	const description = type.description;
+function coerce(value, type) {
+	if (value === void 0) return;
+	if (type === "number" || type === "integer") {
+		const n = Number(value);
+		return Number.isNaN(n) ? value : n;
+	}
+	return value;
+}
+function addCliOption(command, key, prop) {
 	const flag = kebabCase(key);
-	if (type instanceof z.ZodBoolean) {
+	const description = prop.description;
+	const defaultValue = prop.default;
+	const type = prop.type;
+	if (type === "boolean") {
 		command.option(`--${flag}`, description, defaultValue);
 		command.option(`--no-${flag}`);
-	} else if (type instanceof z.ZodNumber) command.option(`--${flag} <number>`, description, defaultValue);
-	else if (type instanceof z.ZodString || type instanceof z.ZodEnum) command.option(`--${flag} <string>`, description, defaultValue);
-	else if (type instanceof z.ZodObject || type instanceof z.ZodRecord || type instanceof z.ZodArray) command.option(`--${flag} <json>`, description ?? "", JSON.parse, defaultValue);
-	else throw new Error(`Invalid zod type: ${type.def.type}`);
+		return;
+	}
+	if (type === "number" || type === "integer") {
+		command.option(`--${flag} <number>`, description, defaultValue);
+		return;
+	}
+	if (type === "string" || prop.enum) {
+		command.option(`--${flag} <string>`, description, defaultValue);
+		return;
+	}
+	if (type === "object" || type === "array") {
+		command.option(`--${flag} <json>`, description ?? "", JSON.parse, defaultValue);
+		return;
+	}
+	throw new Error(`Unsupported JSON Schema type for CLI option "${key}": ${type ?? "undefined"}`);
 }
 const defaultFormatter = (message) => {
 	if (message.type === "text" && !message.text.includes("mcp://toolResult/")) return `${message.text}`;
@@ -126,13 +146,8 @@ const cliProxy = ({ url, formatter = defaultFormatter }) => {
 					const name = kebabCase(tool.name);
 					const command = program.command(name);
 					if (tool.description) command.description(tool.description);
-					const schema = z.fromJSONSchema(tool.inputSchema);
-					if (!(schema instanceof z.ZodObject)) throw new Error("Invalid schema");
-					const shape = schema.shape;
-					for (const key of Object.keys(shape)) {
-						const [type, { defaultValue }] = unwrap(shape[key]);
-						addCliOption(command, key, type, defaultValue);
-					}
+					const properties = tool.inputSchema.properties ?? {};
+					for (const key of Object.keys(properties)) addCliOption(command, key, properties[key]);
 					command.action(async (args) => {
 						const { silent } = program.opts();
 						const logger = createCLILogger();
@@ -149,7 +164,11 @@ const cliProxy = ({ url, formatter = defaultFormatter }) => {
 								});
 							});
 						}
-						const input = await schema.parseAsync(args);
+						const input = {};
+						for (const key of Object.keys(properties)) {
+							const value = args[key];
+							if (value !== void 0) input[key] = coerce(value, properties[key]?.type);
+						}
 						(await client.callTool({
 							name: tool.name,
 							arguments: input,
@@ -171,67 +190,147 @@ const cliProxy = ({ url, formatter = defaultFormatter }) => {
 	};
 };
 //#endregion
-//#region src/adapter/http.ts
+//#region src/handlers/auth.ts
+/**
+* Per-request bearer-token storage used by tool handlers to read the resolved
+* `AuthInfo` for the currently-handled MCP call.
+*/
 const authStorage = new AsyncLocalStorage();
-/** Headers required by the MCP protocol that must always be exposed */
+/**
+* Express middleware that validates the `Authorization: Bearer …` header via
+* the supplied `AuthConfig`. On success the resolved `AuthInfo` is placed in
+* `authStorage` for the duration of the downstream handler - `mcpTransport`'s
+* tool callbacks pick it up to populate the silkweave context's `auth` key.
+*
+* The middleware should NOT be applied to OAuth-discovery / token routes -
+* compose it only on the routes that require an authenticated caller (the MCP
+* transport itself, sideload, etc.).
+*/
+function authMiddleware(auth, context) {
+	return async (req, res, next) => {
+		const result = await validateToken(req.headers.authorization, auth, context.fork({ request: req }));
+		if (result.error) {
+			for (const [key, value] of Object.entries(result.error.headers)) res.header(key, value);
+			res.status(result.error.statusCode).json(result.error.body);
+			return;
+		}
+		if (result.auth) authStorage.run(result.auth, () => {
+			next();
+		});
+		else next();
+	};
+}
+//#endregion
+//#region src/handlers/cors.ts
+/** Headers required by the MCP protocol that must always be exposed when CORS is in use. */
 const MCP_REQUIRED_HEADERS = [
 	"WWW-Authenticate",
 	"Mcp-Session-Id",
 	"Last-Event-Id",
 	"Mcp-Protocol-Version"
 ];
-function mountOAuthRoutes(app, auth) {
-	const provider = auth.provider;
-	const callbackPath = auth.callbackPath ?? "/auth/callback";
-	const toOAuthReq = (req) => ({
+/**
+* CORS middleware preconfigured to expose the headers MCP clients need
+* (`Mcp-Session-Id`, `Last-Event-Id`, `Mcp-Protocol-Version`, `WWW-Authenticate`)
+* on top of any user-supplied options.
+*
+* Pass `false` to disable, omit / pass `true` for permissive defaults, or pass
+* a `CorsOptions` object to override.
+*/
+function mcpCors(corsConfig = true) {
+	if (corsConfig === false) return null;
+	const userConfig = corsConfig === true ? {} : corsConfig;
+	const userExposed = userConfig.exposedHeaders;
+	const exposedHeaders = [...MCP_REQUIRED_HEADERS, ...Array.isArray(userExposed) ? userExposed : userExposed ? [userExposed] : []];
+	return cors({
+		origin: "*",
+		...userConfig,
+		exposedHeaders
+	});
+}
+//#endregion
+//#region src/handlers/metadata.ts
+/**
+* Handler for `GET /.well-known/oauth-protected-resource` (RFC 9728). Returns
+* the resource server's metadata pointing at the configured authorization
+* servers. Requires `auth.resourceUrl` and a non-empty `auth.authorizationServers`.
+*/
+function protectedResourceMetadata(auth) {
+	if (!auth.resourceUrl || !auth.authorizationServers?.length) throw new Error("@silkweave/mcp protectedResourceMetadata(): auth.resourceUrl and auth.authorizationServers are required");
+	const metadata = generateProtectedResourceMetadata(auth.resourceUrl, auth.authorizationServers);
+	return (_req, res) => {
+		res.json(metadata);
+	};
+}
+//#endregion
+//#region src/handlers/oauth.ts
+function toOAuthReq(req) {
+	return {
 		method: req.method,
 		url: new URL(req.url, `${req.protocol}://${req.get("host")}`),
 		headers: Object.fromEntries(Object.entries(req.headers).map(([k, v]) => [k, Array.isArray(v) ? v[0] : v])),
 		body: req.body
-	});
-	const sendOAuth = (res, oauthRes) => {
-		for (const [key, value] of Object.entries(oauthRes.headers)) res.header(key, value);
-		if (oauthRes.body) res.status(oauthRes.status).send(typeof oauthRes.body === "string" ? oauthRes.body : JSON.stringify(oauthRes.body));
-		else res.status(oauthRes.status).end();
 	};
-	app.get("/.well-known/oauth-authorization-server", (_req, res) => {
-		sendOAuth(res, provider.metadata());
-	});
-	app.get("/authorize", async (req, res) => {
-		sendOAuth(res, await provider.authorize(toOAuthReq(req)));
-	});
-	app.get(callbackPath, async (req, res) => {
-		sendOAuth(res, await provider.callback(toOAuthReq(req)));
-	});
-	app.post("/token", express.urlencoded({ extended: false }), async (req, res) => {
-		sendOAuth(res, await provider.token(toOAuthReq(req)));
-	});
-	app.post("/register", express.json(), async (req, res) => {
-		sendOAuth(res, await provider.register(toOAuthReq(req)));
-	});
-	return new Set([
-		"/.well-known/oauth-authorization-server",
-		"/authorize",
-		callbackPath,
-		"/token",
-		"/register"
-	]);
 }
-function mountAuthMiddleware(app, auth, oauthPaths, context) {
-	app.use(async (req, res, next) => {
-		if (req.path.startsWith("/.well-known/") || oauthPaths.has(req.path)) return next();
-		const result = await validateToken(req.headers.authorization, auth, context.fork({ request: req }));
-		if (result.error) {
-			for (const [key, value] of Object.entries(result.error.headers)) res.header(key, value);
-			res.status(result.error.statusCode).json(result.error.body);
-			return;
-		}
-		if (result.auth) authStorage.run(result.auth, () => {
-			next();
-		});
-		else next();
-	});
+function sendOAuth(res, oauthRes) {
+	for (const [key, value] of Object.entries(oauthRes.headers)) res.header(key, value);
+	if (oauthRes.body) res.status(oauthRes.status).send(typeof oauthRes.body === "string" ? oauthRes.body : JSON.stringify(oauthRes.body));
+	else res.status(oauthRes.status).end();
+}
+/**
+* Build the OAuth 2.1 proxy route handlers (authorize, callback, token,
+* register, well-known) backed by the configured `auth.provider`. Returns the
+* handlers as individual `RequestHandler`s so callers can register them
+* wherever they like - under `/mcp`, at the server root, etc.
+*
+* `token` and `register` are returned as middleware arrays because the
+* appropriate body parser must run before the handler. Apply with
+* `app.post(path, ...token)`.
+*/
+function oauthRoutes(auth) {
+	if (!auth.provider) throw new Error("@silkweave/mcp oauthRoutes(): auth.provider is required");
+	const provider = auth.provider;
+	return {
+		callbackPath: auth.callbackPath ?? "/auth/callback",
+		wellKnownAuthServer: (_req, res) => {
+			sendOAuth(res, provider.metadata());
+		},
+		authorize: async (req, res) => {
+			sendOAuth(res, await provider.authorize(toOAuthReq(req)));
+		},
+		callback: async (req, res) => {
+			sendOAuth(res, await provider.callback(toOAuthReq(req)));
+		},
+		token: [express.urlencoded({ extended: false }), async (req, res) => {
+			sendOAuth(res, await provider.token(toOAuthReq(req)));
+		}],
+		register: [express.json(), async (req, res) => {
+			sendOAuth(res, await provider.register(toOAuthReq(req)));
+		}]
+	};
+}
+//#endregion
+//#region src/handlers/sideload.ts
+/**
+* Handler for `GET /resource/:id` - serves a large MCP response that was
+* sideloaded to disk as a `{id}` payload with a `{id}.json` metadata sidecar.
+*
+* The route param `id` is provided by the host framework (Express, Nest, etc.).
+*/
+function sideloadResource(options = {}) {
+	const { resourceDir = "resources" } = options;
+	return async (req, res) => {
+		const id = req.params["id"];
+		if (!id || typeof id !== "string") throw new Error("Invalid ID");
+		const resourceMeta = JSON.parse(await readFile(`${resourceDir}/${id}.json`, "utf-8"));
+		const buffer = await readFile(`${resourceDir}/${id}`);
+		res.status(200);
+		res.header("Content-Type", resourceMeta.contentType);
+		res.send(buffer);
+	};
 }
+//#endregion
+//#region src/handlers/transport.ts
 function registerTools$1(server, actions, context) {
 	for (const action of actions) server.registerTool(pascalCase(action.name), {
 		title: capitalCase(action.name),
@@ -269,14 +368,28 @@ function registerTools$1(server, actions, context) {
 			...currentAuth ? { auth: currentAuth } : {}
 		});
 		const disposition = extra._meta?.disposition;
-		return action.run(input, actionContext).then((result) => {
+		const progressToken = extra._meta?.progressToken;
+		try {
+			let result;
+			if (isStreamingAction(action)) result = await runStreamingAction(action, input, actionContext, progressToken ? async (chunk, index) => {
+				await extra.sendNotification({
+					method: "notifications/progress",
+					params: {
+						progressToken,
+						progress: index + 1,
+						message: JSON.stringify(chunk)
+					}
+				});
+			} : void 0);
+			else result = await action.run(input, actionContext);
 			if (action.toolResult) {
 				const response = action.toolResult(result, actionContext);
 				if (response) return response;
 			}
-			if (disposition === "json") return jsonToolResult(result);
-			else return smartToolResult(result);
-		}).catch(handleToolError);
+			return disposition === "json" ? jsonToolResult(result) : smartToolResult(result);
+		} catch (error) {
+			return handleToolError(error);
+		}
 	});
 }
 function createMcpServer(options, actions, context) {
@@ -297,7 +410,6 @@ function createSessionTransport(transports) {
 		enableJsonResponse: false,
 		eventStore: new InMemoryEventStore(),
 		onsessioninitialized: (sId) => {
-			console.log(`Session initialized with ID: ${sId}`);
 			transports[sId] = transport;
 		}
 	});
@@ -306,15 +418,20 @@ function createSessionTransport(transports) {
 	};
 	transport.onclose = () => {
 		const sid = transport.sessionId;
-		if (sid && transports[sid]) {
-			console.log(`Transport closed for session ${sid}, removing from transports map`);
-			delete transports[sid];
-		}
+		if (sid && transports[sid]) delete transports[sid];
 	};
 	return transport;
 }
-function mountMcpTransport(app, transports, createServer) {
-	app.post("/mcp", async (req, res) => {
+/**
+* Build the MCP Streamable HTTP transport route handlers.
+*
+* Sessions are kept in a per-call closure (one map per `mcpTransport()` call),
+* so the same handler object should be registered for all three transport
+* routes - `POST /mcp`, `GET /mcp`, `DELETE /mcp` - to share session state.
+*/
+function mcpTransport(silkweaveOptions, context, actions) {
+	const transports = {};
+	const post = async (req, res) => {
 		const sessionId = req.headers["mcp-session-id"];
 		try {
 			if (sessionId && transports[sessionId]) {
@@ -333,7 +450,7 @@ function mountMcpTransport(app, transports, createServer) {
 				return;
 			}
 			const transport = createSessionTransport(transports);
-			await createServer().connect(transport);
+			await createMcpServer(silkweaveOptions, actions, context).connect(transport);
 			await transport.handleRequest(req, res, req.body);
 		} catch (error) {
 			console.error("Error handling MCP request:", error);
@@ -346,8 +463,8 @@ function mountMcpTransport(app, transports, createServer) {
 				id: null
 			});
 		}
-	});
-	const handleSessionStream = async (req, res) => {
+	};
+	const stream = async (req, res) => {
 		const sessionId = req.headers["mcp-session-id"];
 		if (!sessionId || !transports[sessionId]) {
 			res.status(400).send("Invalid or missing session ID");
@@ -355,64 +472,106 @@ function mountMcpTransport(app, transports, createServer) {
 		}
 		await transports[sessionId].handleRequest(req, res);
 	};
-	app.get("/mcp", handleSessionStream);
-	app.delete("/mcp", handleSessionStream);
-	app.get("/mcp/resource/:id", handleSessionStream);
+	return {
+		post,
+		stream
+	};
 }
-const http = ({ host, port, auth, cors: corsConfig, ...mcpOptions }) => {
-	return (options, baseContext) => {
-		const context = baseContext.fork({ adapter: "http" });
-		const app = createMcpExpressApp({
-			...mcpOptions,
-			host
-		});
-		if (corsConfig !== false) {
-			const userConfig = corsConfig === true || corsConfig === void 0 ? {} : corsConfig;
-			const userExposed = userConfig.exposedHeaders;
-			const exposedHeaders = [...MCP_REQUIRED_HEADERS, ...Array.isArray(userExposed) ? userExposed : userExposed ? [userExposed] : []];
-			app.use(cors({
-				origin: "*",
-				...userConfig,
-				exposedHeaders
-			}));
-		}
-		if (auth?.authorizationServers?.length && auth.resourceUrl) app.get("/.well-known/oauth-protected-resource", (_req, res) => {
-			const metadata = generateProtectedResourceMetadata(auth.resourceUrl, auth.authorizationServers);
-			res.json(metadata);
+//#endregion
+//#region src/adapter/http.ts
+/**
+* Build a fully-wired Express app that exposes the MCP Streamable HTTP
+* transport (plus OAuth / sideload / well-known routes when configured).
+*
+* Pass the resulting `app` to `app.listen(port, host)` yourself, or use the
+* top-level `startMcpServer()` / `http()` adapter conveniences.
+*/
+function buildMcpExpressApp(silkweaveOptions, context, actions, options) {
+	const { host, auth, cors: corsConfig, sideloadResources = true, resourceDir, ...mcpAppOptions } = options;
+	const app = createMcpExpressApp({
+		...mcpAppOptions,
+		host
+	});
+	const corsHandler = mcpCors(corsConfig ?? true);
+	if (corsHandler) app.use(corsHandler);
+	if (auth?.authorizationServers?.length && auth.resourceUrl) app.get("/.well-known/oauth-protected-resource", protectedResourceMetadata(auth));
+	let oauthPaths = /* @__PURE__ */ new Set();
+	if (auth?.provider) {
+		const oauth = oauthRoutes(auth);
+		app.get("/.well-known/oauth-authorization-server", oauth.wellKnownAuthServer);
+		app.get("/authorize", oauth.authorize);
+		app.get(oauth.callbackPath, oauth.callback);
+		app.post("/token", ...oauth.token);
+		app.post("/register", ...oauth.register);
+		oauthPaths = new Set([
+			"/.well-known/oauth-authorization-server",
+			"/authorize",
+			oauth.callbackPath,
+			"/token",
+			"/register"
+		]);
+	}
+	if (auth) {
+		const guard = authMiddleware(auth, context);
+		app.use((req, res, next) => {
+			if (req.path.startsWith("/.well-known/") || oauthPaths.has(req.path)) return next();
+			return guard(req, res, next);
 		});
-		const oauthPaths = auth?.provider ? mountOAuthRoutes(app, auth) : /* @__PURE__ */ new Set();
-		if (auth) mountAuthMiddleware(app, auth, oauthPaths, context);
-		const transports = {};
-		let mountedActions = [];
-		app.get("/resource/:id", async (req, res) => {
-			const id = req.params.id;
-			if (!id || typeof id !== "string") throw new Error("Invalid ID");
-			const resourceMeta = JSON.parse(await readFile(`resources/${id}.json`, "utf-8"));
-			const buffer = await readFile(`resources/${id}`);
-			res.status(200);
-			res.header("Content-Type", resourceMeta.contentType);
-			res.send(buffer);
+	}
+	if (sideloadResources) app.get("/resource/:id", sideloadResource({ resourceDir }));
+	const transport = mcpTransport(silkweaveOptions, context, actions);
+	app.post("/mcp", express.json(), transport.post);
+	app.get("/mcp", transport.stream);
+	app.delete("/mcp", transport.stream);
+	app.get("/mcp/resource/:id", transport.stream);
+	return app;
+}
+/**
+* Spin up a standalone MCP Streamable HTTP server on `host:port` for the
+* given `actions`. Returns the underlying `Server` so callers can close it.
+*
+* Convenience for use cases that don't go through the `silkweave()` builder.
+*/
+async function startMcpServer(silkweaveOptions, actions, options, context) {
+	const app = buildMcpExpressApp(silkweaveOptions, context ?? createContext({ adapter: "http" }), actions, options);
+	return new Promise((resolve, reject) => {
+		const server = app.listen(options.port, options.host, (error) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			console.log(`MCP Streamable HTTP Server listening on http://${options.host}:${options.port}/mcp`);
+			resolve(server);
 		});
-		mountMcpTransport(app, transports, () => createMcpServer(options, mountedActions, context));
+	});
+}
+/**
+* Silkweave adapter that owns its own HTTP server. Composes the MCP handler
+* primitives into a fully-wired Express app and listens on `host:port`.
+*/
+const http = (options) => {
+	return (silkweaveOptions, baseContext) => {
+		const context = baseContext.fork({ adapter: "http" });
 		let httpServer;
 		return {
 			context,
 			start: async (actions) => {
-				mountedActions = actions;
-				httpServer = app.listen(port, host, (error) => {
-					if (error) {
-						console.error("Failed to start server:", error);
-						process.exit(1);
-					}
-					console.log(`MCP Streamable HTTP Server listening on http://${host}:${port}/mcp`);
+				const app = buildMcpExpressApp(silkweaveOptions, context, actions, options);
+				httpServer = await new Promise((resolve, reject) => {
+					const s = app.listen(options.port, options.host, (error) => {
+						if (error) {
+							reject(error);
+							return;
+						}
+						console.log(`MCP Streamable HTTP Server listening on http://${options.host}:${options.port}/mcp`);
+						resolve(s);
+					});
 				});
 			},
 			stop: async () => {
-				if (httpServer) await new Promise((resolve, reject) => {
-					return httpServer.close((err) => {
-						if (err) reject(err);
-						else resolve();
-					});
+				if (!httpServer) return;
+				await new Promise((resolve, reject) => {
+					httpServer.close((err) => err ? reject(err) : resolve());
 				});
 				httpServer = void 0;
 			}
@@ -455,7 +614,24 @@ function registerTools(server, actions, context) {
 			logger,
 			extra
 		});
-		return action.run(input, actionContext).then((result) => action.toolResult?.(result, actionContext) ?? smartToolResult(result)).catch(handleToolError);
+		const progressToken = extra._meta?.progressToken;
+		try {
+			let result;
+			if (isStreamingAction(action)) result = await runStreamingAction(action, input, actionContext, progressToken ? async (chunk, index) => {
+				await extra.sendNotification({
+					method: "notifications/progress",
+					params: {
+						progressToken,
+						progress: index + 1,
+						message: JSON.stringify(chunk)
+					}
+				});
+			} : void 0);
+			else result = await action.run(input, actionContext);
+			return action.toolResult?.(result, actionContext) ?? smartToolResult(result);
+		} catch (error) {
+			return handleToolError(error);
+		}
 	});
 }
 const stdio = () => {
@@ -496,6 +672,6 @@ async function createSideloadResource(buffer, { name, contentType }) {
 	return resource;
 }
 //#endregion
-export { cliProxy, createSideloadResource, errorToolResult, handleToolError, http, jsonToolResult, parseResourceMessage, smartToolResult, stdio };
+export { MCP_REQUIRED_HEADERS, authMiddleware, authStorage, buildMcpExpressApp, cliProxy, createSideloadResource, errorToolResult, handleToolError, http, jsonToolResult, mcpCors, mcpTransport, oauthRoutes, parseResourceMessage, protectedResourceMetadata, sideloadResource, smartToolResult, startMcpServer, stdio };
 
 //# sourceMappingURL=index.mjs.map