better-supabase 0.7.1 → 0.9.0

package/dist/mcp/index.js

@@ -1,16 +1,167 @@
-import { n as dbError } from "../errors-B11Duf73.js";
-import { t as base64ToText } from "../base64-D2gsioCY.js";
-import { n as validate } from "../standard-BK0cqJ7y.js";
-import { a as problemResponse, o as toProblem } from "../problem-BreOl8b8.js";
-import { t as SPEC_PINS } from "../spec-pins--j6mTok4.js";
-import { t as buildJsonSchema } from "../json-schema-CvER4kgT.js";
-import { c as extendServer, l as withExtra, n as flushEvents, s as createServer } from "../adapter-iKgjHVPx.js";
+import { n as dbError } from "../errors-8i6tSICm.js";
+import { a as ok } from "../result-BlgnMB0H.js";
+import { t as base64ToText } from "../base64-BmeCBgGo.js";
+import { n as validate } from "../standard-B5fe2gnW.js";
+import { a as methodNotAllowed, c as toProblem, o as problemResponse } from "../problem-pIiL3WbE.js";
+import { t as SPEC_PINS } from "../spec-pins-S4PymRxp.js";
+import { t as buildJsonSchema, v as toDraft07 } from "../json-schema-CpYINXG8.js";
+import { c as extendServer, n as flushEvents, s as createServer } from "../adapter-CEjmtazZ.js";
 import { n as jsonResponse, t as jsonReplacer } from "../json-CEnpTHlZ.js";
-import { o as settle, r as guard, t as defaultExpose } from "../respond-BUgsXNgk.js";
-import { t as defineResource } from "../resource-BsvzCMlX.js";
-import { r as hasRole } from "../kit-Fm-Fv7q5.js";
+import { o as settle, r as guard, t as defaultExpose } from "../respond-DdhZ9Wbn.js";
+import { t as boundedTtlCache } from "../ttl-cache-XzZ-Q2eX.js";
+import { n as checkPermission, t as checkEach } from "../authorizer-DH7DjkL3.js";
+import { t as defineResource } from "../resource-C8r5xGqY.js";
+import { r as hasRole } from "../kit-MUK34-ZG.js";
+import { t as withExtra } from "../extra-CGQ2_q3S.js";
+import { r as pageSchema, t as pageInputSchema } from "../resource-schemas-BJ518zFH.js";
 import { a as withCors, i as metadataPreflight, n as endpointPreflight, r as isMetadataRequest, t as discovery } from "../http-DdYadv-o.js";
+import { r as operationPermission, t as OPERATION_PREFIXES } from "../operations-CsIfMED7.js";
 import { resourceMetadataResponse, unauthorizedResponse } from "@supabase/server/oauth-protected-resource";
