drupal-mcp-connector 2.15.2 → 2.17.0

package/src/lib/backends/jsonapi.js

@@ -32,6 +32,38 @@ const INTERNAL_ATTR_RE = /^drupal_internal__/;
 const COUNT_PAGE_SIZE = 50;
 const COUNT_MAX_RECORDS = 1000;
 
+/**
+ * JSON:API language headers. Drupal negotiates Content-Language / Accept-Language
+ * when URL prefixes are not used on /jsonapi.
+ * @param {?string} langcode
+ * @returns {object}
+ */
+function languageFetchOptions(langcode) {
+  if (!langcode) return {};
+  return { headers: { "Content-Language": langcode, "Accept-Language": langcode } };
+}
+
+/**
+ * Fail if JSON:API served a different language than requested.
+ * @param {?object} entity
+ * @param {?string} langcode
+ */
+function assertServedLanguage(entity, langcode) {
+  if (!langcode || !entity) return;
+  if (!entity.langcode) {
+    throw new Error(
+      `JSON:API did not report a language for requested langcode "${langcode}". ` +
+      "The translation may not exist, or this backend does not negotiate language.",
+    );
+  }
+  if (entity.langcode !== langcode) {
+    throw new Error(
+      `JSON:API served language "${entity.langcode}" for requested langcode "${langcode}". ` +
+      "The translation may not exist, or this site does not negotiate JSON:API by language.",
+    );
+  }
+}
+
 /**
  * Whether a JSON:API collection document advertises another page.
  * `links.next` may be a string href or a `{ href }` link object.
@@ -358,14 +390,16 @@ export class JsonApiBackend extends Backend {
    * @param {{entityType: string, bundle: string, id: string, resourceVersion?: string}} ref
    * @returns {Promise<?import("../canonical.js").CanonicalEntity>} Entity, or null.
    */
