@lovable.dev/mcp-js 0.30.0-rc.0 → 1.0.0

package/dist/forwarded-Bhwcj22u.cjs

@@ -0,0 +1,48 @@
+//#region src/core/forwarded.ts
+/**
+* Rewrites a request's URL to the public origin a reverse proxy forwards via
+* `X-Forwarded-*`, so SDK-derived OAuth `resource`/metadata/`WWW-Authenticate`
+* URLs name the host the client actually connected to — not the internal
+* backend origin the proxy rewrites `Host` to. Without this, an app on a custom
+* domain advertises its internal `*.lovable.dev`/`*.supabase.co` host and every
+* MCP call 401s on an audience the client can't satisfy.
+*
+* Each header is trusted independently, because a forwarded value is only as
+* trustworthy as the proxy that sets it:
+* - `X-Forwarded-Host` can redirect the advertised resource to an attacker
+*   origin (the threat `auth/resource.ts` guards against), so it is honored only
+*   when `trustForwardedHost` is set — enabled on emit paths that sit behind a
+*   proxy which *overwrites* the header (Lovable's web-proxy does), never by a
+*   bare SDK consumer.
+* - `X-Forwarded-Proto` only selects http/https, so it is gated separately:
+*   Supabase terminates TLS upstream and forwards over http with a
+*   gateway-stamped proto, so that stack always trusts it; the TanStack proxy
+*   does not sanitize proto, so its Vite plugin never emits the flag.
+*/
+function applyForwardedOrigin(request, options) {
+	const proto = options.trustForwardedProto ? firstForwardedValue(request, "x-forwarded-proto") : void 0;
+	const host = options.trustForwardedHost ? firstForwardedValue(request, "x-forwarded-host") : void 0;
+	if (proto === void 0 && host === void 0) return request;
+	const url = new URL(request.url);
+	let changed = false;
+	if (proto !== void 0 && `${proto}:` !== url.protocol) {
+		url.protocol = `${proto}:`;
+		changed = true;
+	}
+	if (host !== void 0 && host !== url.host) {
+		url.host = host;
+		changed = true;
+	}
+	return changed ? new Request(url.href, request) : request;
+}
+function firstForwardedValue(request, header) {
+	const value = request.headers.get(header)?.split(",")[0]?.trim();
+	return value ? value : void 0;
+}
+//#endregion
+Object.defineProperty(exports, "applyForwardedOrigin", {
+	enumerable: true,
+	get: function() {
+		return applyForwardedOrigin;
+	}
+});

package/dist/forwarded-BlLF3dfc.js

@@ -0,0 +1,43 @@
+//#region src/core/forwarded.ts
+/**
+* Rewrites a request's URL to the public origin a reverse proxy forwards via
+* `X-Forwarded-*`, so SDK-derived OAuth `resource`/metadata/`WWW-Authenticate`
+* URLs name the host the client actually connected to — not the internal
+* backend origin the proxy rewrites `Host` to. Without this, an app on a custom
+* domain advertises its internal `*.lovable.dev`/`*.supabase.co` host and every
+* MCP call 401s on an audience the client can't satisfy.
+*
+* Each header is trusted independently, because a forwarded value is only as
+* trustworthy as the proxy that sets it:
+* - `X-Forwarded-Host` can redirect the advertised resource to an attacker
+*   origin (the threat `auth/resource.ts` guards against), so it is honored only
+*   when `trustForwardedHost` is set — enabled on emit paths that sit behind a
+*   proxy which *overwrites* the header (Lovable's web-proxy does), never by a
+*   bare SDK consumer.
+* - `X-Forwarded-Proto` only selects http/https, so it is gated separately:
+*   Supabase terminates TLS upstream and forwards over http with a
+*   gateway-stamped proto, so that stack always trusts it; the TanStack proxy
+*   does not sanitize proto, so its Vite plugin never emits the flag.
+*/
+function applyForwardedOrigin(request, options) {
+	const proto = options.trustForwardedProto ? firstForwardedValue(request, "x-forwarded-proto") : void 0;
+	const host = options.trustForwardedHost ? firstForwardedValue(request, "x-forwarded-host") : void 0;
+	if (proto === void 0 && host === void 0) return request;
+	const url = new URL(request.url);
+	let changed = false;
+	if (proto !== void 0 && `${proto}:` !== url.protocol) {
+		url.protocol = `${proto}:`;
+		changed = true;
+	}
+	if (host !== void 0 && host !== url.host) {
+		url.host = host;
+		changed = true;
+	}
+	return changed ? new Request(url.href, request) : request;
+}
+function firstForwardedValue(request, header) {
+	const value = request.headers.get(header)?.split(",")[0]?.trim();
+	return value ? value : void 0;
+}
+//#endregion
+export { applyForwardedOrigin as t };

