drupal-mcp-connector 3.1.0 → 3.2.1

package/src/lib/operations.js

@@ -18,7 +18,7 @@ const WRITE_PREFIXES = ["drupal_create_", "drupal_update_", "drupal_upload_",
   "drupal_drush_updatedb", "drupal_drush_module_enable",
   "drupal_drush_module_disable", "drupal_drush_user_create",
   // v1.0 feature tools that perform writes but don't start with create_/update_:
-  "drupal_bulk_", "drupal_revert_", "drupal_schedule_", "drupal_set_",
+  "drupal_bulk_", "drupal_revert_", "drupal_schedule_", "drupal_set_", "drupal_draft_",
   // Governed config write (also gated inside the handler by the config-write cap):
   "drupal_config_set"];
 

package/src/lib/patch-preflight.js

@@ -24,6 +24,12 @@
 
 import { entityLooksModerated, hasExplicitModerationState } from "./moderation-default.js";
 import { entityRevisionId } from "./write-revision.js";
+import {
+  isCanonicalDraftType,
+  preflightGovernedCanonicalDraft,
+  resolveCanonicalDraftIdentity,
+  writeCanonicalModeratedEntity,
+} from "./canonical-draft.js";
 import { httpStatusOf } from "./error-status.js";
 import {
   writeDraft,
@@ -245,6 +251,20 @@ export async function loadWorkingCopy(backend, { entityType, bundle, id }) {
  * @throws {PatchTargetAmbiguousError}
  */
 export async function resolveWorkingCopyPatchTarget(backend, { entityType, bundle, id, existing }) {
+  if (isCanonicalDraftType(entityType)) {
+    // A readable unmoderated block or library item has no draft alias to
+    // prove. Identity resolution stays fail-closed when the entity is
+    // moderated or could not be read.
+    if (existing && !entityLooksModerated(existing)) {
+      return {
+        resourceVersion: undefined,
+        workingCopy: null,
+        liveVid: entityRevisionId(existing, entityType),
+        workingVid: null,
+      };
+    }
+    return resolveCanonicalDraftIdentity(backend, { entityType, bundle, id, existing });
+  }
   const workingCopy = await loadWorkingCopy(backend, { entityType, bundle, id });
   if (workingCopy?.id && workingCopy.id !== id) {
     throw new PatchTargetAmbiguousError(id, workingCopy.id);
@@ -478,6 +498,17 @@ export async function prepareGuardedPatch(backend, {
     target.preflight = PREFLIGHT_SENTINEL_DRAFT;
     return target;
   }
+  if (target.governedDraft) {
+    try {
+      await preflightGovernedCanonicalDraft(backend, {
+        entityType, bundle, id, attributes, relationships, governedDraft: target.governedDraft,
+      });
+    } catch (err) {
+      throw rewriteStaleCopyError(err);
+    }
+    target.preflight = PREFLIGHT_SENTINEL_DRAFT;
+    return target;
+  }
   if (target.resourceVersion) {
     const draftRevisionFor = (lang) => ({
       liveVid: target.liveVid,
@@ -584,6 +615,9 @@ function explainDefaultLanguageRefusal(err, inferredLangcode) {
  * @throws {PatchBlockedError|WorkingCopyStaleError|*}
  */
 export async function updateEntityGuarded(backend, input) {
+  if (isCanonicalDraftType(input?.entityType) && !input?.draftRevision && !input?.resourceVersion) {
+    return writeCanonicalModeratedEntity(backend, input);
+  }
   try {
     if (input?.draftRevision) return await writeDraft(backend, input);
     if (input?.resourceVersion) {

package/src/lib/text-format-context.js

@@ -0,0 +1,248 @@
+/**
+ * Text-format restrictions from MCP Sentinel's site schema (#429).
+ *
+ * A content-tier token cannot read JSON:API `field_config` (that needs
+ * "administer node fields") and this connector's production configs often
+ * have no Drush bridge. Sentinel's `GET /drupal-mcp/context` is the schema
+ * that token can read. When a field entry includes `allowed_formats`, that
+ * list is Field API's restriction: one entry is the default, any other
+ * format is refused. A missing key means an older Sentinel that does not
+ * report the restriction — the caller must not treat that as "all formats".
+ * An empty array means the field has no format restriction.
+ *
+ * Dispatch fills the process cache before a tool that resolves text formats.
+ * A failed fetch is remembered only briefly so a Sentinel outage does not
+ * add the timeout to every later write, and concurrent writes share one
+ * request. Unit tests that call handlers directly can seed a successful
+ * document with `rememberTextFormatContext`.
+ */
+
+import { authHeadersAsync, clientHeaders } from "./config.js";
+
+/** How long a successful context document is reused. */
+const CONTEXT_TTL_MS = 10 * 60 * 1000;
+
+/** How long a miss is remembered. Short, so a recovered Sentinel is retried. */
+const FAILURE_TTL_MS = 30 * 1000;
+
+/** Context fetch budget. A miss must not stall the write past this. */
+const CONTEXT_TIMEOUT_MS = 8000;
+
+/**
+ * Tools whose handlers call the text-format resolver. Other writes must not
+ * wait on this document.
+ */
+const TEXT_FORMAT_TOOLS = new Set([
+  "drupal_create_node",
+  "drupal_update_node",
+  "drupal_entity_create",
+  "drupal_entity_update",
+  "drupal_create_translation",
+  "drupal_bulk_create",
+  "drupal_bulk_update",
+  "drupal_create_paragraph",
+  "drupal_update_paragraph",
+  "drupal_create_media",
+  "drupal_update_media",
+  "drupal_draft_nested_components",
+]);
+
+/** @type {Map<string, {at: number, document: ?object, ttl: number}>} */
+const cache = new Map();
+
+/** @type {Map<string, {slot: object, promise: Promise<void>}>} */
+const inflight = new Map();
+
+/** @type {(site: object) => Promise<?object>} */
+let fetcher = async () => null;
+
+/**
+ * Cache key for one configured site. Name and base URL both matter so two
+ * sites that share a name in different processes cannot collide here, and a
+ * renamed base URL does not reuse the previous document.
+ * @param {object} site Resolved site config.
+ * @returns {string}
+ */
+function cacheKey(site) {
+  return `${site?._name ?? ""}\0${site?.baseUrl ?? ""}`;
+}
+
+/**
+ * Drop cached schema documents. Tests call this between cases.
+ * @returns {void}
+ */
+export function clearTextFormatContextCache() {
+  cache.clear();
+  inflight.clear();
+}
+
+/**
+ * Whether this tool resolves text formats and should wait for context.
+ * @param {string} toolName
+ * @returns {boolean}
+ */
+export function toolNeedsTextFormatContext(toolName) {
+  return TEXT_FORMAT_TOOLS.has(toolName);
+}
+
+/**
+ * Seed the cache without a network call. A seeded document uses the success TTL.
+ * @param {object} site Resolved site config.
+ * @param {object} document Sentinel context JSON.
+ * @returns {void}
+ */
+export function rememberTextFormatContext(site, document) {
+  cache.set(cacheKey(site), { at: Date.now(), document, ttl: CONTEXT_TTL_MS });
+}
+
+/**
+ * @param {string} key
+ * @returns {boolean}
+ */
+function fresh(key) {
+  const hit = cache.get(key);
+  if (!hit) return false;
+  return Date.now() - hit.at < hit.ttl;
+}
+
+/**
+ * Install the process fetcher. The server entry calls this with
+ * {@link fetchTextFormatContext}. Tests leave the default, which returns
+ * null and does not touch the network.
+ * @param {(site: object) => Promise<?object>} next
+ * @returns {void}
+ */
+export function installTextFormatContextFetcher(next) {
+  fetcher = next;
+}
+
+/**
+ * Load `GET /drupal-mcp/context` when the cache is cold. A failure is cached
+ * as a miss for 30 seconds: the write keeps the historical path
+ * for an unknown format list, and the next write does not wait again.
+ * Concurrent callers share one in-flight request.
+ * @param {object} site Resolved site config.
+ * @returns {Promise<void>}
+ */
+export async function ensureTextFormatContext(site) {
+  if (!site?.baseUrl) return;
+  const key = cacheKey(site);
+  if (fresh(key)) return;
+  const pending = inflight.get(key);
+  if (pending) {
+    await pending.promise;
+    return;
+  }
+  // Identity is a plain object. Comparing the promise itself is what CodeQL
+  // reports as a missing await.
+  const slot = {};
+  const promise = loadTextFormatContext(site, key);
+  inflight.set(key, { slot, promise });
+  try {
+    await promise;
+  } finally {
+    const row = inflight.get(key);
+    if (row?.slot === slot) inflight.delete(key);
+  }
+}
+
+/**
+ * @param {object} site
+ * @param {string} key
+ * @returns {Promise<void>}
+ */
+async function loadTextFormatContext(site, key) {
+  let document = null;
+  try {
+    const loaded = await fetcher(site);
+    if (loaded && typeof loaded === "object" && !Array.isArray(loaded)) document = loaded;
+  } catch {
+    document = null;
+  }
+  cache.set(key, {
+    at: Date.now(),
+    document,
+    ttl: document ? CONTEXT_TTL_MS : FAILURE_TTL_MS,
+  });
+}
+
+/**
+ * GET /drupal-mcp/context as the site's own principal.
+ * @param {object} site Resolved site config.
+ * @returns {Promise<?object>} The JSON document, or null on any miss.
+ */
+export async function fetchTextFormatContext(site) {
+  let headers;
+  try {
+    headers = {
+      Accept: "application/json",
+      ...clientHeaders(),
+      ...(await authHeadersAsync(site)),
+    };
+  } catch {
+    return null;
+  }
+  let res;
+  try {
+    res = await fetch(`${site.baseUrl}/drupal-mcp/context`, {
+      method: "GET",
+      headers,
+      signal: AbortSignal.timeout(CONTEXT_TIMEOUT_MS),
+    });
+  } catch {
+    return null;
+  }
+  if (!res.ok) return null;
+  try {
+    const body = await res.json();
+    if (!body || typeof body !== "object" || Array.isArray(body)) return null;
+    if (!Object.prototype.hasOwnProperty.call(body, "content_types")) return null;
+    return body;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Field definition from a cached context document.
+ * Only node bundles are present. A field with no `allowed_formats` key is
+ * unknown (older Sentinel), not unrestricted.
+ * @param {object} site Resolved site config.
+ * @param {string} entityType
+ * @param {string} bundle
+ * @param {string} fieldName
+ * @returns {?{fieldName: string, fieldType: ?string, allowedFormats: string[]}}
+ */
+export function textFormatDefinitionFromContext(site, entityType, bundle, fieldName) {
+  if (entityType !== "node") return null;
+  const hit = cache.get(cacheKey(site));
+  // A cached miss (document null) is not a schema. Do not invent a list.
+  if (!hit?.document || !fresh(cacheKey(site))) return null;
+  const types = hit.document?.content_types;
+  if (!types || typeof types !== "object" || Array.isArray(types)) return null;
+  const schema = new Map(Object.entries(types)).get(bundle);
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return null;
+  const fields = new Map(Object.entries(schema)).get("fields");
+  if (!fields || typeof fields !== "object" || Array.isArray(fields)) return null;
+  const field = new Map(Object.entries(fields)).get(fieldName);
+  if (!field || typeof field !== "object" || Array.isArray(field)) return null;
+  const attrs = new Map(Object.entries(field));
+  if (!attrs.has("allowed_formats")) return null;
+  const fieldType = attrs.get("type");
+  return {
+    fieldName,
+    fieldType: typeof fieldType === "string" ? fieldType : null,
+    allowedFormats: normalizeContextFormats(attrs.get("allowed_formats")),
+  };
+}
+
+/**
+ * @param {*} raw `allowed_formats` from the context document.
+ * @returns {string[]}
+ */
+function normalizeContextFormats(raw) {
+  const values = Array.isArray(raw)
+    ? raw
+    : (raw && typeof raw === "object" ? [...new Map(Object.entries(raw)).values()] : []);
+  return values.filter((value) => typeof value === "string" && value !== "" && value !== "0");
+}

package/src/lib/write-revision.js

@@ -11,27 +11,73 @@
  */
 
 /**
- * Read a revision id off a canonical (or raw-ish) entity body.
- * @param {?object} entity
+ * JSON:API revision attribute for entity types whose revision key is known.
+ * `taxonomy_term`'s `drupal_internal__vid` is the vocabulary id, not a revision.
+ * Node and media revisions use `vid`. Paragraphs, library items, and custom
+ * blocks use `revision_id`.
+ */
+const REVISION_ATTRIBUTE = {
+  node: "drupal_internal__vid",
+  media: "drupal_internal__vid",
+  paragraph: "drupal_internal__revision_id",
+  paragraphs_library_item: "drupal_internal__revision_id",
+  block_content: "drupal_internal__revision_id",
+};
+
+/**
+ * @param {object} entity
+ * @param {object} fields
+ * @param {object} attrs
+ * @param {string} key
+ * @returns {unknown}
+ */
+function readRevisionAttribute(entity, fields, attrs, key) {
+  if (key === "drupal_internal__vid") {
+    return entity.vid
+      ?? fields.drupal_internal__vid
+      ?? attrs.drupal_internal__vid
+      ?? entity.drupal_internal__vid;
+  }
+  if (Object.prototype.hasOwnProperty.call(fields, key)) return fields[key];
+  if (Object.prototype.hasOwnProperty.call(attrs, key)) return attrs[key];
+  if (Object.prototype.hasOwnProperty.call(entity, key)) return entity[key];
+  return undefined;
+}
+
+/**
+ * @param {unknown} raw
  * @returns {?number|string}
  */
-export function entityRevisionId(entity) {
-  if (!entity || typeof entity !== "object") return null;
-  const fields = entity.fields && typeof entity.fields === "object"
-    ? entity.fields
-    : {};
-  const attrs = entity.attributes && typeof entity.attributes === "object"
-    ? entity.attributes
-    : {};
-  const raw = entity.vid
-    ?? fields.drupal_internal__vid
-    ?? attrs.drupal_internal__vid
-    ?? entity.drupal_internal__vid;
+function normalizeRevisionId(raw) {
   if (raw === undefined || raw === null || raw === "") return null;
   const n = Number(raw);
   return Number.isFinite(n) ? n : raw;
 }
 
+/**
+ * Read a revision id off a canonical (or raw-ish) entity body.
+ * When `entityType` is known, only that type's revision attribute is read.
+ * When it is omitted, a node-style vid is kept and `revision_id` is used
+ * only if no vid is present, so existing callers stay unchanged.
+ *
+ * @param {?object} entity
+ * @param {?string} [entityType]
+ * @returns {?number|string}
+ */
+export function entityRevisionId(entity, entityType) {
+  if (!entity || typeof entity !== "object") return null;
+  const type = entityType || entity.entityType || null;
+  const fields = entity.fields && typeof entity.fields === "object" ? entity.fields : {};
+  const attrs = entity.attributes && typeof entity.attributes === "object" ? entity.attributes : {};
+  if (type === "taxonomy_term") return null;
+  if (type && REVISION_ATTRIBUTE[type]) {
+    return normalizeRevisionId(readRevisionAttribute(entity, fields, attrs, REVISION_ATTRIBUTE[type]));
+  }
+  const vid = readRevisionAttribute(entity, fields, attrs, "drupal_internal__vid");
+  if (vid !== undefined && vid !== null && vid !== "") return normalizeRevisionId(vid);
+  return normalizeRevisionId(readRevisionAttribute(entity, fields, attrs, "drupal_internal__revision_id"));
+}
+
 /**
  * Attach distinct live vs working revision ids when both are known.
  * Does not invent vids.
@@ -65,7 +111,8 @@ export async function attachWrittenRevisionPair({
   backend, entityType, bundle, id, entity, liveVid,
 }) {
   if (liveVid === null || liveVid === undefined || !entity) return entity;
-  let workingVid = entityRevisionId(entity);
+  if (entity._revisions) return entity;
+  let workingVid = entityRevisionId(entity, entityType);
   if (workingVid !== null && String(workingVid) !== String(liveVid)) {
     return attachRevisionPair(entity, { live: liveVid, working: workingVid });
   }
@@ -74,7 +121,7 @@ export async function attachWrittenRevisionPair({
       const wc = await backend.getEntity({
         entityType, bundle, id, resourceVersion: "rel:working-copy",
       });
-      workingVid = entityRevisionId(wc);
+      workingVid = entityRevisionId(wc, entityType);
     } catch {
       workingVid = null;
     }
@@ -106,6 +153,9 @@ export async function readWrittenRevision({
   // Sentinel returned the requested translation; a canonical read would replace
   // it with live English, and the core working-copy alias may not address it.
   if (langcode && patchResult) return patchResult;
+  if (patchResult?._revision?.source === "working-copy" || patchResult?._revision?.source === "latest-version") {
+    return patchResult;
+  }
   if (!relationshipsSent) {
     if (preferCanonical && typeof backend.getEntity === "function") {
       const fresh = await backend.getEntity({

package/src/tools/bulk.js

@@ -14,12 +14,14 @@
 import { getSiteConfig } from "../lib/config.js";
 import { resolveBackend } from "../lib/backends/index.js";
 import { resolveSecurityConfig, assertWriteAllowed, assertPublishAllowed, withUnpublishedDefault } from "../lib/security.js";
-import { applySafeDraftDefault, hasExplicitModerationState } from "../lib/moderation-default.js";
+import { applySafeDraftDefault } from "../lib/moderation-default.js";
+import { readUpdateTarget } from "../lib/canonical-draft.js";
 import {
   resolveErrRelationships, embedParagraphRef,
   resolveParagraphRevisionId, missingParagraphRevisionError,
 } from "../lib/err-relationships.js";
 import { prepareGuardedPatch, updateEntityGuarded } from "../lib/patch-preflight.js";
+import { applyAllowedFormatsToAttributes } from "../lib/field-definition.js";
 
 /**
  * Normalize an unknown thrown value into a human-readable message.
@@ -52,11 +54,15 @@ async function bulkCreate({ site: siteName, entityType, bundle, items = [] }) {
   for (const [index, rawItem] of items.entries()) {
     const item = rawItem || {};
     try {
-      assertPublishAllowed(sec, item.attributes ?? {});
+      const formatted = await applyAllowedFormatsToAttributes({
+        backend, site, entityType, bundle, attributes: { ...(item.attributes ?? {}) },
+        defaultBodyFormat: false,
+      });
+      assertPublishAllowed(sec, formatted);
       const resolvedRelationships = await resolveErrRelationships(backend, item.relationships ?? {});
       const entity = await backend.createEntity({
         entityType, bundle,
-        attributes: withUnpublishedDefault(sec, entityType, item.attributes ?? {}),
+        attributes: withUnpublishedDefault(sec, entityType, formatted),
         relationships: resolvedRelationships,
       });
       created += 1;
@@ -103,17 +109,16 @@ async function bulkUpdate({ site: siteName, entityType, bundle, items = [] }) {
     const item = rawItem || {};
     try {
       if (!item.id) throw new Error("Missing 'id' for update item");
-      let existing = null;
-      if (!hasExplicitModerationState(item.attributes ?? {})) {
-        try {
-          existing = (await backend.getEntity({ entityType, bundle, id: item.id })) ?? null;
-        } catch {
-          existing = null;
-        }
-      }
+      const existing = await readUpdateTarget(backend, {
+        entityType, bundle, id: item.id, attributes: item.attributes ?? {},
+      });
+      const formatted = await applyAllowedFormatsToAttributes({
+        backend, site, entityType, bundle, attributes: { ...(item.attributes ?? {}) },
+        existingEntity: existing, defaultBodyFormat: false,
+      });
       const attributes = await applySafeDraftDefault({
         backend, entityType, bundle, id: item.id,
-        attributes: item.attributes ?? {},
+        attributes: formatted,
         existingEntity: existing,
       });
       assertPublishAllowed(sec, attributes);

package/src/tools/entities.js

@@ -11,13 +11,15 @@
 import { getSiteConfig } from "../lib/config.js";
 import { resolveBackend } from "../lib/backends/index.js";
 import { shapeWriteResponse, flagUnrequestedStatusChange, RETURNING_SCHEMA } from "../lib/entity-response.js";
-import { applySafeDraftDefault, hasExplicitModerationState } from "../lib/moderation-default.js";
+import { applySafeDraftDefault } from "../lib/moderation-default.js";
 import {
   resolveErrRelationships, relationshipsWereSent, embedParagraphRef,
   resolveParagraphRevisionId, missingParagraphRevisionError,
 } from "../lib/err-relationships.js";
 import { attachWrittenRevisionPair, readWrittenRevision } from "../lib/write-revision.js";
 import { prepareGuardedPatch, updateEntityGuarded } from "../lib/patch-preflight.js";
+import { readUpdateTarget } from "../lib/canonical-draft.js";
+import { applyAllowedFormatsToAttributes } from "../lib/field-definition.js";
 import { dryRunChecks, PREFLIGHT_NONE } from "../lib/dry-run-checks.js";
 import {
   resolveSecurityConfig, assertReadAllowed, assertWriteAllowed, assertDeleteAllowed, assertPublishAllowed,
@@ -69,9 +71,12 @@ async function createEntity({ site: siteName, entityType, bundle, attributes: ca
   const site = getSiteConfig(siteName);
   const sec = resolveSecurityConfig(site);
   assertWriteAllowed(sec, "create", entityType, bundle);
-  assertPublishAllowed(sec, callerAttributes);
-  const attributes = withUnpublishedDefault(sec, entityType, callerAttributes);
   const backend = await resolveBackend(site);
+  const formatted = await applyAllowedFormatsToAttributes({
+    backend, site, entityType, bundle, attributes: { ...callerAttributes }, defaultBodyFormat: false,
+  });
+  assertPublishAllowed(sec, formatted);
+  const attributes = withUnpublishedDefault(sec, entityType, formatted);
   const resolvedRelationships = await resolveErrRelationships(backend, relationships);
   if (dryRun) {
     return {
@@ -111,16 +116,13 @@ async function updateEntity({ site: siteName, entityType, bundle, id, attributes
   // One pre-write read serves both the #131 draft default and the #171
   // unrequested-status-change flag. Skipped when the caller pinned the
   // moderation state explicitly (same condition the draft default uses).
-  let existing = null;
-  if (!hasExplicitModerationState(attributes)) {
-    try {
-      existing = (await backend.getEntity({ entityType, bundle, id })) ?? null;
-    } catch {
-      existing = null; // Unreadable target: server-side gates stay authoritative.
-    }
-  }
+  const existing = await readUpdateTarget(backend, { entityType, bundle, id, attributes });
+  const formatted = await applyAllowedFormatsToAttributes({
+    backend, site, entityType, bundle, attributes: { ...attributes }, existingEntity: existing,
+    defaultBodyFormat: false,
+  });
   const safeAttributes = await applySafeDraftDefault({
-    backend, entityType, bundle, id, attributes, existingEntity: existing,
+    backend, entityType, bundle, id, attributes: formatted, existingEntity: existing,
   });
   assertPublishAllowed(sec, safeAttributes);
   const resolvedRelationships = await resolveErrRelationships(backend, relationships);
@@ -297,7 +299,7 @@ export const definitions = [
   },
   {
     name: "drupal_entity_update",
-    description: "Update an existing entity of any Drupal entity type. Only include attributes/relationships you want to change. Published moderated targets without an explicit attributes.moderation_state default to moderation_state 'draft' (forward revision). Paragraph / ERR identifiers are resolved to include meta.target_revision_id before PATCH; the write fails if any ref cannot be resolved. On moderated targets a non-saving PATCH preflight runs first (including dryRun) against the same URL the write will hit. An addressable node draft uses Sentinel's governed draft endpoint with live/working revision preconditions (#166); a stray revision with no addressable working copy still fails with revision-surgery language (#201). Preflight does not un-orphan paragraphs already created — probe the host before creating dependents. A dryRun that returns without a refusal is not proof the write will succeed: field access and entity validation are checked only when Sentinel's draft endpoint ran, and the result's `checks` block says which checks ran.",
+    description: "Update an existing entity of any Drupal entity type. Only include attributes/relationships you want to change. Published moderated targets without an explicit attributes.moderation_state default to moderation_state 'draft' (forward revision). Paragraph / ERR identifiers are resolved to include meta.target_revision_id before PATCH; the write fails if any ref cannot be resolved. On moderated targets a non-saving PATCH preflight runs first (including dryRun) against the same URL the write will hit. An addressable node draft uses Sentinel's governed draft endpoint with live/working revision preconditions (#166); a stray revision with no addressable working copy still fails with revision-surgery language (#201). Preflight does not un-orphan paragraphs already created — probe the host before creating dependents. A dryRun that returns without a refusal is not proof the write will succeed: field access and entity validation are checked only when Sentinel's draft endpoint ran, and the result's `checks` block says which checks ran. When the draft inventory advertises open_draft, a published moderated paragraphs_library_item or block_content opens and continues through /mcp-draft with If-Match live or live:working, no mcp_components, and a re-read of the published pins. A continuation compares the forward revision with the pre-write working pins. When open_draft is not advertised, a published moderated paragraphs_library_item or block_content with no forward revision is saved by that canonical draft PATCH, then the published revision, rel:working-copy, and paragraph pins (including order) are re-read. The result fails if the published revision changed or no forward revision appeared. An existing forward draft, a missing revision id, or a denied version read is refused before any write. An unmoderated item keeps the ordinary update. A completed 4xx is returned when that re-read matches the pre-write revision and pins; a lost response stays uncertain (#420).",
     inputSchema: {
       type: "object", required: ["entityType", "bundle", "id"],
       properties: {
@@ -308,7 +310,7 @@ export const definitions = [
         langcode:      { type: "string", description: "Target language for an unpublished working translation (nodes). Continues that translation via Sentinel." },
         attributes:    { type: "object" },
         relationships: { type: "object" },
-        dryRun:        { type: "boolean", default: false, description: "Validate, resolve ERR identifiers, run the server-side preflight when one applies, and return a preview without the real write. The result's `checks` block says what was checked; `caveat` names what was not. Only an existing node draft (or a langcode translation draft) is checked with the real payload: Sentinel's non-saving draft endpoint applies the submitted fields through field access and validates the entity (`serverPreflight: sentinel_draft`). On other moderated targets an id-mismatch core PATCH with no fields checks entity update access and core's working-copy guard only; field access and entity validation are NOT checked (`core_patch_guard`), so the real write can still fail with a field-access 403 or a 422. Unmoderated targets get no server-side check at all (`none`). A changed/revision_timestamp gap on the default revision (possiblyPatchBlocked) is a warning on list_revisions, not a local dryRun refusal — the write proceeds to the core probe / Sentinel (#405). An actual Sentinel stale-copy refusal is still rewritten. Any refusal fails the dryRun." },
+        dryRun:        { type: "boolean", default: false, description: "Validate, resolve ERR identifiers, run the server-side preflight when one applies, and return a preview without the real write. The result's `checks` block says what was checked; `caveat` names what was not. An existing node draft (or a langcode translation draft), and a paragraphs_library_item or block_content whose inventory advertises open_draft, are checked with the real payload: Sentinel's non-saving draft endpoint applies the submitted fields through field access and validates the entity (`serverPreflight: sentinel_draft`). On other moderated targets an id-mismatch core PATCH with no fields checks entity update access and core's working-copy guard only; field access and entity validation are NOT checked (`core_patch_guard`), so the real write can still fail with a field-access 403 or a 422. Unmoderated targets get no server-side check at all (`none`). A changed/revision_timestamp gap on the default revision (possiblyPatchBlocked) is a warning on list_revisions, not a local dryRun refusal — the write proceeds to the core probe / Sentinel (#405). An actual Sentinel stale-copy refusal is still rewritten. Any refusal fails the dryRun." },
         returning:     RETURNING_SCHEMA,
       },
     },

package/src/tools/index.js

@@ -29,6 +29,7 @@ import * as references   from "./references.js";
 import * as bulk         from "./bulk.js";
 import * as translations from "./translations.js";
 import * as paragraphs   from "./paragraphs.js";
+import * as nested       from "./nested.js";
 import * as structure    from "./structure.js";
 import * as redirects    from "./redirects.js";
 import * as search       from "./search.js";
@@ -42,7 +43,7 @@ import * as codegen      from "./codegen.js";
 import { SITE_PARAM } from "../lib/site-target.js";
 
 const allModules = [nodes, taxonomy, users, media, graphql, site, entities, reports, drush,
-  revisions, moderation, scheduler, fields, references, bulk, translations, paragraphs, structure, redirects, search, reportsExtra,
+  revisions, moderation, scheduler, fields, references, bulk, translations, paragraphs, nested, structure, redirects, search, reportsExtra,
   reportsLinks, reportsConfig, reportsContent, auditComposite, config, codegen];
 
 /**

package/src/tools/media.js

@@ -19,6 +19,7 @@ import {
 } from "../lib/sentinel-draft.js";
 import { prepareGuardedPatch, updateEntityGuarded } from "../lib/patch-preflight.js";
 import { entityRevisionId } from "../lib/write-revision.js";
+import { applyAllowedFormatsToAttributes } from "../lib/field-definition.js";
 
 /**
  * List all media types (bundles of the media entity type).
@@ -110,8 +111,11 @@ async function createMedia({ site: siteName, type, name, status = false, fields
   // Layer name/status after fields so they win, matching prior behaviour.
   attributes.name = name;
   attributes.status = status;
-  assertPublishAllowed(sec, attributes);
   const backend = await resolveBackend(site);
+  await applyAllowedFormatsToAttributes({
+    backend, site, entityType: "media", bundle: type, attributes, defaultBodyFormat: false,
+  });
+  assertPublishAllowed(sec, attributes);
   return backend.createEntity({
     entityType: "media", bundle: type, attributes,
     ...(relationships ? { relationships } : {}),
@@ -134,8 +138,11 @@ async function updateMedia({ site: siteName, type, id, name, status, fields = {}
   const { attributes, relationships } = splitReferenceFields(fields);
   if (name !== undefined) attributes.name = name;
   if (status !== undefined) attributes.status = status;
-  assertPublishAllowed(sec, attributes);
   const backend = await resolveBackend(site);
+  await applyAllowedFormatsToAttributes({
+    backend, site, entityType: "media", bundle: type, attributes, defaultBodyFormat: false,
+  });
+  assertPublishAllowed(sec, attributes);
   if (langcode) {
     const targetLang = assertDraftLangcode(langcode);
     const patchTarget = await prepareGuardedPatch(backend, {