better-supabase 0.0.0 → 0.1.0

package/dist/live-D8rV1Ldw.js

@@ -0,0 +1,168 @@
+import { REALTIME_SUBSCRIBE_STATES } from "@supabase/supabase-js";
+//#region src/realtime/live.ts
+/** Topic a `realtime-tables` trigger broadcasts on: `bs:t:<schema>.<table>[:<tenant>]`. */
+function liveTopic(meta, table, tenant) {
+	const found = meta.tables[table];
+	if (!found) throw new TypeError(`better-supabase: unknown table "${table}"`);
+	const base = `bs:t:${found.schema}.${found.name}`;
+	if (!meta.realtime?.[table]?.tenant) return base;
+	if (tenant === void 0) throw new TypeError(`better-supabase: "${table}" broadcasts per tenant; pass \`tenant\` to watch it`);
+	return `${base}:${tenant}`;
+}
+const channels = /* @__PURE__ */ new WeakMap();
+function join(client, topic, listener) {
+	let byTopic = channels.get(client);
+	if (!byTopic) {
+		byTopic = /* @__PURE__ */ new Map();
+		channels.set(client, byTopic);
+	}
+	let shared = byTopic.get(topic);
+	if (!shared) {
+		const channel = client.channel(topic, { config: { private: true } });
+		const listeners = /* @__PURE__ */ new Set();
+		channel.on("broadcast", { event: "change" }, () => {
+			for (const notify of listeners) notify();
+		});
+		let joined = false;
+		const ready = (async () => {
+			await client.realtime.setAuth();
+			await new Promise((resolve, reject) => {
+				channel.subscribe((status, error) => {
+					switch (status) {
+						case REALTIME_SUBSCRIBE_STATES.SUBSCRIBED:
+							if (joined) for (const notify of listeners) notify();
+							joined = true;
+							resolve();
+							return;
+						case REALTIME_SUBSCRIBE_STATES.CLOSED:
+							resolve();
+							return;
+						case REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR:
+						case REALTIME_SUBSCRIBE_STATES.TIMED_OUT:
+							reject(error ?? /* @__PURE__ */ new Error(`Realtime ${status.toLowerCase()} on ${topic}`));
+							return;
+						default: reject(/* @__PURE__ */ new Error(`Unknown realtime status ${String(status)}`));
+					}
+				});
+			});
+		})();
+		ready.catch(() => void 0);
+		shared = {
+			channel,
+			listeners,
+			ready
+		};
+		byTopic.set(topic, shared);
+	}
+	const current = shared;
+	current.listeners.add(listener);
+	let left = false;
+	return {
+		ready: current.ready,
+		leave: async () => {
+			if (left) return;
+			left = true;
+			current.listeners.delete(listener);
+			if (current.listeners.size > 0) return;
+			byTopic.delete(topic);
+			await client.removeChannel(current.channel);
+		}
+	};
+}
+/**
+* Calls `onChange` when a table the spec reads changes, so you can refetch.
+* Needs the `realtime-tables` SQL module and the tables in
+* `realtime.tables`. Live queries on the same client share one channel per
+* table, so any number of them can run at once.
+*
+* ```ts
+* using live = liveQuery(sb, supabase, spec, { onChange: () => refetch() });
+* ```
+*/
+function liveQuery(sb, client, spec, options) {
+	const touched = Array.isArray(spec) ? spec : sb.tablesOf(spec);
+	const tables = touched.filter((table) => sb.meta.realtime?.[table]);
+	const unwatched = touched.filter((table) => !sb.meta.realtime?.[table]);
+	const debounceMs = options.debounceMs ?? 100;
+	const changed = /* @__PURE__ */ new Set();
+	let timer;
+	let closed = false;
+	const flush = () => {
+		timer = void 0;
+		if (closed || changed.size === 0) return;
+		const batch = [...changed];
+		changed.clear();
+		options.onChange(batch);
+	};
+	const memberships = tables.map((table) => join(client, liveTopic(sb.meta, table, options.tenant), () => {
+		changed.add(table);
+		if (timer !== void 0) clearTimeout(timer);
+		timer = setTimeout(flush, debounceMs);
+	}));
+	options.onStatus?.(tables.length === 0 ? "closed" : "joining");
+	const ready = Promise.all(memberships.map((member) => member.ready)).then(() => {
+		if (!closed && tables.length > 0) options.onStatus?.("subscribed");
+	}, (cause) => {
+		const error = cause instanceof Error ? cause : new Error(String(cause));
+		options.onStatus?.("error", error);
+		throw error;
+	});
+	ready.catch(() => void 0);
+	const unsubscribe = async () => {
+		if (closed) return;
+		closed = true;
+		if (timer !== void 0) clearTimeout(timer);
+		await Promise.all(memberships.map((member) => member.leave()));
+		options.onStatus?.("closed");
+	};
+	return {
+		tables,
+		unwatched,
+		ready,
+		unsubscribe,
+		[Symbol.dispose]: () => void unsubscribe(),
+		[Symbol.asyncDispose]: unsubscribe
+	};
+}
+/**
+* Keeps a count current: runs the `count` spec (a HEAD request) now, after
+* each debounced change to a table it reads, and after the channel rejoins.
+* Responses that arrive out of order are dropped.
+*
+* ```ts
+* using live = liveCount(sb, supabase, db, sb.spec.notes.count(), {
+*   onCount: (count) => render(count),
+* });
+* ```
+*/
+function liveCount(sb, client, db, spec, options) {
+	let latest = 0;
+	let closed = false;
+	const refetch = () => {
+		const call = ++latest;
+		Promise.resolve(db.$run(spec)).then((result) => {
+			if (closed || call !== latest) return;
+			if (result.ok) options.onCount(result.data);
+			else options.onError?.(result.error);
+		});
+	};
+	const live = liveQuery(sb, client, spec, {
+		onChange: refetch,
+		...options.tenant === void 0 ? {} : { tenant: options.tenant },
+		...options.debounceMs === void 0 ? {} : { debounceMs: options.debounceMs },
+		...options.onStatus ? { onStatus: options.onStatus } : {}
+	});
+	if (options.immediate ?? true) refetch();
+	const unsubscribe = async () => {
+		closed = true;
+		await live.unsubscribe();
+	};
+	return {
+		...live,
+		unsubscribe,
+		[Symbol.dispose]: () => void unsubscribe(),
+		[Symbol.asyncDispose]: unsubscribe
+	};
+}
+//#endregion
+export { liveQuery as n, liveTopic as r, liveCount as t };

