@abinnovision/payloadcms-mcpx 1.0.0-beta.10

package/dist/tools/list-capabilities.mjs

@@ -0,0 +1,68 @@
+import { translatorFor } from "../i18n.mjs";
+import { jsonResult } from "../endpoint/result.mjs";
+import { translateLabel } from "./shared.mjs";
+import { hasDraftValidationEnabled } from "payload/shared";
+//#region src/tools/list-capabilities.ts
+const listCapabilities = {
+	name: "listCapabilities",
+	description: `Lists what this key may do: the collections and globals it can read or write, their draft behaviour and id type, the configured locales, the limits in force and the custom tools available. Call it first to orient; nothing here changes with the content model.
+
+A global is a singleton: it has no id, is not listed by findDocuments and cannot be created. Address one with the "global" argument where a collection document would take "collection" and "id".`,
+	annotations: {
+		readOnlyHint: true,
+		openWorldHint: false
+	},
+	isEnabled: () => true,
+	inputSchema: () => ({}),
+	handler: (_args, scope) => {
+		const { payload } = scope.req;
+		const translate = translatorFor(scope.req.i18n);
+		const collections = scope.options.collections.flatMap((entry) => {
+			const capability = scope.capabilities.collections[entry.slug];
+			const collection = payload.collections[entry.slug];
+			if (!capability || !collection || !(capability.read || capability.write)) return [];
+			const { config } = collection;
+			const description = translate(config.admin.description);
+			return [{
+				slug: entry.slug,
+				labels: {
+					singular: translateLabel(scope, config.labels.singular, entry.slug),
+					plural: translateLabel(scope, config.labels.plural, entry.slug)
+				},
+				...description === void 0 ? {} : { description },
+				read: capability.read,
+				write: capability.write,
+				drafts: entry.hasDrafts,
+				draftValidation: hasDraftValidationEnabled(config),
+				idType: collection.customIDType ?? payload.db.defaultIDType
+			}];
+		});
+		const globals = scope.options.globals.flatMap((entry) => {
+			const capability = scope.capabilities.globals[entry.slug];
+			const config = payload.globals.config.find((candidate) => candidate.slug === entry.slug);
+			if (!capability || !config || !(capability.read || capability.write)) return [];
+			const description = translate(config.admin.description);
+			return [{
+				slug: entry.slug,
+				label: translateLabel(scope, config.label, entry.slug),
+				...description === void 0 ? {} : { description },
+				read: capability.read,
+				write: capability.write,
+				drafts: entry.hasDrafts,
+				draftValidation: hasDraftValidationEnabled(config)
+			}];
+		});
+		return Promise.resolve(jsonResult({
+			collections,
+			...globals.length > 0 ? { globals } : {},
+			locales: scope.locales ? {
+				codes: scope.locales,
+				default: scope.defaultLocale
+			} : null,
+			limits: scope.options.limits,
+			tools: Object.entries(scope.capabilities.tools).filter(([, enabled]) => enabled).map(([name]) => name)
+		}));
+	}
+};
+//#endregion
+export { listCapabilities };

package/dist/tools/names.mjs

@@ -0,0 +1,14 @@
+//#region src/tools/names.ts
+/**
+* Names of the builtin tools. Custom tools must not reuse them.
+*/ const BUILTIN_TOOL_NAMES = [
+	"listCapabilities",
+	"describeSchema",
+	"findDocuments",
+	"getDocument",
+	"patchDocument",
+	"createDocument",
+	"validateDocument"
+];
+//#endregion
+export { BUILTIN_TOOL_NAMES };

package/dist/tools/patch-document.mjs

