@silkweave/mcp 1.4.0 → 1.5.0

package/.turbo/turbo-build.log

@@ -1,18 +1,17 @@
 
 
-> @silkweave/mcp@1.3.2 build /Users/atomic/projects/ai/silkweave/packages/mcp
-> tsup
+> @silkweave/mcp@1.4.1 build /Users/atomic/projects/ai/silkweave/packages/mcp
+> tsdown
 
-CLI Building entry: src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.5.1
-CLI Using tsup config: /Users/atomic/projects/ai/silkweave/packages/mcp/tsup.config.ts
-CLI Target: es2022
-CLI Cleaning output folder
-ESM Build start
-ESM build/index.js     16.40 KB
-ESM build/index.js.map 30.34 KB
-ESM ⚡️ Build success in 9ms
-DTS Build start
-DTS ⚡️ Build success in 711ms
-DTS build/index.d.ts 1.34 KB
+ℹ tsdown v0.21.8 powered by rolldown v1.0.0-rc.15
+ℹ config file: /Users/atomic/projects/ai/silkweave/packages/mcp/tsdown.config.ts 
+ℹ entry: src/index.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ Cleaning 4 files
+ℹ build/index.mjs        15.25 kB │ gzip: 4.33 kB
+ℹ build/index.mjs.map    28.57 kB │ gzip: 7.76 kB
+ℹ build/index.d.mts.map   0.77 kB │ gzip: 0.38 kB
+ℹ build/index.d.mts       1.62 kB │ gzip: 0.60 kB
+ℹ 4 files, total: 46.22 kB
+✔ Build complete in 797ms

package/.turbo/turbo-check.log

@@ -1,12 +1,13 @@
-
-> @silkweave/mcp@1.3.2 check /Users/atomic/projects/ai/silkweave/packages/mcp
-> pnpm lint && pnpm typecheck
-
-
-> @silkweave/mcp@1.3.2 lint /Users/atomic/projects/ai/silkweave/packages/mcp
-> eslint
-
-
-> @silkweave/mcp@1.3.2 typecheck /Users/atomic/projects/ai/silkweave/packages/mcp
-> tsc --noEmit
-
+
+
+> @silkweave/mcp@1.4.1 check /Users/atomic/projects/ai/silkweave/packages/mcp
+> pnpm lint && pnpm typecheck
+
+
+> @silkweave/mcp@1.4.1 lint /Users/atomic/projects/ai/silkweave/packages/mcp
+> eslint
+
+
+> @silkweave/mcp@1.4.1 typecheck /Users/atomic/projects/ai/silkweave/packages/mcp
+> tsc --noEmit
+

package/.turbo/turbo-lint.log

@@ -1,5 +1,5 @@
 
 
-> @silkweave/mcp@1.3.2 lint /Users/atomic/projects/ai/silkweave/packages/mcp
+> @silkweave/mcp@1.4.1 lint /Users/atomic/projects/ai/silkweave/packages/mcp
 > eslint
 

package/.turbo/turbo-prepack.log

@@ -1,26 +1,24 @@
 
 
-> @silkweave/mcp@1.4.0 prepack /Users/atomic/projects/ai/silkweave/packages/mcp
+> @silkweave/mcp@1.5.0 prepack /Users/atomic/projects/ai/silkweave/packages/mcp
 > pnpm clean && pnpm build
 
 
-> @silkweave/mcp@1.4.0 clean /Users/atomic/projects/ai/silkweave/packages/mcp
+> @silkweave/mcp@1.5.0 clean /Users/atomic/projects/ai/silkweave/packages/mcp
 > rimraf build
 
 
-> @silkweave/mcp@1.4.0 build /Users/atomic/projects/ai/silkweave/packages/mcp
-> tsup
+> @silkweave/mcp@1.5.0 build /Users/atomic/projects/ai/silkweave/packages/mcp
+> tsdown
 
