@abinnovision/payloadcms-mcpx 1.0.0-beta.3

package/dist/schema/shape.mjs

@@ -0,0 +1,147 @@
+import { blockOf, blockSlugsOf, describeFields, findBlocksField, joinPath, splitPath } from "./walk.mjs";
+//#region src/schema/shape.ts
+/**
+* Keys Payload manages on a row that a client may echo back harmlessly.
+*/ const TOLERATED_VALUE_KEYS = /* @__PURE__ */ new Set([
+	"blockName",
+	"blockType",
+	"id"
+]);
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Checks every node type in an editor state against what the field's editor
+* can actually produce.
+*
+* Payload does not: the Lexical validator runs node validations only for the
+* few node types that register one, so a `heading` inside a field whose
+* editor has no heading feature is stored without complaint and only fails
+* later, at render or when the document is reopened in the admin editor.
+*/ const checkRichText = (scope, allowed, value) => {
+	if (!isPlainObject(value) || !isPlainObject(value["root"])) {
+		scope.problems.push(`${scope.pointer}: expected a Lexical editor state with a "root".`);
+		return;
+	}
+	const walk = (nodes) => {
+		if (!Array.isArray(nodes)) return;
+		for (const node of nodes) {
+			if (!isPlainObject(node) || typeof node["type"] !== "string") {
+				scope.problems.push(`${scope.pointer}: every node needs a "type".`);
+				continue;
+			}
+			if (!allowed.includes(node["type"])) scope.problems.push(`${scope.pointer}: "${node["type"]}" is not available in this field's editor. Allowed: ${allowed.join(", ")}`);
+			walk(node["children"]);
+		}
+	};
+	walk(value["root"]["children"]);
+};
+const checkLeafValue = (scope, descriptor, value) => {
+	if (descriptor.readOnly) {
+		scope.problems.push(`${scope.pointer}: "${descriptor.path}" is read-only and cannot be written.`);
+		return;
+	}
+	if (descriptor.type === "richText") {
+		checkRichText(scope, descriptor.nodes ?? [], value);
+		return;
+	}
+	if (descriptor.type !== "blocks") return;
+	if (!Array.isArray(value)) {
+		scope.problems.push(`${scope.pointer}: expected an array of blocks.`);
+		return;
+	}
+	const field = findBlocksField(scope.fields, splitPath(descriptor.path));
+	if (!field) return;
+	value.forEach((row, index) => {
+		const slug = isPlainObject(row) ? row["blockType"] : void 0;
+		const block = typeof slug === "string" ? blockOf(scope.config, field, slug) : void 0;
+		if (!block) {
+			scope.problems.push(`${scope.pointer}/${String(index)}: "${String(slug)}" is not allowed here. Allowed: ${blockSlugsOf(field).join(", ")}`);
+			return;
+		}
+		checkValue({
+			...scope,
+			fields: block.flattenedFields,
+			pointer: `${scope.pointer}/${String(index)}`,
+			prefix: ""
+		}, row);
+	});
+};
+/**
+* Walks an incoming value against the schema, reporting every shape problem
+* rather than the first.
+*
+* Shape only: unknown field names, unknown block slugs, read-only fields and
+* unusable rich text nodes. Required-ness, row counts, enum membership and
+* relationship existence stay with Payload, which already checks them and
+* reports them per field. Without this pass a misspelled field inside a new
+* block would be stripped in silence.
+*/ const checkValue = (scope, value) => {
+	if (!isPlainObject(value)) return;
+	const prefixParts = scope.prefix ? splitPath(scope.prefix) : [];
+	const relative = describeFields(scope.fields).flatMap((descriptor) => {
+		const parts = splitPath(descriptor.path);
+		return prefixParts.every((part, offset) => part === parts[offset]) ? [{
+			descriptor,
+			parts: parts.slice(prefixParts.length)
+		}] : [];
+	});
+	for (const [key, entry] of Object.entries(value)) {
+		if (TOLERATED_VALUE_KEYS.has(key)) continue;
+		const candidates = relative.filter(({ parts }) => parts[0] === key);
+		const pointer = `${scope.pointer}/${key}`;
+		if (candidates.length === 0) {
+			scope.problems.push(`${pointer}: no such field. Available: ${[...new Set(relative.map(({ parts }) => parts[0]))].join(", ")}`);
+			continue;
+		}
+		const exact = candidates.find(({ parts }) => parts.length === 1);
+		if (exact) {
+			checkLeafValue({
+				...scope,
+				pointer
+			}, exact.descriptor, entry);
+			continue;
+		}
+		if (candidates.some(({ parts }) => parts[1] === "[]")) {
+			if (!Array.isArray(entry)) {
+				scope.problems.push(`${pointer}: expected an array.`);
+				continue;
+			}
+			entry.forEach((row, index) => {
+				checkValue({
+					...scope,
+					pointer: `${pointer}/${String(index)}`,
+					prefix: joinPath([
+						...prefixParts,
+						key,
+						"[]"
+					])
+				}, row);
+			});
+			continue;
+		}
+		checkValue({
+			...scope,
+			pointer,
+			prefix: joinPath([...prefixParts, key])
+		}, entry);
+	}
+};
+/**
+* Shape problems with a value about to be written at a resolved pointer.
+*/ const validateWriteValue = (config, target, value) => {
+	const problems = [];
+	const scope = {
+		config,
+		fields: target.resolution.fields,
+		pointer: target.pointer,
+		prefix: target.resolution.prefix,
+		problems
+	};
+	if (target.resolution.descriptor) {
+		checkLeafValue(scope, target.resolution.descriptor, value);
+		return problems;
+	}
+	checkValue(scope, value);
+	return problems;
+};
+//#endregion
+export { validateWriteValue };

