@lovable.dev/mcp-js 1.0.0 → 2.0.1

package/dist/{errors-DSe96Ffd.js → errors-Bwd1L0Rf.js}

@@ -1,15 +1,30 @@
 //#region src/auth/context.ts
-/**
-* The auth surface passed to every tool handler as its second argument. It wraps
-* the verified per-request auth context in a private field, so the context — and
-* the bearer token inside it — can't be read, enumerated, spread, or
-* `JSON.stringify`'d off the instance; the accessors below are the only way out.
-* `getToken()` is the single intentional escape hatch for the raw bearer.
-*/
+const NEVER_ABORTED = new AbortController().signal;
+/** The per-request context passed to every tool handler as its second argument. The
+* auth context lives in a private field so the accessors are the only way out; `getToken()` is the sole bearer escape hatch. */
 var ToolContext = class {
 	#auth;
-	constructor(auth) {
+	#signal;
+	#client;
+	#sendProgress;
+	constructor(auth, request = {}) {
 		this.#auth = auth;
+		this.#signal = request.signal ?? NEVER_ABORTED;
+		this.#client = request.client ?? { protocol: "legacy" };
+		this.#sendProgress = request.sendProgress;
+	}
+	/** Aborts when the client cancels the request or disconnects. */
+	get signal() {
+		return this.#signal;
+	}
+	/** What the client declared about itself on this request. Unverified input. */
+	get client() {
+		return this.#client;
+	}
+	/** Send a progress notification for this call. A no-op when the client
+	* didn't request progress (no `progressToken` on the request). */
+	async progress(update) {
+		await this.#sendProgress?.(update);
 	}
 	/** Whether the in-flight tool call carries a verified auth context. */
 	isAuthenticated() {

package/dist/{errors-CN6Da8iz.cjs → errors-Cr95rSkB.cjs}

@@ -1,15 +1,30 @@
 //#region src/auth/context.ts
-/**
-* The auth surface passed to every tool handler as its second argument. It wraps
-* the verified per-request auth context in a private field, so the context — and
-* the bearer token inside it — can't be read, enumerated, spread, or
-* `JSON.stringify`'d off the instance; the accessors below are the only way out.
-* `getToken()` is the single intentional escape hatch for the raw bearer.
-*/
+const NEVER_ABORTED = new AbortController().signal;
+/** The per-request context passed to every tool handler as its second argument. The
+* auth context lives in a private field so the accessors are the only way out; `getToken()` is the sole bearer escape hatch. */
 var ToolContext = class {
 	#auth;
-	constructor(auth) {
+	#signal;
+	#client;
+	#sendProgress;
+	constructor(auth, request = {}) {
 		this.#auth = auth;
+		this.#signal = request.signal ?? NEVER_ABORTED;
+		this.#client = request.client ?? { protocol: "legacy" };
+		this.#sendProgress = request.sendProgress;
+	}
+	/** Aborts when the client cancels the request or disconnects. */
+	get signal() {
+		return this.#signal;
+	}
+	/** What the client declared about itself on this request. Unverified input. */
+	get client() {
+		return this.#client;
+	}
+	/** Send a progress notification for this call. A no-op when the client
+	* didn't request progress (no `progressToken` on the request). */
+	async progress(update) {
+		await this.#sendProgress?.(update);
 	}
 	/** Whether the in-flight tool call carries a verified auth context. */
 	isAuthenticated() {

package/dist/forwarded-B37IdmMX.cjs

@@ -0,0 +1,31 @@
+//#region src/core/forwarded.ts
+/** Rewrites the request URL to the proxy-forwarded public origin so derived OAuth
+*  URLs name the client-facing host. Trust model: AGENTS.md § Forwarded-header trust model. */
+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;
+		if (!/:\d+$/.test(host)) url.port = "";
+		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-BBXvFeh6.js

@@ -0,0 +1,26 @@
+//#region src/core/forwarded.ts
+/** Rewrites the request URL to the proxy-forwarded public origin so derived OAuth
+*  URLs name the client-facing host. Trust model: AGENTS.md § Forwarded-header trust model. */
+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;
+		if (!/:\d+$/.test(host)) url.port = "";
+		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,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_logger = require("./logger-CN1q-KNn.cjs");
-const require_errors = require("./errors-CN6Da8iz.cjs");
+const require_schema = require("./schema-D3vClxb7.cjs");
+const require_errors = require("./errors-Cr95rSkB.cjs");
 //#region src/core/define.ts
 function assertUniqueNames(mcp) {
 	const seen = /* @__PURE__ */ new Set();
@@ -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 { 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";
 //#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 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 };

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 { 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";
 //#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 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 };

package/dist/index.js

@@ -1,5 +1,6 @@
 import { a as setLogLevel, o as parseSafeUrl, s as trimTrailingSlash, u as resolveMetricsConfig } from "./logger-Ctv5xUSD.js";
-import { i as ToolContext, t as ToolError } from "./errors-DSe96Ffd.js";
+import { t as jsonSchemaFromDefinition } from "./schema-CW1jKvio.js";
+import { i as ToolContext, t as ToolError } from "./errors-Bwd1L0Rf.js";
 //#region src/core/define.ts
 function assertUniqueNames(mcp) {
 	const seen = /* @__PURE__ */ new Set();
@@ -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-Dx0nPc1-.d.cts → io-CDV3mud0.d.cts}

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

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

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

package/dist/mcp-BsvVuQvW.cjs

@@ -0,0 +1,353 @@
+const require_logger = require("./logger-CN1q-KNn.cjs");
+const require_schema = require("./schema-D3vClxb7.cjs");
+const require_errors = require("./errors-Cr95rSkB.cjs");
+const require_cors = require("./cors-BvJ-XM16.cjs");
+let _modelcontextprotocol_sdk_server_zod_compat_js = require("@modelcontextprotocol/sdk/server/zod-compat.js");
+let _modelcontextprotocol_server = require("@modelcontextprotocol/server");
+//#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/core/tool-result.ts
+function normalizeResourceLinkIcon(icon) {
+	if (typeof icon.sizes !== "string") return icon;
+	const { sizes, ...rest } = icon;
+	const normalized = sizes.trim();
+	return normalized === "" ? rest : {
+		...rest,
+		sizes: normalized.split(/\s+/)
+	};
+}
+function normalizeToolContent(content) {
+	return (content ?? []).map((block) => {
+		if (block.type !== "resource_link" || block.icons === void 0) return block;
+		return {
+			...block,
+			icons: block.icons.map(normalizeResourceLinkIcon)
+		};
+	});
+}
+function outputValidationError(text) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		isError: true
+	};
+}
+function isJsonValue(value, ancestors = /* @__PURE__ */ new Set()) {
+	if (value === null || typeof value === "boolean" || typeof value === "string") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (typeof value !== "object" || ancestors.has(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) return false;
+	ancestors.add(value);
+	const valid = (Array.isArray(value) ? value : Object.values(value).filter((entry) => entry !== void 0)).every((entry) => isJsonValue(entry, ancestors));
+	ancestors.delete(value);
+	return valid;
+}
+async function finalizeToolResult(tool, result) {
+	const content = normalizeToolContent(result.content);
+	let structuredContent = result.structuredContent;
+	if (tool.outputSchema && !result.isError) {
+		if (structuredContent === void 0) return outputValidationError(`Output validation error: Tool ${tool.name} has an output schema but no structured content was provided`);
+		try {
+			const parsed = await (0, _modelcontextprotocol_sdk_server_zod_compat_js.safeParseAsync)(require_schema.schemaFromDefinition(tool.outputSchema), structuredContent);
+			if (!parsed.success) return outputValidationError(`Output validation error: Invalid structured content for tool ${tool.name}: ${(0, _modelcontextprotocol_sdk_server_zod_compat_js.getParseErrorMessage)(parsed.error)}`);
+			structuredContent = parsed.data;
+		} catch {
+			return outputValidationError(`Output validation error: Could not validate structured content for tool ${tool.name}`);
+		}
+	}
+	if (structuredContent !== void 0 && !isJsonValue(structuredContent)) {
+		if (!result.isError) return outputValidationError(`Output validation error: Tool ${tool.name} returned a non-JSON structured value`);
+		structuredContent = void 0;
+	}
+	if (structuredContent !== void 0 && (structuredContent === null || typeof structuredContent !== "object" || Array.isArray(structuredContent)) && !content.some((block) => block.type === "text")) content.push({
+		type: "text",
+		text: JSON.stringify(structuredContent)
+	});
+	return {
+		content,
+		structuredContent,
+		isError: result.isError
+	};
+}
+//#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_cors.createNoopRecorder()) => {
+		const cors = require_cors.evaluateCors(request, gate.allowedOrigins);
+		if (!cors.ok) {
+			const httpMethod = require_cors.normalizeHttpMethod(request.method);
+			require_logger.log.info("cors.origin_rejected", {
+				origin: request.headers.get("Origin"),
+				httpMethod
+			});
+			await recorder.emit({
+				tool: null,
+				method: "authorize",
+				outcome: "origin_rejected",
+				httpMethod,
+				durationMs: 0
+			});
+			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)));
+		if (!final.headers.has("Cache-Control")) final.headers.set("Cache-Control", "no-store");
+		return final;
+	};
+}
+//#endregion
+//#region src/protocols/mcp/protocol.ts
+const MODERN_PROTOCOL_VERSION = "2026-07-28";
+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 }
+	});
+}
+function zodIssues(error) {
+	const issues = error?.issues;
+	if (!Array.isArray(issues)) return [{ message: String(error) }];
+	return issues.map((issue) => {
+		const value = issue;
+		return {
+			message: typeof value.message === "string" ? value.message : String(value.message),
+			...Array.isArray(value.path) ? { path: value.path } : {}
+		};
+	});
+}
+function standardSchemaFromDefinition(definition) {
+	const schema = require_schema.schemaFromDefinition(definition);
+	return { "~standard": {
+		version: 1,
+		vendor: "zod",
+		validate: async (value) => {
+			const parsed = await (0, _modelcontextprotocol_sdk_server_zod_compat_js.safeParseAsync)(schema, value);
+			return parsed.success ? { value: parsed.data } : { issues: zodIssues(parsed.error) };
+		},
+		jsonSchema: {
+			input: () => require_schema.jsonSchemaFromDefinition(definition, "input"),
+			output: () => require_schema.jsonSchemaFromDefinition(definition, "output")
+		}
+	} };
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toolRequestContext(sdkCtx, protocol) {
+	const mcpReq = sdkCtx?.mcpReq;
+	const client = { protocol };
+	const envelope = mcpReq?.envelope;
+	const info = envelope?.[_modelcontextprotocol_server.CLIENT_INFO_META_KEY];
+	if (isPlainObject(info) && typeof info.name === "string" && typeof info.version === "string") client.info = info;
+	const capabilities = envelope?.[_modelcontextprotocol_server.CLIENT_CAPABILITIES_META_KEY];
+	if (isPlainObject(capabilities)) {
+		client.capabilities = capabilities;
+		if (isPlainObject(capabilities.extensions)) client.extensions = capabilities.extensions;
+	}
+	const progressToken = (mcpReq?._meta)?.progressToken;
+	const notify = mcpReq?.notify;
+	const sendProgress = progressToken !== void 0 && notify ? async (update) => {
+		try {
+			await notify({
+				method: "notifications/progress",
+				params: {
+					progressToken,
+					...update
+				}
+			});
+		} catch (err) {
+			require_logger.log.debug("mcp.progress_notify_failed", require_logger.describeError(err));
+		}
+	} : void 0;
+	return {
+		signal: mcpReq?.signal,
+		client,
+		sendProgress
+	};
+}
+async function invokeTool(tool, auth, recorder, args, protocol, sdkCtx) {
+	const endUserId = auth?.principal.sub;
+	const start = require_cors.nowMs();
+	let result;
+	try {
+		result = await tool.handler(args, new require_errors.ToolContext(auth, toolRequestContext(sdkCtx, protocol)));
+	} 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_cors.nowMs() - start,
+				errorText: require_errors.errorSummary(err),
+				endUserId,
+				protocol
+			});
+			return finalizeToolResult(tool, {
+				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_cors.nowMs() - start,
+			endUserId,
+			protocol
+		});
+		return finalizeToolResult(tool, {
+			content: [{
+				type: "text",
+				text: `tool "${tool.name}" returned no result`
+			}],
+			isError: true
+		});
+	}
+	result = await finalizeToolResult(tool, result);
+	await recorder.emit({
+		tool: tool.name,
+		method: "tools/call",
+		outcome: result.isError ? "tool_error" : "ok",
+		durationMs: require_cors.nowMs() - start,
+		errorText: result.isError ? extractTextContent(result.content) : void 0,
+		endUserId,
+		protocol
+	});
+	return result;
+}
+function adaptToolCallback(tool, auth, recorder, protocol) {
+	return async (first, second) => {
+		const sdkCtx = tool.inputSchema ? second : first;
+		const result = await invokeTool(tool, auth, recorder, tool.inputSchema ? first ?? {} : {}, protocol, sdkCtx);
+		return {
+			content: result.content ?? [],
+			structuredContent: result.structuredContent,
+			isError: result.isError
+		};
+	};
+}
+function buildServer(mcp, auth, recorder, era) {
+	const server = new _modelcontextprotocol_server.McpServer({
+		name: mcp.name,
+		version: mcp.version,
+		title: mcp.title
+	}, {
+		instructions: mcp.instructions,
+		capabilities: { tools: { listChanged: false } }
+	});
+	for (const tool of mcp.tools) {
+		const config = {
+			title: tool.title,
+			description: tool.description,
+			annotations: tool.annotations,
+			...tool.outputSchema ? { outputSchema: standardSchemaFromDefinition(tool.outputSchema) } : {}
+		};
+		const callback = adaptToolCallback(tool, auth, recorder, era === "legacy" ? "legacy" : MODERN_PROTOCOL_VERSION);
+		if (tool.inputSchema) server.registerTool(tool.name, {
+			...config,
+			inputSchema: standardSchemaFromDefinition(tool.inputSchema)
+		}, callback);
+		else server.registerTool(tool.name, config, callback);
+	}
+	return server;
+}
+/**
+* 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_cors.createRequestAuthorizer(mcp, options);
+	const handle = async (request, authResult, recorder) => {
+		let protocolError;
+		const reportTransportError = async (error) => {
+			await recorder.emit({
+				tool: null,
+				method: "transport",
+				outcome: "transport_error",
+				durationMs: 0,
+				endUserId: authResult.auth?.principal.sub
+			});
+			require_logger.log.error("mcp.transport_error", {
+				...error === void 0 ? {} : require_logger.describeError(error),
+				outcome: "500 internal error"
+			});
+		};
+		try {
+			const response = await (0, _modelcontextprotocol_server.createMcpHandler)(({ era }) => buildServer(mcp, authResult.auth, recorder, era), {
+				legacy: "stateless",
+				maxSubscriptions: 0,
+				onerror: (error) => {
+					protocolError = error;
+				}
+			}).fetch(request);
+			if (response.status >= 500) await reportTransportError(protocolError);
+			return response;
+		} catch (err) {
+			await reportTransportError(err);
+			return Response.json({
+				jsonrpc: "2.0",
+				id: null,
+				error: {
+					code: -32603,
+					message: "internal error"
+				}
+			}, { status: 500 });
+		}
+	};
+	return createGatedHandler({
+		authorizer,
+		allowedOrigins: mcp.allowedOrigins,
+		methods: ["POST"],
+		methodNotAllowed: statelessMethodNotAllowed,
+		handle
+	});
+}
+//#endregion
+Object.defineProperty(exports, "createMcpProtocolHandler", {
+	enumerable: true,
+	get: function() {
+		return createMcpProtocolHandler;
+	}
+});