-CLI Building entry: src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.5.1
-CLI Using tsup config: /Users/atomic/projects/ai/silkweave/packages/mcp/tsup.config.ts
-CLI Target: es2022
-CLI Cleaning output folder
-ESM Build start
-ESM build/index.js     16.40 KB
-ESM build/index.js.map 30.34 KB
-ESM ⚡️ Build success in 8ms
-DTS Build start
-DTS ⚡️ Build success in 728ms
-DTS build/index.d.ts 1.34 KB
+ℹ tsdown v0.21.8 powered by rolldown v1.0.0-rc.15
+ℹ config file: /Users/atomic/projects/ai/silkweave/packages/mcp/tsdown.config.ts 
+ℹ entry: src/index.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ build/index.mjs        15.25 kB │ gzip: 4.33 kB
+ℹ build/index.mjs.map    28.57 kB │ gzip: 7.76 kB
+ℹ build/index.d.mts.map   0.77 kB │ gzip: 0.38 kB
+ℹ build/index.d.mts       1.62 kB │ gzip: 0.60 kB
+ℹ 4 files, total: 46.22 kB
+✔ Build complete in 598ms

package/build/index.d.mts

@@ -0,0 +1,46 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { AdapterFactory, SilkweaveError } from "@silkweave/core";
+import { CreateMcpExpressAppOptions } from "@modelcontextprotocol/sdk/server/express.js";
+import { AuthConfig } from "@silkweave/auth";
+
+//#region src/adapter/cliProxy.d.ts
+interface CliProxyOptions {
+  url: URL;
+}
+declare const cliProxy: AdapterFactory<CliProxyOptions>;
+//#endregion
+//#region src/adapter/http.d.ts
+interface HttpAdapterOptions extends CreateMcpExpressAppOptions {
+  host: string;
+  port: number;
+  auth?: AuthConfig;
+}
+declare const http: AdapterFactory<HttpAdapterOptions>;
+//#endregion
+//#region src/adapter/stdio.d.ts
+declare const stdio: AdapterFactory;
+//#endregion
+//#region src/util/result.d.ts
+declare function smartToolResult(data: string | object | object[]): CallToolResult;
+declare function jsonToolResult(data: object, isError?: boolean): CallToolResult;
+declare function errorToolResult({
+  code,
+  name,
+  message
+}: SilkweaveError): CallToolResult;
+declare function handleToolError(error: unknown): CallToolResult;
+//#endregion
+//#region src/util/sideload.d.ts
+interface SideloadResource {
+  id: string;
+  name: string;
+  contentType: string;
+  size: number;
+}
+declare function createSideloadResource(buffer: Buffer, {
+  name,
+  contentType
+}: Pick<SideloadResource, 'name' | 'contentType'>): Promise<SideloadResource>;
+//#endregion
+export { CliProxyOptions, HttpAdapterOptions, SideloadResource, cliProxy, createSideloadResource, errorToolResult, handleToolError, http, jsonToolResult, smartToolResult, stdio };
+//# sourceMappingURL=index.d.mts.map

package/build/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/adapter/cliProxy.ts","../src/adapter/http.ts","../src/adapter/stdio.ts","../src/util/result.ts","../src/util/sideload.ts"],"mappings":";;;;;;UAYiB,eAAA;EACf,GAAA,EAAK,GAAA;AAAA;AAAA,cA4DM,QAAA,EAAU,cAAA,CAAe,eAAA;;;UCrDrB,kBAAA,SAA2B,0BAAA;EAC1C,IAAA;EACA,IAAA;EACA,IAAA,GAAO,UAAA;AAAA;AAAA,cAqLI,IAAA,EAAM,cAAA,CAAe,kBAAA;;;cCzKrB,KAAA,EAAO,cAAA;;;iBC/BJ,eAAA,CAAgB,IAAA,+BAAmC,cAAA;AAAA,iBAqBnD,cAAA,CAAe,IAAA,UAAc,OAAA,aAAkB,cAAA;AAAA,iBAM/C,eAAA,CAAA;EAAkB,IAAA;EAAM,IAAA;EAAM;AAAA,GAAW,cAAA,GAAiB,cAAA;AAAA,iBAU1D,eAAA,CAAgB,KAAA,YAAiB,cAAA;;;UCtChC,gBAAA;EACf,EAAA;EACA,IAAA;EACA,WAAA;EACA,IAAA;AAAA;AAAA,iBAGoB,sBAAA,CAAuB,MAAA,EAAQ,MAAA;EAAU,IAAA;EAAM;AAAA,GAAe,IAAA,CAAK,gBAAA,4BAAyC,OAAA,CAAA,gBAAA"}