package/dist/schema/walk.mjs

@@ -0,0 +1,109 @@
+import { allowedNodeTypes } from "./lexical.mjs";
+import { fieldIsHiddenOrDisabled, fieldIsVirtual } from "payload/shared";
+//#region src/schema/walk.ts
+/**
+* Fields Payload maintains, which a client may neither address nor supply.
+*/ const RESERVED_FIELD_NAMES = /* @__PURE__ */ new Set([
+	"_status",
+	"createdAt",
+	"deletedAt",
+	"id",
+	"updatedAt"
+]);
+/**
+* Joins path segments, attaching the array marker to its field rather than
+* separating it, so an array subfield reads `items[].title`.
+*/ const joinPath = (parts) => parts.reduce((path, part) => part === "[]" ? `${path}[]` : path ? `${path}.${part}` : part, "");
+/**
+* Splits a descriptor path back into pointer-comparable segments, with the
+* array marker as a segment of its own.
+*/ const splitPath = (path) => path.split(".").flatMap((part) => part.endsWith("[]") ? [part.slice(0, -2), "[]"] : [part]);
+/**
+* Blocks a blocks field accepts, by slug. On a flattened field, whichever of
+* `blockReferences` and `blocks` was declared carries the definitions.
+*/ const blockSlugsOf = (field) => [...new Set((field.blockReferences ?? field.blocks).map((block) => typeof block === "string" ? block : block.slug))];
+/**
+* Resolves one of a blocks field's slugs to its definition.
+*
+* A definition inlined on the field wins over the shared registry. A block's
+* own fields are identical wherever it appears, but the blocks its children
+* accept are not, so an inline definition has to be read at its position.
+* The registry (`config.blocks`) is the fallback for slugs referenced by name.
+*/ const blockOf = (config, field, slug) => {
+	const declared = field.blockReferences ?? field.blocks;
+	const inline = declared.find((block) => typeof block !== "string" && block.slug === slug);
+	if (inline) return inline;
+	return declared.includes(slug) ? config.blocks?.find((block) => block.slug === slug) : void 0;
+};
+const isSkipped = (field) => !("name" in field) || field.type === "join" || RESERVED_FIELD_NAMES.has(field.name) || fieldIsVirtual(field) || fieldIsHiddenOrDisabled(field);
+const isReadOnly = (field) => "admin" in field && field.admin.readOnly === true;
+/**
+* The `admin.description` of a field or collection, when it is serializable:
+* a string or a locale-keyed record. Functions and components are admin-UI
+* constructs and are dropped.
+*/ const staticDescription = (description) => {
+	if (typeof description === "string") return description;
+	return typeof description === "object" && description !== null && Object.values(description).every((entry) => typeof entry === "string") ? description : void 0;
+};
+const describeBase = (field, path, readOnly) => {
+	const description = staticDescription("admin" in field ? field.admin.description : void 0);
+	return {
+		path,
+		type: field.type,
+		...description === void 0 ? {} : { description },
+		..."required" in field && field.required ? { required: true } : {},
+		..."localized" in field && field.localized ? { localized: true } : {},
+		...readOnly ? { readOnly: true } : {}
+	};
+};
+const describeLeaf = (field, path, readOnly) => {
+	const descriptor = describeBase(field, path, readOnly);
+	if (field.type === "select" || field.type === "radio") descriptor.options = field.options.map((option) => typeof option === "string" ? option : option.value);
+	if (field.type === "relationship" || field.type === "upload") descriptor.relationTo = field.relationTo;
+	if ((field.type === "select" || field.type === "relationship" || field.type === "upload") && field.hasMany === true) descriptor.hasMany = true;
+	if (field.type === "richText") descriptor.nodes = allowedNodeTypes(field);
+	return descriptor;
+};
+const withRows = (descriptor, field) => ({
+	...descriptor,
+	...field.minRows === void 0 ? {} : { minRows: field.minRows },
+	...field.maxRows === void 0 ? {} : { maxRows: field.maxRows }
+});
+/**
+* Flattens a field list into descriptors addressed relative to the node.
+*
+* The input is Payload's own flattened shape, which has already merged every
+* construct that exists only in the admin UI (unnamed tabs, unnamed groups,
+* `row`, `collapsible`) and dropped `ui` fields. Named tabs, groups and
+* arrays contribute a path segment. The walk stops at every blocks field and
+* names the slugs instead of descending, which keeps a node proportional to
+* the number of blocks it allows rather than to the size of their definitions.
+*/ const describeFields = (fields, prefix = [], parentReadOnly = false) => fields.flatMap((field) => {
+	if (isSkipped(field)) return [];
+	const readOnly = parentReadOnly || isReadOnly(field);
+	const path = [...prefix, field.name];
+	if (field.type === "tab" || field.type === "group") return describeFields(field.flattenedFields, path, readOnly);
+	if (field.type === "array") return describeFields(field.flattenedFields, [...path, "[]"], readOnly);
+	if (field.type === "blocks") return [withRows({
+		...describeBase(field, joinPath(path), readOnly),
+		blocks: blockSlugsOf(field)
+	}, field)];
+	return [describeLeaf(field, joinPath(path), readOnly)];
+});
+/**
+* Locates the blocks field that a resolved descriptor path refers to.
+*/ const findBlocksField = (fields, path) => {
+	for (const field of fields) {
+		if (!("name" in field) || field.name !== path[0]) continue;
+		if (field.type === "blocks" && path.length === 1) return field;
+		if (field.type === "tab" || field.type === "group") return findBlocksField(field.flattenedFields, path.slice(1));
+		if (field.type === "array" && path[1] === "[]") return findBlocksField(field.flattenedFields, path.slice(2));
+	}
+};
+const collectionOf = (config, collection) => {
+	const found = config.collections.find((candidate) => candidate.slug === collection);
+	if (!found) throw new Error(`Unknown collection "${collection}".`);
+	return found;
+};
+//#endregion
+export { RESERVED_FIELD_NAMES, blockOf, blockSlugsOf, collectionOf, describeFields, findBlocksField, joinPath, splitPath, staticDescription };