package/dist/index.cjs

@@ -1,7 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_logger = require("./logger-CN1q-KNn.cjs");
-const require_schema = require("./schema-D3vClxb7.cjs");
-const require_errors = require("./errors-Cr95rSkB.cjs");
+const require_errors = require("./errors-CN6Da8iz.cjs");
 //#region src/core/define.ts
 function assertUniqueNames(mcp) {
 	const seen = /* @__PURE__ */ new Set();
@@ -80,39 +79,6 @@ function freezeAuth(auth) {
 	if (auth.accessTokenTyp) Object.freeze(auth.accessTokenTyp);
 	Object.freeze(auth);
 }
-function assertAllowedOrigins(allowedOrigins) {
-	if (allowedOrigins === void 0 || allowedOrigins === "any") return;
-	if (!Array.isArray(allowedOrigins)) throw new Error(`@lovable.dev/mcp-js: allowedOrigins must be "any" or an array of exact origins`);
-	for (const origin of allowedOrigins) {
-		if (typeof origin !== "string") throw new Error(`@lovable.dev/mcp-js: allowedOrigins must contain strings`);
-		let parsed;
-		try {
-			parsed = new URL(origin);
-		} catch {
-			throw new Error(`@lovable.dev/mcp-js: allowedOrigins must contain valid exact origins`);
-		}
-		if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.origin !== origin) throw new Error(`@lovable.dev/mcp-js: allowedOrigins entry "${origin}" must be an exact http(s) origin without a path, query, fragment, or trailing slash`);
-	}
-}
-function assertToolSchemas(mcp) {
-	for (const tool of mcp.tools) for (const [name, definition, strategy] of [[
-		"inputSchema",
-		tool.inputSchema,
-		"input"
-	], [
-		"outputSchema",
-		tool.outputSchema,
-		"output"
-	]]) {
-		if (!definition) continue;
-		try {
-			require_schema.jsonSchemaFromDefinition(definition, strategy);
-		} catch (error) {
-			const detail = error instanceof Error ? `: ${error.message}` : "";
-			throw new Error(`@lovable.dev/mcp-js: tool "${tool.name}" ${name} cannot be represented as JSON Schema${detail}`);
-		}
-	}
-}
 /**
 * Declare a single MCP tool. Import the result into your MCP definition's
 * `tools` array — `defineMcp({ tools: [echoTool, ...] })`.
@@ -135,11 +101,8 @@ function defineMcp(def) {
 	assertNonEmptyString("version", def.version);
 	assertUniqueNames(def);
 	if (def.auth) assertOAuthConfig(def.auth);
-	assertAllowedOrigins(def.allowedOrigins);
-	assertToolSchemas(def);
 	require_logger.resolveMetricsConfig(def.metrics);
 	freezeAuth(def.auth);
-	if (Array.isArray(def.allowedOrigins)) Object.freeze(def.allowedOrigins);
 	Object.freeze(def.tools);
 	for (const tool of def.tools) Object.freeze(tool);
 	return def;

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { A as McpAuthConfig, C as MetricsConfig, D as ProgressUpdate, E as McpProtocolEra, O as ToolContext, S as ZodSchema, T as McpClientInfo, _ as ToolContent, a as EmbeddedResource, b as ZodOutputSchema, c as JsonValue, d as McpDefinition, f as McpDefinitionInput, g as ToolAnnotations, h as TextContent, i as EmbeddedBlobResource, k as JwtClaims, l as JsonValueInput, m as ResourceLinkIcon, n as ContentAnnotations, o as EmbeddedTextResource, p as ResourceLink, r as ContentBlock, s as ImageContent, t as AudioContent, u as McpAllowedOrigins, v as ToolDefinition, w as MetricsOptions, x as ZodRawShape, y as ToolHandlerResult } from "./types-3CZPz364.cjs";
+import { C as McpAuthConfig, S as JwtClaims, _ as ZodRawShape, a as EmbeddedResource, b as MetricsOptions, c as McpDefinition, d as ResourceLinkIcon, f as TextContent, g as ToolHandlerResult, h as ToolDefinition, i as EmbeddedBlobResource, l as McpDefinitionInput, m as ToolContent, n as ContentAnnotations, o as EmbeddedTextResource, p as ToolAnnotations, r as ContentBlock, s as ImageContent, t as AudioContent, u as ResourceLink, v as ZodSchema, x as ToolContext, y as MetricsConfig } from "./types-C0Wgm9zp.cjs";
 //#region src/core/define.d.ts
 /**
  * Declare a single MCP tool. Import the result into your MCP definition's
@@ -8,7 +8,7 @@ import { A as McpAuthConfig, C as MetricsConfig, D as ProgressUpdate, E as McpPr
  * full `z.object(...)` — the MCP SDK builds the object wrapper internally
  * and the raw shape is what the JSON-RPC `tools/list` payload exposes.
  */