@@ -0,0 +1,127 @@
+import { errorResult, jsonResult } from "../endpoint/result.mjs";
+import { idShape, localeOf, localeShape, readTarget, targetShape } from "./shared.mjs";
+import { refOf, requireIdFor, resolveTarget } from "./target.mjs";
+import { PATCH_OPERATION_SCHEMA, applyPatchToCopy, buildWriteData, findPatchProblems, isElementPointer } from "../write/patch.mjs";
+import { collectPublishBlockers } from "../write/publish-blockers.mjs";
+import { withTransaction } from "../write/transaction.mjs";
+import { z } from "zod";
+import { Pointer } from "rfc6902";
+//#region src/tools/patch-document.ts
+const DESCRIPTION = `Applies RFC 6902 JSON Patch operations to one document.
+
+Pass exactly one of "collection" and "global". "id" is required with "collection" and must be omitted with "global", because a global is a singleton.
+
+The write always lands as a draft and is never published, whatever it contains; publishing stays a human action in the admin panel.
+
+Only the fields describeSchema lists can be addressed. A pointer that does not resolve is refused with the fields that are valid at that point, and nothing is applied unless every operation in the batch validates first. describeSchema reports field paths in this same pointer syntax; a path becomes a pointer into a document by replacing each "*" and each block slug with its 0-based index.
+
+Adding a block requires "blockType" on the value. Append with "/-" as the last segment. To clear a field use "replace" with null; an array or blocks field refuses null and is emptied with [] instead. "remove" is only for list elements, because a field left out of a write is kept rather than cleared. Read the document first to learn the indices, and pass its "updatedAt" as expectedUpdatedAt so a concurrent edit is refused rather than overwritten.
+
+A successful write may come back with "publishBlockers": everything still wrong with the draft, such as required fields left empty. Those do not fail the write, because a draft is allowed to be incomplete, but a human cannot publish the document until the list is empty. "notApplied" lists pointers whose value Payload kept unchanged, which happens when field-level access denies the update.`;
+const sameInstant = (left, right) => typeof left === "string" && new Date(left).getTime() === new Date(right).getTime();
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Whether the intended value survived the write. The saved document is
+* allowed to carry more than was sent: Payload assigns fresh row ids and
+* backfills defaults and nulls on save, so `id` keys are ignored and only
+* the keys the client sent are compared. Null and absent count as equal.
+*/ const survives = (expected, actual) => {
+	if (expected === void 0 || expected === null) return actual === void 0 || actual === null;
+	if (Array.isArray(expected)) return Array.isArray(actual) && expected.length === actual.length && expected.every((entry, index) => survives(entry, actual[index]));
+	if (isPlainObject(expected)) return isPlainObject(actual) && Object.entries(expected).every(([key, value]) => key === "id" || survives(value, actual[key]));
+	return isPlainObject(actual) || Array.isArray(actual) ? false : JSON.stringify(expected) === JSON.stringify(actual);
+};
+/**
+* Pointers whose intended value did not survive the write. Element pointers
+* are skipped: an append pointer (`/-`) does not resolve against the saved
+* document.
+*/ const notAppliedPointers = (patches, intended, saved) => patches.flatMap((operation) => {
+	if (operation.op !== "add" && operation.op !== "replace" || isElementPointer(operation.path)) return [];
+	const pointer = Pointer.fromJSON(operation.path);
+	const expected = pointer.get(intended);
+	const actual = pointer.get(saved);
+	return survives(expected, actual) ? [] : [operation.path];
+});
+const patchDocument = {
+	name: "patchDocument",
+	description: DESCRIPTION,
+	annotations: {
+		readOnlyHint: false,
+		destructiveHint: false,
+		idempotentHint: false,
+		openWorldHint: false
+	},
+	isEnabled: (scope) => scope.writable.length + scope.writableGlobals.length > 0,
+	inputSchema: (scope) => ({
+		...targetShape(scope, "write", {
+			collection: "Collection holding the document.",
+			global: "Global to patch."
+		}),
+		...idShape(scope, "write"),
+		...localeShape(scope, {
+			required: true,
+			description: "Locale the patch applies to. Localized fields write here only."
+		}),
+		patches: z.array(PATCH_OPERATION_SCHEMA).min(1).describe("Operations, applied in order."),
+		expectedUpdatedAt: z.string().optional().describe("The updatedAt read before patching. The write is refused if the document has changed since.")
+	}),
+	handler: async (args, scope) => {
+		const target = resolveTarget(scope, args, "write");
+		const id = requireIdFor(target, args.id);
+		const { payload } = scope.req;
+		const locale = localeOf(scope, args.locale);
+		return await withTransaction(scope.req, async () => {
+			const doc = await readTarget(scope, {
+				target,
+				id,
+				locale
+			});
+			if (args.expectedUpdatedAt !== void 0 && !sameInstant(doc["updatedAt"], args.expectedUpdatedAt)) return errorResult("The document changed since you read it. Read it again and re-apply the patch.", { updatedAt: doc["updatedAt"] });
+			const problems = findPatchProblems(payload.config, {
+				doc,
+				patches: args.patches,
+				ref: refOf(target)
+			});
+			if (problems.length > 0) return errorResult("No operation was applied.", { problems });
+			const applied = applyPatchToCopy(doc, args.patches);
+			if ("problems" in applied) return errorResult("No operation was applied.", { problems: applied.problems });
+			const write = {
+				data: buildWriteData(payload.config, target.config, applied.next),
+				depth: 0,
+				draft: true,
+				overrideAccess: false,
+				req: scope.req,
+				...locale === void 0 ? {} : { locale }
+			};
+			if (target.kind === "collection") await payload.update({
+				...write,
+				collection: target.slug,
+				id
+			});
+			else await payload.updateGlobal({
+				...write,
+				slug: target.slug
+			});
+			const saved = await readTarget(scope, {
+				target,
+				id,
+				locale,
+				privileged: true
+			});
+			const notApplied = notAppliedPointers(args.patches, applied.next, saved);
+			const publishBlockers = await collectPublishBlockers(scope.req, {
+				doc: saved,
+				entity: target
+			});
+			return jsonResult({
+				...target.kind === "collection" ? { id: saved["id"] } : { global: target.slug },
+				status: saved["_status"],
+				updatedAt: saved["updatedAt"],
+				...publishBlockers.length > 0 ? { publishBlockers } : {},
+				...notApplied.length > 0 ? { notApplied } : {}
+			});
+		});
+	}
+};
+//#endregion
+export { patchDocument };