package/dist/tools/create-document.mjs

@@ -0,0 +1,67 @@
+import { errorResult, jsonResult } from "../endpoint/result.mjs";
+import { collectionEnum, ensureAllowed, localeOf, localeShape, readDraft } from "./shared.mjs";
+import { validateWriteValue } from "../schema/shape.mjs";
+import { stripRowIds } from "../write/patch.mjs";
+import { collectPublishBlockers } from "../write/publish-blockers.mjs";
+import { z } from "zod";
+//#region src/tools/create-document.ts
+const createDocument = {
+	name: "createDocument",
+	description: `Creates a new document as a draft from a minimal seed. Only the fields describeSchema lists may appear in "data"; unknown keys are refused with the valid siblings. The draft may be incomplete: the response lists "publishBlockers", which patchDocument can then work through. Use this when no document exists yet; prefer patching an existing draft otherwise.`,
+	annotations: {
+		readOnlyHint: false,
+		destructiveHint: false,
+		idempotentHint: false,
+		openWorldHint: false
+	},
+	isEnabled: (scope) => scope.writable.length > 0,
+	inputSchema: (scope) => ({
+		collection: collectionEnum(scope.writable).describe("Collection to create the document in."),
+		...localeShape(scope, {
+			required: true,
+			description: "Locale the localized fields of the seed belong to."
+		}),
+		data: z.record(z.string(), z.unknown()).describe("Initial field values, as describeSchema lists them.")
+	}),
+	handler: async (args, scope) => {
+		const collection = ensureAllowed(scope, args.collection, "write");
+		const { payload } = scope.req;
+		const locale = localeOf(scope, args.locale);
+		const { id: _ignored, ...seed } = args.data;
+		const problems = validateWriteValue(payload.config, {
+			pointer: "",
+			resolution: {
+				fields: collection.flattenedFields,
+				prefix: ""
+			}
+		}, seed);
+		if (problems.length > 0) return errorResult("Nothing was created.", { problems });
+		const created = await payload.create({
+			collection: args.collection,
+			data: stripRowIds(seed),
+			depth: 0,
+			draft: true,
+			overrideAccess: false,
+			req: scope.req,
+			...locale === void 0 ? {} : { locale }
+		});
+		const saved = await readDraft(scope, {
+			collection: args.collection,
+			id: created["id"],
+			locale,
+			privileged: true
+		});
+		const publishBlockers = await collectPublishBlockers(scope.req, {
+			collection,
+			doc: saved
+		});
+		return jsonResult({
+			id: saved["id"],
+			status: saved["_status"],
+			updatedAt: saved["updatedAt"],
+			...publishBlockers.length > 0 ? { publishBlockers } : {}
+		});
+	}
+};
+//#endregion
+export { createDocument };