-declare function defineTool<TInput extends ZodRawShape | undefined = undefined, TOutput extends ZodOutputSchema | undefined = undefined>(def: ToolDefinition<TInput, TOutput>): ToolDefinition<TInput, TOutput>;
+declare function defineTool<TInput extends ZodRawShape | undefined = undefined, TOutput extends ZodRawShape | undefined = undefined>(def: ToolDefinition<TInput, TOutput>): ToolDefinition<TInput, TOutput>;
 /**
  * Declare the MCP server. `export default` the result from your MCP
  * entrypoint (default `lib/mcp/index.ts`); the Vite plugin reads it to
@@ -71,4 +71,4 @@ type LogLevel = "silent" | "error" | "warn" | "info" | "debug";
  */
 declare function setLogLevel(level: LogLevel): LogLevel;
 //#endregion
-export { type AudioContent, type ContentAnnotations, type ContentBlock, type EmbeddedBlobResource, type EmbeddedResource, type EmbeddedTextResource, type ImageContent, type IssuerOAuthOptions, type JsonValue, type JsonValueInput, type JwtClaims, type LogLevel, type McpAllowedOrigins, type McpClientInfo, type McpDefinitionInput, type McpProtocolEra, type MetricsConfig, type MetricsOptions, type ProgressUpdate, type ResourceLink, type ResourceLinkIcon, type TextContent, type ToolAnnotations, type ToolContent, ToolContext, type ToolDefinition, ToolError, type ToolHandlerResult, type ZodOutputSchema, type ZodRawShape, type ZodSchema, auth, defineMcp, defineTool, setLogLevel };
+export { type AudioContent, type ContentAnnotations, type ContentBlock, type EmbeddedBlobResource, type EmbeddedResource, type EmbeddedTextResource, type ImageContent, type IssuerOAuthOptions, type JwtClaims, type LogLevel, type McpDefinitionInput, type MetricsConfig, type MetricsOptions, type ResourceLink, type ResourceLinkIcon, type TextContent, type ToolAnnotations, type ToolContent, ToolContext, type ToolDefinition, ToolError, type ToolHandlerResult, type ZodRawShape, type ZodSchema, auth, defineMcp, defineTool, setLogLevel };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { A as McpAuthConfig, C as MetricsConfig, D as ProgressUpdate, E as McpProtocolEra, O as ToolContext, S as ZodSchema, T as McpClientInfo, _ as ToolContent, a as EmbeddedResource, b as ZodOutputSchema, c as JsonValue, d as McpDefinition, f as McpDefinitionInput, g as ToolAnnotations, h as TextContent, i as EmbeddedBlobResource, k as JwtClaims, l as JsonValueInput, m as ResourceLinkIcon, n as ContentAnnotations, o as EmbeddedTextResource, p as ResourceLink, r as ContentBlock, s as ImageContent, t as AudioContent, u as McpAllowedOrigins, v as ToolDefinition, w as MetricsOptions, x as ZodRawShape, y as ToolHandlerResult } from "./types-3CZPz364.js";
+import { C as McpAuthConfig, S as JwtClaims, _ as ZodRawShape, a as EmbeddedResource, b as MetricsOptions, c as McpDefinition, d as ResourceLinkIcon, f as TextContent, g as ToolHandlerResult, h as ToolDefinition, i as EmbeddedBlobResource, l as McpDefinitionInput, m as ToolContent, n as ContentAnnotations, o as EmbeddedTextResource, p as ToolAnnotations, r as ContentBlock, s as ImageContent, t as AudioContent, u as ResourceLink, v as ZodSchema, x as ToolContext, y as MetricsConfig } from "./types-C0Wgm9zp.js";
 //#region src/core/define.d.ts
 /**
  * Declare a single MCP tool. Import the result into your MCP definition's
@@ -8,7 +8,7 @@ import { A as McpAuthConfig, C as MetricsConfig, D as ProgressUpdate, E as McpPr
  * full `z.object(...)` — the MCP SDK builds the object wrapper internally
  * and the raw shape is what the JSON-RPC `tools/list` payload exposes.
  */
