@lovable.dev/mcp-js 0.27.1 → 0.29.0-rc.0

package/dist/mcp-ECo1Ixk8.cjs

@@ -1,153 +0,0 @@
-const require_logger = require("./logger-BkMMCFTv.cjs");
-const require_errors = require("./errors-CN6Da8iz.cjs");
-const require_authorize = require("./authorize-CB35c3Wg.cjs");
-const require_content = require("./content-NCYIGgOb.cjs");
-const require_gate = require("./gate-B9RSzvoI.cjs");
-let _modelcontextprotocol_sdk_server_mcp_js = require("@modelcontextprotocol/sdk/server/mcp.js");
-let _modelcontextprotocol_sdk_server_webStandardStreamableHttp_js = require("@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js");
-//#region src/protocols/mcp/protocol.ts
-function statelessMethodNotAllowed(allow) {
-	return Response.json({
-		jsonrpc: "2.0",
-		id: null,
-		error: {
-			code: -32e3,
-			message: "Method not allowed: stateless server offers no standalone SSE stream (GET) or session (DELETE)."
-		}
-	}, {
-		status: 405,
-		headers: { Allow: allow }
-	});
-}
-/**
-* Adapt a Lovable tool to the SDK's tool callback. The boundary cast bridges
-* our SDK-decoupled content-block types to the SDK's; they match structurally.
-*/
-function adaptToolToSdkCallback(tool, auth, recorder) {
-	const endUserId = auth?.principal.sub;
-	return (async (first) => {
-		const args = tool.inputSchema ? first ?? {} : {};
-		const start = require_authorize.nowMs();
-		let result;
-		try {
-			result = await tool.handler(args, new require_errors.ToolContext(auth));
-		} catch (err) {
-			const callerMessage = require_errors.resolveToolErrorMessage(err);
-			if (callerMessage === void 0) {
-				await recorder.emit({
-					tool: tool.name,
-					method: "tools/call",
-					outcome: "handler_error",
-					durationMs: require_authorize.nowMs() - start,
-					errorText: require_errors.errorSummary(err),
-					endUserId
-				});
-				return {
-					content: [{
-						type: "text",
-						text: "tool execution failed"
-					}],
-					isError: true
-				};
-			}
-			result = {
-				content: [{
-					type: "text",
-					text: callerMessage
-				}],
-				isError: true
-			};
-		}
-		if (result == null) {
-			await recorder.emit({
-				tool: tool.name,
-				method: "tools/call",
-				outcome: "handler_error",
-				durationMs: require_authorize.nowMs() - start,
-				endUserId
-			});
-			return {
-				content: [{
-					type: "text",
-					text: `tool "${tool.name}" returned no result`
-				}],
-				isError: true
-			};
-		}
-		await recorder.emit({
-			tool: tool.name,
-			method: "tools/call",
-			outcome: result.isError ? "tool_error" : "ok",
-			durationMs: require_authorize.nowMs() - start,
-			errorText: result.isError ? require_content.extractTextContent(result.content) : void 0,
-			endUserId
-		});
-		return {
-			content: result.content ?? [],
-			structuredContent: result.structuredContent,
-			isError: result.isError
-		};
-	});
-}
-/**
-* Build a Web-Standard request handler that serves the MCP protocol over
-* streamable HTTP. A fresh `McpServer` + transport is constructed per
-* request — the transport is stateless, so this is cheap and there is no
-* cross-request state to leak. The per-request `recorder` is supplied by the
-* caller (the stack handler) so telemetry reads the runtime env in-flight.
-*/
-function createMcpProtocolHandler(mcp, options = {}) {
-	const authorizer = require_authorize.createRequestAuthorizer(mcp, options);
-	const handle = async (request, authResult, recorder) => {
-		try {
-			const server = new _modelcontextprotocol_sdk_server_mcp_js.McpServer({
-				name: mcp.name,
-				version: mcp.version,
-				title: mcp.title
-			}, { instructions: mcp.instructions });
-			for (const tool of mcp.tools) server.registerTool(tool.name, {
-				title: tool.title,
-				description: tool.description,
-				inputSchema: tool.inputSchema,
-				outputSchema: tool.outputSchema,
-				annotations: tool.annotations
-			}, adaptToolToSdkCallback(tool, authResult.auth, recorder));
-			const transport = new _modelcontextprotocol_sdk_server_webStandardStreamableHttp_js.WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
-			await server.connect(transport);
-			return await transport.handleRequest(request);
-		} catch (err) {
-			await recorder.emit({
-				tool: null,
-				method: "transport",
-				outcome: "transport_error",
-				durationMs: 0,
-				endUserId: authResult.auth?.principal.sub
-			});
-			require_logger.log.error("mcp.transport_error", {
-				...require_logger.describeError(err),
-				outcome: "500 internal error"
-			});
-			return Response.json({
-				jsonrpc: "2.0",
-				id: null,
-				error: {
-					code: -32603,
-					message: "internal error"
-				}
-			}, { status: 500 });
-		}
-	};
-	return require_gate.createGatedHandler({
-		authorizer,
-		methods: ["POST"],
-		methodNotAllowed: statelessMethodNotAllowed,
-		handle
-	});
-}
-//#endregion
-Object.defineProperty(exports, "createMcpProtocolHandler", {
-	enumerable: true,
-	get: function() {
-		return createMcpProtocolHandler;
-	}
-});