package/dist/tools/describe-schema.mjs

@@ -0,0 +1,44 @@
+import { jsonResult } from "../endpoint/result.mjs";
+import { collectionEnum, ensureAllowed } from "./shared.mjs";
+import { describeNode, reachableSchemaPaths } from "../schema/describe.mjs";
+import { z } from "zod";
+//#region src/tools/describe-schema.ts
+const describeSchema = {
+	name: "describeSchema",
+	description: `Describes the writable shape of a document, one node at a time.
+
+Call it with no "paths" to get a collection's own fields. Every "blocks" field stops there and lists the block slugs it accepts instead of nesting them; each node's "next" lists the ready-to-use paths for those blocks, so pass any entry of "next" as a "paths" element to descend, e.g. "layout.sections.sectionWrapper" and then "layout.sections.sectionWrapper.modules.hero". A block is described as it exists at that position, because the same block can accept different children elsewhere.
+
+Field paths are dotted and already resolved through anything that does not nest in the stored document. To turn one into a patchDocument pointer, replace each "." with "/", add a leading "/", and replace each "[]" with a 0-based index. Note a path here names a block by its slug where a pointer names it by its index.
+
+Fields Payload maintains (id, _status, createdAt, updatedAt) are never listed and cannot be written. Fields marked readOnly are listed but refused on write.`,
+	annotations: {
+		readOnlyHint: true,
+		openWorldHint: false
+	},
+	isEnabled: (scope) => scope.readable.length > 0,
+	inputSchema: (scope) => ({
+		collection: collectionEnum(scope.readable).describe("Collection to describe."),
+		paths: z.array(z.string()).optional().describe("Schema paths to describe, e.g. \"layout.sections.sectionWrapper\". Omit for the collection root."),
+		expand: z.boolean().optional().describe("Return every node reachable from the root in one response. Ignores paths.")
+	}),
+	handler: (args, scope) => {
+		ensureAllowed(scope, args.collection, "read");
+		const { config } = scope.req.payload;
+		const expanded = args.expand === true ? reachableSchemaPaths(config, args.collection) : void 0;
+		const nodes = (expanded?.paths ?? (args.paths && args.paths.length > 0 ? args.paths : [""])).map((schemaPath) => {
+			try {
+				return describeNode(config, args.collection, schemaPath);
+			} catch (error) {
+				return {
+					error: error instanceof Error ? error.message : "Unknown error",
+					schemaPath
+				};
+			}
+		});
+		if (expanded?.truncated) nodes.push({ error: `Result truncated after ${String(400)} nodes. Request explicit paths instead.` });
+		return Promise.resolve(jsonResult(nodes));
+	}
+};
+//#endregion
+export { describeSchema };