package/build/index.mjs

@@ -0,0 +1,475 @@
+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";
+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 { generateProtectedResourceMetadata, validateToken } from "@silkweave/auth";
+import cors from "cors";
+import express from "express";
+import { readFile, writeFile } from "fs/promises";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID as randomUUID$1 } from "node:crypto";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+//#region src/adapter/cliProxy.ts
+function addCliOption(command, key, type, defaultValue) {
+	const description = type.description;
+	const flag = kebabCase(key);
+	if (type instanceof z.ZodBoolean) {
+		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}`);
+}
+function registerProxyCommand(program, client, tool, options) {
+	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);
+	}
+	command.action(async (args) => {
+		const { silent } = program.opts();
+		const logger = createCLILogger();
+		if (!silent) {
+			intro(`${options.name} - ${tool.name}`);
+			client.setNotificationHandler(LoggingMessageNotificationSchema, ({ params: { level, data } }) => {
+				logger[level](data);
+			});
+			client.setNotificationHandler(ProgressNotificationSchema, ({ params: { progress, total, message } }) => {
+				logger.info({
+					progress,
+					total,
+					message
+				});
+			});
+		}
+		const input = await schema.parseAsync(args);
+		const response = await client.callTool({
+			name: tool.name,
+			arguments: input,
+			_meta: { progressToken: randomUUID() }
+		});
+		process.stdout.write(JSON.stringify(response));
+	});
+}
+const cliProxy = ({ url }) => {
+	return (options, baseContext) => {
+		const context = baseContext.fork({ adapter: "cliProxy" });
+		const program = new Command().name(options.name).description(options.description).version(options.version).option("-s, --silent", "Silent mode, prevent log messages", false);
+		return {
+			context,
+			start: async () => {
+				const client = new Client({
+					name: options.name,
+					description: options.description,
+					version: options.version
+				});
+				const transport = new StreamableHTTPClientTransport(url);
+				await client.connect(transport);
+				const { tools } = await client.listTools();
+				for (const tool of tools) registerProxyCommand(program, client, tool, options);
+				await program.parseAsync();
+				await transport.close();
+			},
+			stop: async () => {}
+		};
+	};
+};
+//#endregion
+//#region src/util/result.ts
+function smartToolResult(data) {
+	const text = typeof data === "string" ? data : JSON.stringify(data);
+	const mimeType = typeof data === "string" ? "text/plain" : "application/json";
+	const ext = typeof data === "string" ? "txt" : "json";
+	if (text.length > 4096) {
+		const uri = `mcp://toolResult/${randomUUID$1()}.${ext}`;
+		const buffer = Buffer.from(text);
+		const blob = buffer.toString("base64");
+		return { content: [{
+			type: "text",
+			text: `Received resource ${uri} with ${buffer.byteLength} bytes`
+		}, {
+			type: "resource",
+			resource: {
+				uri,
+				mimeType,
+				blob
+			}
+		}] };
+	} else return { content: [{
+		type: "text",
+		text
+	}] };
+}
+function jsonToolResult(data, isError = false) {
+	const result = { content: [{
+		type: "text",
+		text: JSON.stringify(data)
+	}] };
+	if (isError) result.isError = true;
+	return result;
+}
+function errorToolResult({ code, name, message }) {
+	return {
+		isError: true,
+		content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				code,
+				name,
+				message
+			})
+		}]
+	};
+}
+function handleToolError(error) {
+	if (error instanceof SilkweaveError) return jsonToolResult({
+		success: false,
+		name: error.name,
+		message: error.message,
+		code: error.code
+	}, true);
+	else if (error instanceof Error) return jsonToolResult({
+		success: false,
+		name: error.name,
+		message: error.message,
+		stack: error.stack
+	}, true);
+	else return jsonToolResult({
+		success: false,
+		name: "Unknown error",
+		message: "An unknown error occurred",
+		error
+	}, true);
+}
+//#endregion
+//#region src/adapter/http.ts
+const authStorage = new AsyncLocalStorage();
+function mountOAuthRoutes(app, auth) {
+	const provider = auth.provider;
+	const callbackPath = auth.callbackPath ?? "/auth/callback";
+	const toOAuthReq = (req) => ({
+		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 registerTools$1(server, actions, context) {
+	for (const action of actions) server.registerTool(pascalCase(action.name), {
+		title: capitalCase(action.name),
+		description: action.description,
+		inputSchema: action.input
+	}, async (input, extra) => {
+		const logger = createLogger({
+			stream: process.stderr,
+			onLog: (level, data) => {
+				extra.sendNotification({
+					method: "notifications/message",
+					params: {
+						level,
+						data
+					}
+				});
+			},
+			onProgress: ({ progress, total, message }) => {
+				if (!extra._meta?.progressToken) return;
+				extra.sendNotification({
+					method: "notifications/progress",
+					params: {
+						progress,
+						total,
+						message,
+						progressToken: extra._meta.progressToken
+					}
+				});
+			}
+		});
+		const currentAuth = authStorage.getStore();
+		const actionContext = context.fork({
+			logger,
+			extra,
+			...currentAuth ? { auth: currentAuth } : {}
+		});
+		return action.run(input, actionContext).then((result) => {
+			return action.toolResult?.(result, actionContext) ?? smartToolResult(result);
+		}).catch(handleToolError);
+	});
+}
+function createMcpServer(options, actions, context) {
+	const server = new McpServer({
+		name: options.name,
+		description: options.description,
+		version: options.version
+	}, { capabilities: {
+		tools: {},
+		logging: {}
+	} });
+	registerTools$1(server, actions, context);
+	return server;
+}
+function createSessionTransport(transports) {
+	const transport = new StreamableHTTPServerTransport({
+		sessionIdGenerator: () => randomUUID(),
+		enableJsonResponse: false,
+		eventStore: new InMemoryEventStore(),
+		onsessioninitialized: (sId) => {
+			console.log(`Session initialized with ID: ${sId}`);
+			transports[sId] = transport;
+		}
+	});
+	transport.onerror = (error) => {
+		console.error(error);
+	};
+	transport.onclose = () => {
+		const sid = transport.sessionId;
+		if (sid && transports[sid]) {
+			console.log(`Transport closed for session ${sid}, removing from transports map`);
+			delete transports[sid];
+		}
+	};
+	return transport;
+}
+function mountMcpTransport(app, transports, createServer) {
+	app.post("/mcp", async (req, res) => {
+		const sessionId = req.headers["mcp-session-id"];
+		try {
+			if (sessionId && transports[sessionId]) {
+				await transports[sessionId].handleRequest(req, res, req.body);
+				return;
+			}
+			if (!isInitializeRequest(req.body)) {
+				res.status(404).json({
+					jsonrpc: "2.0",
+					error: {
+						code: -32e3,
+						message: "Session not found"
+					},
+					id: null
+				});
+				return;
+			}
+			const transport = createSessionTransport(transports);
+			await createServer().connect(transport);
+			await transport.handleRequest(req, res, req.body);
+		} catch (error) {
+			console.error("Error handling MCP request:", error);
+			if (!res.headersSent) res.status(500).json({
+				jsonrpc: "2.0",
+				error: {
+					code: -32603,
+					message: "Internal server error"
+				},
+				id: null
+			});
+		}
+	});
+	const handleSessionStream = async (req, res) => {
+		const sessionId = req.headers["mcp-session-id"];
+		if (!sessionId || !transports[sessionId]) {
+			res.status(400).send("Invalid or missing session ID");
+			return;
+		}
+		await transports[sessionId].handleRequest(req, res);
+	};
+	app.get("/mcp", handleSessionStream);
+	app.delete("/mcp", handleSessionStream);
+	app.get("/mcp/resource/:id", handleSessionStream);
+}
+const http = ({ host, port, auth, ...mcpOptions }) => {
+	return (options, baseContext) => {
+		const context = baseContext.fork({ adapter: "http" });
+		const app = createMcpExpressApp({
+			...mcpOptions,
+			host
+		});
+		app.use(cors({
+			exposedHeaders: [
+				"WWW-Authenticate",
+				"Mcp-Session-Id",
+				"Last-Event-Id",
+				"Mcp-Protocol-Version"
+			],
+			origin: "*"
+		}));
+		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);
+		});
+		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);
+		});
+		mountMcpTransport(app, transports, () => createMcpServer(options, mountedActions, context));
+		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`);
+				});
+			},
+			stop: async () => {
+				if (httpServer) await new Promise((resolve, reject) => {
+					return httpServer.close((err) => {
+						if (err) reject(err);
+						else resolve();
+					});
+				});
+				httpServer = void 0;
+			}
+		};
+	};
+};
+//#endregion
+//#region src/adapter/stdio.ts
+function registerTools(server, actions, context) {
+	for (const action of actions) server.registerTool(pascalCase(action.name), {
+		title: capitalCase(action.name),
+		description: action.description,
+		inputSchema: action.input
+	}, async (input, extra) => {
+		const logger = createLogger({
+			stream: false,
+			onLog: (level, data) => {
+				extra.sendNotification({
+					method: "notifications/message",
+					params: {
+						level,
+						data
+					}
+				});
+			},
+			onProgress: ({ progress, total, message }) => {
+				if (!extra._meta?.progressToken) return;
+				extra.sendNotification({
+					method: "notifications/progress",
+					params: {
+						progress,
+						total,
+						message,
+						progressToken: extra._meta.progressToken
+					}
+				});
+			}
+		});
+		const actionContext = context.fork({
+			logger,
+			extra
+		});
+		return action.run(input, actionContext).then((result) => action.toolResult?.(result, actionContext) ?? smartToolResult(result)).catch(handleToolError);
+	});
+}
+const stdio = () => {
+	return (options, baseContext) => {
+		const context = baseContext.fork({ adapter: "stdio" });
+		const server = new McpServer({
+			name: options.name,
+			description: options.description,
+			version: options.version
+		}, { capabilities: {
+			tools: {},
+			logging: {}
+		} });
+		return {
+			context,
+			start: async (actions) => {
+				registerTools(server, actions, context);
+				const transport = new StdioServerTransport();
+				await server.connect(transport);
+			},
+			stop: async () => {
+				await server?.close();
+			}
+		};
+	};
+};
+//#endregion
+//#region src/util/sideload.ts
+async function createSideloadResource(buffer, { name, contentType }) {
+	const id = randomUUID();
+	const resource = {
+		id,
+		name,
+		contentType,
+		size: buffer.length
+	};
+	await Promise.all([writeFile(`resources/${id}`, buffer), writeFile(`resources/${id}.json`, JSON.stringify(resource), "utf-8")]);
+	return resource;
+}
+//#endregion
+export { cliProxy, createSideloadResource, errorToolResult, handleToolError, http, jsonToolResult, smartToolResult, stdio };
+
+//# sourceMappingURL=index.mjs.map