@umbraco-cms/mcp-dev 17.0.0 → 17.0.1-beta.1

package/dist/index.cjs

@@ -7597,7 +7597,7 @@ var UmbracoManagementClient2 = (_class2 = class {
 // package.json
 var package_default = {
   name: "@umbraco-cms/mcp-dev",
-  version: "17.0.0",
+  version: "17.0.1-beta.1",
   type: "module",
   description: "A model context protocol (MCP) server for Umbraco CMS",
   main: "index.js",
@@ -7620,6 +7620,8 @@ var package_default = {
     "eval-mcp:create-document-type": "npx mcp-server-tester@1.4.0 evals tests/e2e/create-document-type/create-document-type.yaml --server-config tests/e2e/create-document-type/create-document-type-config.json",
     "eval-mcp:create-document-copy": "npx mcp-server-tester@1.4.0 evals tests/e2e/create-document-copy/create-document-copy.yaml --server-config tests/e2e/create-document-copy/create-document-copy-config.json",
     "eval-mcp:create-document-with-template": "npx mcp-server-tester@1.4.0 evals tests/e2e/create-document-with-template/create-document-with-template.yaml --server-config tests/e2e/create-document-with-template/create-document-with-template-config.json",
+    "eval-mcp:update-document-properties": "npx mcp-server-tester@1.4.0 evals tests/e2e/update-document-properties/update-document-properties.yaml --server-config tests/e2e/update-document-properties/update-document-properties-config.json",
+    "eval-mcp:update-block-property": "npx mcp-server-tester@1.4.0 evals tests/e2e/update-block-property/update-block-property.yaml --server-config tests/e2e/update-block-property/update-block-property-config.json",
     "eval-mcp:all": "npm run eval-mcp:basic && npm run eval-mcp:create-data-type && npm run eval-mcp:create-document-type && npm run eval-mcp:create-blog-post"
   },
   engines: {
@@ -19544,9 +19546,19 @@ var move_to_recycle_bin_default = MoveDocumentToRecycleBinTool;
 
 var UpdateDocumentTool = CreateUmbracoTool(
   "update-document",
-  `Updates a document by Id
-  Always read the current document value first and only update the required values.
-  Don't miss any properties from the original document that you are updating`,
+  `Updates a document by Id. USE AS LAST RESORT ONLY.
+
+  IMPORTANT: Prefer these specialized tools instead:
+  - update-document-properties: For updating individual property values (simpler, safer)
+  - update-block-property: For updating properties within BlockList/BlockGrid/RichText blocks
+
+  Only use this tool when you need to update document-level metadata (template, variants)
+  or when the specialized tools cannot handle your specific use case.
+
+  If you must use this tool:
+  - Always read the current document value first
+  - Only update the required values
+  - Don't miss any properties from the original document`,
   {
     id: putDocumentByIdParams.shape.id,
     data: _zod.z.object(putDocumentByIdBody.shape)
@@ -19567,6 +19579,761 @@ var UpdateDocumentTool = CreateUmbracoTool(
 );
 var update_document_default = UpdateDocumentTool;
 
+// src/umb-management-api/tools/document/put/update-document-properties.ts
+
+
+// src/umb-management-api/tools/document/put/helpers/document-type-properties-resolver.ts
+async function getAllDocumentTypeProperties(documentTypeId) {
+  const client = UmbracoManagementClient2.getClient();
+  const visitedIds = /* @__PURE__ */ new Set();
+  const properties = [];
+  async function resolveDocumentType(docTypeId) {
+    if (visitedIds.has(docTypeId)) {
+      return;
+    }
+    visitedIds.add(docTypeId);
+    const docType = await client.getDocumentTypeById(docTypeId);
+    for (const prop of docType.properties) {
+      if (!properties.some((p) => p.alias === prop.alias)) {
+        properties.push({
+          alias: prop.alias,
+          name: prop.name,
+          dataTypeId: prop.dataType.id,
+          variesByCulture: prop.variesByCulture,
+          variesBySegment: prop.variesBySegment
+        });
+      }
+    }
+    for (const composition of docType.compositions) {
+      await resolveDocumentType(composition.documentType.id);
+    }
+  }
+  await resolveDocumentType(documentTypeId);
+  return properties;
+}
+function validateCultureSegment(prop, def) {
+  if (!def.variesByCulture && prop.culture) {
+    return `Property '${prop.alias}' does not vary by culture, but culture '${prop.culture}' was provided`;
+  }
+  if (def.variesByCulture && !prop.culture) {
+    return `Property '${prop.alias}' varies by culture - culture is required`;
+  }
+  if (!def.variesBySegment && prop.segment) {
+    return `Property '${prop.alias}' does not vary by segment, but segment '${prop.segment}' was provided`;
+  }
+  if (def.variesBySegment && !prop.segment) {
+    return `Property '${prop.alias}' varies by segment - segment is required`;
+  }
+  return null;
+}
+
+// src/umb-management-api/tools/document/put/helpers/property-value-validator.ts
+var EDITOR_FORMAT_MAP = {
+  // Editors with allowed values validation
+  "Umbraco.DropDown.Flexible": { valueType: "string[]", allowedValuesKey: "items", validateAllowedValues: true },
+  "Umbraco.RadioButtonList": { valueType: "string", allowedValuesKey: "items", validateAllowedValues: true },
+  "Umbraco.CheckBoxList": { valueType: "string[]", allowedValuesKey: "items", validateAllowedValues: true },
+  "Umbraco.ColorPicker": { valueType: "object", allowedValuesKey: "items", validateAllowedValues: true },
+  // Editors with format-only validation
+  "Umbraco.TextBox": { valueType: "string" },
+  "Umbraco.TextArea": { valueType: "string" },
+  "Umbraco.Integer": { valueType: "number" },
+  "Umbraco.Decimal": { valueType: "number" },
+  "Umbraco.TrueFalse": { valueType: "boolean" },
+  "Umbraco.Tags": { valueType: "string[]" },
+  "Umbraco.MultipleTextstring": { valueType: "string[]" },
+  "Umbraco.DateTime": { valueType: "string" },
+  "Umbraco.EmailAddress": { valueType: "string" },
+  "Umbraco.MarkdownEditor": { valueType: "string" },
+  "Umbraco.ColorPicker.EyeDropper": { valueType: "string" }
+};
+function validateValueType(value, expectedType, propertyAlias, editorAlias) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  switch (expectedType) {
+    case "string":
+      if (typeof value !== "string") {
+        return `Property '${propertyAlias}': Value must be a string for ${editorAlias} editor, got ${typeof value}`;
+      }
+      break;
+    case "string[]":
+      if (!Array.isArray(value)) {
+        return `Property '${propertyAlias}': Value must be an array for ${editorAlias} editor, got ${typeof value}`;
+      }
+      if (!value.every((item) => typeof item === "string")) {
+        return `Property '${propertyAlias}': All array items must be strings for ${editorAlias} editor`;
+      }
+      break;
+    case "number":
+      if (typeof value !== "number") {
+        return `Property '${propertyAlias}': Value must be a number for ${editorAlias} editor, got ${typeof value}`;
+      }
+      break;
+    case "boolean":
+      if (typeof value !== "boolean") {
+        return `Property '${propertyAlias}': Value must be a boolean for ${editorAlias} editor, got ${typeof value}`;
+      }
+      break;
+    case "object":
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return `Property '${propertyAlias}': Value must be an object for ${editorAlias} editor, got ${Array.isArray(value) ? "array" : typeof value}`;
+      }
+      break;
+  }
+  return null;
+}
+function extractAllowedValues(dataType, configKey) {
+  const configItem = dataType.values.find((v) => v.alias === configKey);
+  if (!configItem || !configItem.value) {
+    return null;
+  }
+  const value = configItem.value;
+  if (Array.isArray(value)) {
+    if (value.every((item) => typeof item === "string")) {
+      return value;
+    }
+    if (value.every((item) => typeof item === "object" && item !== null && "value" in item)) {
+      return value.map((item) => item.value);
+    }
+  }
+  return null;
+}
+function validateAllowedValues(value, allowedValues, propertyAlias, editorAlias, valueType) {
+  const errors = [];
+  if (value === null || value === void 0) {
+    return errors;
+  }
+  if (editorAlias === "Umbraco.ColorPicker" && typeof value === "object" && value !== null && "value" in value) {
+    const colorValue = value.value;
+    if (!allowedValues.includes(colorValue)) {
+      errors.push(`Property '${propertyAlias}': Color value '${colorValue}' is not in allowed values: [${allowedValues.map((v) => `'${v}'`).join(", ")}]`);
+    }
+    return errors;
+  }
+  if (valueType === "string[]" && Array.isArray(value)) {
+    for (const item of value) {
+      if (!allowedValues.includes(item)) {
+        errors.push(`Property '${propertyAlias}': Value '${item}' is not in allowed values: [${allowedValues.map((v) => `'${v}'`).join(", ")}]`);
+      }
+    }
+    return errors;
+  }
+  if (valueType === "string" && typeof value === "string") {
+    if (!allowedValues.includes(value)) {
+      errors.push(`Property '${propertyAlias}': Value '${value}' is not in allowed values: [${allowedValues.map((v) => `'${v}'`).join(", ")}]`);
+    }
+    return errors;
+  }
+  return errors;
+}
+function validatePropertyValue(dataType, value, propertyAlias) {
+  const errors = [];
+  const editorAlias = dataType.editorAlias;
+  const formatConfig = EDITOR_FORMAT_MAP[editorAlias];
+  if (!formatConfig) {
+    return { isValid: true, errors: [] };
+  }
+  const typeError = validateValueType(value, formatConfig.valueType, propertyAlias, editorAlias);
+  if (typeError) {
+    errors.push(typeError);
+    return { isValid: false, errors };
+  }
+  if (formatConfig.validateAllowedValues && formatConfig.allowedValuesKey) {
+    const allowedValues = extractAllowedValues(dataType, formatConfig.allowedValuesKey);
+    if (allowedValues && allowedValues.length > 0) {
+      const allowedValueErrors = validateAllowedValues(
+        value,
+        allowedValues,
+        propertyAlias,
+        editorAlias,
+        formatConfig.valueType
+      );
+      errors.push(...allowedValueErrors);
+    }
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+async function validatePropertiesBeforeSave(properties) {
+  const client = UmbracoManagementClient2.getClient();
+  const errors = [];
+  const dataTypeCache = /* @__PURE__ */ new Map();
+  async function getCachedDataType(dataTypeId) {
+    if (!dataTypeCache.has(dataTypeId)) {
+      try {
+        const dataType = await client.getDataTypeById(dataTypeId);
+        dataTypeCache.set(dataTypeId, dataType);
+      } catch (error) {
+        console.error(`Failed to fetch Data Type ${dataTypeId}:`, error);
+        return null;
+      }
+    }
+    return _nullishCoalesce(dataTypeCache.get(dataTypeId), () => ( null));
+  }
+  for (const prop of properties) {
+    if (!prop.dataTypeId) {
+      continue;
+    }
+    const dataType = await getCachedDataType(prop.dataTypeId);
+    if (!dataType) {
+      continue;
+    }
+    const validation = validatePropertyValue(dataType, prop.value, prop.alias);
+    if (!validation.isValid) {
+      errors.push(...validation.errors);
+    }
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+
+// src/umb-management-api/tools/document/put/helpers/property-matching.ts
+function matchesProperty(value, alias, culture, segment) {
+  return value.alias === alias && (_nullishCoalesce(value.culture, () => ( null))) === (_nullishCoalesce(culture, () => ( null))) && (_nullishCoalesce(value.segment, () => ( null))) === (_nullishCoalesce(segment, () => ( null)));
+}
+function getPropertyKey(alias, culture, segment) {
+  let key = alias;
+  if (culture) key += `[${culture}]`;
+  if (segment) key += `[${segment}]`;
+  return key;
+}
+
+// src/umb-management-api/tools/document/put/update-document-properties.ts
+var propertySchema2 = _zod.z.object({
+  alias: _zod.z.string().min(1).describe("The property alias to update or add"),
+  value: _zod.z.any().nullish().describe("The new value for the property"),
+  culture: _zod.z.string().nullish().describe("Optional culture code for variant properties (e.g., 'en-US')"),
+  segment: _zod.z.string().nullish().describe("Optional segment identifier for variant properties")
+});
+var updateDocumentPropertiesSchema = {
+  id: _zod.z.string().uuid().describe("The unique identifier of the document to update"),
+  properties: _zod.z.array(propertySchema2).min(1).describe("Array of properties to update or add - at least one property is required")
+};
+var UpdateDocumentPropertiesTool = CreateUmbracoTool(
+  "update-document-properties",
+  `Updates or adds property values on a document without requiring the full document JSON payload.
+
+  This tool simplifies property updates by handling the read-modify-write cycle internally.
+  You can update existing properties, add new properties, or do both in a single call.
+
+  Key features:
+  - Update existing properties or add new ones
+  - Property must exist on the document type (including compositions)
+  - Full i18n support with culture and segment parameters
+  - Automatic validation of property aliases against document type
+  - Culture/segment requirements validated against property variance flags
+  - Returns detailed error messages with available properties
+
+  Example usage:
+  - Update a single property: { id: "...", properties: [{ alias: "title", value: "New Title" }] }
+  - Add a new property: { id: "...", properties: [{ alias: "author", value: "John Doe" }] }
+  - Update with culture: { id: "...", properties: [{ alias: "title", value: "Nuevo T\xEDtulo", culture: "es-ES" }] }
+  - Mix update and add: { id: "...", properties: [{ alias: "title", value: "New" }, { alias: "newProp", value: "Value" }] }`,
+  updateDocumentPropertiesSchema,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const currentDocument = await client.getDocumentById(model.id);
+    const invalidAliases = [];
+    const varianceErrors = [];
+    const propertiesToUpdate = [];
+    const propertiesToAdd = [];
+    let documentTypeProperties = null;
+    const getDocumentTypeProperties = async () => {
+      if (documentTypeProperties === null) {
+        try {
+          documentTypeProperties = await getAllDocumentTypeProperties(currentDocument.documentType.id);
+        } catch (error) {
+          console.error("Failed to fetch document type properties:", error);
+          documentTypeProperties = [];
+        }
+      }
+      return documentTypeProperties;
+    };
+    for (const prop of model.properties) {
+      const existsOnDocument = currentDocument.values.some(
+        (v) => matchesProperty(v, prop.alias, prop.culture, prop.segment)
+      );
+      if (existsOnDocument) {
+        propertiesToUpdate.push({
+          alias: prop.alias,
+          value: prop.value,
+          culture: prop.culture,
+          segment: prop.segment
+        });
+      } else {
+        const docTypeProperties = await getDocumentTypeProperties();
+        const propertyDef = docTypeProperties.find((p) => p.alias === prop.alias);
+        if (propertyDef) {
+          const validationError = validateCultureSegment(prop, propertyDef);
+          if (validationError) {
+            varianceErrors.push(validationError);
+          } else {
+            propertiesToAdd.push({
+              alias: prop.alias,
+              value: prop.value,
+              culture: prop.culture,
+              segment: prop.segment
+            });
+          }
+        } else if (docTypeProperties.length > 0) {
+          invalidAliases.push(getPropertyKey(prop.alias, prop.culture, prop.segment));
+        } else {
+          invalidAliases.push(getPropertyKey(prop.alias, prop.culture, prop.segment));
+        }
+      }
+    }
+    if (varianceErrors.length > 0) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: false,
+            error: "Culture/segment validation failed",
+            message: varianceErrors.join("; "),
+            errors: varianceErrors,
+            availableProperties: (_nullishCoalesce(documentTypeProperties, () => ( []))).map((p) => ({
+              alias: p.alias,
+              name: p.name,
+              variesByCulture: p.variesByCulture,
+              variesBySegment: p.variesBySegment
+            }))
+          }, null, 2)
+        }]
+      };
+    }
+    if (invalidAliases.length > 0) {
+      const docTypeProps = _nullishCoalesce(documentTypeProperties, () => ( []));
+      const availableProperties = docTypeProps.length > 0 ? docTypeProps.map((p) => ({
+        alias: p.alias,
+        name: p.name,
+        variesByCulture: p.variesByCulture,
+        variesBySegment: p.variesBySegment
+      })) : currentDocument.values.map((v) => ({
+        alias: v.alias,
+        culture: _nullishCoalesce(v.culture, () => ( null)),
+        segment: _nullishCoalesce(v.segment, () => ( null)),
+        editorAlias: v.editorAlias
+      }));
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: false,
+            error: "Invalid property aliases",
+            message: `The following properties do not exist on this document type: ${invalidAliases.join(", ")}`,
+            invalidAliases,
+            availableProperties
+          }, null, 2)
+        }]
+      };
+    }
+    const allPropertiesToValidate = [...propertiesToUpdate, ...propertiesToAdd];
+    if (allPropertiesToValidate.length > 0) {
+      const docTypeProps = await getDocumentTypeProperties();
+      const propsToValidate = allPropertiesToValidate.map((p) => {
+        const def = docTypeProps.find((d) => d.alias === p.alias);
+        return { alias: p.alias, value: p.value, dataTypeId: _nullishCoalesce(_optionalChain([def, 'optionalAccess', _50 => _50.dataTypeId]), () => ( "")) };
+      }).filter((p) => p.dataTypeId);
+      if (propsToValidate.length > 0) {
+        const valueValidation = await validatePropertiesBeforeSave(propsToValidate);
+        if (!valueValidation.isValid) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Property value validation failed",
+                errors: valueValidation.errors
+              }, null, 2)
+            }]
+          };
+        }
+      }
+    }
+    const updatedValues = currentDocument.values.map((existingValue) => {
+      const updateProp = propertiesToUpdate.find(
+        (p) => matchesProperty(existingValue, p.alias, p.culture, p.segment)
+      );
+      if (updateProp) {
+        return {
+          alias: existingValue.alias,
+          culture: existingValue.culture,
+          segment: existingValue.segment,
+          value: updateProp.value
+        };
+      }
+      return {
+        alias: existingValue.alias,
+        culture: existingValue.culture,
+        segment: existingValue.segment,
+        value: existingValue.value
+      };
+    });
+    for (const newProp of propertiesToAdd) {
+      updatedValues.push({
+        alias: newProp.alias,
+        culture: _nullishCoalesce(newProp.culture, () => ( null)),
+        segment: _nullishCoalesce(newProp.segment, () => ( null)),
+        value: newProp.value
+      });
+    }
+    const variants = currentDocument.variants.map((v) => ({
+      culture: v.culture,
+      segment: v.segment,
+      name: v.name
+    }));
+    const updatePayload = {
+      values: updatedValues,
+      variants,
+      template: currentDocument.template
+    };
+    await client.putDocumentById(model.id, updatePayload);
+    const updatedDocument = await client.getDocumentById(model.id);
+    const updatedPropertyKeys = propertiesToUpdate.map(
+      (p) => getPropertyKey(p.alias, p.culture, p.segment)
+    );
+    const addedPropertyKeys = propertiesToAdd.map(
+      (p) => getPropertyKey(p.alias, p.culture, p.segment)
+    );
+    const totalCount = propertiesToUpdate.length + propertiesToAdd.length;
+    let message = `Successfully processed ${totalCount} property value(s)`;
+    if (propertiesToUpdate.length > 0 && propertiesToAdd.length > 0) {
+      message = `Successfully updated ${propertiesToUpdate.length} and added ${propertiesToAdd.length} property value(s)`;
+    } else if (propertiesToAdd.length > 0) {
+      message = `Successfully added ${propertiesToAdd.length} property value(s)`;
+    } else {
+      message = `Successfully updated ${propertiesToUpdate.length} property value(s)`;
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          message,
+          updatedProperties: updatedPropertyKeys,
+          addedProperties: addedPropertyKeys,
+          document: updatedDocument
+        }, null, 2)
+      }]
+    };
+  },
+  (user) => user.fallbackPermissions.includes(UmbracoDocumentPermissions.Update)
+);
+var update_document_properties_default = UpdateDocumentPropertiesTool;
+
+// src/umb-management-api/tools/document/put/update-block-property.ts
+
+
+// src/umb-management-api/tools/document/put/helpers/block-discovery.ts
+function isRichTextValue(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (!("markup" in value)) {
+    return false;
+  }
+  if (!value.blocks || typeof value.blocks !== "object") {
+    return false;
+  }
+  return Array.isArray(value.blocks.contentData) && Array.isArray(value.blocks.settingsData);
+}
+function isBlockStructure(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  return Array.isArray(value.contentData) && Array.isArray(value.settingsData);
+}
+function discoverAllBlockArrays(value, path4 = "root") {
+  const results = [];
+  if (!value || typeof value !== "object") {
+    return results;
+  }
+  if (isRichTextValue(value)) {
+    const nestedResults = discoverAllBlockArrays(value.blocks, `${path4}.blocks`);
+    results.push(...nestedResults);
+    return results;
+  }
+  if (isBlockStructure(value)) {
+    results.push({
+      contentData: value.contentData,
+      settingsData: value.settingsData,
+      path: path4
+    });
+    value.contentData.forEach((block, index) => {
+      if (block.values && Array.isArray(block.values)) {
+        block.values.forEach((prop, propIndex) => {
+          const propPath = `${path4}.contentData[${index}].values[${propIndex}](${prop.alias})`;
+          if (isRichTextValue(prop.value)) {
+            const nestedResults = discoverAllBlockArrays(prop.value.blocks, `${propPath}.blocks`);
+            results.push(...nestedResults);
+          } else if (isBlockStructure(prop.value)) {
+            const nestedResults = discoverAllBlockArrays(prop.value, propPath);
+            results.push(...nestedResults);
+          }
+        });
+      }
+    });
+    value.settingsData.forEach((block, index) => {
+      if (block.values && Array.isArray(block.values)) {
+        block.values.forEach((prop, propIndex) => {
+          const propPath = `${path4}.settingsData[${index}].values[${propIndex}](${prop.alias})`;
+          if (isRichTextValue(prop.value)) {
+            const nestedResults = discoverAllBlockArrays(prop.value.blocks, `${propPath}.blocks`);
+            results.push(...nestedResults);
+          } else if (isBlockStructure(prop.value)) {
+            const nestedResults = discoverAllBlockArrays(prop.value, propPath);
+            results.push(...nestedResults);
+          }
+        });
+      }
+    });
+  }
+  return results;
+}
+function findBlockByKey(discoveredArrays, contentKey, blockType) {
+  for (const discovered of discoveredArrays) {
+    const array = blockType === "content" ? discovered.contentData : discovered.settingsData;
+    const block = array.find((b) => b.key === contentKey);
+    if (block) {
+      return { block, arrayRef: array, path: discovered.path };
+    }
+  }
+  return null;
+}
+
+// src/umb-management-api/tools/document/put/update-block-property.ts
+var blockPropertyUpdateSchema = _zod.z.object({
+  alias: _zod.z.string().min(1).describe("The property alias within the block to update"),
+  value: _zod.z.any().nullish().describe("The new value for the property"),
+  culture: _zod.z.string().nullish().describe("Optional culture code for variant block properties"),
+  segment: _zod.z.string().nullish().describe("Optional segment identifier for variant block properties")
+});
+var blockUpdateSchema = _zod.z.object({
+  contentKey: _zod.z.string().uuid().describe("The unique key (UUID) identifying the block"),
+  blockType: _zod.z.enum(["content", "settings"]).describe("'content' for contentData, 'settings' for settingsData"),
+  properties: _zod.z.array(blockPropertyUpdateSchema).min(1).describe("Properties to update within this block")
+});
+var updateBlockPropertySchema = {
+  documentId: _zod.z.string().uuid().describe("The document containing the block"),
+  propertyAlias: _zod.z.string().min(1).describe("Document property alias containing BlockList/BlockGrid"),
+  culture: _zod.z.string().nullish().describe("Optional culture for variant document properties"),
+  segment: _zod.z.string().nullish().describe("Optional segment for variant document properties"),
+  updates: _zod.z.array(blockUpdateSchema).min(1).describe("Array of block updates")
+};
+var UpdateBlockPropertyTool = CreateUmbracoTool(
+  "update-block-property",
+  `Updates or adds property values within BlockList, BlockGrid, or RichText block content.
+
+  This tool enables targeted updates to individual block properties without sending the entire JSON payload.
+  You can update existing properties, add new properties, or do both in a single call.
+  It automatically handles deep traversal of nested block structures (e.g., RichText blocks containing nested blocks).
+
+  Key features:
+  - Update existing properties or add new ones to blocks
+  - Property must exist on the Element Type (including compositions)
+  - Support for both content and settings blocks
+  - Batch updates to multiple blocks in a single call
+  - Deep traversal of nested block structures
+  - Full i18n support with culture and segment parameters
+  - Culture/segment requirements validated against property variance flags
+
+  Example usage:
+  - Update a block property: { documentId: "...", propertyAlias: "mainContent", updates: [{ contentKey: "block-uuid", blockType: "content", properties: [{ alias: "title", value: "New Title" }] }] }
+  - Add a new property to block: { documentId: "...", propertyAlias: "mainContent", updates: [{ contentKey: "block-uuid", blockType: "content", properties: [{ alias: "newProp", value: "Value" }] }] }
+  - Update with culture: { documentId: "...", propertyAlias: "mainContent", culture: "es-ES", updates: [...] }
+  - Batch update multiple blocks: { documentId: "...", propertyAlias: "mainContent", updates: [{ contentKey: "uuid1", ... }, { contentKey: "uuid2", ... }] }`,
+  updateBlockPropertySchema,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const currentDocument = await client.getDocumentById(model.documentId);
+    const documentProperty = currentDocument.values.find(
+      (v) => matchesProperty(v, model.propertyAlias, model.culture, model.segment)
+    );
+    if (!documentProperty) {
+      const availableAliases = currentDocument.values.map((v) => ({
+        alias: v.alias,
+        culture: _nullishCoalesce(v.culture, () => ( null)),
+        segment: _nullishCoalesce(v.segment, () => ( null)),
+        editorAlias: v.editorAlias
+      }));
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: false,
+            error: "Property not found",
+            message: `Property '${getPropertyKey(model.propertyAlias, model.culture, model.segment)}' does not exist on this document`,
+            availableProperties: availableAliases
+          }, null, 2)
+        }]
+      };
+    }
+    const discoveredArrays = discoverAllBlockArrays(documentProperty.value, `property(${model.propertyAlias})`);
+    if (discoveredArrays.length === 0) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: false,
+            error: "No block structure found",
+            message: `Property '${model.propertyAlias}' does not contain a BlockList, BlockGrid, or RichText block structure`,
+            propertyValue: documentProperty.value
+          }, null, 2)
+        }]
+      };
+    }
+    const results = [];
+    const notFoundBlocks = [];
+    const elementTypePropertiesCache = /* @__PURE__ */ new Map();
+    const getElementTypeProperties = async (contentTypeKey) => {
+      if (!elementTypePropertiesCache.has(contentTypeKey)) {
+        try {
+          const properties = await getAllDocumentTypeProperties(contentTypeKey);
+          elementTypePropertiesCache.set(contentTypeKey, properties);
+        } catch (error) {
+          console.error(`Failed to fetch Element Type properties for ${contentTypeKey}:`, error);
+          elementTypePropertiesCache.set(contentTypeKey, []);
+        }
+      }
+      return elementTypePropertiesCache.get(contentTypeKey);
+    };
+    for (const update of model.updates) {
+      const foundBlock = findBlockByKey(discoveredArrays, update.contentKey, update.blockType);
+      if (!foundBlock) {
+        notFoundBlocks.push({ contentKey: update.contentKey, blockType: update.blockType });
+        results.push({
+          success: false,
+          contentKey: update.contentKey,
+          message: `Block with contentKey '${update.contentKey}' not found in ${update.blockType}Data`
+        });
+        continue;
+      }
+      const warnings = [];
+      const errors = [];
+      let updatedCount = 0;
+      let addedCount = 0;
+      const elementTypeProperties = await getElementTypeProperties(foundBlock.block.contentTypeKey);
+      if (elementTypeProperties.length > 0) {
+        const propsToValidate = update.properties.map((p) => {
+          const def = elementTypeProperties.find((d) => d.alias === p.alias);
+          return { alias: p.alias, value: p.value, dataTypeId: _nullishCoalesce(_optionalChain([def, 'optionalAccess', _51 => _51.dataTypeId]), () => ( "")) };
+        }).filter((p) => p.dataTypeId);
+        if (propsToValidate.length > 0) {
+          const valueValidation = await validatePropertiesBeforeSave(propsToValidate);
+          if (!valueValidation.isValid) {
+            errors.push(...valueValidation.errors);
+          }
+        }
+      }
+      for (const propUpdate of update.properties) {
+        const blockProperty = foundBlock.block.values.find(
+          (v) => matchesProperty(v, propUpdate.alias, propUpdate.culture, propUpdate.segment)
+        );
+        if (blockProperty) {
+          blockProperty.value = propUpdate.value;
+          updatedCount++;
+        } else {
+          const propertyDef = elementTypeProperties.find((p) => p.alias === propUpdate.alias);
+          if (propertyDef) {
+            const validationError = validateCultureSegment(propUpdate, propertyDef);
+            if (validationError) {
+              errors.push(validationError);
+            } else {
+              foundBlock.block.values.push({
+                alias: propUpdate.alias,
+                culture: _nullishCoalesce(propUpdate.culture, () => ( null)),
+                segment: _nullishCoalesce(propUpdate.segment, () => ( null)),
+                value: propUpdate.value
+              });
+              addedCount++;
+            }
+          } else if (elementTypeProperties.length > 0) {
+            errors.push(
+              `Property '${getPropertyKey(propUpdate.alias, propUpdate.culture, propUpdate.segment)}' does not exist on Element Type`
+            );
+          } else {
+            warnings.push(
+              `Property '${getPropertyKey(propUpdate.alias, propUpdate.culture, propUpdate.segment)}' not found in block (could not validate against Element Type)`
+            );
+          }
+        }
+      }
+      const totalProcessed = updatedCount + addedCount;
+      let message;
+      if (updatedCount > 0 && addedCount > 0) {
+        message = `Updated ${updatedCount} and added ${addedCount} properties in block at ${foundBlock.path}`;
+      } else if (addedCount > 0) {
+        message = `Added ${addedCount} properties in block at ${foundBlock.path}`;
+      } else if (updatedCount > 0) {
+        message = `Updated ${updatedCount} properties in block at ${foundBlock.path}`;
+      } else {
+        message = `No properties were processed in block at ${foundBlock.path}`;
+      }
+      results.push({
+        success: totalProcessed > 0 || errors.length === 0,
+        contentKey: update.contentKey,
+        message,
+        updatedCount: updatedCount > 0 ? updatedCount : void 0,
+        addedCount: addedCount > 0 ? addedCount : void 0,
+        warnings: warnings.length > 0 ? warnings : void 0,
+        errors: errors.length > 0 ? errors : void 0
+      });
+    }
+    if (notFoundBlocks.length === model.updates.length) {
+      const allBlocks = discoveredArrays.flatMap((d) => [
+        ...d.contentData.map((b) => ({ key: b.key, type: "content", path: d.path })),
+        ...d.settingsData.map((b) => ({ key: b.key, type: "settings", path: d.path }))
+      ]);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: false,
+            error: "Blocks not found",
+            message: "None of the specified blocks were found in the document",
+            notFoundBlocks,
+            availableBlocks: allBlocks
+          }, null, 2)
+        }]
+      };
+    }
+    const updatedValues = currentDocument.values.map((existingValue) => ({
+      alias: existingValue.alias,
+      culture: existingValue.culture,
+      segment: existingValue.segment,
+      value: existingValue.value
+    }));
+    const variants = currentDocument.variants.map((v) => ({
+      culture: v.culture,
+      segment: v.segment,
+      name: v.name
+    }));
+    const updatePayload = {
+      values: updatedValues,
+      variants,
+      template: currentDocument.template
+    };
+    await client.putDocumentById(model.documentId, updatePayload);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          message: `Successfully processed ${model.updates.length} block update(s)`,
+          results
+        }, null, 2)
+      }]
+    };
+  },
+  (user) => user.fallbackPermissions.includes(UmbracoDocumentPermissions.Update)
+);
+var update_block_property_default = UpdateBlockPropertyTool;
+
 // src/umb-management-api/tools/document/items/get/get-root.ts
 var GetDocumentRootTool = CreateUmbracoTool(
   "get-document-root",
@@ -19740,6 +20507,8 @@ var DocumentCollection = {
       tools.push(sort_document_default());
       tools.push(unpublish_document_default());
       tools.push(update_document_default());
+      tools.push(update_document_properties_default());
+      tools.push(update_block_property_default());
       tools.push(put_document_domains_default());
       tools.push(put_document_notifications_default());
       tools.push(put_document_public_access_default());
@@ -20165,7 +20934,7 @@ function getExtensionFromMimeType(mimeType) {
   return extension ? `.${extension}` : void 0;
 }
 function validateMediaTypeForSvg(filePath, fileUrl, fileName, mediaTypeName) {
-  const isSvg = _optionalChain([filePath, 'optionalAccess', _50 => _50.toLowerCase, 'call', _51 => _51(), 'access', _52 => _52.endsWith, 'call', _53 => _53(".svg")]) || _optionalChain([fileUrl, 'optionalAccess', _54 => _54.toLowerCase, 'call', _55 => _55(), 'access', _56 => _56.endsWith, 'call', _57 => _57(".svg")]) || fileName.toLowerCase().endsWith(".svg");
+  const isSvg = _optionalChain([filePath, 'optionalAccess', _52 => _52.toLowerCase, 'call', _53 => _53(), 'access', _54 => _54.endsWith, 'call', _55 => _55(".svg")]) || _optionalChain([fileUrl, 'optionalAccess', _56 => _56.toLowerCase, 'call', _57 => _57(), 'access', _58 => _58.endsWith, 'call', _59 => _59(".svg")]) || fileName.toLowerCase().endsWith(".svg");
   if (isSvg && mediaTypeName === MEDIA_TYPE_IMAGE) {
     console.warn(`SVG detected - using ${MEDIA_TYPE_VECTOR_GRAPHICS} media type instead of ${MEDIA_TYPE_IMAGE}`);
     return MEDIA_TYPE_VECTOR_GRAPHICS;
@@ -20322,8 +21091,8 @@ async function uploadMediaFile(client, params) {
       });
     } catch (error) {
       const err = error;
-      const errorData = _optionalChain([err, 'access', _58 => _58.response, 'optionalAccess', _59 => _59.data]) ? typeof err.response.data === "string" ? err.response.data : JSON.stringify(err.response.data) : err.message;
-      throw new Error(`Failed to upload temporary file: ${_optionalChain([err, 'access', _60 => _60.response, 'optionalAccess', _61 => _61.status]) || "Unknown error"} - ${errorData}`);
+      const errorData = _optionalChain([err, 'access', _60 => _60.response, 'optionalAccess', _61 => _61.data]) ? typeof err.response.data === "string" ? err.response.data : JSON.stringify(err.response.data) : err.message;
+      throw new Error(`Failed to upload temporary file: ${_optionalChain([err, 'access', _62 => _62.response, 'optionalAccess', _63 => _63.status]) || "Unknown error"} - ${errorData}`);
     }
     const valueStructure = buildValueStructure(validatedMediaTypeName, params.temporaryFileId);
     try {
@@ -20342,7 +21111,7 @@ async function uploadMediaFile(client, params) {
       });
     } catch (error) {
       const err = error;
-      throw new Error(`Failed to create media item: ${_optionalChain([err, 'access', _62 => _62.response, 'optionalAccess', _63 => _63.status]) || "Unknown error"} - ${JSON.stringify(_optionalChain([err, 'access', _64 => _64.response, 'optionalAccess', _65 => _65.data])) || err.message}`);
+      throw new Error(`Failed to create media item: ${_optionalChain([err, 'access', _64 => _64.response, 'optionalAccess', _65 => _65.status]) || "Unknown error"} - ${JSON.stringify(_optionalChain([err, 'access', _66 => _66.response, 'optionalAccess', _67 => _67.data])) || err.message}`);
     }
     return params.name;
   } finally {
@@ -21547,7 +22316,7 @@ var update_folder_default4 = UpdateMediaTypeFolderTool;
 
 // src/umb-management-api/tools/media-type/post/create-media-type.ts
 
-var propertySchema2 = postMediaTypeBody.shape.properties;
+var propertySchema3 = postMediaTypeBody.shape.properties;
 var containerSchema = postMediaTypeBody.shape.containers;
 var allowedMediaTypeSchema = postMediaTypeBody.shape.allowedMediaTypes;
 var compositionSchema = postMediaTypeBody.shape.compositions;
@@ -21561,7 +22330,7 @@ var createMediaTypeSchema = _zod.z.object({
   variesByCulture: _zod.z.boolean(),
   variesBySegment: _zod.z.boolean(),
   isElement: _zod.z.boolean(),
-  properties: propertySchema2,
+  properties: propertySchema3,
   containers: containerSchema,
   id: _zod.z.string().uuid().nullish(),
   parentId: _zod.z.string().uuid().optional(),
@@ -26176,8 +26945,8 @@ var mapTools = (server, user, tools, config) => {
   return tools.forEach((tool) => {
     const userHasPermission = tool.enabled === void 0 || tool.enabled(user);
     if (!userHasPermission) return;
-    if (_optionalChain([config, 'access', _66 => _66.disabledTools, 'optionalAccess', _67 => _67.includes, 'call', _68 => _68(tool.name)])) return;
-    if (_optionalChain([config, 'access', _69 => _69.enabledTools, 'optionalAccess', _70 => _70.length]) && !config.enabledTools.includes(tool.name)) return;
+    if (_optionalChain([config, 'access', _68 => _68.disabledTools, 'optionalAccess', _69 => _69.includes, 'call', _70 => _70(tool.name)])) return;
+    if (_optionalChain([config, 'access', _71 => _71.enabledTools, 'optionalAccess', _72 => _72.length]) && !config.enabledTools.includes(tool.name)) return;
     server.tool(tool.name, tool.description, tool.schema, tool.handler);
   });
 };
@@ -26198,7 +26967,7 @@ function resolveDependencies(requestedNames, collections) {
   const collectionMap = new Map(collections.map((c) => [c.metadata.name, c]));
   function addDependencies(collectionName) {
     const collection = collectionMap.get(collectionName);
-    if (_optionalChain([collection, 'optionalAccess', _71 => _71.metadata, 'access', _72 => _72.dependencies])) {
+    if (_optionalChain([collection, 'optionalAccess', _73 => _73.metadata, 'access', _74 => _74.dependencies])) {
       collection.metadata.dependencies.forEach((dep) => {
         if (!result.has(dep)) {
           result.add(dep);