package/dist/mcp/index.d.ts

@@ -0,0 +1,105 @@
+import { k as TableKey, n as AnyModels, t as AnyFunctions } from "../types-C2fslP1z.js";
+import { t as BetterSupabase } from "../define-CTfWw-SS.js";
+import { d as ServerContext, f as ServerOptions, l as BetterServer, n as GuardOptions } from "../respond-PoTpy5DT.js";
+import { i as ResourceRouteOptions } from "../resource-SkPTRJDD.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/mcp/index.d.ts
+export declare const MCP_PROTOCOL_VERSION: string;
+type Json = Readonly<Record<string, unknown>>;
+/** MCP tool annotations (hints for clients, not guarantees). */
+export interface ToolAnnotations {
+  readonly title?: string;
+  readonly readOnlyHint?: boolean;
+  readonly destructiveHint?: boolean;
+  readonly idempotentHint?: boolean;
+  readonly openWorldHint?: boolean;
+}
+/** A tool as listed by `tools/list`. */
+export interface ToolInfo {
+  readonly name: string;
+  readonly title?: string;
+  readonly description?: string;
+  readonly inputSchema: Json;
+  readonly outputSchema?: Json;
+  readonly annotations?: ToolAnnotations;
+}
+export interface ToolContext<M extends AnyModels, F extends AnyFunctions, E> extends ServerContext<M, F, E> {
+  readonly request: Request;
+  readonly signal: AbortSignal;
+}
+export interface McpTool<M extends AnyModels, F extends AnyFunctions, E> {
+  readonly info: ToolInfo;
+  /** Validates arguments; its output is what `run` receives. */
+  readonly input?: StandardSchemaV1;
+  run(args: never, ctx: ToolContext<M, F, E>): unknown;
+}
+export interface ToolDefinition<M extends AnyModels, F extends AnyFunctions, E, I> {
+  readonly name: string;
+  readonly title?: string;
+  readonly description: string;
+  /**
+   * Validator for the arguments. Its JSON Schema comes from Standard JSON
+   * Schema (zod 4, arktype, valibot) unless `inputSchema` is given.
+   */
+  readonly input?: StandardSchemaV1<unknown, I>;
+  readonly inputSchema?: Json;
+  readonly outputSchema?: Json;
+  readonly annotations?: ToolAnnotations;
+  run(args: I, ctx: ToolContext<M, F, E>): unknown;
+}
+export type ToolResources<M extends AnyModels> = { readonly [T in TableKey<M>]?: ResourceRouteOptions<M, T> | true; };
+export interface McpOptions<M extends AnyModels, F extends AnyFunctions, E> extends ServerOptions, GuardOptions {
+  readonly name: string;
+  readonly version: string;
+  readonly title?: string;
+  /** Sent to clients on `initialize`, e.g. how the tools fit together. */
+  readonly instructions?: string;
+  /** Tables exposed as tools: `<table>_list`, `_get`, `_create`, `_update`, `_delete`. */
+  readonly resources?: ToolResources<M>;
+  readonly tools?: readonly McpTool<M, F, E>[];
+  /**
+   * Canonical URL of this MCP server (RFC 9728 `resource`). Defaults to the
+   * request URL without query.
+   */
+  readonly resource?: string | ((request: Request) => string);
+  /** Defaults to Supabase Auth of `env.url` (`<url>/auth/v1`). */
+  readonly authorizationServers?: readonly string[];
+  /** Origins allowed to call the server (DNS rebinding protection). Defaults to any. */
+  readonly allowedOrigins?: readonly string[];
+  /** Custom jsonb types, as in `createOpenApi`. */
+  readonly json?: Readonly<Record<string, unknown>>;
+  /** Include internal error messages in tool results. Defaults to `NODE_ENV === 'development'`. */
+  readonly exposeErrors?: boolean;
+}
+export interface BetterMcp<M extends AnyModels, F extends AnyFunctions, E> extends BetterServer<M, F, E> {
+  /** Everything in one handler: the MCP endpoint and `/.well-known/oauth-protected-resource`. */
+  readonly fetch: (request: Request) => Promise<Response>;
+  /** The Streamable HTTP endpoint (POST JSON-RPC). */
+  readonly handler: (request: Request) => Promise<Response>;
+  /** RFC 9728 protected resource metadata. */
+  metadata(request: Request): Response;
+  readonly tools: readonly ToolInfo[];
+  /** Adds a tool typed against this app's repositories. */
+  tool<I = Record<string, unknown>>(definition: ToolDefinition<M, F, E, I>): this;
+  /** Calls a tool directly, e.g. from tests or another transport. */
+  call(name: string, args: unknown, ctx: ToolContext<M, F, E>): Promise<ToolResult>;
+}
+export interface ToolResult {
+  readonly content: readonly {
+    readonly type: "text";
+    readonly text: string;
+  }[];
+  readonly structuredContent?: Json;
+  readonly isError?: boolean;
+}
+/** A custom tool. Pass it in `createMcp({ tools: [...] })`. */
+export declare function defineTool<M extends AnyModels, F extends AnyFunctions, E, I = Record<string, unknown>>(definition: ToolDefinition<M, F, E, I>): McpTool<M, F, E>;
+/**
+ * An MCP server (Streamable HTTP, stateless) whose tools run as the caller:
+ * the Bearer token from the MCP client is verified and every query goes
+ * through RLS. Answers 401 with RFC 9728 metadata so clients can sign in with
+ * Supabase Auth's OAuth server.
+ */
+export declare function createMcp<M extends AnyModels, D, F extends AnyFunctions, E>(sb: BetterSupabase<M, D, F, E>, options: McpOptions<M, F, E>): BetterMcp<M, F, E>;
+//#endregion
+export type { GuardOptions, ResourceRouteOptions };