-  async getEntity({ entityType, bundle, id, resourceVersion }) {
+  async getEntity({ entityType, bundle, id, resourceVersion, langcode }) {
     validateUuid(id);
     let path = `${this.resourcePath(entityType, bundle)}/${encodeURIComponent(id)}`;
     if (resourceVersion) {
       path += `?resourceVersion=${encodeURIComponent(resourceVersion)}`;
     }
-    const data = await drupalFetch(this.site, path);
-    return data?.data ? this.toCanonical(data.data) : null;
+    const data = await drupalFetch(this.site, path, languageFetchOptions(langcode));
+    const entity = data?.data ? this.toCanonical(data.data) : null;
+    assertServedLanguage(entity, langcode);
+    return entity;
   }
 
   /**
@@ -478,14 +512,15 @@ export class JsonApiBackend extends Backend {
    * @param {object} attributes Entity attributes (may include `status`).
    * @returns {Promise<object>} The JSON:API response body.
    */
-  async writeWithModerationFallback(path, method, buildPayload, attributes) {
+  async writeWithModerationFallback(path, method, buildPayload, attributes, langcode) {
+    const lang = languageFetchOptions(langcode);
     try {
-      return await drupalFetch(this.site, path, { method, body: JSON.stringify(buildPayload(attributes)) });
+      return await drupalFetch(this.site, path, { method, body: JSON.stringify(buildPayload(attributes)), ...lang });
     } catch (err) {
       if (!isModeratedStatusError(err) || !("status" in attributes)) throw err;
       const withoutStatus = { ...attributes };
       delete withoutStatus.status;
-      return drupalFetch(this.site, path, { method, body: JSON.stringify(buildPayload(withoutStatus)) });
+      return drupalFetch(this.site, path, { method, body: JSON.stringify(buildPayload(withoutStatus)), ...lang });
     }
   }
 
@@ -515,7 +550,7 @@ export class JsonApiBackend extends Backend {
    *   canonical default (#166 / Drupal #2795279).
    * @returns {Promise<import("../canonical.js").CanonicalEntity>} The updated entity.
    */
-  async updateEntity({ entityType, bundle, id, attributes = {}, relationships, resourceVersion }) {
+  async updateEntity({ entityType, bundle, id, attributes = {}, relationships, resourceVersion, langcode }) {
     validateUuid(id);
     const buildPayload = (attrs) => {
       const payload = { data: { type: `${entityType}--${bundle}`, id, attributes: attrs } };
@@ -527,8 +562,10 @@ export class JsonApiBackend extends Backend {
     if (resourceVersion) {
       path += `?resourceVersion=${encodeURIComponent(resourceVersion)}`;
     }
-    const data = await this.writeWithModerationFallback(path, "PATCH", buildPayload, attributes);
-    return this.toCanonical(data.data);
+    const data = await this.writeWithModerationFallback(path, "PATCH", buildPayload, attributes, langcode);
+    const entity = this.toCanonical(data.data);
+    assertServedLanguage(entity, langcode);
+    return entity;
   }
 
   /**
@@ -704,6 +741,45 @@ export class JsonApiBackend extends Backend {
    * @param {{entityType: string, bundle: string, fieldName: string}} ref
    * @returns {Promise<?{fieldName: string, fieldType: ?string, allowedFormats: string[]}>}
    */
+  /**
+   * Map of field machine name → translatable from JSON:API field_config.
+   * Base fields (title, moderation_state) are omitted unless exposed as
+   * base_field_override. Missing keys must not be treated as false.
+   * @param {string} entityType
+   * @param {string} bundle
+   * @returns {Promise<Object<string, boolean>>}
+   */
+  async listFieldTranslatability(entityType, bundle) {
+    validateMachineName(entityType, "entityType");
+    validateMachineName(bundle, "bundle");
+    const map = new Map();
+    const params = new URLSearchParams();
+    params.set("filter[entity_type]", entityType);
+    params.set("filter[bundle]", bundle);
+    params.set("page[limit]", "50");
+    const ingest = (rows) => {
+      for (const row of rows) {
+        const name = row?.attributes?.field_name;
+        if (typeof name === "string" && typeof row.attributes?.translatable === "boolean") {
+          map.set(name, row.attributes.translatable);
+        }
+      }
+    };
+    try {
+      const data = await drupalFetch(this.site, `/jsonapi/field_config/field_config?${params}`);
+      ingest(Array.isArray(data?.data) ? data.data : []);
+    } catch {
+      // field_config may be unexposed.
+    }
+    try {
+      const data = await drupalFetch(this.site, `/jsonapi/base_field_override/base_field_override?${params}`);
+      ingest(Array.isArray(data?.data) ? data.data : []);
+    } catch {
+      // base_field_override is often not JSON:API-exposed.
+    }
+    return Object.fromEntries(map);
+  }
+
   async getFieldDefinition({ entityType, bundle, fieldName }) {
     validateMachineName(entityType, "entityType");
     validateMachineName(bundle, "bundle");

package/src/lib/canonical.js

@@ -65,14 +65,19 @@ export function normalizeRelationship(ref) {
   // JSON:API encodes type as "entityType--bundle"; split into the two parts.
   const [entityType = null, bundle = null] = (ref.type || "").split("--");
   const out = { id: ref.id, entityType, bundle };
-  // ERR identifiers carry the revision id in JSON:API `meta` (#192). Dropping
-  // it made every canonical re-read look like a plain {id, type} even when the
-  // write sent target_revision_id.
+  // ERR identifiers carry the revision id in JSON:API `meta` (#192). Image
+  // fields carry alt/title the same way (#296). Dropping either made a
+  // canonical re-read look like a plain {id, type}.
   if (ref.meta && typeof ref.meta === "object") {
-    const vid = new Map(Object.entries(ref.meta)).get("target_revision_id");
+    const entries = new Map(Object.entries(ref.meta));
+    const meta = {};
+    const vid = entries.get("target_revision_id");
     if (vid !== undefined && vid !== null && vid !== "") {
-      out.meta = { target_revision_id: vid };
+      meta.target_revision_id = vid;
     }
+    if (typeof entries.get("alt") === "string") meta.alt = entries.get("alt");
+    if (typeof entries.get("title") === "string") meta.title = entries.get("title");
+    if (Object.keys(meta).length > 0) out.meta = meta;
   }
   return out;
 }

package/src/lib/config.js

@@ -16,9 +16,26 @@ import { getAccessToken }                from "./oauth.js";
 // eslint-disable-next-line security/detect-non-literal-fs-filename -- fixed path relative to this module (the package's own package.json), not user input
 const pkg = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
 
+/** npm / protocol machine name. Public identifier — not the display name. */
+export const CLIENT_NAME = "drupal-mcp-connector";
+
+/** Human-readable product name for docs and MCP `serverInfo.title`. */
+export const CLIENT_TITLE = "Drupal MCP Connector";
+
 /** Connector version, sourced from package.json so it never drifts out of sync. */
 export const CLIENT_VERSION = pkg.version;
 
+/**
+ * MCP Implementation advertised in the handshake.
+ * `name` is the protocol identifier; `title` is the display name.
+ * @type {{name: string, title: string, version: string}}
+ */
+export const SERVER_INFO = {
+  name: CLIENT_NAME,
+  title: CLIENT_TITLE,
+  version: CLIENT_VERSION,
+};
+
 /**
  * Identity headers sent on every outbound Drupal request. Lets governance layers
  * label/identify connector traffic. ON by default; set MCP_CLIENT_ID to override
@@ -26,7 +43,7 @@ export const CLIENT_VERSION = pkg.version;
  * @returns {Object<string,string>} Header map (empty when the identity is disabled).
  */
 export function clientHeaders() {
-  const id = process.env.MCP_CLIENT_ID ?? `drupal-mcp-connector/${CLIENT_VERSION}`;
+  const id = process.env.MCP_CLIENT_ID ?? `${CLIENT_NAME}/${CLIENT_VERSION}`;
   if (!id) return {};
   return { "X-MCP-Client": id, "User-Agent": id };
 }

package/src/lib/draft-write.js

@@ -46,7 +46,7 @@ function requireWorkingPair(draftRevision) {
   const live = String(draftRevision?.liveVid ?? "");
   const working = String(draftRevision?.workingVid ?? "");
   if (!/^[1-9]\d*$/.test(live) || !/^[1-9]\d*$/.test(working) || live === working) {
-    throw new Error("Draft continuation requires distinct, verified live and working node revision IDs.");
+    throw new Error("Draft continuation requires distinct, verified live and working revision IDs.");
   }
   return { live, working };
 }
@@ -59,8 +59,8 @@ function requireWorkingPair(draftRevision) {
  * @returns {string}
  */
 function draftResource(backend, entityType, bundle, id) {
-  if (entityType !== "node" && entityType !== "paragraph") {
-    throw new Error("Governed draft translation is implemented for nodes and paragraphs.");
+  if (entityType !== "node" && entityType !== "paragraph" && entityType !== "media") {
+    throw new Error("Governed draft translation is implemented for nodes, paragraphs, and media.");
   }
   if (typeof backend.rawQuery !== "function" || typeof backend.resourcePath !== "function") {
     throw new Error("This backend does not support governed draft continuation.");
@@ -150,8 +150,8 @@ export async function createTranslationDraft(backend, input, preflight = false)
   const working = workingRaw === undefined || workingRaw === null || workingRaw === ""
     ? ""
     : String(workingRaw);
-  if (entityType !== "node" || !/^[1-9]\d*$/.test(live)) {
-    throw new Error("Translation create requires a verified live node revision ID.");
+  if ((entityType !== "node" && entityType !== "media") || !/^[1-9]\d*$/.test(live)) {
+    throw new Error("Translation create requires a verified live revision ID.");
   }
   if (working && (!/^[1-9]\d*$/.test(working) || working === live)) {
     throw new Error("Translation create requires distinct live and working revision IDs when a working copy exists.");

package/src/lib/err-relationships.js

@@ -38,6 +38,28 @@ export function isParagraphResourceType(type) {
   return typeof type === "string" && type.startsWith("paragraph--");
 }
 
+/**
+ * Paragraph ERR pins on a canonical host entity.
+ * @param {object} entity Canonical node (or other host).
+ * @returns {Array<{field: string, id: string, paragraphType: string, revisionId: ?string}>}
+ */
+export function paragraphPinsFromEntity(entity) {
+  const pins = [];
+  const rels = entity?.relationships && typeof entity.relationships === "object" ? entity.relationships : {};
+  for (const [field, value] of Object.entries(rels)) {
+    const list = Array.isArray(value) ? value : value ? [value] : [];
+    for (const ref of list) {
+      if (!ref?.id) continue;
+      const paragraphType = ref.bundle || parseResourceType(ref.type)?.bundle;
+      if (ref.entityType !== "paragraph" && !isParagraphResourceType(ref.type)) continue;
+      if (!paragraphType) continue;
+      const revisionId = ref.meta?.target_revision_id ?? null;
+      pins.push({ field, id: ref.id, paragraphType, revisionId });
+    }
+  }
+  return pins;
+}
+
 /**
  * Split a JSON:API resource type into entity type + bundle.
  * @param {string} type e.g. "paragraph--capability".

package/src/lib/mcp-server.js

@@ -29,7 +29,7 @@ function resourceUriIsListed(listed, requested) {
  * Create the server factory shared by HTTP and stdio transports.
  *
  * @param {object} surface
- * @param {{name: string, version: string}} surface.serverInfo
+ * @param {{name: string, title?: string, version: string}} surface.serverInfo
  * @param {{definitions: Array<object>, list?: () => Promise<Array<object>>, call: (name: string, args: object, context: object) => Promise<object>}} surface.tools
  *   `definitions` is the full static surface (schema projection); the optional
  *   `list` hook decides what is DISCOVERABLE per request (governance + entitlement).

package/src/lib/node-draft-inventory.js

@@ -9,7 +9,8 @@ import { readTranslationInventory } from "./draft-write.js";
  * @returns {Promise<object|null>}
  */
 export async function readNodeDraftInventory(backend, ref) {
-  if (ref.entityType !== "node" || typeof backend.rawQuery !== "function"
+  if ((ref.entityType !== "node" && ref.entityType !== "media")
+    || typeof backend.rawQuery !== "function"
     || typeof backend.resourcePath !== "function") return null;
   let inventory;
   try {
@@ -24,7 +25,7 @@ export async function readNodeDraftInventory(backend, ref) {
       || !Array.isArray(inventory.working.translations)
       || inventory.working.translations.some((row) => !row || typeof row.langcode !== "string"
         || typeof row.status !== "boolean")))) {
-    throw new Error("Sentinel returned an invalid node revision inventory. Re-read before updating.");
+    throw new Error("Sentinel returned an invalid revision inventory. Re-read before updating.");
   }
   return inventory;
 }

package/src/lib/server-tools.js

@@ -23,7 +23,7 @@
  */
 
 import fetch from "node-fetch";
-import { authHeadersAsync, clientHeaders, CLIENT_VERSION } from "./config.js";
+import { authHeadersAsync, clientHeaders, CLIENT_NAME, CLIENT_VERSION } from "./config.js";
 import { consumeBudgetIfEnforced, northboundHeaders, sourceBudgetDenial } from "./data-flow.js";
 import { clearToken } from "./oauth.js";
 
@@ -164,7 +164,7 @@ async function initializeSession(site, endpoint) {
     params: {
       protocolVersion: MCP_PROTOCOL_VERSION,
       capabilities: {},
-      clientInfo: { name: "drupal-mcp-connector", version: CLIENT_VERSION },
+      clientInfo: { name: CLIENT_NAME, version: CLIENT_VERSION },
     },
   };
 

package/src/lib/translation-rows.js

@@ -0,0 +1,59 @@
+/**
+ * Normalize Sentinel translation-inventory rows for tools and reports.
+ *
+ * Extra keys (`outdated`, `source`) are passed through only when present so
+ * older Sentinel versions do not grow invented `outdated: false`.
+ */
+
+/**
+ * @param {object} row Inventory translation row.
+ * @returns {object}
+ */
+export function mapTranslationRow(row) {
+  if (!row || typeof row !== "object") return row;
+  const out = {
+    langcode: row.langcode,
+    default: Boolean(row.default),
+    status: row.status,
+    title: row.title,
+    moderation_state: row.moderation_state ?? null,
+  };
+  if (Object.prototype.hasOwnProperty.call(row, "outdated")) {
+    out.outdated = Boolean(row.outdated);
+  }
+  if (typeof row.source === "string" && row.source) {
+    out.source = row.source;
+  }
+  return out;
+}
+
+/**
+ * Editorial current row per langcode: working copy wins over live.
+ * @param {?object} inventory
+ * @returns {object[]}
+ */
+export function inventoryTranslationRows(inventory) {
+  const byLang = new Map();
+  for (const row of inventory?.live?.translations ?? []) {
+    if (row?.langcode) byLang.set(row.langcode, { ...mapTranslationRow(row), revision: "live" });
+  }
+  for (const row of inventory?.working?.translations ?? []) {
+    if (row?.langcode) byLang.set(row.langcode, { ...mapTranslationRow(row), revision: "working" });
+  }
+  return [...byLang.values()];
+}
+
+/**
+ * Whether inventory has a row matching langcode and/or moderation state.
+ * @param {?object} inventory
+ * @param {{langcode?: string, state?: string}} match
+ * @returns {?object}
+ */
+export function inventoryRowMatching(inventory, { langcode, state } = {}) {
+  const wantedState = state === undefined || state === null ? null : String(state).toLowerCase();
+  return inventoryTranslationRows(inventory).find((row) => {
+    if (langcode && row.langcode !== langcode) return false;
+    if (wantedState && String(row.moderation_state || "").toLowerCase() !== wantedState) return false;
+    return true;
+  }) ?? null;
+}

package/src/tools/codegen.js

@@ -0,0 +1,150 @@
+/**
+ * Tool group: GraphQL Compose Codegen (TypeScript / Next.js scaffolds).
+ *
+ * Thin Drush wrappers around `drupal/graphql_compose_codegen`. The generator
+ * lives on the Drupal site; this connector does not reimplement it and does
+ * not run GraphQL Code Generator against the SDL.
+ *
+ * All three tools are reads. `drupal_codegen_generate` always passes
+ * `--dry-run` and never `--output-dir`, so artefacts come back as text for
+ * the agent to write locally. Disk writes stay a local DDEV/script concern.
+ *
+ * Capability: missing module or unknown Drush command fails loud. If
+ * `drushSsh.allowedCommands` is set, the `graphql-compose-codegen:*`
+ * subcommand must be on that list (same exact-match rule as other Drush tools).
+ */
+
+import { getSiteConfig } from "../lib/config.js";
+import { sshDrush } from "./drush.js";
+import { SecurityError } from "../lib/security.js";
+import { validateMachineName } from "../lib/validate.js";
+
+const INSPECT = "graphql-compose-codegen:inspect";
+const DIFF = "graphql-compose-codegen:diff";
+const GENERATE = "graphql-compose-codegen:generate";
+
+const GENERATE_TIMEOUT_MS = 60000;
+
+/**
+ * Parse an optional list of Drupal machine names (array or comma string).
+ *
+ * @param {string[]|string|undefined} raw Caller value.
+ * @param {string} fieldName Error label.
+ * @returns {string[]} Validated names, possibly empty.
+ */
+function parseMachineNameList(raw, fieldName) {
+  if (raw === undefined || raw === null || raw === "") return [];
+  const parts = Array.isArray(raw)
+    ? raw
+    : String(raw).split(",");
+  return parts
+    .map((v) => String(v).trim())
+    .filter(Boolean)
+    .map((v) => validateMachineName(v, fieldName));
+}
+
+/**
+ * Whether a Drush failure looks like the codegen module is absent.
+ *
+ * @param {Error} err Bridge error.
+ * @returns {boolean}
+ */
+function looksLikeMissingCodegen(err) {
+  const msg = String(err?.message || err || "");
+  return /graphql-compose-codegen|gqcc:|no commands defined in the ["']graphql-compose-codegen|command .* does not exist|could not find command/i.test(msg);
+}
+
+/**
+ * Run a codegen Drush subcommand and return stdout.
+ *
+ * @param {object} args Tool args.
+ * @param {string} [args.site] Site name.
+ * @param {string[]|string} [args.bundles] Bundle ids.
+ * @param {string[]|string} [args.skipFields] Extra field names to exclude.
+ * @param {string} subcommand Drush subcommand (first arg).
+ * @param {string[]} extra Extra flags (e.g. --dry-run).
+ * @param {number} timeoutMs SSH timeout.
+ * @returns {Promise<{output: string, command: string, wroteFiles: false}>}
+ */
+async function runGqcc(
+  { site: siteName, bundles, skipFields },
+  subcommand,
+  extra = [],
+  timeoutMs = 30000,
+) {
+  const site = getSiteConfig(siteName);
+  const names = parseMachineNameList(bundles, "bundles");
+  const skip = parseMachineNameList(skipFields, "skipFields");
+  const args = [subcommand];
+  if (names.length) args.push(`--bundles=${names.join(",")}`);
+  if (skip.length) args.push(`--skip-fields=${skip.join(",")}`);
+  args.push(...extra);
+  try {
+    const output = await sshDrush(site, args, timeoutMs);
+    return { output, command: args.join(" "), wroteFiles: false };
+  } catch (err) {
+    if (err instanceof SecurityError) throw err;
+    if (looksLikeMissingCodegen(err)) {
+      throw new Error(
+        "graphql_compose_codegen is not available on this site " +
+        `(Drush command "${subcommand}" failed). Install and enable ` +
+        "drupal/graphql_compose_codegen, and if drushSsh.allowedCommands is " +
+        `set, add "${subcommand}" to that list. ${err.message}`,
+      );
+    }
+    throw err;
+  }
+}
+
+async function inspect(args) {
+  return runGqcc(args, INSPECT);
+}
+
+async function diff(args) {
+  return runGqcc(args, DIFF);
+}
+
+async function generate(args) {
+  return runGqcc(args, GENERATE, ["--dry-run"], GENERATE_TIMEOUT_MS);
+}
+
+const LIST_PROPS = {
+  site: { type: "string" },
+  bundles: {
+    type: "array",
+    items: { type: "string", pattern: "^[a-z][a-z0-9_]*$" },
+    description: "Node/paragraph bundle ids. Omit for every bundle graphql_compose exposes.",
+  },
+  skipFields: {
+    type: "array",
+    items: { type: "string", pattern: "^[a-z][a-z0-9_]*$" },
+    description: "Extra field machine names to exclude from the scaffold.",
+  },
+};
+
+export const definitions = [
+  {
+    name: "drupal_codegen_inspect",
+    description:
+      "List node and paragraph bundles and extra fields from graphql_compose_codegen (`drush graphql-compose-codegen:inspect`). Requires the module and drushSsh. Missing command fails loud. If allowedCommands is set, include graphql-compose-codegen:inspect. Does not write files.",
+    inputSchema: { type: "object", properties: LIST_PROPS },
+  },
+  {
+    name: "drupal_codegen_diff",
+    description:
+      "Compare the live graphql_compose schema to the last gqcc:generate snapshot (`drush graphql-compose-codegen:diff`). Requires the module and drushSsh. Missing command fails loud. If allowedCommands is set, include graphql-compose-codegen:diff.",
+    inputSchema: { type: "object", properties: LIST_PROPS },
+  },
+  {
+    name: "drupal_codegen_generate",
+    description:
+      "Return TypeScript/GraphQL scaffold artefacts from graphql_compose_codegen as text (`drush graphql-compose-codegen:generate --dry-run`). Never writes on the Drupal host (no --output-dir). Copy artefacts locally. Requires the module and drushSsh. Missing command fails loud. If allowedCommands is set, include graphql-compose-codegen:generate.",
+    inputSchema: { type: "object", properties: LIST_PROPS },
+  },
+];
+
+export const handlers = {
+  drupal_codegen_inspect: inspect,
+  drupal_codegen_diff: diff,
+  drupal_codegen_generate: generate,
+};

package/src/tools/fields.js

@@ -96,11 +96,18 @@ async function describeFields({ site: siteName, type, entityType: entityTypeArg,
 
   const backend = await resolveBackend(site);
   const schema = await backend.getEntitySchema(entityType, resolvedBundle);
+  const translatable = typeof backend.listFieldTranslatability === "function"
+    ? await backend.listFieldTranslatability(entityType, resolvedBundle).catch(() => ({}))
+    : {};
+  const translatableMap = translatable && typeof translatable === "object" ? new Map(Object.entries(translatable)) : new Map();
 
   const fields = [
     ...Object.entries(schema.attributes ?? {}).map(([name, t]) => attributeField(name, t)),
     ...Object.keys(schema.relationships ?? {}).map((name) => relationshipField(name)),
-  ].sort((a, b) => a.name.localeCompare(b.name));
+  ].sort((a, b) => a.name.localeCompare(b.name)).map((field) => {
+    if (!translatableMap.has(field.name)) return field;
+    return { ...field, translatable: Boolean(translatableMap.get(field.name)) };
+  });
 
   const sampledEmpty = fields.length === 0;
 
@@ -125,11 +132,12 @@ export const definitions = [
     name: "drupal_describe_fields",
     description:
       "Introspect the fields of a Drupal entity type + bundle: returns a per-field " +
-      "list of { name, type, kind, cardinality?, approximate }. Read-only. Built on " +
+      "list of { name, type, kind, cardinality?, translatable?, approximate }. Read-only. Built on " +
       "schema SAMPLING (an existing entity), so results are approximate — only " +
       "populated fields are visible and required/cardinality/allowedValues are " +
-      "inferred from value shape. Authoritative field metadata comes from the Drush " +
-      "bridge (Field API). Use this before creating/updating entities to learn field names.",
+      "inferred from value shape. When JSON:API field_config is readable, translatable " +
+      "is copied from Field API; omitted means unknown, not false. Authoritative field " +
+      "metadata comes from the Drush bridge (Field API). Use this before creating/updating entities to learn field names.",
     inputSchema: {
       type: "object",
       required: ["site"],

package/src/tools/index.js

@@ -38,11 +38,12 @@ import * as reportsConfig  from "./reports-config.js";
 import * as reportsContent from "./reports-content.js";
 import * as auditComposite from "./audit-composite.js";
 import * as config       from "./config.js";
+import * as codegen      from "./codegen.js";
 import { SITE_PARAM } from "../lib/site-target.js";
 
 export const allModules = [nodes, taxonomy, users, media, graphql, site, entities, reports, drush,
   revisions, moderation, scheduler, fields, references, bulk, translations, paragraphs, structure, redirects, search, reportsExtra,
-  reportsLinks, reportsConfig, reportsContent, auditComposite, config];
+  reportsLinks, reportsConfig, reportsContent, auditComposite, config, codegen];
 
 /**
  * Stamp the shared `site` description onto every tool that accepts one so