@contentful/mcp-tools 0.4.5 → 0.8.0

package/dist/index.js

@@ -81,6 +81,13 @@ function createClientConfig(config) {
   };
   return clientConfig;
 }
+function assertEnvironmentNotProtected(environmentId, protectedEnvironments) {
+  if (protectedEnvironments && protectedEnvironments.includes(environmentId)) {
+    throw new Error(
+      `Environment '${environmentId}' is protected. Write and delete operations are not allowed.`
+    );
+  }
+}
 
 // src/utils/ai-actions.ts
 import { z as z2 } from "zod";
@@ -171,13 +178,18 @@ var CreateAiActionToolParams = BaseToolSchema.extend({
 });
 function createAiActionTool(config) {
   async function tool2(args) {
+    const resolvedEnvironmentId = args.environmentId || "master";
+    assertEnvironmentNotProtected(
+      resolvedEnvironmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
-      environmentId: args.environmentId || "master"
+      environmentId: resolvedEnvironmentId
     };
     const contentfulClient = createToolClient(config, {
       ...args,
-      environmentId: args.environmentId || "master"
+      environmentId: resolvedEnvironmentId
     });
     const aiAction = await contentfulClient.aiAction.create(params, {
       name: args.name,
@@ -186,7 +198,9 @@ function createAiActionTool(config) {
       configuration: args.configuration,
       testCases: args.testCases
     });
-    return createSuccessResponse("AI action created successfully", { aiAction });
+    return createSuccessResponse("AI action created successfully", {
+      aiAction
+    });
   }
   return withErrorHandling(tool2, "Error creating AI action");
 }
@@ -305,11 +319,49 @@ function getAiActionInvocationTool(config) {
 
 // src/tools/ai-actions/deleteAiAction.ts
 import { z as z7 } from "zod";
+
+// src/utils/confirmation.ts
+import { createHash } from "crypto";
+var CONFIRMATION_MESSAGE_PREFIX = "Confirmation required to delete";
+function buildConfirmToken(resource, id, version) {
+  const payload = `${resource}:${id}:${version ?? ""}`;
+  return createHash("sha256").update(payload).digest("hex").slice(0, 16);
+}
+var RESOURCE_DISPLAY_NAME = {
+  entry: "entry",
+  environment: "environment",
+  contentType: "content type",
+  asset: "asset",
+  aiAction: "AI action",
+  locale: "locale",
+  concept: "concept",
+  conceptScheme: "concept scheme"
+};
+function buildConfirmationPreview(resource, id, details, confirmToken) {
+  const displayName = RESOURCE_DISPLAY_NAME[resource];
+  return {
+    preview: details,
+    confirmToken,
+    instructions: `This will permanently delete ${displayName} "${id}". This action cannot be undone. To proceed, call this tool again with confirm: true and confirmToken: "${confirmToken}".`
+  };
+}
+
+// src/tools/ai-actions/deleteAiAction.ts
 var DeleteAiActionToolParams = BaseToolSchema.extend({
-  aiActionId: z7.string().describe("The ID of the AI action to delete")
+  aiActionId: z7.string().describe("The ID of the AI action to delete"),
+  confirm: z7.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z7.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
 });
 function deleteAiActionTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId,
@@ -317,8 +369,26 @@ function deleteAiActionTool(config) {
     };
     const contentfulClient = createToolClient(config, args);
     const aiAction = await contentfulClient.aiAction.get(params);
+    const expectedToken = buildConfirmToken(
+      "aiAction",
+      args.aiActionId,
+      aiAction.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} AI action`,
+        buildConfirmationPreview(
+          "aiAction",
+          args.aiActionId,
+          { aiAction },
+          expectedToken
+        )
+      );
+    }
     await contentfulClient.aiAction.delete(params);
-    return createSuccessResponse("AI action deleted successfully", { aiAction });
+    return createSuccessResponse("AI action deleted successfully", {
+      aiAction
+    });
   }
   return withErrorHandling(tool2, "Error deleting AI action");
 }
@@ -452,6 +522,10 @@ var PublishAiActionToolParams = BaseToolSchema.extend({
 });
 function publishAiActionTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId,
@@ -488,6 +562,10 @@ var UnpublishAiActionToolParams = BaseToolSchema.extend({
 });
 function unpublishAiActionTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId,
@@ -534,6 +612,10 @@ var UpdateAiActionToolParams = BaseToolSchema.extend({
 });
 function updateAiActionTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId,
@@ -605,13 +687,12 @@ function createAiActionTools(config) {
     },
     deleteAiAction: {
       title: "delete_ai_action",
-      description: "Delete a specific AI action from your Contentful space",
+      description: "Delete a specific AI action from your Contentful space. This is a two-phase operation: the first call (without confirm/confirmToken) returns a preview of the AI action and a confirmToken. To complete the deletion, call this tool again with the same aiActionId, confirm: true, and the confirmToken from the preview response.",
       inputParams: DeleteAiActionToolParams.shape,
       annotations: {
         readOnlyHint: false,
         destructiveHint: true,
-        idempotentHint: true,
-        // Deleting same item multiple times has same effect
+        idempotentHint: false,
         openWorldHint: false
       },
       tool: deleteAiAction
@@ -765,6 +846,10 @@ var UploadAssetToolParams = BaseToolSchema.extend({
 });
 function uploadAssetTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId
@@ -918,6 +1003,10 @@ var UpdateAssetToolParams = BaseToolSchema.extend({
 });
 function updateAssetTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId,
@@ -941,7 +1030,9 @@ function updateAssetTool(config) {
         concepts: allConcepts
       }
     });
-    return createSuccessResponse("Asset updated successfully", { updatedAsset });
+    return createSuccessResponse("Asset updated successfully", {
+      updatedAsset
+    });
   }
   return withErrorHandling(tool2, "Error updating asset");
 }
@@ -949,10 +1040,20 @@ function updateAssetTool(config) {
 // src/tools/assets/deleteAsset.ts
 import { z as z18 } from "zod";
 var DeleteAssetToolParams = BaseToolSchema.extend({
-  assetId: z18.string().describe("The ID of the asset to delete")
+  assetId: z18.string().describe("The ID of the asset to delete"),
+  confirm: z18.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z18.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
 });
 function deleteAssetTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId,
@@ -960,6 +1061,22 @@ function deleteAssetTool(config) {
     };
     const contentfulClient = createToolClient(config, args);
     const asset = await contentfulClient.asset.get(params);
+    const expectedToken = buildConfirmToken(
+      "asset",
+      args.assetId,
+      asset.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} asset`,
+        buildConfirmationPreview(
+          "asset",
+          args.assetId,
+          { asset },
+          expectedToken
+        )
+      );
+    }
     await contentfulClient.asset.delete(params);
     return createSuccessResponse("Asset deleted successfully", { asset });
   }
@@ -1063,20 +1180,74 @@ function createEntitiesCollection(entities) {
   };
 }
 
+// src/utils/bulkLimits.ts
+var DEFAULT_MAX_BULK_SIZE = 10;
+function resolveMaxBulkSize(configured) {
+  if (configured === void 0 || !Number.isInteger(configured) || configured <= 0) {
+    return DEFAULT_MAX_BULK_SIZE;
+  }
+  return configured;
+}
+function assertBulkSizeAllowed(count, configured) {
+  const limit = resolveMaxBulkSize(configured);
+  if (count > limit) {
+    throw new Error(
+      `Bulk operation rejected: ${count} IDs exceeds MAX_BULK_SIZE of ${limit}. Reduce batch size or increase the limit.`
+    );
+  }
+}
+var PLURAL_BY_ENTITY = {
+  entry: "entries",
+  asset: "assets"
+};
+function buildDryRunPreview(input) {
+  const { operation, entityType, ids, spaceId, environmentId } = input;
+  const noun = ids.length === 1 ? entityType : PLURAL_BY_ENTITY[entityType];
+  return {
+    dryRun: true,
+    operation,
+    entityType,
+    count: ids.length,
+    ids,
+    target: { spaceId, environmentId },
+    message: `Dry run: would ${operation} ${ids.length} ${noun} in ${spaceId}/${environmentId}. No changes were made. Re-run without dryRun to execute.`
+  };
+}
+
 // src/tools/assets/publishAsset.ts
 var PublishAssetToolParams = BaseToolSchema.extend({
   assetId: z19.union([z19.string(), z19.array(z19.string()).max(100)]).describe(
-    "The ID of the asset to publish (string) or an array of asset IDs (up to 100 assets)"
+    "A single asset ID (string) or an array of asset IDs to publish (up to MAX_BULK_SIZE per call; default 10, max 100 \u2014 configurable via MAX_BULK_SIZE env var)."
+  ),
+  dryRun: z19.boolean().optional().describe(
+    "When true, returns a preview of the operation without executing it. Still subject to MAX_BULK_SIZE \u2014 use this to confirm intent for within-limit calls."
   )
 });
 function publishAssetTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const assetIds = Array.isArray(args.assetId) ? args.assetId : [args.assetId];
+    assertBulkSizeAllowed(assetIds.length, config.maxBulkSize);
+    if (args.dryRun) {
+      return createSuccessResponse(
+        "Dry run: no changes were made",
+        buildDryRunPreview({
+          operation: "publish",
+          entityType: "asset",
+          ids: assetIds,
+          spaceId: args.spaceId,
+          environmentId: args.environmentId
+        })
+      );
+    }
     const baseParams = {
       spaceId: args.spaceId,
       environmentId: args.environmentId
     };
     const contentfulClient = createToolClient(config, args);