-declare function defineTool<TInput extends ZodRawShape | undefined = undefined, TOutput extends ZodOutputSchema | undefined = undefined>(def: ToolDefinition<TInput, TOutput>): ToolDefinition<TInput, TOutput>;
+declare function defineTool<TInput extends ZodRawShape | undefined = undefined, TOutput extends ZodRawShape | undefined = undefined>(def: ToolDefinition<TInput, TOutput>): ToolDefinition<TInput, TOutput>;
 /**
  * Declare the MCP server. `export default` the result from your MCP
  * entrypoint (default `lib/mcp/index.ts`); the Vite plugin reads it to
@@ -71,4 +71,4 @@ type LogLevel = "silent" | "error" | "warn" | "info" | "debug";
  */
 declare function setLogLevel(level: LogLevel): LogLevel;
 //#endregion
-export { type AudioContent, type ContentAnnotations, type ContentBlock, type EmbeddedBlobResource, type EmbeddedResource, type EmbeddedTextResource, type ImageContent, type IssuerOAuthOptions, type JsonValue, type JsonValueInput, type JwtClaims, type LogLevel, type McpAllowedOrigins, type McpClientInfo, type McpDefinitionInput, type McpProtocolEra, type MetricsConfig, type MetricsOptions, type ProgressUpdate, type ResourceLink, type ResourceLinkIcon, type TextContent, type ToolAnnotations, type ToolContent, ToolContext, type ToolDefinition, ToolError, type ToolHandlerResult, type ZodOutputSchema, type ZodRawShape, type ZodSchema, auth, defineMcp, defineTool, setLogLevel };
+export { type AudioContent, type ContentAnnotations, type ContentBlock, type EmbeddedBlobResource, type EmbeddedResource, type EmbeddedTextResource, type ImageContent, type IssuerOAuthOptions, type JwtClaims, type LogLevel, type McpDefinitionInput, type MetricsConfig, type MetricsOptions, type ResourceLink, type ResourceLinkIcon, type TextContent, type ToolAnnotations, type ToolContent, ToolContext, type ToolDefinition, ToolError, type ToolHandlerResult, type ZodRawShape, type ZodSchema, auth, defineMcp, defineTool, setLogLevel };

package/dist/index.js

@@ -1,6 +1,5 @@
 import { a as setLogLevel, o as parseSafeUrl, s as trimTrailingSlash, u as resolveMetricsConfig } from "./logger-Ctv5xUSD.js";