package/dist/tools/find-documents.mjs

@@ -0,0 +1,54 @@
+import { jsonResult } from "../endpoint/result.mjs";
+import { collectionEnum, depthShape, ensureAllowed, localeOf, localeShape } from "./shared.mjs";
+import { z } from "zod";
+//#region src/tools/find-documents.ts
+const findDocuments = {
+	name: "findDocuments",
+	description: `Finds documents in a collection. "where" is a Payload query object, e.g. {"title":{"contains":"home"}} or {"and":[...]}; "select" picks fields, e.g. {"title":true}. Drafts are included by default so unpublished work is visible. Keep depth at 0 unless populated relationships are needed; ids are enough for writes.`,
+	annotations: {
+		readOnlyHint: true,
+		openWorldHint: false
+	},
+	isEnabled: (scope) => scope.readable.length > 0,
+	inputSchema: (scope) => ({
+		collection: collectionEnum(scope.readable).describe("Collection to search."),
+		where: z.record(z.string(), z.unknown()).optional().describe("Payload where query."),
+		sort: z.string().optional().describe("Sort field, prefix with \"-\" for descending."),
+		limit: z.number().int().min(1).max(scope.options.limits.maxLimit).optional().describe(`Documents per page. Default 10, at most ${String(scope.options.limits.maxLimit)}.`),
+		page: z.number().int().min(1).optional().describe("Page number, from 1."),
+		...depthShape(scope),
+		select: z.record(z.string(), z.unknown()).optional().describe("Fields to return, e.g. {\"title\":true}."),
+		...localeShape(scope, {
+			required: false,
+			description: "Locale to read. Defaults to the default locale."
+		}),
+		draft: z.boolean().optional().describe("Include the latest drafts. Default true.")
+	}),
+	handler: async (args, scope) => {
+		ensureAllowed(scope, args.collection, "read");
+		const locale = localeOf(scope, args.locale);
+		const result = await scope.req.payload.find({
+			collection: args.collection,
+			depth: args.depth ?? 0,
+			draft: args.draft ?? true,
+			limit: args.limit ?? 10,
+			overrideAccess: false,
+			req: scope.req,
+			...args.page === void 0 ? {} : { page: args.page },
+			...args.sort === void 0 ? {} : { sort: args.sort },
+			...args.where === void 0 ? {} : { where: args.where },
+			...args.select === void 0 ? {} : { select: args.select },
+			...locale === void 0 ? {} : { locale }
+		});
+		return jsonResult({
+			docs: result.docs,
+			totalDocs: result.totalDocs,
+			page: result.page,
+			totalPages: result.totalPages,
+			limit: result.limit,
+			hasNextPage: result.hasNextPage
+		});
+	}
+};
+//#endregion
+export { findDocuments };

