@lovable.dev/mcp-js 0.29.0-rc.1 → 0.29.0-rc.3

package/dist/{cors-BDTQQJE2.js → cors-kKiIJSyL.js}

@@ -1,5 +1,5 @@
 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-BI5r4uGM.js";
+import { t as version } from "./package-2ZppkCKf.js";
 import "./metadata-path-CAkNcfyY.js";
 import { createLocalJWKSet, decodeProtectedHeader, errors, jwtVerify } from "jose";
 //#region src/core/http.ts
@@ -28,7 +28,8 @@ function methodNotAllowed(allow) {
 //#endregion
 //#region src/metrics/otlp.ts
 const SCOPE_NAME = "@lovable.dev/mcp-js";
-const EVENT_NAME = "mcp.tool.invocation";
+const TOOL_EVENT_NAME = "mcp.tool.invocation";
+const GATE_EVENT_NAME = "mcp.gate.rejection";
 const SEVERITY_INFO = 9;
 function strAttr(key, value) {
 	return {
@@ -43,8 +44,9 @@ function intAttr(key, value) {
 	};
 }
 function toLogRecord(rec) {
+	const eventName = rec.method === "authorize" ? GATE_EVENT_NAME : TOOL_EVENT_NAME;
 	const attributes = [
-		strAttr("event.name", EVENT_NAME),
+		strAttr("event.name", eventName),
 		strAttr("mcp.method", rec.method),
 		strAttr("mcp.outcome", rec.outcome),
 		intAttr("mcp.duration_ms", rec.durationMs)
@@ -61,7 +63,7 @@ function toLogRecord(rec) {
 		observedTimeUnixNano: rec.timeUnixNano,
 		severityNumber: SEVERITY_INFO,
 		severityText: "INFO",
-		body: { stringValue: EVENT_NAME },
+		body: { stringValue: eventName },
 		attributes
 	};
 }
@@ -151,7 +153,7 @@ var BaseMetricRecorder = class {
 	}
 	async emit(ev) {
 		await this.applyLazyLogLevel();
-		if (ev.outcome !== "auth_challenge") log.info("tool.invoked", {
+		if (ev.outcome !== "auth_challenge") log.info(ev.method === "authorize" ? "gate.rejected" : "tool.invoked", {
 			tool: ev.tool,
 			method: ev.method,
 			outcome: ev.outcome,
@@ -827,17 +829,6 @@ function getOAuthRuntime(mcp, options = {}) {
 		options: stableOptions
 	};
 }
-/**
-* REST companion routes (`/.mcp/list-tools`, `/.mcp/invoke-tool/*`) are internal
-* RPC the main MCP server calls, so their own request path must never become the
-* advertised resource. Require `auth.resource` or a `resourcePath` so the bound
-* `principal.resource` is the public MCP route, not the internal `/.mcp/*` path.
-* The MCP protocol handler is exempt: its own path is the public resource.
-*/
-function assertRestResourceBinding(mcp, options = {}) {
-	const auth = mcp.auth?.type === "oauth" ? mcp.auth : void 0;
-	if (auth && auth.resource === void 0 && options.resourcePath === void 0) throw new Error(`@lovable.dev/mcp-js: REST companion handlers require auth.resource or a resourcePath so principal.resource binds to the public MCP route, not the internal /.mcp/* request path`);
-}
 function missingRequiredScopes(auth, scopes) {
 	const requiredScopes = auth.requiredScopes ?? [];
 	if (requiredScopes.length === 0) return [];
@@ -942,7 +933,15 @@ function createRequestAuthorizer(mcp, options = {}) {
 //#endregion
 //#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 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));
@@ -958,7 +957,7 @@ function addCorsHeaders(response, allowedOrigin, variesByOrigin) {
 	return response;
 }
 function allowedRequestHeaders(request) {
-	const allowed = new Map(ALLOW_HEADERS.split(", ").map((header) => [header.toLowerCase(), header]));
+	const allowed = new Map(ALLOW_HEADERS.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);
@@ -968,12 +967,8 @@ function allowedRequestHeaders(request) {
 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 originAllowed = origin === null || origin === new URL(request.url).origin || allowedOrigins?.includes(origin) === true;
+	if (!allowAny && !originAllowed) {
 		const response = Response.json({ error: "origin not allowed" }, {
 			status: 403,
 			headers: { "Cache-Control": "no-store" }
@@ -984,6 +979,7 @@ function evaluateCors(request, allowedOrigins) {
 			response
 		};
 	}
+	const allowedOrigin = allowAny ? "*" : origin ?? void 0;
 	return {
 		ok: true,
 		withHeaders: (response) => addCorsHeaders(response, allowedOrigin, !allowAny),
@@ -1003,4 +999,4 @@ function evaluateCors(request, allowedOrigins) {
 	};
 }
 //#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 };
+export { oauthConfigurationErrorResponse as a, createRecorderForRuntime as c, JSON_HEADERS as d, finalizeWireResponse as f, normalizeHttpMethod as i, createNoopRecorder as l, createRequestAuthorizer as n, assertResourcePathShape as o, methodNotAllowed as p, getOAuthRuntime as r, resolveProtectedResource as s, evaluateCors as t, nowMs as u };

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-Bnrwxbuj.js

@@ -0,0 +1,25 @@
+//#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;
+		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/forwarded-OdBzzCMF.cjs

@@ -0,0 +1,30 @@
+//#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;
+		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/index.cjs

@@ -1,7 +1,7 @@
 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-CN6Da8iz.cjs");
+const require_errors = require("./errors-Cr95rSkB.cjs");
 //#region src/core/define.ts
 function assertUniqueNames(mcp) {
 	const seen = /* @__PURE__ */ new Set();

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-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";
+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
@@ -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 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 };
+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 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";
+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
@@ -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 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 };
+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,6 +1,6 @@
 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";
+import { i as ToolContext, t as ToolError } from "./errors-Bwd1L0Rf.js";
 //#region src/core/define.ts
 function assertUniqueNames(mcp) {
 	const seen = /* @__PURE__ */ new Set();

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

@@ -1,4 +1,4 @@
-import "./list-tools-DXqSPvNY.js";
+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-B_YLNWDL.d.cts → io-D_5cuaEL.d.ts}

@@ -1,4 +1,4 @@
-import "./list-tools-C3AoI2Zw.cjs";
+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-BSNdmnJl.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-BDv7pyfD.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;
+	}
+});