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

package/dist/{authorize-FOlzhxrM.js → cors-D4YbODs-.js}

@@ -1,28 +1,7 @@
-import { i as log, n as applyLogLevelFromEnv, o as parseSafeUrl, r as describeError, s as trimTrailingSlash, t as LOG_LEVEL_ENV_VAR, u as resolveMetricsConfig } from "./logger-rGakBvJ1.js";
-import { t as version } from "./package-dtiombMt.js";
+import { i as log, n as applyLogLevelFromEnv, o as parseSafeUrl, r as describeError, s as trimTrailingSlash, t as LOG_LEVEL_ENV_VAR, u as resolveMetricsConfig } from "./logger-Ctv5xUSD.js";
+import { t as version } from "./package-DzB_5Hur.js";
 import "./metadata-path-CAkNcfyY.js";
-import { createLocalJWKSet, decodeProtectedHeader, jwtVerify } from "jose";
-//#region src/core/cors.ts
-const EXPOSE_HEADERS = "WWW-Authenticate, Mcp-Session-Id, Mcp-Protocol-Version";
-const ALLOW_HEADERS = "Authorization, Content-Type, Mcp-Session-Id, Mcp-Protocol-Version, Last-Event-ID";
-/** Add permissive CORS to a built response, preserving its other headers. */
-function withCors(response) {
-	response.headers.set("Access-Control-Allow-Origin", "*");
-	response.headers.set("Access-Control-Expose-Headers", EXPOSE_HEADERS);
-	return response;
-}
-function corsPreflightResponse(allowMethods) {
-	return new Response(null, {
-		status: 204,
-		headers: {
-			"Access-Control-Allow-Origin": "*",
-			"Access-Control-Allow-Methods": allowMethods,
-			"Access-Control-Allow-Headers": ALLOW_HEADERS,
-			"Access-Control-Max-Age": "86400"
-		}
-	});
-}
-//#endregion
+import { createLocalJWKSet, decodeProtectedHeader, errors, jwtVerify } from "jose";
 //#region src/core/http.ts
 const JSON_HEADERS = { "Content-Type": "application/json" };
 /** Strip the body from a built response, preserving status and headers, for HEAD. */