package/dist/tools/shared.mjs

@@ -0,0 +1,97 @@
+import { translateStatic } from "../i18n.mjs";
+import { NotFound } from "payload";
+import { z } from "zod";
+//#region src/tools/shared.ts
+const slugEnum = (slugs) => z.enum(slugs);
+const idSchema = z.union([z.string(), z.number()]).describe("Document id.");
+const slugsFor = (scope, operation) => ({
+	collections: operation === "read" ? scope.readable : scope.writable,
+	globals: operation === "read" ? scope.readableGlobals : scope.writableGlobals
+});
+/**
+* The `collection` and `global` arguments.
+*
+* When the key can reach no global, `global` is left out of the shape entirely
+* and `collection` stays required, mirroring how {@link localeShape} omits
+* `locale` when localization is off. A deployment without globals therefore
+* sees exactly the schema it saw before. Only the mixed case makes either
+* argument optional, and the handler enforces the exclusivity there.
+*/ const targetShape = (scope, operation, descriptions) => {
+	const { collections, globals } = slugsFor(scope, operation);
+	if (globals.length === 0) return { collection: slugEnum(collections).describe(descriptions.collection) };
+	if (collections.length === 0) return { global: slugEnum(globals).describe(descriptions.global) };
+	return {
+		collection: slugEnum(collections).optional().describe(descriptions.collection),
+		global: slugEnum(globals).optional().describe(descriptions.global)
+	};
+};
+/**
+* The `id` argument, which only a collection document has. Omitted when the key
+* can reach no collection, required when it can reach no global, and optional
+* in between, where `requireIdFor` enforces the dependency.
+*/ const idShape = (scope, operation) => {
+	const { collections, globals } = slugsFor(scope, operation);
+	if (collections.length === 0) return {};
+	if (globals.length === 0) return { id: idSchema };
+	return { id: idSchema.optional().describe("Document id. Required with \"collection\"; must be omitted with \"global\".") };
+};
+/**
+* The `locale` argument, present only when localization is configured.
+*/ const localeShape = (scope, options) => {
+	if (!scope.locales) return {};
+	const locale = z.enum(scope.locales);
+	return { locale: (options.required ? locale : locale.optional()).describe(options.description) };
+};
+const depthShape = (scope) => ({ depth: z.number().int().min(0).max(scope.options.limits.maxDepth).optional().describe(`Relationship population depth. Default 0, at most ${String(scope.options.limits.maxDepth)}.`) });
+/**
+* The locale to operate on: the explicit argument, else the request's, else
+* the default. `undefined` when localization is off.
+*/ const localeOf = (scope, locale) => {
+	if (!scope.locales) return;
+	const requested = locale ?? scope.req.locale;
+	return (requested && scope.locales.includes(requested) ? requested : scope.defaultLocale) ?? void 0;
+};
+/**
+* Reads the current draft in a fixed locale with no fallback, which is the
+* shape that may be written back or validated without mixing locales.
+*/ const readTarget = async (scope, args) => {
+	const { payload } = scope.req;
+	const privileged = args.privileged === true;
+	const shared = {
+		depth: 0,
+		draft: true,
+		...args.locale === void 0 ? {} : {
+			locale: args.locale,
+			fallbackLocale: false
+		},
+		overrideAccess: privileged,
+		showHiddenFields: privileged,
+		req: scope.req
+	};
+	if (args.target.kind === "collection") {
+		const doc = await payload.findByID({
+			...shared,
+			collection: args.target.slug,
+			id: args.id,
+			disableErrors: true
+		});
+		if (!doc) throw new NotFound(scope.req.t);
+		return doc;
+	}
+	return await payload.findGlobal({
+		...shared,
+		slug: args.target.slug
+	});
+};
+/**
+* Resolves a collection label for the request's language.
+*/ const translateLabel = (scope, label, fallback) => {
+	const { i18n, t } = scope.req;
+	const resolved = typeof label === "function" ? label({
+		i18n,
+		t
+	}) : label;
+	return translateStatic(resolved, i18n) ?? fallback;
+};
+//#endregion
+export { depthShape, idSchema, idShape, localeOf, localeShape, readTarget, slugEnum, targetShape, translateLabel };