-import { t as jsonSchemaFromDefinition } from "./schema-CW1jKvio.js";
-import { i as ToolContext, t as ToolError } from "./errors-Bwd1L0Rf.js";
+import { i as ToolContext, t as ToolError } from "./errors-DSe96Ffd.js";
 //#region src/core/define.ts
 function assertUniqueNames(mcp) {
 	const seen = /* @__PURE__ */ new Set();
@@ -79,39 +78,6 @@ function freezeAuth(auth) {
 	if (auth.accessTokenTyp) Object.freeze(auth.accessTokenTyp);
 	Object.freeze(auth);
 }
-function assertAllowedOrigins(allowedOrigins) {
-	if (allowedOrigins === void 0 || allowedOrigins === "any") return;
-	if (!Array.isArray(allowedOrigins)) throw new Error(`@lovable.dev/mcp-js: allowedOrigins must be "any" or an array of exact origins`);
-	for (const origin of allowedOrigins) {
-		if (typeof origin !== "string") throw new Error(`@lovable.dev/mcp-js: allowedOrigins must contain strings`);
-		let parsed;
-		try {
-			parsed = new URL(origin);
-		} catch {
-			throw new Error(`@lovable.dev/mcp-js: allowedOrigins must contain valid exact origins`);
-		}
-		if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.origin !== origin) throw new Error(`@lovable.dev/mcp-js: allowedOrigins entry "${origin}" must be an exact http(s) origin without a path, query, fragment, or trailing slash`);
-	}
-}
-function assertToolSchemas(mcp) {
-	for (const tool of mcp.tools) for (const [name, definition, strategy] of [[
-		"inputSchema",
-		tool.inputSchema,
-		"input"
-	], [
-		"outputSchema",
-		tool.outputSchema,
-		"output"
-	]]) {
-		if (!definition) continue;
-		try {
-			jsonSchemaFromDefinition(definition, strategy);
-		} catch (error) {
-			const detail = error instanceof Error ? `: ${error.message}` : "";
-			throw new Error(`@lovable.dev/mcp-js: tool "${tool.name}" ${name} cannot be represented as JSON Schema${detail}`);
-		}
-	}
-}
 /**
 * Declare a single MCP tool. Import the result into your MCP definition's
 * `tools` array — `defineMcp({ tools: [echoTool, ...] })`.
@@ -134,11 +100,8 @@ function defineMcp(def) {
 	assertNonEmptyString("version", def.version);
 	assertUniqueNames(def);
 	if (def.auth) assertOAuthConfig(def.auth);
-	assertAllowedOrigins(def.allowedOrigins);
-	assertToolSchemas(def);
 	resolveMetricsConfig(def.metrics);
 	freezeAuth(def.auth);
-	if (Array.isArray(def.allowedOrigins)) Object.freeze(def.allowedOrigins);
 	Object.freeze(def.tools);
 	for (const tool of def.tools) Object.freeze(tool);
 	return def;

package/dist/{io-D_5cuaEL.d.ts → io-DP3icuxa.d.ts}

@@ -1,4 +1,4 @@
-import "./types-3CZPz364.js";
+import "./types-C0Wgm9zp.js";
 //#region src/manifest/io.d.ts
 /**
  * Shape every MCP Vite plugin exposes on its `api` so `runExtract` can read

package/dist/{io-CDV3mud0.d.cts → io-Dx0nPc1-.d.cts}

@@ -1,4 +1,4 @@
-import "./types-3CZPz364.cjs";
+import "./types-C0Wgm9zp.cjs";
 //#region src/manifest/io.d.ts
 /**
  * Shape every MCP Vite plugin exposes on its `api` so `runExtract` can read

package/dist/mcp-BDsG9I0t.js

@@ -0,0 +1,174 @@
+import { i as log, r as describeError } from "./logger-Ctv5xUSD.js";
+import { i as ToolContext, n as errorSummary, r as resolveToolErrorMessage } from "./errors-DSe96Ffd.js";
+import { c as nowMs, f as corsPreflightResponse, s as createNoopRecorder, t as createRequestAuthorizer, u as finalizeWireResponse } from "./authorize-9wHgaqeQ.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+//#region src/core/content.ts
+/** Join the text of a result's `type: "text"` blocks into one string, dropping
+*  binary/resource blocks. Used to surface a `tool_error` message in the local
+*  log; never sent over the telemetry wire. Returns undefined when there is no
+*  text to show. */
+function extractTextContent(content) {
+	if (!content) return void 0;
+	const text = content.filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
+	return text.length > 0 ? text : void 0;
+}
+//#endregion
+//#region src/protocols/gate.ts
+function createGatedHandler(gate) {
+	const allow = [...gate.methods, "OPTIONS"].join(", ");
+	const respond = async (request, recorder) => {
+		const authResult = await gate.authorizer.authorize(request, recorder);
+		if (!authResult.ok) return authResult.response;
+		if (!gate.methods.includes(request.method)) return gate.methodNotAllowed(allow);
+		return gate.handle(request, authResult, recorder);
+	};
+	return async (request, recorder = createNoopRecorder()) => {
+		if (request.method === "OPTIONS") return corsPreflightResponse(allow);
+		const final = finalizeWireResponse(request, await respond(request, recorder));
+		if (!final.headers.has("Cache-Control")) final.headers.set("Cache-Control", "no-store");
+		return final;
+	};
+}
+//#endregion
+//#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 = nowMs();
+		let result;
+		try {
+			result = await tool.handler(args, new ToolContext(auth));
+		} catch (err) {
+			const callerMessage = resolveToolErrorMessage(err);
+			if (callerMessage === void 0) {
+				await recorder.emit({
+					tool: tool.name,
+					method: "tools/call",
+					outcome: "handler_error",
+					durationMs: nowMs() - start,
+					errorText: 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: 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: nowMs() - start,
+			errorText: result.isError ? 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 = createRequestAuthorizer(mcp, options);
+	const handle = async (request, authResult, recorder) => {
+		try {
+			const server = new 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 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
+			});
+			log.error("mcp.transport_error", {
+				...describeError(err),
+				outcome: "500 internal error"
+			});
+			return Response.json({
+				jsonrpc: "2.0",
+				id: null,
+				error: {
+					code: -32603,
+					message: "internal error"
+				}
+			}, { status: 500 });
+		}
+	};
+	return createGatedHandler({
+		authorizer,
+		methods: ["POST"],
+		methodNotAllowed: statelessMethodNotAllowed,
+		handle
+	});
+}
+//#endregion
+export { createMcpProtocolHandler as t };

package/dist/mcp-CS1MF39p.cjs

@@ -0,0 +1,179 @@
+const require_logger = require("./logger-CN1q-KNn.cjs");
+const require_errors = require("./errors-CN6Da8iz.cjs");
+const require_authorize = require("./authorize-DBk5GkN_.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/core/content.ts
+/** Join the text of a result's `type: "text"` blocks into one string, dropping
+*  binary/resource blocks. Used to surface a `tool_error` message in the local
+*  log; never sent over the telemetry wire. Returns undefined when there is no
+*  text to show. */
+function extractTextContent(content) {
+	if (!content) return void 0;
+	const text = content.filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
+	return text.length > 0 ? text : void 0;
+}
+//#endregion
+//#region src/protocols/gate.ts
+function createGatedHandler(gate) {
+	const allow = [...gate.methods, "OPTIONS"].join(", ");
+	const respond = async (request, recorder) => {
+		const authResult = await gate.authorizer.authorize(request, recorder);
+		if (!authResult.ok) return authResult.response;
+		if (!gate.methods.includes(request.method)) return gate.methodNotAllowed(allow);
+		return gate.handle(request, authResult, recorder);
+	};
+	return async (request, recorder = require_authorize.createNoopRecorder()) => {
+		if (request.method === "OPTIONS") return require_authorize.corsPreflightResponse(allow);
+		const final = require_authorize.finalizeWireResponse(request, await respond(request, recorder));
+		if (!final.headers.has("Cache-Control")) final.headers.set("Cache-Control", "no-store");
+		return final;
+	};
+}
+//#endregion
+//#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 ? 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 createGatedHandler({
+		authorizer,
+		methods: ["POST"],
+		methodNotAllowed: statelessMethodNotAllowed,
+		handle
+	});
+}
+//#endregion
+Object.defineProperty(exports, "createMcpProtocolHandler", {
+	enumerable: true,
+	get: function() {
+		return createMcpProtocolHandler;
+	}
+});

package/dist/{package-ZFJI6B7S.js → package-CLhOKbJP.js}

@@ -1,4 +1,4 @@
 //#region package.json
-var version = "0.30.0-rc.0";
+var version = "1.0.0";
 //#endregion
 export { version as t };

package/dist/{package-QViIguII.cjs → package-C_8WAZRS.cjs}

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "0.30.0-rc.0";
+var version = "1.0.0";
 //#endregion
 Object.defineProperty(exports, "version", {
 	enumerable: true,

package/dist/protocols/mcp/index.cjs

@@ -1,3 +1,3 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_mcp = require("../../mcp-Dq6dXUKT.cjs");
+const require_mcp = require("../../mcp-CS1MF39p.cjs");
 exports.createMcpProtocolHandler = require_mcp.createMcpProtocolHandler;