package/dist/tools/get-document.mjs

@@ -0,0 +1,54 @@
+import { errorResult, jsonResult } from "../endpoint/result.mjs";
+import { collectionEnum, depthShape, ensureAllowed, idSchema, localeOf, localeShape } from "./shared.mjs";
+import { z } from "zod";
+import { Pointer } from "rfc6902";
+//#region src/tools/get-document.ts
+const getDocument = {
+	name: "getDocument",
+	description: `Reads one document, or one subtree of it when "path" is given as a JSON pointer such as "/layout/sections/2". Returns the latest draft by default. Read before patching: the response carries "updatedAt" for expectedUpdatedAt and the indices pointers need.`,
+	annotations: {
+		readOnlyHint: true,
+		openWorldHint: false
+	},
+	isEnabled: (scope) => scope.readable.length > 0,
+	inputSchema: (scope) => ({
+		collection: collectionEnum(scope.readable).describe("Collection holding the document."),
+		id: idSchema,
+		path: z.string().optional().describe("JSON pointer to return only a subtree, e.g. \"/layout/sections/0\"."),
+		...depthShape(scope),
+		...localeShape(scope, {
+			required: false,
+			description: "Locale to read. Defaults to the default locale."
+		}),
+		draft: z.boolean().optional().describe("Return the latest draft. Default true.")
+	}),
+	handler: async (args, scope) => {
+		ensureAllowed(scope, args.collection, "read");
+		const locale = localeOf(scope, args.locale);
+		const doc = await scope.req.payload.findByID({
+			collection: args.collection,
+			id: args.id,
+			depth: args.depth ?? 0,
+			draft: args.draft ?? true,
+			overrideAccess: false,
+			req: scope.req,
+			...locale === void 0 ? {} : { locale }
+		});
+		if (args.path === void 0 || args.path === "") return jsonResult(doc);
+		let value;
+		try {
+			value = Pointer.fromJSON(args.path).get(doc);
+		} catch {
+			return errorResult(`"${args.path}" is not a valid JSON pointer.`);
+		}
+		return jsonResult({
+			id: doc["id"],
+			status: doc["_status"],
+			updatedAt: doc["updatedAt"],
+			path: args.path,
+			value
+		});
+	}
+};
+//#endregion
+export { getDocument };

package/dist/tools/index.mjs

@@ -0,0 +1,23 @@
+import { createDocument } from "./create-document.mjs";
+import { describeSchema } from "./describe-schema.mjs";
+import { findDocuments } from "./find-documents.mjs";
+import { getDocument } from "./get-document.mjs";
+import { listCapabilities } from "./list-capabilities.mjs";
+import { patchDocument } from "./patch-document.mjs";
+import { validateDocument } from "./validate-document.mjs";
+//#region src/tools/index.ts
+/**
+* The builtin tools in registration order. The surface is fixed: adding a
+* collection, block or field never changes it. Typed over `never` because
+* each tool validates its own arguments through its input schema.
+*/ const BUILTIN_TOOLS = [
+	listCapabilities,
+	describeSchema,
+	findDocuments,
+	getDocument,
+	patchDocument,
+	createDocument,
+	validateDocument
+];
+//#endregion
+export { BUILTIN_TOOLS };

package/dist/tools/list-capabilities.mjs

@@ -0,0 +1,49 @@
+import { jsonResult } from "../endpoint/result.mjs";
+import { translateLabel } from "./shared.mjs";
+import { staticDescription } from "../schema/walk.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 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.`,
+	annotations: {
+		readOnlyHint: true,
+		openWorldHint: false
+	},
+	isEnabled: () => true,
+	inputSchema: () => ({}),
+	handler: (_args, scope) => {
+		const { payload } = scope.req;
+		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 = staticDescription(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
+			}];
+		});
+		return Promise.resolve(jsonResult({
+			collections,
+			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 };