package/dist/tools/target.d.mts

@@ -0,0 +1,3 @@
+import "./types.mjs";
+import "../schema/walk.mjs";
+import "payload";

package/dist/tools/target.mjs

@@ -0,0 +1,49 @@
+import { APIError, Forbidden } from "payload";
+//#region src/tools/target.ts
+const refOf = (target) => ({
+	kind: target.kind,
+	slug: target.slug
+});
+/**
+* Resolves the `collection`/`global` arguments to one entity and checks the key
+* may perform `operation` on it.
+*
+* A tool's `inputSchema` returns a raw shape, which leaves no top-level
+* `.refine` to express "exactly one of collection and global". The rule is
+* enforced here instead, with a message naming the offending arguments so one
+* failed call teaches it.
+*/ const resolveTarget = (scope, args, operation) => {
+	const { collection, global } = args;
+	if (collection !== void 0 && global !== void 0) throw new APIError("Pass either \"collection\" or \"global\", not both.", 400);
+	if (collection === void 0 && global === void 0) throw new APIError("One of \"collection\" or \"global\" is required. Call listCapabilities to see which slugs are available.", 400);
+	if (collection !== void 0) {
+		const allowed = operation === "read" ? scope.readable : scope.writable;
+		const found = scope.req.payload.collections[collection];
+		if (!allowed.includes(collection) || !found) throw new Forbidden(scope.req.t);
+		return {
+			kind: "collection",
+			slug: collection,
+			config: found.config
+		};
+	}
+	const slug = global;
+	const allowed = operation === "read" ? scope.readableGlobals : scope.writableGlobals;
+	const found = scope.req.payload.globals.config.find((candidate) => candidate.slug === slug);
+	if (!allowed.includes(slug) || !found) throw new Forbidden(scope.req.t);
+	return {
+		kind: "global",
+		slug,
+		config: found
+	};
+};
+/**
+* Checks `id` against the resolved target. A collection document needs one; a
+* global is a singleton and must not carry one. The schema cannot express the
+* dependency, so it is stated here and in every affected tool description.
+*/ const requireIdFor = (target, id) => {
+	if (target.kind === "collection" && id === void 0) throw new APIError(`"id" is required when "collection" is "${target.slug}".`, 400);
+	if (target.kind === "global" && id !== void 0) throw new APIError(`"id" must be omitted when "global" is "${target.slug}"; a global is a singleton.`, 400);
+	return target.kind === "collection" ? id : void 0;
+};
+//#endregion
+export { refOf, requireIdFor, resolveTarget };

package/dist/tools/types.d.mts