+//#region src/mcp/dialect.ts
+/**
+* Revisions before 2025-11-25 have no default dialect, and clients written
+* for them validate tool schemas as draft-07.
+*/
+function schemaTargetFor(version) {
+	return version < "2025-11-25" ? "draft-07" : "draft-2020-12";
+}
+/**
+* Returns the listed tool with its schemas in a target's dialect, built
+* once per target. `convert` asks the input's Standard Schema library for
+* the target; without it, or when it can't, the 2020-12 schema is lowered.
+*/
+function toolDialects(info, convert) {
+	const built = /* @__PURE__ */ new Map();
+	return (target) => {
+		const cached = built.get(target);
+		if (cached) return cached;
+		const input = convert?.(target);
+		const lower = target === "draft-07";
+		const result = input === void 0 && !lower ? info : {
+			...info,
+			inputSchema: input ?? toDraft07(info.inputSchema),
+			...info.outputSchema && lower ? { outputSchema: toDraft07(info.outputSchema) } : {}
+		};
+		built.set(target, result);
+		return result;
+	};
+}
+//#endregion
+//#region src/mcp/json-rpc.ts
+const PARSE_ERROR = -32700;
+const INVALID_REQUEST = -32600;
+const METHOD_NOT_FOUND = -32601;
+const INVALID_PARAMS = -32602;
+const HEADER_MISMATCH = -32020;
+const UNSUPPORTED_PROTOCOL_VERSION = -32022;
+const META_VERSION = "io.modelcontextprotocol/protocolVersion";
+const META_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
+const META_SERVER_INFO = "io.modelcontextprotocol/serverInfo";
+/** A JSON-RPC error response. */
+function rpcError(id, code, message, status = 200, data) {
+	return Response.json({
+		jsonrpc: "2.0",
+		id: id ?? null,
+		error: {
+			code,
+			message,
+			...data ? { data } : {}
+		}
+	}, { status });
+}
+/** A non-array object. */
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** An `Mcp-Name` value, decoding the `=?base64?...?=` sentinel. */
+function headerName(value) {
+	const encoded = /^=\?base64\?(.*)\?=$/.exec(value)?.[1];
+	if (encoded === void 0) return value;
+	try {
+		return base64ToText(encoded);
+	} catch {
+		return value;
+	}
+}
+/** A value as a quoted string, with backslashes and quotes escaped. */
+const quoted = (value) => `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+/** A well-formed JSON-RPC 2.0 request. */
+function isRpcRequest(value) {
+	return isObject(value) && value["jsonrpc"] === "2.0" && typeof value["method"] === "string" && (value["params"] === void 0 || isObject(value["params"]));
+}
+//#endregion
+//#region src/mcp/permissions.ts
+/** The refusal for a caller without one of `required`'s roles. */
+function missingRole(auth, required) {
+	if (!required || auth.kind === "service") return;
+	const { roles, claim } = "roles" in required ? required : {
+		roles: required,
+		claim: void 0
+	};
+	if (roles.length === 0 || hasRole(auth, roles, claim)) return;
+	return dbError("forbidden", `This server needs the role ${roles.join(" or ")}`, { code: "MISSING_ROLE" });
+}
+/**
+* The permission a tool needs: the provider's entry for the tool's
+* `operation` (default `mcp.tool.<name>`) first, then the tool's own
+* `permission`.
+*/
+function toolPermission(operations, name, declared, operation = `${OPERATION_PREFIXES.mcpTool}${name}`) {
+	return operationPermission(operations, operation, typeof declared === "string" ? declared : void 0) ?? declared;
+}
+/** The context of a `tools/call` or `tools/list` request, if the client has one. */
+function contextOf(db) {
+	if (typeof db !== "object" || db === null || !("$context" in db)) return;
+	return db.$context;
+}
+/**
+* Checks a tool call as the caller of `db`: the tool is the resource, its
+* arguments its properties. A tool without a permission passes.
+*/
+async function checkTool(authorizer, tool, args, db) {
+	if (tool.permission === void 0) return ok(void 0);
+	const properties = typeof args === "object" && args !== null && !Array.isArray(args) ? args : void 0;
+	return checkPermission({
+		authorizer,
+		permission: tool.permission,
+		resource: {
+			type: "mcp_tool",
+			id: tool.info.name,
+			...properties ? { properties } : {}
+		},
+		context: contextOf(db)
+	});
+}
+/**
+* Which tools the caller may see, in `tools` order: one batch per
+* permission, and a tool without a permission is always shown.
+*/
+async function permittedTools(authorizer, tools, context) {
+	const shown = tools.map((tool) => tool.permission === void 0);
+	const groups = /* @__PURE__ */ new Map();
+	for (const [index, tool] of tools.entries()) {
+		if (tool.permission === void 0 || !authorizer) continue;
+		let key;
+		try {
+			key = authorizer.key(tool.permission);
+		} catch {
+			continue;
+		}
+		const group = groups.get(key) ?? {
+			permission: tool.permission,
+			indexes: []
+		};
+		group.indexes.push(index);
+		groups.set(key, group);
+	}
+	await Promise.all([...groups.values()].map(async ({ permission, indexes }) => {
+		const granted = await checkEach(authorizer, permission, indexes.map((index) => ({
+			type: "mcp_tool",
+			id: tools[index].name
+		})), context);
+		for (const [position, index] of indexes.entries()) shown[index] = granted[position] ?? false;
+	}));
+	return shown;
+}
+//#endregion
 //#region src/mcp/mcp.ts
 const MCP_PROTOCOL_VERSION = SPEC_PINS.mcp;
 /** Revisions before 2026-07-28 open with an `initialize` handshake. */
@@ -29,27 +180,26 @@ function hostAllowed(host, allowed) {
 		return false;
 	}
 }
-/** The refusal for a caller without one of `required`'s roles. */
-function missingRole(auth, required) {
-	if (!required || auth.kind === "service") return void 0;
-	const { roles, claim } = "roles" in required ? required : {
-		roles: required,
-		claim: void 0
-	};
-	if (roles.length === 0 || hasRole(auth, roles, claim)) return void 0;
-	return dbError("forbidden", `This server needs the role ${roles.join(" or ")}`, { code: "MISSING_ROLE" });
-}
 /** A custom tool. Pass it in `createMcp({ tools: [...] })`. */
 function defineTool(definition) {
 	if (!/^[A-Za-z0-9_.-]{1,64}$/.test(definition.name)) throw new TypeError(`Invalid tool name "${definition.name}": use 1-64 letters, digits, "_", "-" or "."`);
 	const standard = definition.input?.["~standard"];
-	const inputSchema = definition.inputSchema ?? standard?.jsonSchema?.input({ target: "draft-2020-12" }) ?? (definition.input ? void 0 : {
+	const convert = definition.inputSchema === void 0 ? standard?.jsonSchema : void 0;
+	const inputSchema = definition.inputSchema ?? convert?.input({ target: definition.jsonSchemaTarget ?? "draft-2020-12" }) ?? (definition.input ? void 0 : {
 		type: "object",
 		properties: {}
 	});
 	if (!inputSchema) throw new TypeError(`Tool "${definition.name}": the input schema has no JSON Schema; pass inputSchema`);
 	const { $schema: _, ...schema } = inputSchema;
 	return {
+		...convert ? { inputSchemaFor: (target) => {
+			try {
+				const { $schema: _dialect, ...converted } = convert.input({ target });
+				return converted;
+			} catch {
+				return;
+			}
+		} } : {},
 		info: {
 			name: definition.name,
 			...definition.title ? { title: definition.title } : {},
@@ -60,6 +210,8 @@ function defineTool(definition) {
 		},
 		...definition.input ? { input: definition.input } : {},
 		...definition.meta === void 0 ? {} : { meta: definition.meta },
+		...definition.permission === void 0 ? {} : { permission: definition.permission },
+		...definition.operation === void 0 ? {} : { operation: definition.operation },
 		run: (args, ctx) => definition.run(args, ctx)
 	};
 }
@@ -90,25 +242,6 @@ const ANNOTATIONS = {
 		openWorldHint: false
 	}
 };
-function pageSchema(max, cursor) {
-	return {
-		type: "object",
-		properties: {
-			...cursor ? { after: { type: "string" } } : { page: {
-				type: "integer",
-				minimum: 1,
-				default: 1
-			} },
-			size: {
-				type: "integer",
-				minimum: 1,
-				maximum: max,
-				default: 50
-			}
-		},
-		additionalProperties: false
-	};
-}
 function tableTools(resource, defs) {
 	const { table, keyParam } = resource;
 	const row = defs[`${table}Row`] ?? { type: "object" };
@@ -123,32 +256,7 @@ function tableTools(resource, defs) {
 		additionalProperties: false
 	});
 	const cursor = resource.pagination === "cursor";
-	const page = cursor ? {
-		type: "object",
-		properties: {
-			items: {
-				type: "array",
-				items: row
-			},
-			nextCursor: { type: ["string", "null"] },
-			hasMore: { type: "boolean" }
-		},
-		required: [
-			"items",
-			"nextCursor",
-			"hasMore"
-		]
-	} : {
-		type: "object",
-		properties: {
-			items: {
-				type: "array",
-				items: row
-			},
-			page: { type: "object" }
-		},
-		required: ["items", "page"]
-	};
+	const page = pageSchema(row, cursor);
 	const tools = [];
 	const add = (operation, description, inputSchema, outputSchema) => {
 		tools.push({
@@ -165,7 +273,7 @@ function tableTools(resource, defs) {
 	};
 	for (const operation of resource.operations) switch (operation) {
 		case "list": {
-			const { $schema: _, ...listSchema } = resource.list?.jsonSchema ?? pageSchema(resource.maxPageSize, cursor);
+			const { $schema: _, ...listSchema } = resource.list?.jsonSchema ?? pageInputSchema(cursor, resource.maxPageSize);
 			add("list", `List ${table} rows visible to the caller, one page at a time.`, listSchema, page);
 			break;
 		}
@@ -185,45 +293,10 @@ function tableTools(resource, defs) {
 	}
 	return tools;
 }
-const PARSE_ERROR = -32700;
-const INVALID_REQUEST = -32600;
-const METHOD_NOT_FOUND = -32601;
-const INVALID_PARAMS = -32602;
-const HEADER_MISMATCH = -32020;
-const UNSUPPORTED_PROTOCOL_VERSION = -32022;
-const META_VERSION = "io.modelcontextprotocol/protocolVersion";
-const META_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
-const META_SERVER_INFO = "io.modelcontextprotocol/serverInfo";
 /** How long clients may cache `tools/list` and `server/discover` (per token). */
 const LIST_TTL_MS = 3e5;
 /** Callers whose visible tool lists are kept; the oldest goes first. */
 const VISIBLE_LISTS_MAX = 1e3;
-function rpcError(id, code, message, status = 200, data) {
-	return Response.json({
-		jsonrpc: "2.0",
-		id: id ?? null,
-		error: {
-			code,
-			message,
-			...data ? { data } : {}
-		}
-	}, { status });
-}
-const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-/** An `Mcp-Name` value, decoding the `=?base64?...?=` sentinel. */
-function headerName(value) {
-	const encoded = /^=\?base64\?(.*)\?=$/.exec(value)?.[1];
-	if (encoded === void 0) return value;
-	try {
-		return base64ToText(encoded);
-	} catch {
-		return value;
-	}
-}
-const quoted = (value) => `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
-function isRpcRequest(value) {
-	return isObject(value) && value["jsonrpc"] === "2.0" && typeof value["method"] === "string" && (value["params"] === void 0 || isObject(value["params"]));
-}
 function textResult(value, isError = false) {
 	const structured = typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 	return {
@@ -250,19 +323,21 @@ function createMcp(betterSupabase, options) {
 	})["$defs"];
 	const registry = /* @__PURE__ */ new Map();
 	let allTools;
+	const listed = /* @__PURE__ */ new Map();
 	/** Bumped on every registration, so cached visible lists built before it miss. */
 	let generation = 0;
 	const register = (entry) => {
 		if (registry.has(entry.info.name)) throw new TypeError(`Duplicate MCP tool "${entry.info.name}"`);
 		registry.set(entry.info.name, entry);
 		allTools = void 0;
+		listed.clear();
 		generation++;
 	};
 	const failure = (error) => textResult(toProblem(error, { expose }), true);
 	const refused = async (tool, args, ctx) => {
-		if (!options.authorize) return void 0;
+		if (!options.authorize) return;
 		const decision = await options.authorize(ctx, tool, args);
-		if (decision.allowed) return void 0;
+		if (decision.allowed) return;
 		return {
 			refusal: decision.reason ?? `Not allowed to call ${tool.info.name}`,
 			scopes: decision.scopes ?? []
@@ -274,7 +349,7 @@ function createMcp(betterSupabase, options) {
 		const key = table;
 		const entry = raw;
 		const { meta, ...route } = entry === true ? {} : entry;
-		const resource = defineResource(betterSupabase, key, route);
+		const resource = defineResource(betterSupabase, key, route, options.authorizer);
 		for (const { info, operation } of tableTools(resource, defs)) {
 			const ref = {
 				info,
@@ -282,6 +357,7 @@ function createMcp(betterSupabase, options) {
 			};
 			register({
 				...ref,
+				infoFor: toolDialects(info),
 				async call(args, ctx) {
 					const input = args ?? {};
 					const refusal = await refused(ref, input, ctx);
@@ -298,13 +374,20 @@ function createMcp(betterSupabase, options) {
 			});
 		}
 	}
-	const addTool = (tool) => {
+	const addTool = (declared) => {
+		const permission = toolPermission(options.operations, declared.info.name, declared.permission, declared.operation);
+		const tool = {
+			...declared,
+			permission
+		};
 		const ref = {
 			info: tool.info,
 			meta: tool.meta
 		};
 		register({
 			...ref,
+			...permission === void 0 ? {} : { permission },
+			infoFor: toolDialects(tool.info, tool.inputSchemaFor),
 			async call(args, ctx) {
 				let value = args ?? {};
 				if (tool.input) {
@@ -312,6 +395,8 @@ function createMcp(betterSupabase, options) {
 					if (!parsed.ok) return failure(parsed.error);
 					value = parsed.data;
 				}
+				const checked = await checkTool(options.authorizer, tool, value, ctx.db);
+				if (!checked.ok) return failure(checked.error);
 				const refusal = await refused(ref, value, ctx);
 				if (refusal) return refusal;
 				const outcome = await settle(() => tool.run(value, ctx));
@@ -321,35 +406,38 @@ function createMcp(betterSupabase, options) {
 	};
 	for (const tool of options.tools ?? []) addTool(tool);
 	const listTools = () => allTools ??= [...registry.values()].map((entry) => entry.info);
+	const listFor = (target) => {
+		let tools = listed.get(target);
+		if (!tools) {
+			tools = [...registry.values()].map((entry) => entry.infoFor(target));
+			listed.set(target, tools);
+		}
+		return tools;
+	};
 	/**
 	* A user's visible list per token, for as long as clients may cache it
 	* (`ttlMs`). `tools/call` still checks `visible` on every call.
 	*/
-	const visibleLists = /* @__PURE__ */ new Map();
-	/** Without a `visible` hook every caller sees the same list, built once. */
-	const visibleTools = async (context) => {
-		if (!options.visible) return listTools();
+	const visibleLists = boundedTtlCache({ max: VISIBLE_LISTS_MAX });
+	/** Without a `visible` hook or permissions every caller sees the same list, built once. */
+	const visibleTools = async (context, target) => {
+		const all = [...registry.values()];
+		const gated = all.some((entry) => entry.permission !== void 0);
+		if (!options.visible && !gated) return listFor(target);
 		const ctx = context();
 		const token = ctx.auth.kind === "user" ? ctx.auth.token : void 0;
-		const now = Date.now();
 		const cached = token === void 0 ? void 0 : visibleLists.get(token);
-		if (cached && cached.until > now && cached.generation === generation) return cached.tools;
-		const entries = [...registry.values()];
-		const shown = await Promise.all(entries.map((entry) => isVisible(entry, ctx)));
-		const tools = entries.filter((_, index) => shown[index]).map((e) => e.info);
-		if (token !== void 0) {
-			visibleLists.delete(token);
-			if (visibleLists.size >= VISIBLE_LISTS_MAX) {
-				const oldest = visibleLists.keys().next();
-				if (!oldest.done) visibleLists.delete(oldest.value);
-			}
-			visibleLists.set(token, {
-				tools,
-				until: now + LIST_TTL_MS,
-				generation
-			});
-		}
-		return tools;
+		if (cached?.generation === generation) return cached.entries.map((entry) => entry.infoFor(target));
+		const [shown, permitted] = await Promise.all([Promise.all(all.map((entry) => isVisible(entry, ctx))), permittedTools(options.authorizer, all.map((entry) => ({
+			name: entry.info.name,
+			...entry
+		})), contextOf(ctx.db))]);
+		const entries = all.filter((_, index) => shown[index] && permitted[index]);
+		if (token !== void 0) visibleLists.set(token, {
+			entries,
+			generation
+		}, Date.now() + LIST_TTL_MS);
+		return entries.map((entry) => entry.infoFor(target));
 	};
 	const urls = discovery(options, () => server.env.url);
 	const { metadataUrl } = urls;
@@ -405,7 +493,7 @@ function createMcp(betterSupabase, options) {
 	const checkModern = (message, header, headers) => {
 		const meta = message.params?.["_meta"];
 		const version = isObject(meta) ? meta[META_VERSION] : void 0;
-		if (!isObject(meta) || typeof version !== "string" || !isObject(meta[META_CAPABILITIES])) return rpcError(message.id, INVALID_PARAMS, `Requests need _meta["${META_VERSION}"] and _meta["${META_CAPABILITIES}"]`, 400);
+		if (!isObject(meta) || typeof version !== "string" || !isObject(meta["io.modelcontextprotocol/clientCapabilities"])) return rpcError(message.id, INVALID_PARAMS, `Requests need _meta["${META_VERSION}"] and _meta["${META_CAPABILITIES}"]`, 400);
 		if (version !== MCP_PROTOCOL_VERSION) return unsupportedVersion(message.id, version);
 		const mismatch = (detail) => rpcError(message.id, HEADER_MISMATCH, `Header mismatch: ${detail}`, 400);
 		if (header !== version) return mismatch(`MCP-Protocol-Version must be ${version}`);
@@ -427,10 +515,7 @@ function createMcp(betterSupabase, options) {
 		if (origin && options.allowedOrigins && !options.allowedOrigins.includes(origin)) return rpcError(null, INVALID_REQUEST, "Origin not allowed", 403);
 		if (options.allowedHosts && !hostAllowed(urls.host(request), options.allowedHosts)) return rpcError(null, INVALID_REQUEST, "Host not allowed", 403);
 		if (request.method === "OPTIONS" && cors) return endpointPreflight(request, options.allowedOrigins);
-		if (request.method !== "POST") return new Response(null, {
-			status: 405,
-			headers: { allow: cors ? "POST, OPTIONS" : "POST" }
-		});
+		if (request.method !== "POST") return methodNotAllowed(cors ? ["POST", "OPTIONS"] : ["POST"]);
 		const header = request.headers.get("mcp-protocol-version");
 		if (header && !SUPPORTED_VERSIONS.includes(header)) return unsupportedVersion(null, header);
 		const ctx = await server.context(request, { cookies: false });
@@ -446,7 +531,7 @@ function createMcp(betterSupabase, options) {
 		}
 		if (!isRpcRequest(message)) return rpcError(null, INVALID_REQUEST, "Expected one JSON-RPC 2.0 message", 400);
 		const meta = message.params?.["_meta"];
-		const modern = isObject(meta) && meta[META_VERSION] !== void 0 || header === MCP_PROTOCOL_VERSION;
+		const modern = isObject(meta) && meta["io.modelcontextprotocol/protocolVersion"] !== void 0 || header === MCP_PROTOCOL_VERSION;
 		if (modern) {
 			const invalid = checkModern(message, header, request.headers);
 			if (invalid) return invalid;
@@ -486,7 +571,7 @@ function createMcp(betterSupabase, options) {
 			}
 			case "ping": return modern ? notFound() : reply({});
 			case "tools/list": return reply({
-				tools: await visibleTools(toolContext),
+				tools: await visibleTools(toolContext, schemaTargetFor(modern ? MCP_PROTOCOL_VERSION : header ?? "2025-03-26")),
 				...modern ? {
 					ttlMs: LIST_TTL_MS,
 					cacheScope: "private"

package/dist/mcp/sdk/index.d.ts

@@ -1,8 +1,10 @@
-import { a as AnyModels, i as AnyFunctions } from "../../types-6BdhkmZe.js";
-import { r as AuthState } from "../../resolve-ChTYeTEl.js";
-import { t as BetterSupabase } from "../../define-CJJkkr1-.js";
-import { i as ServerContext$1, o as ServerOptions, t as BetterServer } from "../../server-Bh0EVSwU.js";
-import { r as GuardOptions, t as AllowedCaller } from "../../respond-DprrgyXX.js";
+import { a as AnyModels, i as AnyFunctions } from "../../types-YfwpIE-d.js";
+import { r as AuthState } from "../../resolve-w9EpHzuM.js";
+import { i as CredentialRef, r as CredentialProvider } from "../../provider-9gBq9W6k.js";
+import { i as SupabaseMcpScope, n as SupabaseMcpModule, r as SupabaseMcpPlatformModule, t as SupabaseMcpFeature } from "../../supabase-mcp-C6tMoEjn.js";
+import { t as BetterSupabase } from "../../define-DxHHbNEb.js";
+import { i as ServerContext$1, s as ServerOptions, t as BetterServer } from "../../server-types-OohhIQb2.js";
+import { r as GuardOptions, t as AllowedCaller } from "../../respond-C7I8kLK_.js";
 import { AuthInfo, CallToolResult, Icon, InputRequiredResult, OAuthTokenVerifier, RegisteredTool, ScopeChallengeHandler, ServerContext, StandardSchemaWithJSON, ToolAnnotations } from "@modelcontextprotocol/server";
 //#region src/mcp/sdk/sdk.d.ts
 interface McpAuthOptions extends ServerOptions, Omit<GuardOptions, "scopes"> {
@@ -102,4 +104,34 @@ export declare function createMcpAuth<M extends AnyModels, D, F extends AnyFunct
  */
 export declare function withBetterSupabaseMcp<S extends ToolRegistrar, M extends AnyModels, F extends AnyFunctions, E, C, P>(server: S, auth: Pick<BetterMcpAuth<M, F, E, C, P>, "contextOf">): BetterMcpServer<S, M, F, E, C, P>;
 //#endregion
-export type { AllowedCaller, BetterMcpAuth, BetterMcpServer, BetterToolCallback, BetterToolConfig, BetterToolContext, BetterToolExtra, GuardOptions, McpAuthOptions, McpFetchHandler, ToolRegistrar };
+//#region src/mcp/sdk/supabase.d.ts
+type UserAuth<C, P> = Extract<AuthState<C, P>, {
+  kind: "user";
+}>;
+interface SupabaseMcpHandlerOptions<C = unknown, P = unknown> extends SupabaseMcpScope {
+  /** Resolves the Management API token, as the app; never the caller's JWT. */
+  readonly credentials: CredentialProvider;
+  /** The app credential that holds a Management API access token. */
+  readonly credentialRef: CredentialRef;
+  /**
+   * Who may use the server once the bearer token verified. Its tools
+   * administer the project, so allow only the people who run it.
+   */
+  readonly authorize: (auth: UserAuth<C, P>) => boolean | Promise<boolean>;
+  /** The Management API URL; Supabase's when unset. */
+  readonly apiUrl?: string;
+}
+/** Loads `@supabase/mcp-server-supabase`; tests pass their own. */
+interface SupabaseMcpLoaders {
+  readonly server?: () => Promise<SupabaseMcpModule>;
+  readonly platform?: () => Promise<SupabaseMcpPlatformModule>;
+}
+/**
+ * Serves Supabase's MCP server (`@supabase/mcp-server-supabase`) behind
+ * `createMcpAuth`: the bearer check and metadata of `auth.serve`, then
+ * `authorize`, then a server built for the request with the Management API
+ * token from `credentials`. The server closes when its response ends.
+ */
+export declare function supabaseMcpHandler<M extends AnyModels, F extends AnyFunctions, E, C, P>(auth: Pick<BetterMcpAuth<M, F, E, C, P>, "serve">, options: SupabaseMcpHandlerOptions<C, P>, loaders?: SupabaseMcpLoaders): (request: Request) => Promise<Response>;
+//#endregion
+export type { AllowedCaller, BetterMcpAuth, BetterMcpServer, BetterToolCallback, BetterToolConfig, BetterToolContext, BetterToolExtra, GuardOptions, McpAuthOptions, McpFetchHandler, SupabaseMcpFeature, SupabaseMcpHandlerOptions, SupabaseMcpLoaders, SupabaseMcpModule, SupabaseMcpPlatformModule, SupabaseMcpScope, ToolRegistrar };