-    const assetIds = Array.isArray(args.assetId) ? args.assetId : [args.assetId];
     if (assetIds.length === 1) {
       try {
         const assetId = assetIds[0];
@@ -1126,17 +1297,37 @@ function publishAssetTool(config) {
 import { z as z20 } from "zod";
 var UnpublishAssetToolParams = BaseToolSchema.extend({
   assetId: z20.union([z20.string(), z20.array(z20.string()).max(100)]).describe(
-    "The ID of the asset to unpublish (string) or an array of asset IDs (up to 100 assets)"
+    "A single asset ID (string) or an array of asset IDs to unpublish (up to MAX_BULK_SIZE per call; default 10, max 100 \u2014 configurable via MAX_BULK_SIZE env var)."
+  ),
+  dryRun: z20.boolean().optional().describe(
+    "When true, returns a preview of the operation without executing it. Still subject to MAX_BULK_SIZE \u2014 use this to confirm intent for within-limit calls."
   )
 });
 function unpublishAssetTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const assetIds = Array.isArray(args.assetId) ? args.assetId : [args.assetId];
+    assertBulkSizeAllowed(assetIds.length, config.maxBulkSize);
+    if (args.dryRun) {
+      return createSuccessResponse(
+        "Dry run: no changes were made",
+        buildDryRunPreview({
+          operation: "unpublish",
+          entityType: "asset",
+          ids: assetIds,
+          spaceId: args.spaceId,
+          environmentId: args.environmentId
+        })
+      );
+    }
     const baseParams = {
       spaceId: args.spaceId,
       environmentId: args.environmentId
     };
     const contentfulClient = createToolClient(config, args);
-    const assetIds = Array.isArray(args.assetId) ? args.assetId : [args.assetId];
     if (assetIds.length === 1) {
       try {
         const assetId = assetIds[0];
@@ -1186,17 +1377,37 @@ function unpublishAssetTool(config) {
 import { z as z21 } from "zod";
 var ArchiveAssetToolParams = BaseToolSchema.extend({
   assetId: z21.union([z21.string(), z21.array(z21.string()).max(100)]).describe(
-    "The ID of the asset to archive (string) or an array of asset IDs (up to 100 assets)"
+    "A single asset ID (string) or an array of asset IDs to archive (up to MAX_BULK_SIZE per call; default 10, max 100 \u2014 configurable via MAX_BULK_SIZE env var)."
+  ),
+  dryRun: z21.boolean().optional().describe(
+    "When true, returns a preview of the operation without executing it. Still subject to MAX_BULK_SIZE \u2014 use this to confirm intent for within-limit calls."
   )
 });
 function archiveAssetTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const assetIds = Array.isArray(args.assetId) ? args.assetId : [args.assetId];
+    assertBulkSizeAllowed(assetIds.length, config.maxBulkSize);
+    if (args.dryRun) {
+      return createSuccessResponse(
+        "Dry run: no changes were made",
+        buildDryRunPreview({
+          operation: "archive",
+          entityType: "asset",
+          ids: assetIds,
+          spaceId: args.spaceId,
+          environmentId: args.environmentId
+        })
+      );
+    }
     const baseParams = {
       spaceId: args.spaceId,
       environmentId: args.environmentId
     };
     const contentfulClient = createToolClient(config, args);
-    const assetIds = Array.isArray(args.assetId) ? args.assetId : [args.assetId];
     const successfullyArchived = [];
     for (const assetId of assetIds) {
       try {
@@ -1232,17 +1443,37 @@ function archiveAssetTool(config) {
 import { z as z22 } from "zod";
 var UnarchiveAssetToolParams = BaseToolSchema.extend({
   assetId: z22.union([z22.string(), z22.array(z22.string()).max(100)]).describe(
-    "The ID of the asset to unarchive (string) or an array of asset IDs (up to 100 assets)"
+    "A single asset ID (string) or an array of asset IDs to unarchive (up to MAX_BULK_SIZE per call; default 10, max 100 \u2014 configurable via MAX_BULK_SIZE env var)."
+  ),
+  dryRun: z22.boolean().optional().describe(
+    "When true, returns a preview of the operation without executing it. Still subject to MAX_BULK_SIZE \u2014 use this to confirm intent for within-limit calls."
   )
 });
 function unarchiveAssetTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const assetIds = Array.isArray(args.assetId) ? args.assetId : [args.assetId];
+    assertBulkSizeAllowed(assetIds.length, config.maxBulkSize);
+    if (args.dryRun) {
+      return createSuccessResponse(
+        "Dry run: no changes were made",
+        buildDryRunPreview({
+          operation: "unarchive",
+          entityType: "asset",
+          ids: assetIds,
+          spaceId: args.spaceId,
+          environmentId: args.environmentId
+        })
+      );
+    }
     const baseParams = {
       spaceId: args.spaceId,
       environmentId: args.environmentId
     };
     const contentfulClient = createToolClient(config, args);
-    const assetIds = Array.isArray(args.assetId) ? args.assetId : [args.assetId];
     const successfullyUnarchived = [];
     for (const assetId of assetIds) {
       try {
@@ -1332,12 +1563,12 @@ function createAssetTools(config) {
     },
     deleteAsset: {
       title: "delete_asset",
-      description: "Delete an asset",
+      description: "Delete an asset from your Contentful space. This is a two-phase operation: the first call (without confirm/confirmToken) returns a preview of the asset and a confirmToken. To complete the deletion, call this tool again with the same assetId, confirm: true, and the confirmToken from the preview response.",
       inputParams: DeleteAssetToolParams.shape,
       annotations: {
         readOnlyHint: false,
         destructiveHint: true,
-        idempotentHint: true,
+        idempotentHint: false,
         openWorldHint: false
       },
       tool: deleteAsset
@@ -1577,6 +1808,10 @@ var CreateContentTypeToolParams = BaseToolSchema.extend({
 });
 function createContentTypeTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId
@@ -1614,6 +1849,10 @@ var UpdateContentTypeToolParams = BaseToolSchema.extend({
 });
 function updateContentTypeTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId,
@@ -1664,16 +1903,43 @@ function updateContentTypeTool(config) {
 // src/tools/content-types/deleteContentType.ts
 import { z as z29 } from "zod";
 var DeleteContentTypeToolParams = BaseToolSchema.extend({
-  contentTypeId: z29.string().describe("The ID of the content type to delete")
+  contentTypeId: z29.string().describe("The ID of the content type to delete"),
+  confirm: z29.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z29.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
 });
 function deleteContentTypeTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId,
       contentTypeId: args.contentTypeId
     };
     const contentfulClient = createToolClient(config, args);
+    const contentType = await contentfulClient.contentType.get(params);
+    const expectedToken = buildConfirmToken(
+      "contentType",
+      args.contentTypeId,
+      contentType.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} content type`,
+        buildConfirmationPreview(
+          "contentType",
+          args.contentTypeId,
+          { contentType },
+          expectedToken
+        )
+      );
+    }
     await contentfulClient.contentType.delete(params);
     return createSuccessResponse("Content type deleted successfully", {
       contentTypeId: args.contentTypeId
@@ -1689,6 +1955,10 @@ var PublishContentTypeToolParams = BaseToolSchema.extend({
 });
 function publishContentTypeTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId,
@@ -1714,6 +1984,10 @@ var UnpublishContentTypeToolParams = BaseToolSchema.extend({
 });
 function unpublishContentTypeTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId,
@@ -1728,6 +2002,146 @@ function unpublishContentTypeTool(config) {
   return withErrorHandling(tool2, "Error unpublishing content type");
 }
 
+// src/tools/content-types/omitContentTypeField.ts
+import { z as z32 } from "zod";
+var OmitContentTypeFieldToolParams = BaseToolSchema.extend({
+  contentTypeId: z32.string().describe("The ID of the content type containing the field"),
+  fieldId: z32.string().describe("The ID of the field to omit"),
+  omitted: z32.boolean().default(true).describe(
+    "Whether the field should be omitted. Defaults to true. Set to false to un-omit a field."
+  )
+});
+function omitContentTypeFieldTool(config) {
+  async function tool2(args) {
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      contentTypeId: args.contentTypeId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const currentContentType = await contentfulClient.contentType.get(params);
+    const field = currentContentType.fields.find((f) => f.id === args.fieldId);
+    if (!field) {
+      throw new Error(
+        `Field "${args.fieldId}" not found on content type "${args.contentTypeId}"`
+      );
+    }
+    const updatedFields = currentContentType.fields.map(
+      (f) => f.id === args.fieldId ? { ...f, omitted: args.omitted } : f
+    );
+    const updatedContentType = await contentfulClient.contentType.update(
+      params,
+      { ...currentContentType, fields: updatedFields }
+    );
+    return createSuccessResponse(
+      `Field "${args.fieldId}" updated (omitted=${args.omitted}) on content type "${args.contentTypeId}". Publish the content type for the change to take effect.`,
+      { contentType: updatedContentType }
+    );
+  }
+  return withErrorHandling(tool2, "Error omitting field");
+}
+
+// src/tools/content-types/deleteContentTypeField.ts
+import { z as z33 } from "zod";
+var DeleteContentTypeFieldToolParams = BaseToolSchema.extend({
+  contentTypeId: z33.string().describe("The ID of the content type containing the field"),
+  fieldId: z33.string().describe("The ID of the field to delete")
+});
+function deleteContentTypeFieldTool(config) {
+  async function tool2(args) {
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      contentTypeId: args.contentTypeId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const currentContentType = await contentfulClient.contentType.get(params);
+    const field = currentContentType.fields.find((f) => f.id === args.fieldId);
+    if (!field) {
+      throw new Error(
+        `Field "${args.fieldId}" not found on content type "${args.contentTypeId}"`
+      );
+    }
+    if (field.required) {
+      throw new Error(
+        `Field "${args.fieldId}" is required. Set required=false via update_content_type and publish before deleting.`
+      );
+    }
+    if (!field.omitted) {
+      throw new Error(
+        `Field "${args.fieldId}" must be omitted and the content type published before it can be deleted. Use omit_content_type_field, then publish_content_type, then retry.`
+      );
+    }
+    const updatedFields = currentContentType.fields.map(
+      (f) => f.id === args.fieldId ? { ...f, deleted: true } : f
+    );
+    const updatedContentType = await contentfulClient.contentType.update(
+      params,
+      { ...currentContentType, fields: updatedFields }
+    );
+    return createSuccessResponse(
+      `Field "${args.fieldId}" marked deleted on content type "${args.contentTypeId}". Publish the content type for the deletion to take effect.`,
+      { contentType: updatedContentType }
+    );
+  }
+  return withErrorHandling(tool2, "Error deleting field");
+}
+
+// src/tools/content-types/disableContentTypeField.ts
+import { z as z34 } from "zod";
+var DisableContentTypeFieldToolParams = BaseToolSchema.extend({
+  contentTypeId: z34.string().describe("The ID of the content type containing the field"),
+  fieldId: z34.string().describe("The ID of the field to update"),
+  disabled: z34.boolean().optional().describe(
+    "Set to true to disable the field in the editor UI (editors cannot edit it), false to re-enable. Takes effect once the content type is published."
+  ),
+  omitted: z34.boolean().optional().describe(
+    "Set to true to omit the field from API responses, false to include it again. Takes effect once the content type is published. Prefer omit_content_type_field when only changing the omitted flag."
+  )
+});
+function disableContentTypeFieldTool(config) {
+  async function tool2(args) {
+    if (args.disabled === void 0 && args.omitted === void 0) {
+      throw new Error(
+        'At least one of "disabled" or "omitted" must be provided'
+      );
+    }
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      contentTypeId: args.contentTypeId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const currentContentType = await contentfulClient.contentType.get(params);
+    const field = currentContentType.fields.find((f) => f.id === args.fieldId);
+    if (!field) {
+      throw new Error(
+        `Field "${args.fieldId}" not found on content type "${args.contentTypeId}"`
+      );
+    }
+    const updatedFields = currentContentType.fields.map((f) => {
+      if (f.id !== args.fieldId) return f;
+      return {
+        ...f,
+        ...args.disabled !== void 0 && { disabled: args.disabled },
+        ...args.omitted !== void 0 && { omitted: args.omitted }
+      };
+    });
+    const updatedContentType = await contentfulClient.contentType.update(
+      params,
+      { ...currentContentType, fields: updatedFields }
+    );
+    const changes = [];
+    if (args.disabled !== void 0) changes.push(`disabled=${args.disabled}`);
+    if (args.omitted !== void 0) changes.push(`omitted=${args.omitted}`);
+    return createSuccessResponse(
+      `Field "${args.fieldId}" updated (${changes.join(", ")}) on content type "${args.contentTypeId}". Publish the content type for the change to take effect.`,
+      { contentType: updatedContentType }
+    );
+  }
+  return withErrorHandling(tool2, "Error updating field");
+}
+
 // src/tools/content-types/register.ts
 function createContentTypeTools(config) {
   const getContentType = getContentTypeTool(config);
@@ -1737,6 +2151,9 @@ function createContentTypeTools(config) {
   const deleteContentType = deleteContentTypeTool(config);
   const publishContentType = publishContentTypeTool(config);
   const unpublishContentType = unpublishContentTypeTool(config);
+  const omitContentTypeField = omitContentTypeFieldTool(config);
+  const deleteContentTypeField = deleteContentTypeFieldTool(config);
+  const disableContentTypeField = disableContentTypeFieldTool(config);
   return {
     getContentType: {
       title: "get_content_type",
@@ -1784,12 +2201,12 @@ function createContentTypeTools(config) {
     },
     deleteContentType: {
       title: "delete_content_type",
-      description: "Delete a content type",
+      description: "Delete a content type from your Contentful space. This is a two-phase operation: the first call (without confirm/confirmToken) returns a preview of the content type and a confirmToken. To complete the deletion, call this tool again with the same contentTypeId, confirm: true, and the confirmToken from the preview response.",
       inputParams: DeleteContentTypeToolParams.shape,
       annotations: {
         readOnlyHint: false,
         destructiveHint: true,
-        idempotentHint: true,
+        idempotentHint: false,
         openWorldHint: false
       },
       tool: deleteContentType
@@ -1817,12 +2234,48 @@ function createContentTypeTools(config) {
         openWorldHint: false
       },
       tool: unpublishContentType
+    },
+    omitContentTypeField: {
+      title: "omit_content_type_field",
+      description: "Mark a single field as omitted (or un-omitted) on a content type. Updates the content type draft only \u2014 call publish_content_type afterwards for the change to take effect. Reversible via the same tool with omitted=false. This is a prerequisite for delete_content_type_field: the field must be omitted in the published version before it can be deleted.",
+      inputParams: OmitContentTypeFieldToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: omitContentTypeField
+    },
+    deleteContentTypeField: {
+      title: "delete_content_type_field",
+      description: "Permanently mark a single field as deleted on a content type. Destructive and irreversible once published. Updates the content type draft only \u2014 call publish_content_type afterwards for the deletion to take effect. The field must not be required AND must already be omitted in the published version of the content type. Run omit_content_type_field, then publish_content_type, before calling this. Use disable_content_type_field to temporarily hide a field instead.",
+      inputParams: DeleteContentTypeFieldToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: deleteContentTypeField
+    },
+    disableContentTypeField: {
+      title: "disable_content_type_field",
+      description: "Toggle the disabled and/or omitted flags on a single field. Setting disabled=true hides the field from the editor UI; setting omitted=true removes it from API responses. Both flags are reversible. Updates the content type draft only \u2014 call publish_content_type afterwards for the change to take effect. Use omit_content_type_field when only changing the omitted flag.",
+      inputParams: DisableContentTypeFieldToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: disableContentTypeField
     }
   };
 }
 
 // src/tools/context/getInitialContextTool.ts
-import { z as z32 } from "zod";
+import { z as z35 } from "zod";
 import { outdent } from "outdent";
 
 // src/tools/context/store.ts
@@ -1959,7 +2412,7 @@ Before running a tool:
 You have access to powerful tools that can help you work with Contentful effectively. Always start with get_initial_context, check the schema when needed, clarify resources when multiple exist, and take action to complete user requests fully.`;
 
 // src/tools/context/getInitialContextTool.ts
-var GetInitialContextToolParams = z32.object({});
+var GetInitialContextToolParams = z35.object({});
 function getInitialContextTool(config) {
   async function tool2(_params) {
     const configInfo = `Current Contentful Configuration:
@@ -2046,9 +2499,9 @@ function listEditorInterfacesTool(config) {
 }
 
 // src/tools/editor-interfaces/getEditorInterface.ts
-import { z as z33 } from "zod";
+import { z as z36 } from "zod";
 var GetEditorInterfaceToolParams = BaseToolSchema.extend({
-  contentTypeId: z33.string().describe(
+  contentTypeId: z36.string().describe(
     "The ID of the content type to retrieve the editor interface for"
   )
 });
@@ -2069,45 +2522,49 @@ function getEditorInterfaceTool(config) {
 }
 
 // src/tools/editor-interfaces/updateEditorInterface.ts
-import { z as z34 } from "zod";
-var ControlSchema = z34.object({
-  fieldId: z34.string().describe("The field ID this control applies to"),
-  widgetId: z34.string().describe("The widget ID to use for this field"),
-  widgetNamespace: z34.enum(["builtin", "extension", "app", "editor-builtin"]).optional().describe(
+import { z as z37 } from "zod";
+var ControlSchema = z37.object({
+  fieldId: z37.string().describe("The field ID this control applies to"),
+  widgetId: z37.string().describe("The widget ID to use for this field"),
+  widgetNamespace: z37.enum(["builtin", "extension", "app", "editor-builtin"]).optional().describe(
     "The namespace of the widget (builtin, extension, app, or editor-builtin)"
   ),
-  settings: z34.record(z34.any()).optional().describe("Settings object for the widget")
+  settings: z37.record(z37.any()).optional().describe("Settings object for the widget")
 });
-var SidebarItemSchema = z34.object({
-  widgetId: z34.string().describe("The widget ID for the sidebar item"),
-  widgetNamespace: z34.enum(["sidebar-builtin", "extension", "app"]).describe("The namespace of the sidebar widget"),
-  settings: z34.record(z34.any()).optional().describe("Settings object for the sidebar widget"),
-  disabled: z34.boolean().optional().describe("Whether the sidebar item is disabled")
+var SidebarItemSchema = z37.object({
+  widgetId: z37.string().describe("The widget ID for the sidebar item"),
+  widgetNamespace: z37.enum(["sidebar-builtin", "extension", "app"]).describe("The namespace of the sidebar widget"),
+  settings: z37.record(z37.any()).optional().describe("Settings object for the sidebar widget"),
+  disabled: z37.boolean().optional().describe("Whether the sidebar item is disabled")
 });
-var EditorLayoutItemSchema = z34.object({
-  fieldId: z34.string().describe("The field ID"),
-  settings: z34.record(z34.any()).optional().describe("Layout settings for the field")
+var EditorLayoutItemSchema = z37.object({
+  fieldId: z37.string().describe("The field ID"),
+  settings: z37.record(z37.any()).optional().describe("Layout settings for the field")
 });
-var EditorLayoutSchema = z34.object({
-  items: z34.array(EditorLayoutItemSchema).optional().describe("Array of editor layout items")
+var EditorLayoutSchema = z37.object({
+  items: z37.array(EditorLayoutItemSchema).optional().describe("Array of editor layout items")
 });
-var GroupControlSchema = z34.object({
-  groupId: z34.string().describe("The group ID"),
-  widgetId: z34.string().describe("The widget ID for the group control"),
-  widgetNamespace: z34.enum(["builtin", "extension", "app"]).optional().describe("The namespace of the group control widget"),
-  settings: z34.record(z34.any()).optional().describe("Settings object for the group control")
+var GroupControlSchema = z37.object({
+  groupId: z37.string().describe("The group ID"),
+  widgetId: z37.string().describe("The widget ID for the group control"),
+  widgetNamespace: z37.enum(["builtin", "extension", "app"]).optional().describe("The namespace of the group control widget"),
+  settings: z37.record(z37.any()).optional().describe("Settings object for the group control")
 });
 var UpdateEditorInterfaceToolParams = BaseToolSchema.extend({
-  contentTypeId: z34.string().describe("The ID of the content type to update the editor interface for"),
-  controls: z34.array(ControlSchema).optional().describe(
+  contentTypeId: z37.string().describe("The ID of the content type to update the editor interface for"),
+  controls: z37.array(ControlSchema).optional().describe(
     "Array of control definitions for fields in the content type. Each control defines which widget to use for a field."
   ),
-  sidebar: z34.array(SidebarItemSchema).optional().describe("Array of sidebar widget configurations"),
-  editorLayout: z34.array(EditorLayoutSchema).optional().describe("Editor layout configuration for organizing fields"),
-  groupControls: z34.array(GroupControlSchema).optional().describe("Array of group control definitions for field groups")
+  sidebar: z37.array(SidebarItemSchema).optional().describe("Array of sidebar widget configurations"),
+  editorLayout: z37.array(EditorLayoutSchema).optional().describe("Editor layout configuration for organizing fields"),
+  groupControls: z37.array(GroupControlSchema).optional().describe("Array of group control definitions for field groups")
 });
 function updateEditorInterfaceTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId,
@@ -2183,7 +2640,7 @@ function createEditorInterfaceTools(config) {
 }
 
 // src/tools/entries/searchEntries.ts
-import { z as z35 } from "zod";
+import { z as z38 } from "zod";
 
 // src/utils/limits.ts
 function searchLimit(userLimit) {
@@ -2206,38 +2663,38 @@ function normalizeArrayFilters(query) {
 
 // src/tools/entries/searchEntries.ts
 var SearchEntriesToolParams = BaseToolSchema.extend({
-  query: z35.object({
+  query: z38.object({
     // Core parameters (maintain backward compatibility)
-    content_type: z35.string().optional().describe("Filter by content type"),
-    include: z35.number().optional().describe("Include this many levels of linked entries"),
-    select: z35.string().optional().describe("Comma-separated list of fields to return"),
-    links_to_entry: z35.string().optional().describe("Find entries that link to the specified entry ID"),
-    limit: z35.number().optional().describe(
+    content_type: z38.string().optional().describe("Filter by content type"),
+    include: z38.number().optional().describe("Include this many levels of linked entries"),
+    select: z38.string().optional().describe("Comma-separated list of fields to return"),
+    links_to_entry: z38.string().optional().describe("Find entries that link to the specified entry ID"),
+    limit: z38.number().optional().describe(
       "Maximum number of entries to return (default: 10, max: 100)"
     ),
-    skip: z35.number().optional().describe("Skip this many entries for pagination"),
-    order: z35.string().optional().describe("Order entries by this field"),
+    skip: z38.number().optional().describe("Skip this many entries for pagination"),
+    order: z38.string().optional().describe("Order entries by this field"),
     // Full-text search
-    query: z35.string().optional().describe("Full-text search across all fields"),
+    query: z38.string().optional().describe("Full-text search across all fields"),
     // Common field-based searches (examples - any field is supported via catchall)
-    "fields.title": z35.string().optional().describe("Search by title field"),
-    "fields.slug": z35.string().optional().describe("Search by slug field"),
-    "fields.internalName": z35.string().optional().describe("Search by internal name field"),
-    "fields.text": z35.string().optional().describe("Search by text field (useful for testimonials)"),
-    "fields.title[match]": z35.string().optional().describe("Pattern match on title field"),
-    "fields.slug[match]": z35.string().optional().describe("Pattern match on slug field"),
-    "fields.title[exists]": z35.boolean().optional().describe("Check if title field exists"),
-    "fields.slug[exists]": z35.boolean().optional().describe("Check if slug field exists"),
+    "fields.title": z38.string().optional().describe("Search by title field"),
+    "fields.slug": z38.string().optional().describe("Search by slug field"),
+    "fields.internalName": z38.string().optional().describe("Search by internal name field"),
+    "fields.text": z38.string().optional().describe("Search by text field (useful for testimonials)"),
+    "fields.title[match]": z38.string().optional().describe("Pattern match on title field"),
+    "fields.slug[match]": z38.string().optional().describe("Pattern match on slug field"),
+    "fields.title[exists]": z38.boolean().optional().describe("Check if title field exists"),
+    "fields.slug[exists]": z38.boolean().optional().describe("Check if slug field exists"),
     // System field searches
-    "sys.id[in]": z35.array(z35.string()).optional().describe("Search by multiple entry IDs"),
-    "sys.contentType.sys.id": z35.string().optional().describe("Filter by content type ID"),
-    "sys.createdAt[gte]": z35.string().optional().describe("Created after date (ISO format)"),
-    "sys.createdAt[lte]": z35.string().optional().describe("Created before date (ISO format)"),
-    "sys.updatedAt[gte]": z35.string().optional().describe("Updated after date (ISO format)"),
-    "sys.updatedAt[lte]": z35.string().optional().describe("Updated before date (ISO format)"),
+    "sys.id[in]": z38.array(z38.string()).optional().describe("Search by multiple entry IDs"),
+    "sys.contentType.sys.id": z38.string().optional().describe("Filter by content type ID"),
+    "sys.createdAt[gte]": z38.string().optional().describe("Created after date (ISO format)"),
+    "sys.createdAt[lte]": z38.string().optional().describe("Created before date (ISO format)"),
+    "sys.updatedAt[gte]": z38.string().optional().describe("Updated after date (ISO format)"),
+    "sys.updatedAt[lte]": z38.string().optional().describe("Updated before date (ISO format)"),
     // Metadata searches
-    "metadata.tags.sys.id[in]": z35.array(z35.string()).optional().describe("Filter by tag IDs")
-  }).catchall(z35.any()).describe(
+    "metadata.tags.sys.id[in]": z38.array(z38.string()).optional().describe("Filter by tag IDs")
+  }).catchall(z38.any()).describe(
     "Flexible search parameters supporting ANY Contentful API query parameter. Use fields.* for field searches, sys.* for system fields, and any other Contentful API parameter."
   )
 });
@@ -2268,110 +2725,110 @@ function searchEntriesTool(config) {
 }
 
 // src/tools/entries/createEntry.ts
-import { z as z38 } from "zod";
+import { z as z41 } from "zod";
 
 // src/types/entryFieldSchema.ts
-import { z as z37 } from "zod";
+import { z as z40 } from "zod";
 
 // src/types/richTextSchema.ts
 import { BLOCKS as BLOCKS2, INLINES as INLINES2, MARKS } from "@contentful/rich-text-types";
-import { z as z36 } from "zod";
-var emptyNodeDataSchema = z36.object({});
-var entryLinkTargetSchema = z36.object({
-  sys: z36.object({
-    id: z36.string(),
-    type: z36.literal("Link"),
-    linkType: z36.literal("Entry")
+import { z as z39 } from "zod";
+var emptyNodeDataSchema = z39.object({});
+var entryLinkTargetSchema = z39.object({
+  sys: z39.object({
+    id: z39.string(),
+    type: z39.literal("Link"),
+    linkType: z39.literal("Entry")
   })
 });
-var assetLinkTargetSchema = z36.object({
-  sys: z36.object({
-    id: z36.string(),
-    type: z36.literal("Link"),
-    linkType: z36.literal("Asset")
+var assetLinkTargetSchema = z39.object({
+  sys: z39.object({
+    id: z39.string(),
+    type: z39.literal("Link"),
+    linkType: z39.literal("Asset")
   })
 });
-var resourceLinkTargetSchema = z36.object({
-  sys: z36.object({
-    type: z36.literal("ResourceLink"),
-    linkType: z36.string(),
-    urn: z36.string()
+var resourceLinkTargetSchema = z39.object({
+  sys: z39.object({
+    type: z39.literal("ResourceLink"),
+    linkType: z39.string(),
+    urn: z39.string()
   })
 });
-var richTextMarkSchema = z36.object({
-  type: z36.nativeEnum(MARKS)
+var richTextMarkSchema = z39.object({
+  type: z39.nativeEnum(MARKS)
 });
-var richTextTextNodeSchema = z36.object({
-  nodeType: z36.literal("text"),
-  value: z36.string(),
-  marks: z36.array(richTextMarkSchema),
+var richTextTextNodeSchema = z39.object({
+  nodeType: z39.literal("text"),
+  value: z39.string(),
+  marks: z39.array(richTextMarkSchema),
   data: emptyNodeDataSchema
 });
-var embeddedEntryBlockNodeSchema = z36.object({
-  nodeType: z36.literal(BLOCKS2.EMBEDDED_ENTRY),
-  data: z36.object({
+var embeddedEntryBlockNodeSchema = z39.object({
+  nodeType: z39.literal(BLOCKS2.EMBEDDED_ENTRY),
+  data: z39.object({
     target: entryLinkTargetSchema
   }),
-  content: z36.array(z36.never())
+  content: z39.array(z39.never())
 });
-var embeddedEntryInlineNodeSchema = z36.object({
-  nodeType: z36.literal(INLINES2.EMBEDDED_ENTRY),
-  data: z36.object({
+var embeddedEntryInlineNodeSchema = z39.object({
+  nodeType: z39.literal(INLINES2.EMBEDDED_ENTRY),
+  data: z39.object({
     target: entryLinkTargetSchema
   }),
-  content: z36.array(z36.never())
+  content: z39.array(z39.never())
 });
-var embeddedAssetBlockNodeSchema = z36.object({
-  nodeType: z36.literal(BLOCKS2.EMBEDDED_ASSET),
-  data: z36.object({
+var embeddedAssetBlockNodeSchema = z39.object({
+  nodeType: z39.literal(BLOCKS2.EMBEDDED_ASSET),
+  data: z39.object({
     target: assetLinkTargetSchema
   }),
-  content: z36.array(z36.never())
+  content: z39.array(z39.never())
 });
-var hyperlinkInlineNodeSchema = z36.object({
-  nodeType: z36.literal(INLINES2.HYPERLINK),
-  data: z36.object({
-    uri: z36.string().url()
+var hyperlinkInlineNodeSchema = z39.object({
+  nodeType: z39.literal(INLINES2.HYPERLINK),
+  data: z39.object({
+    uri: z39.string().url()
   }),
-  content: z36.array(richTextTextNodeSchema)
+  content: z39.array(richTextTextNodeSchema)
 });
-var entryHyperlinkInlineNodeSchema = z36.object({
-  nodeType: z36.literal(INLINES2.ENTRY_HYPERLINK),
-  data: z36.object({
+var entryHyperlinkInlineNodeSchema = z39.object({
+  nodeType: z39.literal(INLINES2.ENTRY_HYPERLINK),
+  data: z39.object({
     target: entryLinkTargetSchema
   }),
-  content: z36.array(richTextTextNodeSchema)
+  content: z39.array(richTextTextNodeSchema)
 });
-var assetHyperlinkInlineNodeSchema = z36.object({
-  nodeType: z36.literal(INLINES2.ASSET_HYPERLINK),
-  data: z36.object({
+var assetHyperlinkInlineNodeSchema = z39.object({
+  nodeType: z39.literal(INLINES2.ASSET_HYPERLINK),
+  data: z39.object({
     target: assetLinkTargetSchema
   }),
-  content: z36.array(richTextTextNodeSchema)
+  content: z39.array(richTextTextNodeSchema)
 });
-var embeddedResourceBlockNodeSchema = z36.object({
-  nodeType: z36.literal(BLOCKS2.EMBEDDED_RESOURCE),
-  data: z36.object({
+var embeddedResourceBlockNodeSchema = z39.object({
+  nodeType: z39.literal(BLOCKS2.EMBEDDED_RESOURCE),
+  data: z39.object({
     target: resourceLinkTargetSchema
   }),
-  content: z36.array(z36.never())
+  content: z39.array(z39.never())
 });
-var embeddedResourceInlineNodeSchema = z36.object({
-  nodeType: z36.literal(INLINES2.EMBEDDED_RESOURCE),
-  data: z36.object({
+var embeddedResourceInlineNodeSchema = z39.object({
+  nodeType: z39.literal(INLINES2.EMBEDDED_RESOURCE),
+  data: z39.object({
     target: resourceLinkTargetSchema
   }),
-  content: z36.array(z36.never())
+  content: z39.array(z39.never())
 });
-var resourceHyperlinkInlineNodeSchema = z36.object({
-  nodeType: z36.literal(INLINES2.RESOURCE_HYPERLINK),
-  data: z36.object({
+var resourceHyperlinkInlineNodeSchema = z39.object({
+  nodeType: z39.literal(INLINES2.RESOURCE_HYPERLINK),
+  data: z39.object({
     target: resourceLinkTargetSchema
   }),
-  content: z36.array(richTextTextNodeSchema)
+  content: z39.array(richTextTextNodeSchema)
 });
-var richTextInlineNodeSchema = z36.lazy(
-  () => z36.union([
+var richTextInlineNodeSchema = z39.lazy(
+  () => z39.union([
     richTextTextNodeSchema,
     embeddedEntryInlineNodeSchema,
     hyperlinkInlineNodeSchema,
@@ -2381,17 +2838,17 @@ var richTextInlineNodeSchema = z36.lazy(
     resourceHyperlinkInlineNodeSchema
   ])
 );
-var paragraphNodeSchema = z36.lazy(
-  () => z36.object({
-    nodeType: z36.literal(BLOCKS2.PARAGRAPH),
+var paragraphNodeSchema = z39.lazy(
+  () => z39.object({
+    nodeType: z39.literal(BLOCKS2.PARAGRAPH),
     data: emptyNodeDataSchema,
-    content: z36.array(richTextInlineNodeSchema)
+    content: z39.array(richTextInlineNodeSchema)
   })
 );
-var headingNodeSchema = (headingNodeType) => z36.object({
-  nodeType: z36.literal(headingNodeType),
+var headingNodeSchema = (headingNodeType) => z39.object({
+  nodeType: z39.literal(headingNodeType),
   data: emptyNodeDataSchema,
-  content: z36.array(richTextInlineNodeSchema)
+  content: z39.array(richTextInlineNodeSchema)
 });
 var heading1NodeSchema = headingNodeSchema(BLOCKS2.HEADING_1);
 var heading2NodeSchema = headingNodeSchema(BLOCKS2.HEADING_2);
@@ -2399,56 +2856,56 @@ var heading3NodeSchema = headingNodeSchema(BLOCKS2.HEADING_3);
 var heading4NodeSchema = headingNodeSchema(BLOCKS2.HEADING_4);
 var heading5NodeSchema = headingNodeSchema(BLOCKS2.HEADING_5);
 var heading6NodeSchema = headingNodeSchema(BLOCKS2.HEADING_6);
-var hrNodeSchema = z36.object({
-  nodeType: z36.literal(BLOCKS2.HR),
+var hrNodeSchema = z39.object({
+  nodeType: z39.literal(BLOCKS2.HR),
   data: emptyNodeDataSchema,
-  content: z36.array(z36.never())
+  content: z39.array(z39.never())
 });
-var quoteNodeSchema = z36.object({
-  nodeType: z36.literal(BLOCKS2.QUOTE),
+var quoteNodeSchema = z39.object({
+  nodeType: z39.literal(BLOCKS2.QUOTE),
   data: emptyNodeDataSchema,
-  content: z36.array(paragraphNodeSchema)
+  content: z39.array(paragraphNodeSchema)
 });
-var tableHeaderCellNodeSchema = z36.object({
-  nodeType: z36.literal(BLOCKS2.TABLE_HEADER_CELL),
+var tableHeaderCellNodeSchema = z39.object({
+  nodeType: z39.literal(BLOCKS2.TABLE_HEADER_CELL),
   data: emptyNodeDataSchema,
-  content: z36.array(paragraphNodeSchema)
+  content: z39.array(paragraphNodeSchema)
 });
-var tableCellNodeSchema = z36.object({
-  nodeType: z36.literal(BLOCKS2.TABLE_CELL),
+var tableCellNodeSchema = z39.object({
+  nodeType: z39.literal(BLOCKS2.TABLE_CELL),
   data: emptyNodeDataSchema,
-  content: z36.array(paragraphNodeSchema)
+  content: z39.array(paragraphNodeSchema)
 });
-var tableRowNodeSchema = z36.object({
-  nodeType: z36.literal(BLOCKS2.TABLE_ROW),
+var tableRowNodeSchema = z39.object({
+  nodeType: z39.literal(BLOCKS2.TABLE_ROW),
   data: emptyNodeDataSchema,
-  content: z36.array(z36.union([tableHeaderCellNodeSchema, tableCellNodeSchema]))
+  content: z39.array(z39.union([tableHeaderCellNodeSchema, tableCellNodeSchema]))
 });
-var tableNodeSchema = z36.object({
-  nodeType: z36.literal(BLOCKS2.TABLE),
+var tableNodeSchema = z39.object({
+  nodeType: z39.literal(BLOCKS2.TABLE),
   data: emptyNodeDataSchema,
-  content: z36.array(tableRowNodeSchema)
+  content: z39.array(tableRowNodeSchema)
 });
-var orderedListNodeSchema = z36.lazy(
-  () => z36.object({
-    nodeType: z36.literal(BLOCKS2.OL_LIST),
+var orderedListNodeSchema = z39.lazy(
+  () => z39.object({
+    nodeType: z39.literal(BLOCKS2.OL_LIST),
     data: emptyNodeDataSchema,
-    content: z36.array(listItemNodeSchema)
+    content: z39.array(listItemNodeSchema)
   })
 );
-var unorderedListNodeSchema = z36.lazy(
-  () => z36.object({
-    nodeType: z36.literal(BLOCKS2.UL_LIST),
+var unorderedListNodeSchema = z39.lazy(
+  () => z39.object({
+    nodeType: z39.literal(BLOCKS2.UL_LIST),
     data: emptyNodeDataSchema,
-    content: z36.array(listItemNodeSchema)
+    content: z39.array(listItemNodeSchema)
   })
 );
-var listItemNodeSchema = z36.lazy(
-  () => z36.object({
-    nodeType: z36.literal(BLOCKS2.LIST_ITEM),
+var listItemNodeSchema = z39.lazy(
+  () => z39.object({
+    nodeType: z39.literal(BLOCKS2.LIST_ITEM),
     data: emptyNodeDataSchema,
-    content: z36.array(
-      z36.union([
+    content: z39.array(
+      z39.union([
         paragraphNodeSchema,
         orderedListNodeSchema,
         unorderedListNodeSchema
@@ -2456,8 +2913,8 @@ var listItemNodeSchema = z36.lazy(
     )
   })
 );
-var topLevelBlockNodeSchema = z36.lazy(
-  () => z36.union([
+var topLevelBlockNodeSchema = z39.lazy(
+  () => z39.union([
     paragraphNodeSchema,
     heading1NodeSchema,
     heading2NodeSchema,
@@ -2475,56 +2932,56 @@ var topLevelBlockNodeSchema = z36.lazy(
     tableNodeSchema
   ])
 );
-var richTextDocumentSchema = z36.object({
-  nodeType: z36.literal(BLOCKS2.DOCUMENT),
+var richTextDocumentSchema = z39.object({
+  nodeType: z39.literal(BLOCKS2.DOCUMENT),
   data: emptyNodeDataSchema,
-  content: z36.array(topLevelBlockNodeSchema)
+  content: z39.array(topLevelBlockNodeSchema)
 }).describe("Contentful Rich Text document");
 
 // src/types/entryFieldSchema.ts
-var linkSchema = z37.object({
-  sys: z37.object({
-    type: z37.literal("Link"),
-    linkType: z37.enum(["Entry", "Asset"]),
-    id: z37.string()
+var linkSchema = z40.object({
+  sys: z40.object({
+    type: z40.literal("Link"),
+    linkType: z40.enum(["Entry", "Asset"]),
+    id: z40.string()
   })
 });
-var resourceLinkSchema = z37.object({
-  sys: z37.object({
-    type: z37.literal("ResourceLink"),
-    linkType: z37.string(),
-    urn: z37.string()
+var resourceLinkSchema = z40.object({
+  sys: z40.object({
+    type: z40.literal("ResourceLink"),
+    linkType: z40.string(),
+    urn: z40.string()
   })
 });
-var locationSchema = z37.object({
-  lat: z37.number(),
-  lon: z37.number()
+var locationSchema = z40.object({
+  lat: z40.number(),
+  lon: z40.number()
 });
-var jsonPrimitive = z37.union([z37.string(), z37.number(), z37.boolean(), z37.null()]);
-var jsonValueSchema = z37.lazy(
-  () => z37.union([jsonPrimitive, z37.array(jsonValueSchema), z37.record(jsonValueSchema)]).describe("Freeform JSON value (not for Rich Text)")
+var jsonPrimitive = z40.union([z40.string(), z40.number(), z40.boolean(), z40.null()]);
+var jsonValueSchema = z40.lazy(
+  () => z40.union([jsonPrimitive, z40.array(jsonValueSchema), z40.record(jsonValueSchema)]).describe("Freeform JSON value (not for Rich Text)")
 );
-var fieldValueSchema = z37.union([
-  z37.string().describe("Symbol, Text, or Date field"),
-  z37.number().describe("Integer or Number field"),
-  z37.boolean().describe("Boolean field"),
+var fieldValueSchema = z40.union([
+  z40.string().describe("Symbol, Text, or Date field"),
+  z40.number().describe("Integer or Number field"),
+  z40.boolean().describe("Boolean field"),
   richTextDocumentSchema,
   linkSchema.describe("Link field (Entry or Asset reference)"),
   resourceLinkSchema.describe("ResourceLink field"),
   locationSchema.describe("Location field"),
-  z37.array(z37.string()).describe("Array field of Symbols"),
-  z37.array(linkSchema).describe("Array field of Links"),
-  z37.array(resourceLinkSchema).describe("Array field of ResourceLinks"),
+  z40.array(z40.string()).describe("Array field of Symbols"),
+  z40.array(linkSchema).describe("Array field of Links"),
+  z40.array(resourceLinkSchema).describe("Array field of ResourceLinks"),
   jsonValueSchema
 ]);
-var localizedFieldSchema = z37.record(fieldValueSchema);
-var entryFieldsSchema = z37.record(localizedFieldSchema).describe(
+var localizedFieldSchema = z40.record(fieldValueSchema);
+var entryFieldsSchema = z40.record(localizedFieldSchema).describe(
   "Field values to update. Keys are field IDs, values are locale-keyed objects. Will be merged with existing fields."
 );
 
 // src/tools/entries/createEntry.ts
 var CreateEntryToolParams = BaseToolSchema.extend({
-  contentTypeId: z38.string().describe("The ID of the content type to create an entry for"),
+  contentTypeId: z41.string().describe("The ID of the content type to create an entry for"),
   fields: entryFieldsSchema.describe(
     "The field values for the new entry. Keys should be field IDs and values should be the field content."
   ),
@@ -2532,6 +2989,10 @@ var CreateEntryToolParams = BaseToolSchema.extend({
 });
 function createEntryTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId
@@ -2553,12 +3014,22 @@ function createEntryTool(config) {
 }
 
 // src/tools/entries/deleteEntry.ts
-import { z as z39 } from "zod";
+import { z as z42 } from "zod";
 var DeleteEntryToolParams = BaseToolSchema.extend({
-  entryId: z39.string().describe("The ID of the entry to delete")
+  entryId: z42.string().describe("The ID of the entry to delete"),
+  confirm: z42.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z42.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
 });
 function deleteEntryTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId,
@@ -2566,6 +3037,22 @@ function deleteEntryTool(config) {
     };
     const contentfulClient = createToolClient(config, args);
     const entry = await contentfulClient.entry.get(params);
+    const expectedToken = buildConfirmToken(
+      "entry",
+      args.entryId,
+      entry.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} entry`,
+        buildConfirmationPreview(
+          "entry",
+          args.entryId,
+          { entry },
+          expectedToken
+        )
+      );
+    }
     await contentfulClient.entry.delete(params);
     return createSuccessResponse("Entry deleted successfully", { entry });
   }
@@ -2573,9 +3060,9 @@ function deleteEntryTool(config) {
 }
 
 // src/tools/entries/updateEntry.ts
-import { z as z40 } from "zod";
+import { z as z43 } from "zod";
 var UpdateEntryToolParams = BaseToolSchema.extend({
-  entryId: z40.string().describe("The ID of the entry to update"),
+  entryId: z43.string().describe("The ID of the entry to update"),
   fields: entryFieldsSchema.describe(
     "The field values to update. Keys should be field IDs and values should be the field content. Will be merged with existing fields."
   ),
@@ -2583,6 +3070,10 @@ var UpdateEntryToolParams = BaseToolSchema.extend({
 });
 function updateEntryTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId,
@@ -2618,9 +3109,9 @@ function updateEntryTool(config) {
 }
 
 // src/tools/entries/getEntry.ts
-import { z as z41 } from "zod";
+import { z as z44 } from "zod";
 var GetEntryToolParams = BaseToolSchema.extend({
-  entryId: z41.string().describe("The ID of the entry to retrieve")
+  entryId: z44.string().describe("The ID of the entry to retrieve")
 });
 function getEntryTool(config) {
   async function tool2(args) {
@@ -2637,20 +3128,40 @@ function getEntryTool(config) {
 }
 
 // src/tools/entries/publishEntry.ts
-import { z as z42 } from "zod";
+import { z as z45 } from "zod";
 var PublishEntryToolParams = BaseToolSchema.extend({
-  entryId: z42.union([z42.string(), z42.array(z42.string()).max(100)]).describe(
-    "The ID of the entry to publish (string) or an array of entry IDs (up to 100 entries)"
+  entryId: z45.array(z45.string()).min(1).max(100).describe(
+    "Array of entry IDs to publish. Single-element array for one entry, or up to MAX_BULK_SIZE per call (default 10, max 100 \u2014 configurable via MAX_BULK_SIZE env var)."
+  ),
+  dryRun: z45.boolean().optional().describe(
+    "When true, returns a preview of the operation without executing it. Still subject to MAX_BULK_SIZE \u2014 use this to confirm intent for within-limit calls."
   )
 });
 function publishEntryTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const entryIds = args.entryId;
+    assertBulkSizeAllowed(entryIds.length, config.maxBulkSize);
+    if (args.dryRun) {
+      return createSuccessResponse(
+        "Dry run: no changes were made",
+        buildDryRunPreview({
+          operation: "publish",
+          entityType: "entry",
+          ids: entryIds,
+          spaceId: args.spaceId,
+          environmentId: args.environmentId
+        })
+      );
+    }
     const baseParams = {
       spaceId: args.spaceId,
       environmentId: args.environmentId
     };
     const contentfulClient = createToolClient(config, args);
-    const entryIds = Array.isArray(args.entryId) ? args.entryId : [args.entryId];
     if (entryIds.length === 1) {
       const entryId = entryIds[0];
       const params = {
@@ -2658,7 +3169,10 @@ function publishEntryTool(config) {
         entryId
       };
       const entry = await contentfulClient.entry.get(params);
-      const publishedEntry = await contentfulClient.entry.publish(params, entry);
+      const publishedEntry = await contentfulClient.entry.publish(
+        params,
+        entry
+      );
       return createSuccessResponse("Entry published successfully", {
         status: publishedEntry.sys.status,
         entryId
@@ -2687,20 +3201,40 @@ function publishEntryTool(config) {
 }
 
 // src/tools/entries/unpublishEntry.ts
-import { z as z43 } from "zod";
+import { z as z46 } from "zod";
 var UnpublishEntryToolParams = BaseToolSchema.extend({
-  entryId: z43.union([z43.string(), z43.array(z43.string()).max(100)]).describe(
-    "The ID of the entry to unpublish (string) or an array of entry IDs (up to 100 entries)"
+  entryId: z46.array(z46.string()).min(1).max(100).describe(
+    "Array of entry IDs to unpublish. Single-element array for one entry, or up to MAX_BULK_SIZE per call (default 10, max 100 \u2014 configurable via MAX_BULK_SIZE env var)."
+  ),
+  dryRun: z46.boolean().optional().describe(
+    "When true, returns a preview of the operation without executing it. Still subject to MAX_BULK_SIZE \u2014 use this to confirm intent for within-limit calls."
   )
 });
 function unpublishEntryTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const entryIds = args.entryId;
+    assertBulkSizeAllowed(entryIds.length, config.maxBulkSize);
+    if (args.dryRun) {
+      return createSuccessResponse(
+        "Dry run: no changes were made",
+        buildDryRunPreview({
+          operation: "unpublish",
+          entityType: "entry",
+          ids: entryIds,
+          spaceId: args.spaceId,
+          environmentId: args.environmentId
+        })
+      );
+    }
     const baseParams = {
       spaceId: args.spaceId,
       environmentId: args.environmentId
     };
     const contentfulClient = createToolClient(config, args);
-    const entryIds = Array.isArray(args.entryId) ? args.entryId : [args.entryId];
     if (entryIds.length === 1) {
       const entryId = entryIds[0];
       const params = {
@@ -2740,20 +3274,40 @@ function unpublishEntryTool(config) {
 }
 
 // src/tools/entries/archiveEntry.ts
-import { z as z44 } from "zod";
+import { z as z47 } from "zod";
 var ArchiveEntryToolParams = BaseToolSchema.extend({
-  entryId: z44.union([z44.string(), z44.array(z44.string()).max(100)]).describe(
-    "The ID of the entry to archive (string) or an array of entry IDs (up to 100 entries)"
+  entryId: z47.array(z47.string()).min(1).max(100).describe(
+    "Array of entry IDs to archive. Single-element array for one entry, or up to MAX_BULK_SIZE per call (default 10, max 100 \u2014 configurable via MAX_BULK_SIZE env var)."
+  ),
+  dryRun: z47.boolean().optional().describe(
+    "When true, returns a preview of the operation without executing it. Still subject to MAX_BULK_SIZE \u2014 use this to confirm intent for within-limit calls."
   )
 });
 function archiveEntryTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const entryIds = args.entryId;
+    assertBulkSizeAllowed(entryIds.length, config.maxBulkSize);
+    if (args.dryRun) {
+      return createSuccessResponse(
+        "Dry run: no changes were made",
+        buildDryRunPreview({
+          operation: "archive",
+          entityType: "entry",
+          ids: entryIds,
+          spaceId: args.spaceId,
+          environmentId: args.environmentId
+        })
+      );
+    }
     const baseParams = {
       spaceId: args.spaceId,
       environmentId: args.environmentId
     };
     const contentfulClient = createToolClient(config, args);
-    const entryIds = Array.isArray(args.entryId) ? args.entryId : [args.entryId];
     const successfullyArchived = [];
     for (const entryId of entryIds) {
       try {
@@ -2786,20 +3340,40 @@ function archiveEntryTool(config) {
 }
 
 // src/tools/entries/unarchiveEntry.ts
-import { z as z45 } from "zod";
+import { z as z48 } from "zod";
 var UnarchiveEntryToolParams = BaseToolSchema.extend({
-  entryId: z45.union([z45.string(), z45.array(z45.string()).max(100)]).describe(
-    "The ID of the entry to unarchive (string) or an array of entry IDs (up to 100 entries)"
+  entryId: z48.array(z48.string()).min(1).max(100).describe(
+    "Array of entry IDs to unarchive. Single-element array for one entry, or up to MAX_BULK_SIZE per call (default 10, max 100 \u2014 configurable via MAX_BULK_SIZE env var)."
+  ),
+  dryRun: z48.boolean().optional().describe(
+    "When true, returns a preview of the operation without executing it. Still subject to MAX_BULK_SIZE \u2014 use this to confirm intent for within-limit calls."
   )
 });
 function unarchiveEntryTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const entryIds = args.entryId;
+    assertBulkSizeAllowed(entryIds.length, config.maxBulkSize);
+    if (args.dryRun) {
+      return createSuccessResponse(
+        "Dry run: no changes were made",
+        buildDryRunPreview({
+          operation: "unarchive",
+          entityType: "entry",
+          ids: entryIds,
+          spaceId: args.spaceId,
+          environmentId: args.environmentId
+        })
+      );
+    }
     const baseParams = {
       spaceId: args.spaceId,
       environmentId: args.environmentId
     };
     const contentfulClient = createToolClient(config, args);
-    const entryIds = Array.isArray(args.entryId) ? args.entryId : [args.entryId];
     const successfullyUnarchived = [];
     for (const entryId of entryIds) {
       try {
@@ -2889,12 +3463,12 @@ function createEntryTools(config) {
     },
     deleteEntry: {
       title: "delete_entry",
-      description: "Delete a specific content entry from your Contentful space",
+      description: "Delete a specific content entry from your Contentful space. This is a two-phase operation: the first call (without confirm/confirmToken) returns a preview of the entry and a confirmToken. To complete the deletion, call this tool again with the same entryId, confirm: true, and the confirmToken from the preview response.",
       inputParams: DeleteEntryToolParams.shape,
       annotations: {
         readOnlyHint: false,
         destructiveHint: true,
-        idempotentHint: true,
+        idempotentHint: false,
         openWorldHint: false
       },
       tool: deleteEntry
@@ -2951,16 +3525,20 @@ function createEntryTools(config) {
 }
 
 // src/tools/environments/createEnvironment.ts
-import { z as z46 } from "zod";
+import { z as z49 } from "zod";
 var CreateEnvironmentToolParams = BaseToolSchema.extend({
-  environmentId: z46.string().describe("The ID of the environment to create"),
-  name: z46.string().describe("The name of the environment to create"),
-  sourceEnvironmentId: z46.string().describe(
+  environmentId: z49.string().describe("The ID of the environment to create"),
+  name: z49.string().describe("The name of the environment to create"),
+  sourceEnvironmentId: z49.string().describe(
     "The ID of the source environment to clone from (defaults to master)"
   ).optional()
 });
 function createEnvironmentTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const contentfulClient = createToolClient(config, args);
     const environment = await contentfulClient.environment.createWithId(
       {
@@ -2982,15 +3560,15 @@ function createEnvironmentTool(config) {
 }
 
 // src/tools/environments/listEnvironments.ts
-import { z as z47 } from "zod";
+import { z as z50 } from "zod";
 var ListEnvironmentsToolParams = BaseToolSchema.extend({
-  environmentId: z47.string().optional().describe(
+  environmentId: z50.string().optional().describe(
     "The ID of the Contentful environment (not required for listing)"
   ),
-  limit: z47.number().optional().describe("Maximum number of environments to return (max 10)"),
-  skip: z47.number().optional().describe("Skip this many environments for pagination"),
-  select: z47.string().optional().describe("Comma-separated list of fields to return"),
-  order: z47.string().optional().describe("Order environments by this field")
+  limit: z50.number().optional().describe("Maximum number of environments to return (max 10)"),
+  skip: z50.number().optional().describe("Skip this many environments for pagination"),
+  select: z50.string().optional().describe("Comma-separated list of fields to return"),
+  order: z50.string().optional().describe("Order environments by this field")
 });
 function listEnvironmentsTool(config) {
   async function tool2(args) {
@@ -3036,17 +3614,44 @@ function listEnvironmentsTool(config) {
 }
 
 // src/tools/environments/deleteEnvironment.ts
-import { z as z48 } from "zod";
+import { z as z51 } from "zod";
 var DeleteEnvironmentToolParams = BaseToolSchema.extend({
-  environmentId: z48.string().describe("The ID of the environment to delete")
+  environmentId: z51.string().describe("The ID of the environment to delete"),
+  confirm: z51.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z51.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
 });
 function deleteEnvironmentTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId
     };
     const contentfulClient = createToolClient(config, args);
+    const environment = await contentfulClient.environment.get(params);
+    const expectedToken = buildConfirmToken(
+      "environment",
+      args.environmentId,
+      environment.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} environment`,
+        buildConfirmationPreview(
+          "environment",
+          args.environmentId,
+          { environment },
+          expectedToken
+        )
+      );
+    }
     await contentfulClient.environment.delete(params);
     return createSuccessResponse("Environment deleted successfully", {
       environmentId: args.environmentId
@@ -3085,12 +3690,12 @@ function createEnvironmentTools(config) {
     },
     deleteEnvironment: {
       title: "delete_environment",
-      description: "Delete an environment",
+      description: "Delete an environment from your Contentful space. This is a two-phase operation: the first call (without confirm/confirmToken) returns a preview and a confirmToken. To complete the deletion, call this tool again with the same environmentId, confirm: true, and the confirmToken from the preview response.",
       inputParams: DeleteEnvironmentToolParams.shape,
       annotations: {
         readOnlyHint: false,
         destructiveHint: true,
-        idempotentHint: true,
+        idempotentHint: false,
         openWorldHint: false
       },
       tool: deleteEnvironment
@@ -3099,9 +3704,9 @@ function createEnvironmentTools(config) {
 }
 
 // src/tools/locales/getLocale.ts
-import { z as z49 } from "zod";
+import { z as z52 } from "zod";
 var GetLocaleToolParams = BaseToolSchema.extend({
-  localeId: z49.string().describe("The ID of the locale to retrieve")
+  localeId: z52.string().describe("The ID of the locale to retrieve")
 });
 function getLocaleTool(config) {
   async function tool2(args) {
@@ -3118,24 +3723,28 @@ function getLocaleTool(config) {
 }
 
 // src/tools/locales/createLocale.ts
-import { z as z50 } from "zod";
+import { z as z53 } from "zod";
 var CreateLocaleToolParams = BaseToolSchema.extend({
-  name: z50.string().describe("The name of the locale"),
-  code: z50.string().describe('The locale code (e.g., "en-US")'),
-  fallbackCode: z50.string().nullable().describe(
+  name: z53.string().describe("The name of the locale"),
+  code: z53.string().describe('The locale code (e.g., "en-US")'),
+  fallbackCode: z53.string().nullable().describe(
     "The locale code to fallback to when there is no content for the current locale"
   ),
-  contentDeliveryApi: z50.boolean().optional().default(true).describe(
+  contentDeliveryApi: z53.boolean().optional().default(true).describe(
     "If the content under this locale should be available on the CDA (for public reading)"
   ),
-  contentManagementApi: z50.boolean().optional().default(true).describe(
+  contentManagementApi: z53.boolean().optional().default(true).describe(
     "If the content under this locale should be available on the CMA (for editing)"
   ),
-  default: z50.boolean().optional().default(false).describe("If this is the default locale"),
-  optional: z50.boolean().optional().default(false).describe("If the locale needs to be filled in on entries or not")
+  default: z53.boolean().optional().default(false).describe("If this is the default locale"),
+  optional: z53.boolean().optional().default(false).describe("If the locale needs to be filled in on entries or not")
 });
 function createLocaleTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId
@@ -3155,13 +3764,13 @@ function createLocaleTool(config) {
 }
 
 // src/tools/locales/listLocales.ts
-import { z as z51 } from "zod";
+import { z as z54 } from "zod";
 var ListLocaleToolParams = BaseToolSchema.extend({
-  limit: z51.number().optional().describe("Maximum number of locales to return"),
-  skip: z51.number().optional().describe("Skip this many locales for pagination"),
-  select: z51.string().optional().describe("Comma-separated list of fields to return"),
-  include: z51.number().optional().describe("Include this many levels of linked entries"),
-  order: z51.string().optional().describe("Order locales by this field")
+  limit: z54.number().optional().describe("Maximum number of locales to return"),
+  skip: z54.number().optional().describe("Skip this many locales for pagination"),
+  select: z54.string().optional().describe("Comma-separated list of fields to return"),
+  include: z54.number().optional().describe("Include this many levels of linked entries"),
+  order: z54.string().optional().describe("Order locales by this field")
 });
 function listLocaleTool(config) {
   async function tool2(args) {
@@ -3214,27 +3823,31 @@ function listLocaleTool(config) {
 }
 
 // src/tools/locales/updateLocale.ts
-import { z as z52 } from "zod";
+import { z as z55 } from "zod";
 var UpdateLocaleToolParams = BaseToolSchema.extend({
-  localeId: z52.string().describe("The ID of the locale to update"),
-  fields: z52.object({
-    name: z52.string().optional().describe("The name of the locale"),
+  localeId: z55.string().describe("The ID of the locale to update"),
+  fields: z55.object({
+    name: z55.string().optional().describe("The name of the locale"),
     // NOTE: internal_code changes are not allowed
-    code: z52.string().optional().describe("The code of the locale"),
-    fallbackCode: z52.string().optional().describe(
+    code: z55.string().optional().describe("The code of the locale"),
+    fallbackCode: z55.string().optional().describe(
       "The locale code to fallback to when there is no content for the current locale"
     ),
-    contentDeliveryApi: z52.boolean().optional().describe(
+    contentDeliveryApi: z55.boolean().optional().describe(
       "If the content under this locale should be available on the CDA (for public reading)"
     ),
-    contentManagementApi: z52.boolean().optional().describe(
+    contentManagementApi: z55.boolean().optional().describe(
       "If the content under this locale should be available on the CMA (for editing)"
     ),
-    optional: z52.boolean().optional().describe("If the locale needs to be filled in on entries or not")
+    optional: z55.boolean().optional().describe("If the locale needs to be filled in on entries or not")
   })
 });
 function updateLocaleTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId,
@@ -3256,12 +3869,22 @@ function updateLocaleTool(config) {
 }
 
 // src/tools/locales/deleteLocale.ts
-import { z as z53 } from "zod";
+import { z as z56 } from "zod";
 var DeleteLocaleToolParams = BaseToolSchema.extend({
-  localeId: z53.string().describe("The ID of the locale to delete")
+  localeId: z56.string().describe("The ID of the locale to delete"),
+  confirm: z56.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z56.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
 });
 function deleteLocaleTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId,
@@ -3269,6 +3892,22 @@ function deleteLocaleTool(config) {
     };
     const contentfulClient = createToolClient(config, args);
     const locale = await contentfulClient.locale.get(params);
+    const expectedToken = buildConfirmToken(
+      "locale",
+      args.localeId,
+      locale.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} locale`,
+        buildConfirmationPreview(
+          "locale",
+          args.localeId,
+          { locale },
+          expectedToken
+        )
+      );
+    }
     await contentfulClient.locale.delete(params);
     return createSuccessResponse("Locale deleted successfully", { locale });
   }
@@ -3329,12 +3968,12 @@ function createLocaleTools(config) {
     },
     deleteLocale: {
       title: "delete_locale",
-      description: "Delete a specific locale from your Contentful environment. This operation permanently removes the locale and cannot be undone.",
+      description: "Delete a specific locale from your Contentful environment. This is a two-phase operation: the first call (without confirm/confirmToken) returns a preview of the locale and a confirmToken. To complete the deletion, call this tool again with the same localeId, confirm: true, and the confirmToken from the preview response.",
       inputParams: DeleteLocaleToolParams.shape,
       annotations: {
         readOnlyHint: false,
         destructiveHint: true,
-        idempotentHint: true,
+        idempotentHint: false,
         openWorldHint: false
       },
       tool: deleteLocale
@@ -3343,13 +3982,13 @@ function createLocaleTools(config) {
 }
 
 // src/tools/orgs/listOrgs.ts
-import { z as z54 } from "zod";
+import { z as z57 } from "zod";
 import { createClient as createClient2 } from "contentful-management";
-var ListOrgsToolParams = z54.object({
-  limit: z54.number().optional().describe("Maximum number of organizations to return (max 10)"),
-  skip: z54.number().optional().describe("Skip this many organizations for pagination"),
-  select: z54.string().optional().describe("Comma-separated list of fields to return"),
-  order: z54.string().optional().describe("Order organizations by this field")
+var ListOrgsToolParams = z57.object({
+  limit: z57.number().optional().describe("Maximum number of organizations to return (max 10)"),
+  skip: z57.number().optional().describe("Skip this many organizations for pagination"),
+  select: z57.string().optional().describe("Comma-separated list of fields to return"),
+  order: z57.string().optional().describe("Order organizations by this field")
 });
 function listOrgsTool(config) {
   async function tool2(args) {
@@ -3391,10 +4030,10 @@ function listOrgsTool(config) {
 }
 
 // src/tools/orgs/getOrg.ts
-import { z as z55 } from "zod";
+import { z as z58 } from "zod";
 import { createClient as createClient3 } from "contentful-management";
-var GetOrgToolParams = z55.object({
-  organizationId: z55.string().describe("The ID of the organization to retrieve")
+var GetOrgToolParams = z58.object({
+  organizationId: z58.string().describe("The ID of the organization to retrieve")
 });
 function getOrgTool(config) {
   async function tool2(args) {
@@ -3440,13 +4079,13 @@ function createOrgTools(config) {
 }
 
 // src/tools/spaces/listSpaces.ts
-import { z as z56 } from "zod";
+import { z as z59 } from "zod";
 import { createClient as createClient4 } from "contentful-management";
-var ListSpacesToolParams = z56.object({
-  limit: z56.number().optional().describe("Maximum number of spaces to return (max 10)"),
-  skip: z56.number().optional().describe("Skip this many spaces for pagination"),
-  select: z56.string().optional().describe("Comma-separated list of fields to return"),
-  order: z56.string().optional().describe("Order spaces by this field")
+var ListSpacesToolParams = z59.object({
+  limit: z59.number().optional().describe("Maximum number of spaces to return (max 10)"),
+  skip: z59.number().optional().describe("Skip this many spaces for pagination"),
+  select: z59.string().optional().describe("Comma-separated list of fields to return"),
+  order: z59.string().optional().describe("Order spaces by this field")
 });
 function listSpacesTool(config) {
   async function tool2(args) {
@@ -3488,10 +4127,10 @@ function listSpacesTool(config) {
 }
 
 // src/tools/spaces/getSpace.ts
-import { z as z57 } from "zod";
+import { z as z60 } from "zod";
 import { createClient as createClient5 } from "contentful-management";
-var GetSpaceToolParams = z57.object({
-  spaceId: z57.string().describe("The ID of the space to retrieve")
+var GetSpaceToolParams = z60.object({
+  spaceId: z60.string().describe("The ID of the space to retrieve")
 });
 function getSpaceTool(config) {
   async function tool2(args) {
@@ -3535,12 +4174,12 @@ function createSpaceTools(config) {
 }
 
 // src/tools/tags/listTags.ts
-import { z as z58 } from "zod";
+import { z as z61 } from "zod";
 var ListTagsToolParams = BaseToolSchema.extend({
-  limit: z58.number().optional().describe("Maximum number of tags to return"),
-  skip: z58.number().optional().describe("Skip this many tags for pagination"),
-  select: z58.string().optional().describe("Comma-separated list of fields to return"),
-  order: z58.string().optional().describe("Order tags by this field")
+  limit: z61.number().optional().describe("Maximum number of tags to return"),
+  skip: z61.number().optional().describe("Skip this many tags for pagination"),
+  select: z61.string().optional().describe("Comma-separated list of fields to return"),
+  order: z61.string().optional().describe("Order tags by this field")
 });
 function listTagsTool(config) {
   async function tool2(args) {
@@ -3586,14 +4225,18 @@ function listTagsTool(config) {
 }
 
 // src/tools/tags/createTag.ts
-import { z as z59 } from "zod";
+import { z as z62 } from "zod";
 var CreateTagToolParams = BaseToolSchema.extend({
-  name: z59.string().describe("The name of the tag"),
-  id: z59.string().describe("The ID of the tag"),
-  visibility: z59.enum(["public", "private"]).describe("The visibility of the tag. Default to private if not specified")
+  name: z62.string().describe("The name of the tag"),
+  id: z62.string().describe("The ID of the tag"),
+  visibility: z62.enum(["public", "private"]).describe("The visibility of the tag. Default to private if not specified")
 });
 function createTagTool(config) {
   async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
     const params = {
       spaceId: args.spaceId,
       environmentId: args.environmentId,
@@ -3640,34 +4283,34 @@ function createTagTools(config) {
 }
 
 // src/tools/taxonomies/concept-schemes/createConceptScheme.ts
-import { z as z61 } from "zod";
+import { z as z64 } from "zod";
 import { createClient as createClient6 } from "contentful-management";
 
 // src/types/conceptPayloadTypes.ts
-import { z as z60 } from "zod";
-var TaxonomyConceptLinkSchema = z60.object({
-  sys: z60.object({
-    type: z60.literal("Link"),
-    linkType: z60.literal("TaxonomyConcept"),
-    id: z60.string()
+import { z as z63 } from "zod";
+var TaxonomyConceptLinkSchema = z63.object({
+  sys: z63.object({
+    type: z63.literal("Link"),
+    linkType: z63.literal("TaxonomyConcept"),
+    id: z63.string()
   })
 });
 
 // src/tools/taxonomies/concept-schemes/createConceptScheme.ts
-var CreateConceptSchemeToolParams = z61.object({
-  organizationId: z61.string().describe("The ID of the Contentful organization"),
-  conceptSchemeId: z61.string().optional().describe(
+var CreateConceptSchemeToolParams = z64.object({
+  organizationId: z64.string().describe("The ID of the Contentful organization"),
+  conceptSchemeId: z64.string().optional().describe(
     "Optional user-defined ID for the concept scheme. If not provided, Contentful will generate one automatically."
   ),
-  prefLabel: z61.record(z61.string()).describe("The preferred label for the concept scheme (localized)"),
-  uri: z61.string().nullable().optional().describe("The URI for the concept scheme"),
-  definition: z61.record(z61.string().nullable()).optional().describe("Definition of the concept scheme (localized)"),
-  editorialNote: z61.record(z61.string().nullable()).optional().describe("Editorial note for the concept scheme (localized)"),
-  historyNote: z61.record(z61.string().nullable()).optional().describe("History note for the concept scheme (localized)"),
-  example: z61.record(z61.string().nullable()).optional().describe("Example for the concept scheme (localized)"),
-  note: z61.record(z61.string().nullable()).optional().describe("General note for the concept scheme (localized)"),
-  scopeNote: z61.record(z61.string().nullable()).optional().describe("Scope note for the concept scheme (localized)"),
-  topConcepts: z61.array(TaxonomyConceptLinkSchema).optional().describe("Links to top-level concepts in this scheme")
+  prefLabel: z64.record(z64.string()).describe("The preferred label for the concept scheme (localized)"),
+  uri: z64.string().nullable().optional().describe("The URI for the concept scheme"),
+  definition: z64.record(z64.string().nullable()).optional().describe("Definition of the concept scheme (localized)"),
+  editorialNote: z64.record(z64.string().nullable()).optional().describe("Editorial note for the concept scheme (localized)"),
+  historyNote: z64.record(z64.string().nullable()).optional().describe("History note for the concept scheme (localized)"),
+  example: z64.record(z64.string().nullable()).optional().describe("Example for the concept scheme (localized)"),
+  note: z64.record(z64.string().nullable()).optional().describe("General note for the concept scheme (localized)"),
+  scopeNote: z64.record(z64.string().nullable()).optional().describe("Scope note for the concept scheme (localized)"),
+  topConcepts: z64.array(TaxonomyConceptLinkSchema).optional().describe("Links to top-level concepts in this scheme")
 });
 function createConceptSchemeTool(config) {
   async function tool2(args) {
@@ -3707,11 +4350,11 @@ function createConceptSchemeTool(config) {
 }
 
 // src/tools/taxonomies/concept-schemes/getConceptScheme.ts
-import { z as z62 } from "zod";
+import { z as z65 } from "zod";
 import { createClient as createClient7 } from "contentful-management";
-var GetConceptSchemeToolParams = z62.object({
-  organizationId: z62.string().describe("The ID of the Contentful organization"),
-  conceptSchemeId: z62.string().describe("The ID of the concept scheme to retrieve")
+var GetConceptSchemeToolParams = z65.object({
+  organizationId: z65.string().describe("The ID of the Contentful organization"),
+  conceptSchemeId: z65.string().describe("The ID of the concept scheme to retrieve")
 });
 function getConceptSchemeTool(config) {
   async function tool2(args) {
@@ -3731,25 +4374,25 @@ function getConceptSchemeTool(config) {
 }
 
 // src/tools/taxonomies/concept-schemes/listConceptSchemes.ts
-import { z as z63 } from "zod";
+import { z as z66 } from "zod";
 import { createClient as createClient8 } from "contentful-management";
 import { cloneDeep } from "lodash-es";
-var ListConceptSchemesToolParams = z63.object({
-  organizationId: z63.string(),
-  query: z63.union([
-    z63.object({
-      query: z63.string().optional(),
-      pageNext: z63.string().optional().describe("Cursor token for the next page of concept schemes"),
-      pagePrev: z63.string().optional().describe(
+var ListConceptSchemesToolParams = z66.object({
+  organizationId: z66.string(),
+  query: z66.union([
+    z66.object({
+      query: z66.string().optional(),
+      pageNext: z66.string().optional().describe("Cursor token for the next page of concept schemes"),
+      pagePrev: z66.string().optional().describe(
         "Cursor token for the previous page of concept schemes"
       ),
-      limit: z63.number().optional().describe("Maximum number of concept schemes to return"),
-      order: z63.string().optional().describe("Order concept schemes by this field"),
-      skip: z63.never().optional()
+      limit: z66.number().optional().describe("Maximum number of concept schemes to return"),
+      order: z66.string().optional().describe("Order concept schemes by this field"),
+      skip: z66.never().optional()
     }).passthrough(),
     // handles [key: string]: any from BasicQueryOptions
-    z63.object({
-      pageUrl: z63.string().optional()
+    z66.object({
+      pageUrl: z66.string().optional()
     })
   ]).optional().describe(
     'Query parameters for listing concept schemes, supports either pageUrl for cursor-based pagination.  Offset "skip" pagination is not supported.'
@@ -3819,22 +4462,22 @@ function listConceptSchemesTool(config) {
 }
 
 // src/tools/taxonomies/concept-schemes/updateConceptScheme.ts
-import { z as z64 } from "zod";
+import { z as z67 } from "zod";
 import { createClient as createClient9 } from "contentful-management";
-var UpdateConceptSchemeToolParams = z64.object({
-  organizationId: z64.string().describe("The ID of the Contentful organization"),
-  conceptSchemeId: z64.string().describe("The ID of the concept scheme to update"),
-  version: z64.number().describe("The current version of the concept scheme"),
-  prefLabel: z64.record(z64.string()).optional().describe("The preferred label for the concept scheme (localized)"),
-  uri: z64.string().nullable().optional().describe("The URI for the concept scheme"),
-  definition: z64.record(z64.string().nullable()).optional().describe("Definition of the concept scheme (localized)"),
-  editorialNote: z64.record(z64.string().nullable()).optional().describe("Editorial note for the concept scheme (localized)"),
-  historyNote: z64.record(z64.string().nullable()).optional().describe("History note for the concept scheme (localized)"),
-  example: z64.record(z64.string().nullable()).optional().describe("Example for the concept scheme (localized)"),
-  note: z64.record(z64.string().nullable()).optional().describe("General note for the concept scheme (localized)"),
-  scopeNote: z64.record(z64.string().nullable()).optional().describe("Scope note for the concept scheme (localized)"),
-  topConcepts: z64.array(TaxonomyConceptLinkSchema).optional().describe("Links to top-level concepts in this scheme"),
-  addConcept: z64.string().optional().describe(
+var UpdateConceptSchemeToolParams = z67.object({
+  organizationId: z67.string().describe("The ID of the Contentful organization"),
+  conceptSchemeId: z67.string().describe("The ID of the concept scheme to update"),
+  version: z67.number().describe("The current version of the concept scheme"),
+  prefLabel: z67.record(z67.string()).optional().describe("The preferred label for the concept scheme (localized)"),
+  uri: z67.string().nullable().optional().describe("The URI for the concept scheme"),
+  definition: z67.record(z67.string().nullable()).optional().describe("Definition of the concept scheme (localized)"),
+  editorialNote: z67.record(z67.string().nullable()).optional().describe("Editorial note for the concept scheme (localized)"),
+  historyNote: z67.record(z67.string().nullable()).optional().describe("History note for the concept scheme (localized)"),
+  example: z67.record(z67.string().nullable()).optional().describe("Example for the concept scheme (localized)"),
+  note: z67.record(z67.string().nullable()).optional().describe("General note for the concept scheme (localized)"),
+  scopeNote: z67.record(z67.string().nullable()).optional().describe("Scope note for the concept scheme (localized)"),
+  topConcepts: z67.array(TaxonomyConceptLinkSchema).optional().describe("Links to top-level concepts in this scheme"),
+  addConcept: z67.string().optional().describe(
     "ID of a concept to add to this scheme (adds to both concepts and topConcepts)"
   )
 });
@@ -3909,22 +4552,47 @@ function updateConceptSchemeTool(config) {
 }
 
 // src/tools/taxonomies/concept-schemes/deleteConceptScheme.ts
-import { z as z65 } from "zod";
+import { z as z68 } from "zod";
 import { createClient as createClient10 } from "contentful-management";
-var DeleteConceptSchemeToolParams = z65.object({
-  organizationId: z65.string().describe("The ID of the Contentful organization"),
-  conceptSchemeId: z65.string().describe("The ID of the concept scheme to delete"),
-  version: z65.number().describe("The version of the concept scheme to delete")
+var DeleteConceptSchemeToolParams = z68.object({
+  organizationId: z68.string().describe("The ID of the Contentful organization"),
+  conceptSchemeId: z68.string().describe("The ID of the concept scheme to delete"),
+  confirm: z68.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z68.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
 });
 function deleteConceptSchemeTool(config) {
   async function tool2(args) {
     const clientConfig = createClientConfig(config);
     delete clientConfig.space;
     const contentfulClient = createClient10(clientConfig);
+    const conceptScheme = await contentfulClient.conceptScheme.get({
+      organizationId: args.organizationId,
+      conceptSchemeId: args.conceptSchemeId
+    });
+    const expectedToken = buildConfirmToken(
+      "conceptScheme",
+      args.conceptSchemeId,
+      conceptScheme.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} concept scheme`,
+        buildConfirmationPreview(
+          "conceptScheme",
+          args.conceptSchemeId,
+          { conceptScheme },
+          expectedToken
+        )
+      );
+    }
     await contentfulClient.conceptScheme.delete({
       organizationId: args.organizationId,
       conceptSchemeId: args.conceptSchemeId,
-      version: args.version
+      version: conceptScheme.sys.version
     });
     return createSuccessResponse("Concept scheme deleted successfully", {
       conceptSchemeId: args.conceptSchemeId
@@ -3987,12 +4655,12 @@ function createConceptSchemeTools(config) {
     },
     deleteConceptScheme: {
       title: "delete_concept_scheme",
-      description: "Delete a taxonomy concept scheme from Contentful. Requires the concept scheme ID and version number for optimistic concurrency control. This operation permanently removes the concept scheme and cannot be undone.",
+      description: "Delete a taxonomy concept scheme from Contentful. This is a two-phase operation: the first call (without confirm/confirmToken) returns a preview of the concept scheme and a confirmToken. To complete the deletion, call this tool again with the same conceptSchemeId, confirm: true, and the confirmToken from the preview response. The concept scheme version is fetched server-side and used for optimistic concurrency control.",
       inputParams: DeleteConceptSchemeToolParams.shape,
       annotations: {
         readOnlyHint: false,
         destructiveHint: true,
-        idempotentHint: true,
+        idempotentHint: false,
         openWorldHint: false
       },
       tool: deleteConceptScheme
@@ -4001,26 +4669,26 @@ function createConceptSchemeTools(config) {
 }
 
 // src/tools/taxonomies/concepts/createConcept.ts
-import { z as z66 } from "zod";
+import { z as z69 } from "zod";
 import { createClient as createClient11 } from "contentful-management";
-var CreateConceptToolParams = z66.object({
-  organizationId: z66.string().describe("The ID of the Contentful organization"),
-  conceptId: z66.string().optional().describe(
+var CreateConceptToolParams = z69.object({
+  organizationId: z69.string().describe("The ID of the Contentful organization"),
+  conceptId: z69.string().optional().describe(
     "Optional user-defined ID for the concept. If not provided, Contentful will generate one automatically."
   ),
-  prefLabel: z66.record(z66.string()).describe("The preferred label for the concept (localized)"),
-  uri: z66.string().nullable().optional().describe("The URI for the concept"),
-  altLabels: z66.record(z66.array(z66.string())).optional().describe("Alternative labels for the concept (localized)"),
-  hiddenLabels: z66.record(z66.array(z66.string())).optional().describe("Hidden labels for the concept (localized)"),
-  definition: z66.record(z66.string().nullable()).optional().describe("Definition of the concept (localized)"),
-  editorialNote: z66.record(z66.string().nullable()).optional().describe("Editorial note for the concept (localized)"),
-  historyNote: z66.record(z66.string().nullable()).optional().describe("History note for the concept (localized)"),
-  example: z66.record(z66.string().nullable()).optional().describe("Example for the concept (localized)"),
-  note: z66.record(z66.string().nullable()).optional().describe("General note for the concept (localized)"),
-  scopeNote: z66.record(z66.string().nullable()).optional().describe("Scope note for the concept (localized)"),
-  notations: z66.array(z66.string()).optional().describe("Notations for the concept"),
-  broader: z66.array(TaxonomyConceptLinkSchema).optional().describe("Links to broader concepts"),
-  related: z66.array(TaxonomyConceptLinkSchema).optional().describe("Links to related concepts")
+  prefLabel: z69.record(z69.string()).describe("The preferred label for the concept (localized)"),
+  uri: z69.string().nullable().optional().describe("The URI for the concept"),
+  altLabels: z69.record(z69.array(z69.string())).optional().describe("Alternative labels for the concept (localized)"),
+  hiddenLabels: z69.record(z69.array(z69.string())).optional().describe("Hidden labels for the concept (localized)"),
+  definition: z69.record(z69.string().nullable()).optional().describe("Definition of the concept (localized)"),
+  editorialNote: z69.record(z69.string().nullable()).optional().describe("Editorial note for the concept (localized)"),
+  historyNote: z69.record(z69.string().nullable()).optional().describe("History note for the concept (localized)"),
+  example: z69.record(z69.string().nullable()).optional().describe("Example for the concept (localized)"),
+  note: z69.record(z69.string().nullable()).optional().describe("General note for the concept (localized)"),
+  scopeNote: z69.record(z69.string().nullable()).optional().describe("Scope note for the concept (localized)"),
+  notations: z69.array(z69.string()).optional().describe("Notations for the concept"),
+  broader: z69.array(TaxonomyConceptLinkSchema).optional().describe("Links to broader concepts"),
+  related: z69.array(TaxonomyConceptLinkSchema).optional().describe("Links to related concepts")
 });
 function createConceptTool(config) {
   async function tool2(args) {
@@ -4055,22 +4723,42 @@ function createConceptTool(config) {
 }
 
 // src/tools/taxonomies/concepts/deleteConcept.ts
-import { z as z67 } from "zod";
+import { z as z70 } from "zod";
 import { createClient as createClient12 } from "contentful-management";
-var DeleteConceptToolParams = z67.object({
-  organizationId: z67.string().describe("The ID of the Contentful organization"),
-  conceptId: z67.string().describe("The ID of the concept to delete"),
-  version: z67.number().describe("The version of the concept to delete")
+var DeleteConceptToolParams = z70.object({
+  organizationId: z70.string().describe("The ID of the Contentful organization"),
+  conceptId: z70.string().describe("The ID of the concept to delete"),
+  confirm: z70.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z70.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
 });
 function deleteConceptTool(config) {
   async function tool2(args) {
     const clientConfig = createClientConfig(config);
     delete clientConfig.space;
     const contentfulClient = createClient12(clientConfig);
+    const concept = await contentfulClient.concept.get({
+      organizationId: args.organizationId,
+      conceptId: args.conceptId
+    });
+    const expectedToken = buildConfirmToken(
+      "concept",
+      args.conceptId,
+      concept.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} concept`,
+        buildConfirmationPreview("concept", args.conceptId, { concept }, expectedToken)
+      );
+    }
     await contentfulClient.concept.delete({
       organizationId: args.organizationId,
       conceptId: args.conceptId,
-      version: args.version
+      version: concept.sys.version
     });
     return createSuccessResponse("Concept deleted successfully", {
       conceptId: args.conceptId
@@ -4080,25 +4768,25 @@ function deleteConceptTool(config) {
 }
 
 // src/tools/taxonomies/concepts/updateConcept.ts
-import { z as z68 } from "zod";
+import { z as z71 } from "zod";
 import { createClient as createClient13 } from "contentful-management";
-var UpdateConceptToolParams = z68.object({
-  organizationId: z68.string().describe("The ID of the Contentful organization"),
-  conceptId: z68.string().describe("The ID of the concept to update"),
-  version: z68.number().describe("The current version of the concept"),
-  prefLabel: z68.record(z68.string()).optional().describe("The preferred label for the concept (localized)"),
-  uri: z68.string().nullable().optional().describe("The URI for the concept"),
-  altLabels: z68.record(z68.array(z68.string())).optional().describe("Alternative labels for the concept (localized)"),
-  hiddenLabels: z68.record(z68.array(z68.string())).optional().describe("Hidden labels for the concept (localized)"),
-  definition: z68.record(z68.string().nullable()).optional().describe("Definition of the concept (localized)"),
-  editorialNote: z68.record(z68.string().nullable()).optional().describe("Editorial note for the concept (localized)"),
-  historyNote: z68.record(z68.string().nullable()).optional().describe("History note for the concept (localized)"),
-  example: z68.record(z68.string().nullable()).optional().describe("Example for the concept (localized)"),
-  note: z68.record(z68.string().nullable()).optional().describe("General note for the concept (localized)"),
-  scopeNote: z68.record(z68.string().nullable()).optional().describe("Scope note for the concept (localized)"),
-  notations: z68.array(z68.string()).optional().describe("Notations for the concept"),
-  broader: z68.array(TaxonomyConceptLinkSchema).optional().describe("Links to broader concepts"),
-  related: z68.array(TaxonomyConceptLinkSchema).optional().describe("Links to related concepts")
+var UpdateConceptToolParams = z71.object({
+  organizationId: z71.string().describe("The ID of the Contentful organization"),
+  conceptId: z71.string().describe("The ID of the concept to update"),
+  version: z71.number().describe("The current version of the concept"),
+  prefLabel: z71.record(z71.string()).optional().describe("The preferred label for the concept (localized)"),
+  uri: z71.string().nullable().optional().describe("The URI for the concept"),
+  altLabels: z71.record(z71.array(z71.string())).optional().describe("Alternative labels for the concept (localized)"),
+  hiddenLabels: z71.record(z71.array(z71.string())).optional().describe("Hidden labels for the concept (localized)"),
+  definition: z71.record(z71.string().nullable()).optional().describe("Definition of the concept (localized)"),
+  editorialNote: z71.record(z71.string().nullable()).optional().describe("Editorial note for the concept (localized)"),
+  historyNote: z71.record(z71.string().nullable()).optional().describe("History note for the concept (localized)"),
+  example: z71.record(z71.string().nullable()).optional().describe("Example for the concept (localized)"),
+  note: z71.record(z71.string().nullable()).optional().describe("General note for the concept (localized)"),
+  scopeNote: z71.record(z71.string().nullable()).optional().describe("Scope note for the concept (localized)"),
+  notations: z71.array(z71.string()).optional().describe("Notations for the concept"),
+  broader: z71.array(TaxonomyConceptLinkSchema).optional().describe("Links to broader concepts"),
+  related: z71.array(TaxonomyConceptLinkSchema).optional().describe("Links to related concepts")
 });
 function updateConceptTool(config) {
   async function tool2(args) {
@@ -4140,11 +4828,11 @@ function updateConceptTool(config) {
 }
 
 // src/tools/taxonomies/concepts/getConcept.ts
-import { z as z69 } from "zod";
+import { z as z72 } from "zod";
 import { createClient as createClient14 } from "contentful-management";
-var GetConceptToolParams = z69.object({
-  organizationId: z69.string().describe("The ID of the Contentful organization"),
-  conceptId: z69.string().describe("The ID of the concept to retrieve")
+var GetConceptToolParams = z72.object({
+  organizationId: z72.string().describe("The ID of the Contentful organization"),
+  conceptId: z72.string().describe("The ID of the concept to retrieve")
 });
 function getConceptTool(config) {
   async function tool2(args) {
@@ -4161,18 +4849,18 @@ function getConceptTool(config) {
 }
 
 // src/tools/taxonomies/concepts/listConcepts.ts
-import { z as z70 } from "zod";
+import { z as z73 } from "zod";
 import { createClient as createClient15 } from "contentful-management";
-var ListConceptsToolParams = z70.object({
-  organizationId: z70.string().describe("The ID of the Contentful organization"),
-  conceptId: z70.string().optional().describe("The ID of the concept (required for descendants/ancestors)"),
-  limit: z70.number().optional().describe("Maximum number of concepts to return"),
-  select: z70.string().optional().describe("Comma-separated list of fields to return"),
-  include: z70.number().optional().describe("Include this many levels of linked entries"),
-  order: z70.string().optional().describe("Order concepts by this field"),
-  getDescendants: z70.boolean().optional().describe("Get descendants of the specified concept (requires conceptId)"),
-  getAncestors: z70.boolean().optional().describe("Get ancestors of the specified concept (requires conceptId)"),
-  getTotalOnly: z70.boolean().optional().describe("Get only the total number of concepts without full data")
+var ListConceptsToolParams = z73.object({
+  organizationId: z73.string().describe("The ID of the Contentful organization"),
+  conceptId: z73.string().optional().describe("The ID of the concept (required for descendants/ancestors)"),
+  limit: z73.number().optional().describe("Maximum number of concepts to return"),
+  select: z73.string().optional().describe("Comma-separated list of fields to return"),
+  include: z73.number().optional().describe("Include this many levels of linked entries"),
+  order: z73.string().optional().describe("Order concepts by this field"),
+  getDescendants: z73.boolean().optional().describe("Get descendants of the specified concept (requires conceptId)"),
+  getAncestors: z73.boolean().optional().describe("Get ancestors of the specified concept (requires conceptId)"),
+  getTotalOnly: z73.boolean().optional().describe("Get only the total number of concepts without full data")
 });
 function listConceptsTool(config) {
   async function tool2(args) {
@@ -4324,12 +5012,12 @@ function createConceptTools(config) {
     },
     deleteConcept: {
       title: "delete_concept",
-      description: "Delete a taxonomy concept from Contentful. Requires the concept ID and version number for optimistic concurrency control. This operation permanently removes the concept and cannot be undone.",
+      description: "Delete a taxonomy concept from Contentful. This is a two-phase operation: the first call (without confirm/confirmToken) returns a preview of the concept and a confirmToken. To complete the deletion, call this tool again with the same conceptId, confirm: true, and the confirmToken from the preview response. The concept version is fetched server-side and used for optimistic concurrency control.",
       inputParams: DeleteConceptToolParams.shape,
       annotations: {
         readOnlyHint: false,
         destructiveHint: true,
-        idempotentHint: true,
+        idempotentHint: false,
         openWorldHint: false
       },
       tool: deleteConcept
@@ -4348,54 +5036,54 @@ function createTaxonomyTools(config) {
 }
 
 // src/tools/jobs/space-to-space-migration/exportSpace.ts
-import { z as z72 } from "zod";
+import { z as z75 } from "zod";
 
 // src/types/querySchema.ts
-import { z as z71 } from "zod";
-var EntryQuerySchema = z71.object({
-  content_type: z71.string().optional().describe("Filter by content type"),
-  include: z71.number().optional().describe("Include this many levels of linked entries"),
-  select: z71.string().optional().describe("Comma-separated list of fields to return"),
-  links_to_entry: z71.string().optional().describe("Find entries that link to the specified entry ID"),
-  limit: z71.number().optional().describe("Maximum number of entries to return"),
-  skip: z71.number().optional().describe("Skip this many entries"),
-  order: z71.string().optional().describe("Order entries by this field")
+import { z as z74 } from "zod";
+var EntryQuerySchema = z74.object({
+  content_type: z74.string().optional().describe("Filter by content type"),
+  include: z74.number().optional().describe("Include this many levels of linked entries"),
+  select: z74.string().optional().describe("Comma-separated list of fields to return"),
+  links_to_entry: z74.string().optional().describe("Find entries that link to the specified entry ID"),
+  limit: z74.number().optional().describe("Maximum number of entries to return"),
+  skip: z74.number().optional().describe("Skip this many entries"),
+  order: z74.string().optional().describe("Order entries by this field")
 });
-var AssetQuerySchema = z71.object({
-  mimetype_group: z71.string().optional().describe("Filter by MIME type group"),
-  select: z71.string().optional().describe("Comma-separated list of fields to return"),
-  limit: z71.number().optional().describe("Maximum number of assets to return"),
-  skip: z71.number().optional().describe("Skip this many assets"),
-  order: z71.string().optional().describe("Order assets by this field")
+var AssetQuerySchema = z74.object({
+  mimetype_group: z74.string().optional().describe("Filter by MIME type group"),
+  select: z74.string().optional().describe("Comma-separated list of fields to return"),
+  limit: z74.number().optional().describe("Maximum number of assets to return"),
+  skip: z74.number().optional().describe("Skip this many assets"),
+  order: z74.string().optional().describe("Order assets by this field")
 });
 
 // src/tools/jobs/space-to-space-migration/exportSpace.ts
 var ExportSpaceToolParams = BaseToolSchema.extend({
-  exportDir: z72.string().optional().describe(
+  exportDir: z75.string().optional().describe(
     "Directory to save the exported space data (optional, defaults to current directory)"
   ),
-  saveFile: z72.boolean().optional().default(true).describe("Save the exported space data to a file"),
-  contentFile: z72.string().optional().describe("Custom filename for the exported space data (optional)"),
-  includeDrafts: z72.boolean().optional().default(false).describe("Include draft entries in the export"),
-  includeArchived: z72.boolean().optional().default(false).describe("Include archived entries in the export"),
-  skipContentModel: z72.boolean().optional().default(false).describe("Skip exporting content types"),
-  skipEditorInterfaces: z72.boolean().optional().default(false).describe("Skip exporting editor interfaces"),
-  skipContent: z72.boolean().optional().default(false).describe("Skip exporting entries and assets"),
-  skipRoles: z72.boolean().optional().default(false).describe("Skip exporting roles and permissions"),
-  skipTags: z72.boolean().optional().default(false).describe("Skip exporting tags"),
-  skipWebhooks: z72.boolean().optional().default(false).describe("Skip exporting webhooks"),
-  stripTags: z72.boolean().optional().default(false).describe("Untag assets and entries"),
-  contentOnly: z72.boolean().optional().default(false).describe("Only export assets and entries"),
+  saveFile: z75.boolean().optional().default(true).describe("Save the exported space data to a file"),
+  contentFile: z75.string().optional().describe("Custom filename for the exported space data (optional)"),
+  includeDrafts: z75.boolean().optional().default(false).describe("Include draft entries in the export"),
+  includeArchived: z75.boolean().optional().default(false).describe("Include archived entries in the export"),
+  skipContentModel: z75.boolean().optional().default(false).describe("Skip exporting content types"),
+  skipEditorInterfaces: z75.boolean().optional().default(false).describe("Skip exporting editor interfaces"),
+  skipContent: z75.boolean().optional().default(false).describe("Skip exporting entries and assets"),
+  skipRoles: z75.boolean().optional().default(false).describe("Skip exporting roles and permissions"),
+  skipTags: z75.boolean().optional().default(false).describe("Skip exporting tags"),
+  skipWebhooks: z75.boolean().optional().default(false).describe("Skip exporting webhooks"),
+  stripTags: z75.boolean().optional().default(false).describe("Untag assets and entries"),
+  contentOnly: z75.boolean().optional().default(false).describe("Only export assets and entries"),
   queryEntries: EntryQuerySchema.optional().describe(
     "Export only entries that match query parameters"
   ),
   queryAssets: AssetQuerySchema.optional().describe(
     "Export only assets that match query parameters"
   ),
-  downloadAssets: z72.boolean().optional().default(false).describe("Download actual asset files"),
-  maxAllowedLimit: z72.number().optional().default(1e3).describe("Maximum number of items per request"),
-  errorLogFile: z72.string().optional().describe("Path to error log output file"),
-  useVerboseRenderer: z72.boolean().optional().describe("Line-by-line logging, useful for CI")
+  downloadAssets: z75.boolean().optional().default(false).describe("Download actual asset files"),
+  maxAllowedLimit: z75.number().optional().default(1e3).describe("Maximum number of items per request"),
+  errorLogFile: z75.string().optional().describe("Path to error log output file"),
+  useVerboseRenderer: z75.boolean().optional().describe("Line-by-line logging, useful for CI")
 });
 function createExportSpaceTool(config) {
   async function tool2(args) {
@@ -4445,70 +5133,70 @@ function createExportSpaceTool(config) {
 }
 
 // src/tools/jobs/space-to-space-migration/paramCollection.ts
-import { z as z73 } from "zod";
+import { z as z76 } from "zod";
 var ParamCollectionToolParams = BaseToolSchema.extend({
-  confirmation: z73.boolean().optional().describe(
+  confirmation: z76.boolean().optional().describe(
     "User confirmation that they are ready to proceed with the workflow"
   ),
-  export: z73.object({
-    spaceId: z73.string().optional().describe("ID of the space with source data"),
-    environmentId: z73.string().optional().describe("ID of the environment in the source space"),
-    deliveryToken: z73.string().optional().describe("CDA token to export only published content (excludes tags)"),
-    exportDir: z73.string().optional().describe("Path to export JSON output"),
-    saveFile: z73.boolean().optional().describe("Save the export as a JSON file"),
-    contentFile: z73.string().optional().describe("Filename for exported data"),
-    includeDrafts: z73.boolean().optional().describe("Include drafts in exported entries"),
-    includeArchived: z73.boolean().optional().describe("Include archived entries"),
-    skipContentModel: z73.boolean().optional().describe("Skip exporting content models"),
-    skipEditorInterfaces: z73.boolean().optional().describe("Skip exporting editor interfaces"),
-    skipContent: z73.boolean().optional().describe("Skip exporting entries and assets"),
-    skipRoles: z73.boolean().optional().describe("Skip exporting roles and permissions"),
-    skipTags: z73.boolean().optional().describe("Skip exporting tags"),
-    skipWebhooks: z73.boolean().optional().describe("Skip exporting webhooks"),
-    stripTags: z73.boolean().optional().describe("Remove tags from entries and assets"),
-    contentOnly: z73.boolean().optional().describe("Export only entries and assets"),
+  export: z76.object({
+    spaceId: z76.string().optional().describe("ID of the space with source data"),
+    environmentId: z76.string().optional().describe("ID of the environment in the source space"),
+    deliveryToken: z76.string().optional().describe("CDA token to export only published content (excludes tags)"),
+    exportDir: z76.string().optional().describe("Path to export JSON output"),
+    saveFile: z76.boolean().optional().describe("Save the export as a JSON file"),
+    contentFile: z76.string().optional().describe("Filename for exported data"),
+    includeDrafts: z76.boolean().optional().describe("Include drafts in exported entries"),
+    includeArchived: z76.boolean().optional().describe("Include archived entries"),
+    skipContentModel: z76.boolean().optional().describe("Skip exporting content models"),
+    skipEditorInterfaces: z76.boolean().optional().describe("Skip exporting editor interfaces"),
+    skipContent: z76.boolean().optional().describe("Skip exporting entries and assets"),
+    skipRoles: z76.boolean().optional().describe("Skip exporting roles and permissions"),
+    skipTags: z76.boolean().optional().describe("Skip exporting tags"),
+    skipWebhooks: z76.boolean().optional().describe("Skip exporting webhooks"),
+    stripTags: z76.boolean().optional().describe("Remove tags from entries and assets"),
+    contentOnly: z76.boolean().optional().describe("Export only entries and assets"),
     queryEntries: EntryQuerySchema.optional().describe(
       "Export only entries that match query parameters"
     ),
     queryAssets: AssetQuerySchema.optional().describe(
       "Export only assets that match query parameters"
     ),
-    downloadAssets: z73.boolean().optional().describe("Download asset files to disk"),
-    host: z73.string().optional().describe("Management API host"),
-    hostDelivery: z73.string().optional().describe("Delivery API host"),
-    proxy: z73.string().optional().describe("HTTP/HTTPS proxy config"),
-    rawProxy: z73.boolean().optional().describe("Pass raw proxy config directly to Axios"),
-    maxAllowedLimit: z73.number().optional().describe("Page size for requests"),
-    headers: z73.record(z73.any()).optional().describe("Additional headers to include in requests"),
-    errorLogFile: z73.string().optional().describe("Path to error log output file"),
-    useVerboseRenderer: z73.boolean().optional().describe("Line-by-line logging, useful for CI"),
-    config: z73.string().optional().describe("Path to a JSON config file with all options")
+    downloadAssets: z76.boolean().optional().describe("Download asset files to disk"),
+    host: z76.string().optional().describe("Management API host"),
+    hostDelivery: z76.string().optional().describe("Delivery API host"),
+    proxy: z76.string().optional().describe("HTTP/HTTPS proxy config"),
+    rawProxy: z76.boolean().optional().describe("Pass raw proxy config directly to Axios"),
+    maxAllowedLimit: z76.number().optional().describe("Page size for requests"),
+    headers: z76.record(z76.any()).optional().describe("Additional headers to include in requests"),
+    errorLogFile: z76.string().optional().describe("Path to error log output file"),
+    useVerboseRenderer: z76.boolean().optional().describe("Line-by-line logging, useful for CI"),
+    config: z76.string().optional().describe("Path to a JSON config file with all options")
   }).optional(),
-  import: z73.object({
-    spaceId: z73.string().optional().describe("ID of the space to import into"),
-    environmentId: z73.string().optional().describe("Target environment in destination space"),
-    contentFile: z73.string().optional().describe("Path to JSON file containing the content to import"),
-    content: z73.record(z73.any()).optional().describe(
+  import: z76.object({
+    spaceId: z76.string().optional().describe("ID of the space to import into"),
+    environmentId: z76.string().optional().describe("Target environment in destination space"),
+    contentFile: z76.string().optional().describe("Path to JSON file containing the content to import"),
+    content: z76.record(z76.any()).optional().describe(
       "JS object containing import content (must match expected structure)"
     ),
-    contentModelOnly: z73.boolean().optional().describe("Import only content types"),
-    skipContentModel: z73.boolean().optional().describe("Skip importing content types and locales"),
-    skipLocales: z73.boolean().optional().describe("Skip importing locales"),
-    skipContentUpdates: z73.boolean().optional().describe("Do not update existing content"),
-    skipContentPublishing: z73.boolean().optional().describe("Create but do not publish content"),
-    uploadAssets: z73.boolean().optional().describe("Upload asset files (requires assetsDirectory)"),
-    skipAssetUpdates: z73.boolean().optional().describe("Do not update existing assets"),
-    assetsDirectory: z73.string().optional().describe("Path to directory containing exported asset files"),
-    timeout: z73.number().optional().describe("Time between retries during asset processing (ms)"),
-    retryLimit: z73.number().optional().describe("Max retries for asset processing"),
-    host: z73.string().optional().describe("Management API host"),
-    proxy: z73.string().optional().describe("HTTP/HTTPS proxy string (host:port or user:pass@host:port)"),
-    rawProxy: z73.boolean().optional().describe("Pass proxy config directly to Axios"),
-    rateLimit: z73.number().optional().describe("Max requests per second to the API"),
-    headers: z73.record(z73.any()).optional().describe("Additional headers to attach to requests"),
-    errorLogFile: z73.string().optional().describe("Path to error log file"),
-    useVerboseRenderer: z73.boolean().optional().describe("Line-by-line progress output (good for CI)"),
-    config: z73.string().optional().describe("Path to config JSON file (merged with CLI args)")
+    contentModelOnly: z76.boolean().optional().describe("Import only content types"),
+    skipContentModel: z76.boolean().optional().describe("Skip importing content types and locales"),
+    skipLocales: z76.boolean().optional().describe("Skip importing locales"),
+    skipContentUpdates: z76.boolean().optional().describe("Do not update existing content"),
+    skipContentPublishing: z76.boolean().optional().describe("Create but do not publish content"),
+    uploadAssets: z76.boolean().optional().describe("Upload asset files (requires assetsDirectory)"),
+    skipAssetUpdates: z76.boolean().optional().describe("Do not update existing assets"),
+    assetsDirectory: z76.string().optional().describe("Path to directory containing exported asset files"),
+    timeout: z76.number().optional().describe("Time between retries during asset processing (ms)"),
+    retryLimit: z76.number().optional().describe("Max retries for asset processing"),
+    host: z76.string().optional().describe("Management API host"),
+    proxy: z76.string().optional().describe("HTTP/HTTPS proxy string (host:port or user:pass@host:port)"),
+    rawProxy: z76.boolean().optional().describe("Pass proxy config directly to Axios"),
+    rateLimit: z76.number().optional().describe("Max requests per second to the API"),
+    headers: z76.record(z76.any()).optional().describe("Additional headers to attach to requests"),
+    errorLogFile: z76.string().optional().describe("Path to error log file"),
+    useVerboseRenderer: z76.boolean().optional().describe("Line-by-line progress output (good for CI)"),
+    config: z76.string().optional().describe("Path to config JSON file (merged with CLI args)")
   }).optional()
 });
 var paramCollectionConfig = {
@@ -4624,28 +5312,33 @@ var createParamCollectionTool = withErrorHandling(
 );
 
 // src/tools/jobs/space-to-space-migration/importSpace.ts
-import { z as z74 } from "zod";
+import { z as z77 } from "zod";
 var ImportSpaceToolParams = BaseToolSchema.extend({
-  contentFile: z74.string().optional().describe("Path to JSON file containing the content to import"),
-  content: z74.record(z74.any()).optional().describe(
+  contentFile: z77.string().optional().describe("Path to JSON file containing the content to import"),
+  content: z77.record(z77.any()).optional().describe(
     "JS object containing import content (must match expected structure)"
   ),
-  contentModelOnly: z74.boolean().optional().default(false).describe("Import only content types"),
-  skipContentModel: z74.boolean().optional().default(false).describe("Skip importing content types and locales"),
-  skipLocales: z74.boolean().optional().default(false).describe("Skip importing locales"),
-  skipContentUpdates: z74.boolean().optional().default(false).describe("Do not update existing content"),
-  skipContentPublishing: z74.boolean().optional().default(false).describe("Create but do not publish content"),
-  uploadAssets: z74.boolean().optional().default(false).describe("Upload asset files (requires assetsDirectory)"),
-  skipAssetUpdates: z74.boolean().optional().default(false).describe("Do not update existing assets"),
-  assetsDirectory: z74.string().optional().describe("Path to directory containing exported asset files"),
-  timeout: z74.number().optional().default(3e3).describe("Time between retries during asset processing (ms)"),
-  retryLimit: z74.number().optional().default(10).describe("Max retries for asset processing"),
-  rateLimit: z74.number().optional().default(7).describe("Max requests per second to the API"),
-  errorLogFile: z74.string().optional().describe("Path to error log file"),
-  useVerboseRenderer: z74.boolean().optional().describe("Line-by-line progress output (good for CI)")
+  contentModelOnly: z77.boolean().optional().default(false).describe("Import only content types"),
+  skipContentModel: z77.boolean().optional().default(false).describe("Skip importing content types and locales"),
+  skipLocales: z77.boolean().optional().default(false).describe("Skip importing locales"),
+  skipContentUpdates: z77.boolean().optional().default(false).describe("Do not update existing content"),
+  skipContentPublishing: z77.boolean().optional().default(false).describe("Create but do not publish content"),
+  uploadAssets: z77.boolean().optional().default(false).describe("Upload asset files (requires assetsDirectory)"),
+  skipAssetUpdates: z77.boolean().optional().default(false).describe("Do not update existing assets"),
+  assetsDirectory: z77.string().optional().describe("Path to directory containing exported asset files"),
+  timeout: z77.number().optional().default(3e3).describe("Time between retries during asset processing (ms)"),
+  retryLimit: z77.number().optional().default(10).describe("Max retries for asset processing"),
+  rateLimit: z77.number().optional().default(7).describe("Max requests per second to the API"),
+  errorLogFile: z77.string().optional().describe("Path to error log file"),
+  useVerboseRenderer: z77.boolean().optional().describe("Line-by-line progress output (good for CI)")
 });
 function createImportSpaceTool(config) {
   async function tool2(args) {
+    const targetEnvironmentId = args.environmentId || "master";
+    assertEnvironmentNotProtected(
+      targetEnvironmentId,
+      config.protectedEnvironments
+    );
     const clientConfig = createClientConfig(config);
     const managementToken = clientConfig.accessToken;
     if (!managementToken) {
@@ -4655,14 +5348,14 @@ function createImportSpaceTool(config) {
       ...args,
       managementToken,
       host: config.host ?? "api.contentful.com",
-      environmentId: args.environmentId || "master"
+      environmentId: targetEnvironmentId
     };
     try {
       const contentfulImport = await import("contentful-import");
       const result = await contentfulImport.default(importOptions);
       return createSuccessResponse("Space imported successfully", {
         spaceId: args.spaceId,
-        environmentId: args.environmentId || "master",
+        environmentId: targetEnvironmentId,
         contentTypes: result.contentTypes?.length || 0,
         entries: result.entries?.length || 0,
         assets: result.assets?.length || 0,
@@ -4682,7 +5375,7 @@ function createImportSpaceTool(config) {
 }
 
 // src/tools/jobs/space-to-space-migration/migrationHandler.ts
-import { z as z75 } from "zod";
+import { z as z78 } from "zod";
 
 // src/tools/jobs/space-to-space-migration/instructions.ts
 var S2S_MIGRATION_INSTRUCTIONS = `
@@ -4725,7 +5418,7 @@ The space to space migration workflow has been concluded and all related tools h
 The workflow is now complete. You can start a new migration workflow by calling space_to_space_migration_handler with enableWorkflow=true if needed.
 `;
 var SpaceToSpaceMigrationHandlerToolParams = BaseToolSchema.extend({
-  enableWorkflow: z75.boolean().describe(
+  enableWorkflow: z78.boolean().describe(
     "Set to true to enable the workflow tools, false to disable them and conclude the workflow"
   )
 });