@@ -0,0 +1,5 @@
+import "../types.mjs";
+import "../options.mjs";
+import { PayloadRequest } from "payload";
+import { z } from "zod";
+import { CallToolResult, ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";

package/dist/tools/validate-document.mjs

@@ -0,0 +1,55 @@
+import { jsonResult } from "../endpoint/result.mjs";
+import { idShape, localeOf, localeShape, readTarget, targetShape } from "./shared.mjs";
+import { requireIdFor, resolveTarget } from "./target.mjs";
+import { collectPublishBlockers } from "../write/publish-blockers.mjs";
+//#region src/tools/validate-document.ts
+const validateDocument = {
+	name: "validateDocument",
+	description: `Reports what still prevents a human from publishing the draft, without writing anything. The same list patchDocument returns after a write; use it to check work or to answer "is this ready".
+
+Pass exactly one of "collection" and "global". "id" is required with "collection" and must be omitted with "global", because a global is a singleton.`,
+	annotations: {
+		readOnlyHint: true,
+		openWorldHint: false
+	},
+	isEnabled: (scope) => scope.writable.length + scope.writableGlobals.length > 0,
+	inputSchema: (scope) => ({
+		...targetShape(scope, "write", {
+			collection: "Collection holding the document.",
+			global: "Global to validate."
+		}),
+		...idShape(scope, "write"),
+		...localeShape(scope, {
+			required: true,
+			description: "Locale to validate."
+		})
+	}),
+	handler: async (args, scope) => {
+		const target = resolveTarget(scope, args, "write");
+		const id = requireIdFor(target, args.id);
+		const locale = localeOf(scope, args.locale);
+		await readTarget(scope, {
+			target,
+			id,
+			locale
+		});
+		const doc = await readTarget(scope, {
+			target,
+			id,
+			locale,
+			privileged: true
+		});
+		const publishBlockers = await collectPublishBlockers(scope.req, {
+			doc,
+			entity: target
+		});
+		return jsonResult({
+			...target.kind === "collection" ? { id: doc["id"] } : { global: target.slug },
+			status: doc["_status"],
+			updatedAt: doc["updatedAt"],
+			publishBlockers
+		});
+	}
+};
+//#endregion
+export { validateDocument };

package/dist/types.d.mts

@@ -0,0 +1,143 @@
+import { CollectionConfig, CollectionSlug, GlobalSlug, PayloadRequest, TypedUser } from "payload";
+import { z } from "zod";
+import { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import { CallToolResult, ServerNotification, ServerRequest, ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
+//#region src/types.d.ts
+declare module "payload" {
+  interface RequestContext {
+    mcpx?: McpxRequestContext;
+  }
+  interface RegisteredPlugins {
+    "@abinnovision/payloadcms-mcpx": McpxPluginOptions;
+  }
+}
+/**
+ * What an exposed collection offers to MCP clients. A key can only enable
+ * what the config exposes here.
+ */
+interface McpxCollectionOptions {
+  /**
+   * Expose `describeSchema`, `findDocuments` and `getDocument`. Default `true`.
+   */
+  read?: boolean;
+  /**
+   * Expose `patchDocument`, `createDocument` and `validateDocument`. Default
+   * `false`. Requires `versions.drafts` unless `allowLiveWrites` is set.
+   */
+  write?: boolean;
+  /**
+   * Permit writes to a collection without drafts. Such writes land on the live
+   * document because there is no draft to land on. Default `false`.
+   */
+  allowLiveWrites?: boolean;
+}
+/**
+ * What an exposed global offers to MCP clients. Structurally the same as
+ * {@link McpxCollectionOptions}, kept separate because the tools it names
+ * differ: a global is a singleton, so neither `findDocuments` nor
+ * `createDocument` reaches one.
+ */
+interface McpxGlobalOptions {
+  /** Expose `describeSchema` and `getDocument`. Default `true`. */
+  read?: boolean;
+  /**
+   * Expose `patchDocument` and `validateDocument`. Default `false`. Requires
+   * `versions.drafts` unless `allowLiveWrites` is set.
+   */
+  write?: boolean;
+  /**
+   * Permit writes to a global without drafts. Such writes land on the live
+   * document because there is no draft to land on. Default `false`.
+   */
+  allowLiveWrites?: boolean;
+}
+type McpxToolExtra = RequestHandlerExtra<ServerRequest, ServerNotification>;
+/**
+ * A custom tool. It is gated by its own checkbox on every API key and runs
+ * with `req.user` resolved from the key and `req.context.mcpx` set.
+ */
+interface McpxTool<Shape extends z.ZodRawShape = z.ZodRawShape> {
+  /** camelCase, unique, not one of the builtin tool names. */
+  name: string;
+  description: string;
+  inputSchema?: Shape;
+  annotations?: ToolAnnotations;
+  handler(ctx: {
+    args: z.infer<z.ZodObject<Shape>>;
+    req: PayloadRequest;
+    extra: McpxToolExtra;
+  }): CallToolResult | Promise<CallToolResult>;
+}
+/**
+ * Identity helper that infers the argument type of a custom tool's handler
+ * from its input schema.
+ */
+declare const defineMcpxTool: <Shape extends z.ZodRawShape>(tool: McpxTool<Shape>) => McpxTool<Shape>;
+/**
+ * Outcome of resolving an API key. `user` must carry `collection`.
+ */
+interface McpxAuthResult {
+  user: TypedUser;
+  apiKeyId: number | string;
+  /** The `capabilities` group as stored on the key document. */
+  capabilities: unknown;
+}
+type McpxPluginOptions = {
+  /** Allow-list of collections. `true` is shorthand for `{ read: true }`. */
+  collections: Partial<Record<CollectionSlug, McpxCollectionOptions | true>>;
+  /** Allow-list of globals. `true` is shorthand for `{ read: true }`. */
+  globals?: Partial<Record<GlobalSlug, McpxGlobalOptions | true>>;
+  /** Collection the keys act as. Default `config.admin.user`, then `users`. */
+  userCollection?: CollectionSlug;
+  apiKeys?: {
+    /** Slug of the generated API key collection. Default `mcpx-api-keys`. */
+    slug?: string;
+    /**
+     * Add a "Connect a client" tab to saved keys, holding ready-to-paste MCP
+     * client config. Default `true`. The snippets contain the key in full.
+     */
+    setupGuide?: boolean;
+    /** Final override applied to the generated collection. */
+    overrideCollection?: (collection: CollectionConfig) => CollectionConfig;
+  };
+  endpoint?: {
+    /** Endpoint path below the API route. Default `/mcpx`. */
+    path?: string;
+  };
+  limits?: {
+    /** Upper bound for `findDocuments.limit`. Default 25. */
+    maxLimit?: number;
+    /** Upper bound for `depth` on reads. Default 1. */
+    maxDepth?: number;
+  };
+  tools?: McpxTool[];
+  auth?: {
+    /** Replace or wrap the default key resolution. Return `null` for 401. */
+    resolve?: (args: {
+      req: PayloadRequest;
+      resolveDefault: () => Promise<McpxAuthResult | null>;
+    }) => Promise<McpxAuthResult | null>;
+  };
+  serverInfo?: {
+    name?: string;
+    version?: string;
+  };
+};
+interface McpxCollectionCapabilities {
+  read: boolean;
+  write: boolean;
+}
+/**
+ * Capabilities in force for one request: plugin config AND key checkboxes.
+ */
+interface McpxResolvedCapabilities {
+  collections: Record<string, McpxCollectionCapabilities>;
+  globals: Record<string, McpxCollectionCapabilities>;
+  tools: Record<string, boolean>;
+}
+interface McpxRequestContext {
+  apiKeyId: number | string;
+  capabilities: McpxResolvedCapabilities;
+}
+//#endregion
+export { McpxAuthResult, McpxCollectionCapabilities, McpxCollectionOptions, McpxGlobalOptions, McpxPluginOptions, McpxRequestContext, McpxResolvedCapabilities, McpxTool, McpxToolExtra, defineMcpxTool };

package/dist/types.mjs

@@ -0,0 +1,7 @@
+//#region src/types.ts
+/**
+* Identity helper that infers the argument type of a custom tool's handler
+* from its input schema.
+*/ const defineMcpxTool = (tool) => tool;
+//#endregion
+export { defineMcpxTool };

package/dist/version.mjs

@@ -0,0 +1,6 @@
+//#region src/version.ts
+/**
+* Package version injected at build time; sources under Vitest report "dev".
+*/ const MCPX_VERSION = "0.0.0";
+//#endregion
+export { MCPX_VERSION };

package/dist/write/draft-guard.d.mts

@@ -0,0 +1,10 @@
+import { CollectionConfig, PayloadRequest } from "payload";
+//#region src/write/draft-guard.d.ts
+/**
+ * Whether a request originated from the MCP endpoint. The endpoint stamps
+ * `req.context.mcpx`, which travels into every local API call made with the
+ * same `req`, including those made by custom tools.
+ */
+declare const isMcpxRequest: (req: PayloadRequest) => boolean;
+//#endregion
+export { isMcpxRequest };