@@ -34,7 +13,7 @@ function headResponse(response) {
 	});
 }
 function finalizeWireResponse(request, response) {
-	return withCors(request.method === "HEAD" ? headResponse(response) : response);
+	return request.method === "HEAD" ? headResponse(response) : response;
 }
 function methodNotAllowed(allow) {
 	return new Response(JSON.stringify({ error: "method not allowed" }), {
@@ -73,6 +52,8 @@ function toLogRecord(rec) {
 	if (rec.tool !== null) attributes.push(strAttr("mcp.tool", rec.tool));
 	if (rec.reqBytes !== void 0) attributes.push(intAttr("mcp.request_size_bytes", rec.reqBytes));
 	if (rec.resBytes !== void 0) attributes.push(intAttr("mcp.response_size_bytes", rec.resBytes));
+	if (rec.httpMethod !== void 0) attributes.push(strAttr("http.request.method", rec.httpMethod));
+	if (rec.protocol !== void 0) attributes.push(strAttr("mcp.protocol", rec.protocol));
 	attributes.push(strAttr("mcp.stack", rec.stack));
 	if (rec.endUserId !== void 0) attributes.push(strAttr("mcp.end_user_id", rec.endUserId));
 	return {
@@ -120,6 +101,8 @@ function nowUnixNano() {
 function nowMs() {
 	return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
 }
+const METRICS_POST_TIMEOUT_MS = 3e3;
+let warnedNoApiKey = false;
 const NOOP_RECORDER = { async emit() {} };
 function createNoopRecorder() {
 	return NOOP_RECORDER;
@@ -168,12 +151,13 @@ var BaseMetricRecorder = class {
 	}
 	async emit(ev) {
 		await this.applyLazyLogLevel();
-		log.info("tool.invoked", {
+		if (ev.outcome !== "auth_challenge") log.info("tool.invoked", {
 			tool: ev.tool,
 			method: ev.method,
 			outcome: ev.outcome,
 			durationMs: ev.durationMs,
 			stack: this.stack,
+			...ev.protocol !== void 0 && { protocol: ev.protocol },
 			...ev.errorText !== void 0 && { errorText: ev.errorText }
 		});
 		if (!this.config.enabled) return;
@@ -181,30 +165,34 @@ var BaseMetricRecorder = class {
 			log.warn("metrics.disabled_no_fetch", { endpoint: this.config.endpoint });
 			return;
 		}
-		const headers = { ...this.baseHeaders };
-		if (this.usesLovableEndpoint) {
-			const key = await this.resolveApiKey();
-			if (!key) {
-				log.warn("metrics.disabled_no_api_key", {
-					envVar: this.config.apiKeyEnvVar,
-					endpoint: this.config.endpoint
-				});
-				return;
-			}
-			headers.authorization = `Bearer ${key}`;
-		}
-		const { errorText: _localOnly, ...wireEvent } = ev;
-		const body = buildLogsPayload([{
-			...wireEvent,
-			timeUnixNano: nowUnixNano(),
-			stack: this.stack
-		}], this.server);
 		try {
+			const headers = { ...this.baseHeaders };
+			if (this.usesLovableEndpoint) {
+				const key = await this.resolveApiKey();
+				if (!key) {
+					if (!warnedNoApiKey) {
+						warnedNoApiKey = true;
+						log.warn("metrics.disabled_no_api_key", {
+							envVar: this.config.apiKeyEnvVar,
+							endpoint: this.config.endpoint
+						});
+					}
+					return;
+				}
+				headers.authorization = `Bearer ${key}`;
+			}
+			const { errorText: _localOnly, ...wireEvent } = ev;
+			const body = buildLogsPayload([{
+				...wireEvent,
+				timeUnixNano: nowUnixNano(),
+				stack: this.stack
+			}], this.server);
 			const res = await this.doFetch(this.config.endpoint, {
 				method: "POST",
 				headers,
 				body,
-				keepalive: true
+				keepalive: true,
+				signal: AbortSignal.timeout(METRICS_POST_TIMEOUT_MS)
 			});
 			if (!res.ok) log.warn("metrics.rejected", {
 				status: res.status,
@@ -295,8 +283,8 @@ var SupabaseMetricRecorder = class extends BaseMetricRecorder {
 //#endregion
 //#region src/metrics/recorder.ts
 /** Vend the recorder for a stack, in-flight per request. Returns a no-op when
-*  metrics are disabled (`metrics: false`); otherwise the stack-specific class,
-*  which still logs `tool.invoked` even if the key or endpoint is unavailable. */
+*  metrics are disabled (`metrics: false`); otherwise the stack-specific class, which
+*  logs `tool.invoked` for tool invocations even if the key or endpoint is unavailable. */
 function createRecorderForRuntime(mcp, opts) {
 	const config = resolveMetricsConfig(mcp.metrics);
 	const server = {
@@ -593,6 +581,16 @@ async function fetchVerificationKeySet(jwksUri) {
 		throw new OAuthConfigurationError(`JWKS fetch failed: ${err instanceof Error ? err.message : String(err)}`, "jwks");
 	}
 }
+function assertCompactJwsShape(token) {
+	const parts = token.split(".");
+	if (parts.length !== 3 || parts.some((part) => part.length === 0)) {
+		log.debug("oauth.verify.bad_shape", {
+			tokenLength: token.length,
+			outcome: "401 invalid_token"
+		});
+		throw new OAuthTokenError(401, "invalid_token", "Access token is not a JWT");
+	}
+}
 function assertAccessTokenTyp(token, allowed) {
 	let header;
 	try {
@@ -694,6 +692,8 @@ function buildMcpAuthContext(args) {
 function createOAuthTokenVerifier(auth, discovery) {
 	const allowedTyps = auth.accessTokenTyp ?? DEFAULT_ACCESS_TOKEN_TYPS;
 	return async (token, request, options) => {
+		assertCompactJwsShape(token);
+		assertAccessTokenTyp(token, allowedTyps);
 		const resource = resolveProtectedResource(auth, request, options);
 		const issuer = await discovery.resolveIssuer();
 		const acceptedAudiences = resolveAcceptedAudiences(auth, resource);
@@ -705,9 +705,7 @@ function createOAuthTokenVerifier(auth, discovery) {
 		});
 		const jwksUri = await discovery.resolveJwksUri();
 		log.debug("oauth.jwks.fetch", { jwksUri });
-		const keySet = await fetchVerificationKeySet(jwksUri);
-		assertAccessTokenTyp(token, allowedTyps);
-		const claims = await verifyJwtClaims(token, keySet, issuer, auth);
+		const claims = await verifyJwtClaims(token, await fetchVerificationKeySet(jwksUri), issuer, auth);
 		const audienceVia = checkAcceptedAudience(claims, acceptedAudiences, auth);
 		assertNonEmptySubject(claims);
 		const context = buildMcpAuthContext({
@@ -719,11 +717,13 @@ function createOAuthTokenVerifier(auth, discovery) {
 		});
 		assertOAuthClientClaim(auth, context.principal.clientId);
 		log.info("oauth.verify.ok", {
-			sub: context.principal.sub,
-			clientId: context.principal.clientId,
 			scopes: context.principal.scopes,
 			audienceVia
 		});
+		log.debug("oauth.verify.principal", {
+			sub: context.principal.sub,
+			clientId: context.principal.clientId
+		});
 		return context;
 	};
 }
@@ -776,6 +776,22 @@ function oauthUpstreamUnreachableResponse() {
 		}
 	});
 }
+const KNOWN_HTTP_METHODS = /* @__PURE__ */ new Set([
+	"GET",
+	"HEAD",
+	"POST",
+	"PUT",
+	"DELETE",
+	"PATCH",
+	"OPTIONS",
+	"TRACE",
+	"CONNECT",
+	"QUERY"
+]);
+function normalizeHttpMethod(method) {
+	const upper = method.toUpperCase();
+	return KNOWN_HTTP_METHODS.has(upper) ? upper : "_OTHER";
+}
 function parseBearerToken(request) {
 	const header = request.headers.get("Authorization");
 	if (!header) return void 0;
@@ -838,7 +854,18 @@ function createRequestAuthorizer(mcp, options = {}) {
 		const startedAt = nowMs();
 		const token = parseBearerToken(request);
 		if (!token) {
-			log.info("auth.no_bearer_token", { outcome: "401" });
+			const httpMethod = normalizeHttpMethod(request.method);
+			log.info("auth.no_bearer_token", {
+				httpMethod,
+				outcome: "401"
+			});
+			await recorder?.emit({
+				tool: null,
+				method: "authorize",
+				outcome: "auth_challenge",
+				httpMethod,
+				durationMs: nowMs() - startedAt
+			});
 			return {
 				ok: false,
 				response: challengeResponse(runtime.auth, request, runtime.options, 401)
@@ -896,7 +923,12 @@ function createRequestAuthorizer(mcp, options = {}) {
 					response: challengeResponse(runtime.auth, request, runtime.options, err.status, err.oauthError, err.message)
 				};
 			}
-			log.error("auth.unexpected_error", {
+			if (err instanceof errors.JOSEError) log.info("auth.token_rejected", {
+				...describeError(err),
+				status: 401,
+				oauthError: "invalid_token"
+			});
+			else log.error("auth.unexpected_error", {
 				...describeError(err),
 				outcome: "401"
 			});
@@ -908,4 +940,67 @@ function createRequestAuthorizer(mcp, options = {}) {
 	} };
 }
 //#endregion
-export { assertResourcePathShape as a, createNoopRecorder as c, finalizeWireResponse as d, methodNotAllowed as f, oauthConfigurationErrorResponse as i, nowMs as l, createRequestAuthorizer as n, resolveProtectedResource as o, corsPreflightResponse as p, getOAuthRuntime as r, createRecorderForRuntime as s, assertRestResourceBinding as t, JSON_HEADERS as u };
+//#region src/core/cors.ts
+const EXPOSE_HEADERS = "WWW-Authenticate, MCP-Protocol-Version, Mcp-Session-Id";
+const ALLOW_HEADERS = "Authorization, Content-Type, MCP-Protocol-Version, Mcp-Method, Mcp-Name, Mcp-Session-Id, Last-Event-ID";
+const MCP_PARAM_HEADER = /^mcp-param-[!#$%&'*+.^_`|~0-9A-Za-z-]+$/i;
+function appendVary(headers, value) {
+	const values = new Set((headers.get("Vary") ?? "").split(",").map((entry) => entry.trim()).filter(Boolean));
+	values.add(value);
+	headers.set("Vary", [...values].join(", "));
+}
+function addCorsHeaders(response, allowedOrigin, variesByOrigin) {
+	if (allowedOrigin !== void 0) {
+		response.headers.set("Access-Control-Allow-Origin", allowedOrigin);
+		response.headers.set("Access-Control-Expose-Headers", EXPOSE_HEADERS);
+	}
+	if (variesByOrigin) appendVary(response.headers, "Origin");
+	return response;
+}
+function allowedRequestHeaders(request) {
+	const allowed = new Map(ALLOW_HEADERS.split(", ").map((header) => [header.toLowerCase(), header]));
+	for (const header of (request.headers.get("Access-Control-Request-Headers") ?? "").split(",")) {
+		const normalized = header.trim();
+		if (MCP_PARAM_HEADER.test(normalized)) allowed.set(normalized.toLowerCase(), normalized);
+	}
+	return [...allowed.values()].join(", ");
+}
+function evaluateCors(request, allowedOrigins) {
+	const origin = request.headers.get("Origin");
+	const allowAny = allowedOrigins === "any";
+	let allowedOrigin;
+	if (allowAny) allowedOrigin = "*";
+	else if (origin === null) allowedOrigin = void 0;
+	else if (origin === new URL(request.url).origin || allowedOrigins?.includes(origin)) allowedOrigin = origin;
+	else allowedOrigin = null;
+	if (allowedOrigin === null) {
+		const response = Response.json({ error: "origin not allowed" }, {
+			status: 403,
+			headers: { "Cache-Control": "no-store" }
+		});
+		appendVary(response.headers, "Origin");
+		return {
+			ok: false,
+			response
+		};
+	}
+	return {
+		ok: true,
+		withHeaders: (response) => addCorsHeaders(response, allowedOrigin, !allowAny),
+		preflight: (allowMethods) => {
+			const requestedHeaders = request.headers.get("Access-Control-Request-Headers");
+			const response = new Response(null, {
+				status: 204,
+				headers: {
+					"Access-Control-Allow-Methods": allowMethods,
+					"Access-Control-Allow-Headers": allowedRequestHeaders(request),
+					"Access-Control-Max-Age": "86400"
+				}
+			});
+			if (requestedHeaders) appendVary(response.headers, "Access-Control-Request-Headers");
+			return addCorsHeaders(response, allowedOrigin, !allowAny);
+		}
+	};
+}
+//#endregion
+export { oauthConfigurationErrorResponse as a, createRecorderForRuntime as c, JSON_HEADERS as d, finalizeWireResponse as f, getOAuthRuntime as i, createNoopRecorder as l, assertRestResourceBinding as n, assertResourcePathShape as o, methodNotAllowed as p, createRequestAuthorizer as r, resolveProtectedResource as s, evaluateCors as t, nowMs as u };

package/dist/{forwarded-BlLF3dfc.js → forwarded-B3EBjHnA.js}

@@ -15,9 +15,9 @@
 *   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.
+*   Supabase's gateway stamps it (that stack always trusts it), and Lovable's
+*   preview proxy overwrites it before the TanStack dev server, so the TanStack
+*   Vite plugin emits the flag by default.
 */
 function applyForwardedOrigin(request, options) {
 	const proto = options.trustForwardedProto ? firstForwardedValue(request, "x-forwarded-proto") : void 0;

package/dist/{forwarded-Bhwcj22u.cjs → forwarded-BC_RHnn5.cjs}

@@ -15,9 +15,9 @@
 *   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.
+*   Supabase's gateway stamps it (that stack always trusts it), and Lovable's
+*   preview proxy overwrites it before the TanStack dev server, so the TanStack
+*   Vite plugin emits the flag by default.
 */
 function applyForwardedOrigin(request, options) {
 	const proto = options.trustForwardedProto ? firstForwardedValue(request, "x-forwarded-proto") : void 0;

package/dist/{gate-B9RSzvoI.cjs → gate-n_HX6eQ5.cjs}

@@ -1,4 +1,4 @@
-const require_authorize = require("./authorize-CB35c3Wg.cjs");
+const require_cors = require("./cors-CmKzDN7k.cjs");
 //#region src/protocols/gate.ts
 function createGatedHandler(gate) {
 	const allow = [...gate.methods, "OPTIONS"].join(", ");
@@ -8,9 +8,11 @@ function createGatedHandler(gate) {
 		if (!gate.methods.includes(request.method)) return gate.methodNotAllowed(allow);
 		return gate.handle(request, authResult, recorder, ...extra);
 	};
-	return async (request, recorder = require_authorize.createNoopRecorder(), ...extra) => {
-		if (request.method === "OPTIONS") return require_authorize.corsPreflightResponse(allow);
-		const final = require_authorize.finalizeWireResponse(request, await respond(request, recorder, ...extra));
+	return async (request, recorder = require_cors.createNoopRecorder(), ...extra) => {
+		const cors = require_cors.evaluateCors(request, gate.allowedOrigins);
+		if (!cors.ok) return require_cors.finalizeWireResponse(request, cors.response);
+		if (request.method === "OPTIONS") return cors.preflight(allow);
+		const final = require_cors.finalizeWireResponse(request, cors.withHeaders(await respond(request, recorder, ...extra)));
 		if (!final.headers.has("Cache-Control")) final.headers.set("Cache-Control", "no-store");
 		return final;
 	};

package/dist/{gate-BeHmyGxk.js → gate-pGsVlY_4.js}

@@ -1,4 +1,4 @@
-import { c as createNoopRecorder, d as finalizeWireResponse, p as corsPreflightResponse } from "./authorize-FOlzhxrM.js";
+import { f as finalizeWireResponse, l as createNoopRecorder, t as evaluateCors } from "./cors-D4YbODs-.js";
 //#region src/protocols/gate.ts
 function createGatedHandler(gate) {
 	const allow = [...gate.methods, "OPTIONS"].join(", ");
@@ -9,8 +9,10 @@ function createGatedHandler(gate) {
 		return gate.handle(request, authResult, recorder, ...extra);
 	};
 	return async (request, recorder = createNoopRecorder(), ...extra) => {
-		if (request.method === "OPTIONS") return corsPreflightResponse(allow);
-		const final = finalizeWireResponse(request, await respond(request, recorder, ...extra));
+		const cors = evaluateCors(request, gate.allowedOrigins);
+		if (!cors.ok) return finalizeWireResponse(request, cors.response);
+		if (request.method === "OPTIONS") return cors.preflight(allow);
+		const final = finalizeWireResponse(request, cors.withHeaders(await respond(request, recorder, ...extra)));
 		if (!final.headers.has("Cache-Control")) final.headers.set("Cache-Control", "no-store");
 		return final;
 	};

package/dist/index.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_logger = require("./logger-BkMMCFTv.cjs");
+const require_logger = require("./logger-CN1q-KNn.cjs");
+const require_schema = require("./schema-D3vClxb7.cjs");
 const require_errors = require("./errors-CN6Da8iz.cjs");
 //#region src/core/define.ts
 function assertUniqueNames(mcp) {
@@ -79,6 +80,39 @@ 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, ...] })`.
@@ -101,8 +135,11 @@ 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 { 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";
+import { C as MetricsOptions, E as McpAuthConfig, S as MetricsConfig, T as JwtClaims, _ as ToolDefinition, a as EmbeddedResource, b as ZodRawShape, c as JsonValue, d as McpDefinitionInput, f as ResourceLink, g as ToolContent, h as ToolAnnotations, i as EmbeddedBlobResource, l as McpAllowedOrigins, m as TextContent, n as ContentAnnotations, o as EmbeddedTextResource, p as ResourceLinkIcon, r as ContentBlock, s as ImageContent, t as AudioContent, u as McpDefinition, v as ToolHandlerResult, w as ToolContext, x as ZodSchema, y as ZodOutputSchema } from "./types-D1cgsnPu.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 { C as McpAuthConfig, S as JwtClaims, _ as ZodRawShape, a as EmbeddedReso
  * 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 ZodRawShape | undefined = undefined>(def: ToolDefinition<TInput, TOutput>): ToolDefinition<TInput, TOutput>;
+declare function defineTool<TInput extends ZodRawShape | undefined = undefined, TOutput extends ZodOutputSchema | 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 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 };
+export { type AudioContent, type ContentAnnotations, type ContentBlock, type EmbeddedBlobResource, type EmbeddedResource, type EmbeddedTextResource, type ImageContent, type IssuerOAuthOptions, type JsonValue, type JwtClaims, type LogLevel, type McpAllowedOrigins, type McpDefinitionInput, type MetricsConfig, type MetricsOptions, 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 };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-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";
+import { C as MetricsOptions, E as McpAuthConfig, S as MetricsConfig, T as JwtClaims, _ as ToolDefinition, a as EmbeddedResource, b as ZodRawShape, c as JsonValue, d as McpDefinitionInput, f as ResourceLink, g as ToolContent, h as ToolAnnotations, i as EmbeddedBlobResource, l as McpAllowedOrigins, m as TextContent, n as ContentAnnotations, o as EmbeddedTextResource, p as ResourceLinkIcon, r as ContentBlock, s as ImageContent, t as AudioContent, u as McpDefinition, v as ToolHandlerResult, w as ToolContext, x as ZodSchema, y as ZodOutputSchema } from "./types-D1cgsnPu.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 { C as McpAuthConfig, S as JwtClaims, _ as ZodRawShape, a as EmbeddedReso
  * 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 ZodRawShape | undefined = undefined>(def: ToolDefinition<TInput, TOutput>): ToolDefinition<TInput, TOutput>;
+declare function defineTool<TInput extends ZodRawShape | undefined = undefined, TOutput extends ZodOutputSchema | 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 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 };
+export { type AudioContent, type ContentAnnotations, type ContentBlock, type EmbeddedBlobResource, type EmbeddedResource, type EmbeddedTextResource, type ImageContent, type IssuerOAuthOptions, type JsonValue, type JwtClaims, type LogLevel, type McpAllowedOrigins, type McpDefinitionInput, type MetricsConfig, type MetricsOptions, 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 };

package/dist/index.js

@@ -1,4 +1,5 @@
-import { a as setLogLevel, o as parseSafeUrl, s as trimTrailingSlash, u as resolveMetricsConfig } from "./logger-rGakBvJ1.js";
+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-DSe96Ffd.js";
 //#region src/core/define.ts
 function assertUniqueNames(mcp) {
@@ -78,6 +79,39 @@ 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, ...] })`.
@@ -100,8 +134,11 @@ 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-BzTGjG_c.d.cts → io-BEwvgN8s.d.cts}

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

package/dist/{io--MeYrWG7.d.ts → io-CvALf9NE.d.ts}

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

package/dist/list-tools-Dkyyje7j.cjs

@@ -0,0 +1,48 @@
+const require_schema = require("./schema-D3vClxb7.cjs");
+const require_cors = require("./cors-CmKzDN7k.cjs");
+const require_gate = require("./gate-n_HX6eQ5.cjs");
+//#region src/protocols/rest/list-tools.ts
+function schemaToJsonSchema(definition, pipeStrategy) {
+	if (!definition) return null;
+	return require_schema.jsonSchemaFromDefinition(definition, pipeStrategy);
+}
+function buildMcpListing(mcp) {
+	return {
+		server: {
+			name: mcp.name,
+			version: mcp.version,
+			title: mcp.title
+		},
+		tools: mcp.tools.map((tool) => ({
+			name: tool.name,
+			title: tool.title,
+			description: tool.description,
+			annotations: tool.annotations,
+			inputSchema: schemaToJsonSchema(tool.inputSchema, "input"),
+			outputSchema: schemaToJsonSchema(tool.outputSchema, "output")
+		}))
+	};
+}
+function createListToolsHandler(mcp, options = {}) {
+	require_cors.assertRestResourceBinding(mcp, options);
+	return require_gate.createGatedHandler({
+		authorizer: require_cors.createRequestAuthorizer(mcp, options),
+		allowedOrigins: mcp.allowedOrigins,
+		methods: ["GET", "HEAD"],
+		methodNotAllowed: require_cors.methodNotAllowed,
+		handle: async () => Response.json(buildMcpListing(mcp))
+	});
+}
+//#endregion
+Object.defineProperty(exports, "buildMcpListing", {
+	enumerable: true,
+	get: function() {
+		return buildMcpListing;
+	}
+});
+Object.defineProperty(exports, "createListToolsHandler", {
+	enumerable: true,
+	get: function() {
+		return createListToolsHandler;
+	}
+});

package/dist/{list-tools-Dt-mhh52.js → list-tools-ePP9tXND.js}

@@ -1,15 +1,10 @@
-import { f as methodNotAllowed, n as createRequestAuthorizer, t as assertRestResourceBinding } from "./authorize-FOlzhxrM.js";
-import { t as createGatedHandler } from "./gate-BeHmyGxk.js";
-import { objectFromShape } from "@modelcontextprotocol/sdk/server/zod-compat.js";
-import { toJsonSchemaCompat } from "@modelcontextprotocol/sdk/server/zod-json-schema-compat.js";
+import { t as jsonSchemaFromDefinition } from "./schema-CW1jKvio.js";
+import { n as assertRestResourceBinding, p as methodNotAllowed, r as createRequestAuthorizer } from "./cors-D4YbODs-.js";
+import { t as createGatedHandler } from "./gate-pGsVlY_4.js";
 //#region src/protocols/rest/list-tools.ts
-function shapeToJsonSchema(shape) {
-	if (!shape) return null;
-	try {
-		return toJsonSchemaCompat(objectFromShape(shape));
-	} catch {
-		return null;
-	}
+function schemaToJsonSchema(definition, pipeStrategy) {
+	if (!definition) return null;
+	return jsonSchemaFromDefinition(definition, pipeStrategy);
 }
 function buildMcpListing(mcp) {
 	return {
@@ -23,8 +18,8 @@ function buildMcpListing(mcp) {
 			title: tool.title,
 			description: tool.description,
 			annotations: tool.annotations,
-			inputSchema: shapeToJsonSchema(tool.inputSchema),
-			outputSchema: shapeToJsonSchema(tool.outputSchema)
+			inputSchema: schemaToJsonSchema(tool.inputSchema, "input"),
+			outputSchema: schemaToJsonSchema(tool.outputSchema, "output")
 		}))
 	};
 }
@@ -32,6 +27,7 @@ function createListToolsHandler(mcp, options = {}) {
 	assertRestResourceBinding(mcp, options);
 	return createGatedHandler({
 		authorizer: createRequestAuthorizer(mcp, options),
+		allowedOrigins: mcp.allowedOrigins,
 		methods: ["GET", "HEAD"],
 		methodNotAllowed,
 		handle: async () => Response.json(buildMcpListing(mcp))