package/dist/mcp/index.js

@@ -0,0 +1,330 @@
+import { n as dbError } from "../errors-Bl3rkOzo.js";
+import { t as validate } from "../standard-FUi3Z3-7.js";
+import { o as toProblem } from "../problem-DPu6Fh-t.js";
+import { t as SPEC_PINS } from "../spec-pins-t6sPaHvl.js";
+import { t as buildJsonSchema } from "../json-schema-BbwO2mZg.js";
+import { a as settle, c as withExtra, n as guard, o as createServer, s as extendServer, t as defaultExpose } from "../respond-4-dhoV7x.js";
+import { t as defineResource } from "../resource-CYiu6Ygi.js";
+import { fromSupabaseUrl, resourceMetadataResponse, unauthorizedResponse } from "@supabase/server/oauth-protected-resource";
+//#region src/mcp/index.ts
+const MCP_PROTOCOL_VERSION = SPEC_PINS.mcp;
+const WELL_KNOWN = "/.well-known/oauth-protected-resource";
+const SUPPORTED_VERSIONS = /* @__PURE__ */ new Set([MCP_PROTOCOL_VERSION, "2025-03-26"]);
+/** 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 : {
+		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 {
+		info: {
+			name: definition.name,
+			...definition.title ? { title: definition.title } : {},
+			description: definition.description,
+			inputSchema: schema,
+			...definition.outputSchema ? { outputSchema: definition.outputSchema } : {},
+			...definition.annotations ? { annotations: definition.annotations } : {}
+		},
+		...definition.input ? { input: definition.input } : {},
+		run: (args, ctx) => definition.run(args, ctx)
+	};
+}
+const ANNOTATIONS = {
+	list: {
+		readOnlyHint: true,
+		openWorldHint: false
+	},
+	get: {
+		readOnlyHint: true,
+		openWorldHint: false
+	},
+	create: {
+		readOnlyHint: false,
+		destructiveHint: false,
+		openWorldHint: false
+	},
+	update: {
+		readOnlyHint: false,
+		destructiveHint: true,
+		idempotentHint: true,
+		openWorldHint: false
+	},
+	delete: {
+		readOnlyHint: false,
+		destructiveHint: true,
+		idempotentHint: true,
+		openWorldHint: false
+	}
+};
+function pageSchema(max) {
+	return {
+		type: "object",
+		properties: {
+			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" };
+	const key = keyParam ? row["properties"]?.[keyParam] ?? { type: "string" } : void 0;
+	const keyInput = (more = {}) => ({
+		type: "object",
+		properties: {
+			[keyParam]: key,
+			...more
+		},
+		required: [keyParam, ...Object.keys(more)],
+		additionalProperties: false
+	});
+	const page = {
+		type: "object",
+		properties: {
+			items: {
+				type: "array",
+				items: row
+			},
+			page: { type: "object" }
+		},
+		required: ["items", "page"]
+	};
+	const tools = [];
+	const add = (operation, description, inputSchema, outputSchema) => {
+		tools.push({
+			operation,
+			info: {
+				name: `${table}_${operation}`,
+				title: `${operation[0].toUpperCase()}${operation.slice(1)} ${table}`,
+				description,
+				inputSchema,
+				...outputSchema ? { outputSchema } : {},
+				annotations: ANNOTATIONS[operation]
+			}
+		});
+	};
+	for (const operation of resource.operations) switch (operation) {
+		case "list": {
+			const { $schema: _, ...listSchema } = resource.list?.jsonSchema ?? pageSchema(resource.maxPageSize);
+			add("list", `List ${table} rows visible to the caller, one page at a time.`, listSchema, page);
+			break;
+		}
+		case "get":
+			if (keyParam) add("get", `Get one ${table} row by ${keyParam}.`, keyInput(), row);
+			break;
+		case "create":
+			add("create", `Create a ${table} row. Returns the created row.`, defs[`${table}Insert`] ?? { type: "object" }, row);
+			break;
+		case "update":
+			if (keyParam) add("update", `Update the columns in "patch" on one ${table} row.`, keyInput({ patch: defs[`${table}Update`] ?? { type: "object" } }), row);
+			break;
+		case "delete":
+			if (keyParam) add("delete", `Delete one ${table} row by ${keyParam}.`, keyInput());
+			break;
+		default: throw new TypeError(`Unknown operation ${String(operation)}`);
+	}
+	return tools;
+}
+const PARSE_ERROR = -32700;
+const INVALID_REQUEST = -32600;
+const METHOD_NOT_FOUND = -32601;
+const INVALID_PARAMS = -32602;
+function rpcError(id, code, message, status = 200) {
+	return Response.json({
+		jsonrpc: "2.0",
+		id: id ?? null,
+		error: {
+			code,
+			message
+		}
+	}, { status });
+}
+function isRpcRequest(value) {
+	return typeof value === "object" && value !== null && value["jsonrpc"] === "2.0" && typeof value["method"] === "string";
+}
+function textResult(value, isError = false) {
+	const structured = typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+	return {
+		content: [{
+			type: "text",
+			text: typeof value === "string" ? value : JSON.stringify(value ?? null)
+		}],
+		...structured ? { structuredContent: structured } : {},
+		...isError ? { isError: true } : {}
+	};
+}
+function canonical(request) {
+	const url = new URL(request.url);
+	return `${url.origin}${url.pathname.replace(/\/$/, "")}`;
+}
+/**
+* An MCP server (Streamable HTTP, stateless) whose tools run as the caller:
+* the Bearer token from the MCP client is verified and every query goes
+* through RLS. Answers 401 with RFC 9728 metadata so clients can sign in with
+* Supabase Auth's OAuth server.
+*/
+function createMcp(sb, options) {
+	const server = createServer(sb, options);
+	const expose = options.exposeErrors ?? defaultExpose();
+	const defs = buildJsonSchema({
+		meta: sb.meta,
+		config: { json: options.json ?? {} }
+	})["$defs"];
+	const registry = /* @__PURE__ */ new Map();
+	const register = (info, call) => {
+		if (registry.has(info.name)) throw new TypeError(`Duplicate MCP tool "${info.name}"`);
+		registry.set(info.name, {
+			info,
+			call
+		});
+	};
+	const failure = (error) => textResult(toProblem(error, { expose }), true);
+	for (const [table, raw] of Object.entries(options.resources ?? {})) {
+		if (!raw) continue;
+		const resource = defineResource(sb, table, raw === true ? {} : raw);
+		for (const { info, operation } of tableTools(resource, defs)) register(info, async (args, ctx) => {
+			const input = args ?? {};
+			const id = resource.keyParam ? input[resource.keyParam] : void 0;
+			const result = await resource.execute(ctx.db, operation, {
+				id,
+				query: input,
+				data: operation === "update" ? input["patch"] : input
+			});
+			if (!result.ok) return failure(result.error);
+			return textResult(operation === "delete" ? { deleted: true } : result.data);
+		});
+	}
+	const addTool = (tool) => {
+		register(tool.info, async (args, ctx) => {
+			let value = args ?? {};
+			if (tool.input) {
+				const parsed = await validate(tool.input, value, "arguments");
+				if (!parsed.ok) return failure(parsed.error);
+				value = parsed.data;
+			}
+			const outcome = await settle(() => tool.run(value, ctx));
+			return outcome.ok ? textResult(outcome.data) : failure(outcome.error);
+		});
+	};
+	for (const tool of options.tools ?? []) addTool(tool);
+	const listTools = () => [...registry.values()].map((entry) => entry.info);
+	const authorizationServers = () => options.authorizationServers ?? [fromSupabaseUrl(server.env.url)];
+	const resourceOf = (request) => {
+		if (typeof options.resource === "function") return options.resource(request);
+		if (options.resource) return options.resource;
+		const url = new URL(canonical(request));
+		return url.pathname.startsWith(WELL_KNOWN) ? `${url.origin}${url.pathname.slice(37)}` : url.href.replace(/\/$/, "");
+	};
+	const metadataUrl = (request) => {
+		const resource = new URL(resourceOf(request));
+		return `${resource.origin}${WELL_KNOWN}${resource.pathname.replace(/\/$/, "")}`;
+	};
+	const call = async (name, args, ctx) => {
+		const entry = registry.get(name);
+		if (!entry) return failure(dbError("not_found", `Unknown tool "${name}"`));
+		try {
+			return await entry.call(args, ctx);
+		} catch (cause) {
+			return failure(dbError("unexpected", expose && cause instanceof Error ? cause.message : "The tool failed"));
+		}
+	};
+	const handler = async (request) => {
+		const origin = request.headers.get("origin");
+		if (origin && options.allowedOrigins && !options.allowedOrigins.includes(origin)) return rpcError(null, INVALID_REQUEST, "Origin not allowed", 403);
+		if (request.method !== "POST") return new Response(null, {
+			status: 405,
+			headers: { allow: "POST" }
+		});
+		const version = request.headers.get("mcp-protocol-version");
+		if (version && !SUPPORTED_VERSIONS.has(version)) return rpcError(null, INVALID_REQUEST, `Unsupported MCP-Protocol-Version ${version}`, 400);
+		const ctx = await server.context(request);
+		const denied = guard(ctx.auth, options.allow, options.aal);
+		if (denied) {
+			if (denied.kind === "unauthorized") return unauthorizedResponse(request, { resourceMetadataUrl: metadataUrl(request) });
+			return rpcError(null, INVALID_REQUEST, denied.message, 403);
+		}
+		let message;
+		try {
+			message = await request.json();
+		} catch {
+			return rpcError(null, PARSE_ERROR, "Parse error", 400);
+		}
+		if (!isRpcRequest(message)) return rpcError(null, INVALID_REQUEST, "Expected one JSON-RPC 2.0 message", 400);
+		if (message.id === void 0) return new Response(null, { status: 202 });
+		const reply = (result) => Response.json({
+			jsonrpc: "2.0",
+			id: message.id,
+			result
+		});
+		switch (message.method) {
+			case "initialize": {
+				const requested = message.params?.["protocolVersion"];
+				return reply({
+					protocolVersion: typeof requested === "string" && SUPPORTED_VERSIONS.has(requested) ? requested : MCP_PROTOCOL_VERSION,
+					capabilities: { tools: { listChanged: false } },
+					serverInfo: {
+						name: options.name,
+						version: options.version,
+						...options.title ? { title: options.title } : {}
+					},
+					...options.instructions ? { instructions: options.instructions } : {}
+				});
+			}
+			case "ping": return reply({});
+			case "tools/list": return reply({ tools: listTools() });
+			case "tools/call": {
+				const name = message.params?.["name"];
+				if (typeof name !== "string" || !registry.has(name)) return rpcError(message.id, INVALID_PARAMS, `Unknown tool ${JSON.stringify(name)}`);
+				return reply(await call(name, message.params?.["arguments"], withExtra(ctx, {
+					request,
+					signal: request.signal
+				})));
+			}
+			default: return rpcError(message.id, METHOD_NOT_FOUND, `Method not found: ${message.method}`);
+		}
+	};
+	const metadata = (request) => resourceMetadataResponse(request, {
+		resource: resourceOf(request),
+		authorizationServers: [...authorizationServers()]
+	});
+	const mcp = extendServer(server, {
+		get tools() {
+			return listTools();
+		},
+		tool(definition) {
+			addTool(defineTool(definition));
+			return mcp;
+		},
+		call,
+		handler,
+		metadata,
+		fetch(request) {
+			const { pathname } = new URL(request.url);
+			if (pathname.startsWith(WELL_KNOWN)) return Promise.resolve(request.method === "OPTIONS" ? new Response(null, {
+				status: 204,
+				headers: {
+					"access-control-allow-origin": "*",
+					"access-control-allow-methods": "GET"
+				}
+			}) : metadata(request));
+			return handler(request);
+		}
+	});
+	return mcp;
+}
+//#endregion
+export { MCP_PROTOCOL_VERSION, createMcp, defineTool };