@contentful/mcp-tools 0.12.3 → 0.12.5

package/dist/index.js

@@ -335,7 +335,12 @@ var RESOURCE_DISPLAY_NAME = {
   aiAction: "AI action",
   locale: "locale",
   concept: "concept",
-  conceptScheme: "concept scheme"
+  conceptScheme: "concept scheme",
+  component: "component",
+  experience: "experience",
+  experienceFragment: "experience fragment",
+  experienceTemplate: "experience template",
+  dataAssembly: "data assembly"
 };
 function buildConfirmationPreview(resource, id, details, confirmToken) {
   const displayName = RESOURCE_DISPLAY_NAME[resource];
@@ -2303,141 +2308,61 @@ var ContextStore = class {
 var contextStore = new ContextStore();
 
 // src/tools/context/instructions.ts
-var MCP_INSTRUCTIONS = `You are a helpful assistant integrated with Contentful through the Model Context Protocol (MCP).
-
-# Core Agent Principles
-
-## IMPORTANT FIRST STEP:
-- Always call get_initial_context first to initialize your connection before using any other tools
-- This is required for all operations and will give you essential information about the current Contentful environment
-
-## Key Principles:
-- **Persistence**: Keep going until the user's query is completely resolved. Only end your turn when you are sure the problem is solved.
-- **Tool Usage**: If you are not sure about content or schema structure, use your tools to gather relevant information. Do NOT guess or make up answers.
-- **Planning**: Plan your approach before each tool call, and reflect on the outcomes of previous tool calls.
-- **Resource Clarification**: ALWAYS ask the user which resource to work with if there are multiple resources available. Never assume or guess which resource to use.
-- **Error Handling**: NEVER apologize for errors when making tool calls. Instead, immediately try a different approach or tool call. You may briefly inform the user what you're doing, but never say sorry.
-
-# Content Handling
-
-## Content-Type-First Approach:
-- **ALWAYS check the content type first** when users ask about finding or editing specific content types (e.g., "Where can I edit our pricing page?")
-- Use get_content_types proactively to understand what content types exist before attempting queries
-- This prevents failed queries and immediately reveals relevant content types (e.g., discovering a \`pricingPage\` type when asked about pricing)
-- Match user requests to the appropriate content types in the entry
-- If a user asks to create a field that doesn't match the content type (e.g., "writer" when the content type has "author"), suggest the correct type
-
-## entry Creation Limits:
-- A user is only allowed to create/edit/mutate a maximum of 5 (five) entries at a time
-- For multiple entry creation, use the 'async' parameter (set to true) for better performance
-- Only use async=true when creating more than one entry in a single conversation
-
-# Searching for Content
-
-## Content-Type-First Search Strategy:
-- **Content-Type-first approach**: When users ask about specific content (e.g., "pricing page", "blog posts"), use get_content_type first to discover relevant content types
-- This immediately reveals the correct content types and prevents wasted time on failed queries
-- After understanding the content type, use search_entries to search for content based on the correct content types and field names
-- If a query returns no results, retry 2-3 times with modified queries by adjusting filters, relaxing constraints, or trying alternative field names
-- When retrying queries, consider using more general terms, removing specific filters, or checking for typos in field names
-
-## Handling Multi-Step Queries:
-- For requests involving related entities (e.g., "Find blog posts by Magnus"), use a multi-step approach
-- ALWAYS check the content type structure first to understand fields and references
-- First, query for the referenced entity (e.g., author) to find its ID or confirm its existence
-- If multiple entities match (e.g., several authors named "Magnus"), query them all and display them to the user
-- Then use the found ID(s) to query for the primary content (e.g., blog posts referencing that author)
-- For references in Contentful, remember to use the proper reference format
-- Verify fields in the content type before constructing queries (single reference vs. array of references)
-
-## Entry Management:
-- For entry creation, use create_entry with clear instructions
-- Use entry_action for operations like publishing, unpublishing, deleting, or discarding entries
-- Use update_entry for content modifications with AI assistance. Always call get_entry first and pass the returned sys.version to update_entry; this is required and prevents overwriting concurrent changes.
-- Use patch_entry for precise, direct modifications without AI generation (one operation at a time)
-- Use transform_entry when preserving rich text formatting is crucial
-- Use translate_entry specifically for language translation tasks
-- Use transform_image for AI-powered image operations
-- Always verify entry existence before attempting to modify it
-
-# Migration Strategies
-- Use the space_to_space migration workflow to help a user when they want to migrate content from one space to another. Start this workflow by calling the start_space_to_space_migration tool.
-- You do not need to fetch content types (ex. list_content_types tool) or entries (ex. search_entries tool) prior to starting the migration workflow. Once the user states they want to start the migration workflow, you simply need to call the start_space_to_space_migration tool.
-
-# Error Handling and Debugging
-
-## Error Response Strategy:
-- If you encounter an error, explain what went wrong clearly
-- Suggest potential solutions or alternatives
-- Make sure to check entry existence, field requirements, and permission issues
-- Try different approaches immediately rather than stopping at the first error
-
-## Common Issues to Check:
-- entry existence and permissions
-- Required field validation
-- Correct field types (array vs single reference)
-
-# Response Format and Communication
-
-## General Guidelines:
-- Keep your responses concise but thorough
-- Format complex data for readability using markdown
-- Focus on completing the requested tasks efficiently
-- Provide context from entries when relevant
-- When displaying entries, show the most important fields first
-
-## Before Using Tools:
-Before running a tool:
-1. Think about what information you need to gather
-2. Determine the right tool and parameters to use
-3. Briefly communicate to the user what you're about to do in a conversational tone
-
-## Problem-Solving Strategy:
-1. **Understand the request**: Analyze what the user is asking for and identify necessary entry types and fields
-2. **Resource identification**: If multiple resources are available, ALWAYS ask which resource to work with
-3. **Plan your approach**: Determine which tools you'll need and in which order
-4. **Execute with tools**: Use appropriate tools to query, create, or update entries
-5. **Verify results**: Check if results match what the user requested and make adjustments if needed
-6. **Respond clearly**: Present results in a clear, concise format
-
-# Best Practices
-
-## Content Management:
-- When creating content, follow the content type structure exactly
-- Always verify entry existence before attempting to modify it
-- Remind users that entry operations can affect live content
-
-## Efficiency Tips:
-- Suggest appropriate entry types based on user needs
-- Recommend efficient ways to structure content
-- Explain how Contentful features like content types, entries, and references work
-- Help users understand the relationship between spaces, environments, and content types
-
-## Bulk Actions:
-- If making multiple calls to the same tool, ALWAYS check and see whether that tool supports bulk operations first, and condense them into a single call if possible.
-
-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.`;
+var CORE_INVARIANTS = `# Core operating rules
+
+- **Schema first.** Before creating or finding content, inspect the environment's schema: list available types and inspect their fields. This prevents failed operations and ensures you use the right type and field names.
+- **Edit safely.** Before updating any item, fetch it first to get the current \`sys.version\`, then pass that version to the update call. The version is required and prevents overwriting concurrent changes.
+- **Bulk cap.** Bulk publish/unpublish/archive/unarchive operations accept at most 10 IDs per call by default. This cap does not apply to creating or updating items.
+- **Ask when ambiguous.** If multiple spaces or environments are available, ask the user which to use. Do not guess.`;
+var SEARCHING_GUIDANCE = `# Searching for content
+
+- **Schema first.** When users ask about specific content, discover the relevant schema before searching: list the environment's available types and inspect a type's fields so you query on real field names. This prevents wasted queries. Use whichever primitives the environment exposes \u2014 classic content types and entries, or Experience Orchestration components and experiences.
+- **Then search.** Query using the correct type and field names. Prefer semantic search when the request is conceptual rather than an exact field match.
+- **Retry thoughtfully.** If a query returns no results, retry 2-3 times: relax filters, use more general terms, or check for typos in field names.
+- **Multi-step reference queries.** For requests that span references (e.g. "posts by Magnus"), first inspect the schema to confirm the reference field, then query for the referenced item to get its ID, then filter the primary query on that ID. If several items match, show them all and ask.`;
+var CONVENTIONS_GUIDANCE = `# Response and workflow conventions
+
+- **Plan, then act.** Before a tool call, think about what you need, pick the right tool, and briefly tell the user what you are about to do.
+- **Persist.** Keep going until the request is fully resolved; do not stop at the first error. On failure, explain what went wrong and immediately try a different approach \u2014 never apologize for tool errors.
+- **Clarify resources.** If multiple spaces or environments exist, always ask which to use before acting.
+- **Format for readability.** Use markdown for complex data; show the most important fields of an entry first; keep responses concise but complete.
+- **Prefer bulk.** If you would call the same tool many times, check whether it supports multiple IDs and condense into one call (respecting the 10-ID cap on publish-family operations).`;
+var EXO_DISPOSITION = `# Tool disposition: Experience Orchestration by default
+
+Experience Orchestration (ExO) tools are enabled. Use ExO primitives \u2014 Components, Experiences, Experience Templates, Experience Fragments, and Data Assemblies \u2014 for all content modeling and authoring. Do not create classic content types or entries unless the user explicitly instructs you to. If you are unsure how to model something with ExO, inspect the tool schemas and proceed with ExO.`;
 
 // src/tools/context/getInitialContextTool.ts
 var GetInitialContextToolParams = z35.object({});
 function getInitialContextTool(config) {
   async function tool2(_params) {
-    const configInfo = `Current Contentful Configuration:
-  - Space ID: ${config.spaceId || "Not set"}
-  - Environment ID: ${config.environmentId || "master"}
-  - Organization ID: ${config.organizationId || "Not set"}`;
-    const todaysDate = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US");
+    const today = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
+      weekday: "long",
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    });
+    const sessionFacts = outdent`
+      Current Contentful session:
+        - Today's date: ${today}
+        - Space ID: ${config.spaceId || "Not set"}
+        - Environment ID: ${config.environmentId || "master"}
+        - Organization ID: ${config.organizationId || "Not set"}`;
+    const exoBlock = config.exoToolsRegistered ? `
+
+${EXO_DISPOSITION}` : "";
     const message = outdent`
-    ${MCP_INSTRUCTIONS}
+      You are an assistant integrated with Contentful through the Model Context Protocol (MCP). Always call this tool first.
+
+      ${sessionFacts}
+    ` + exoBlock + `
 
-    This is the initial context for your Contentful instance:
+` + outdent`
+      ${CORE_INVARIANTS}
 
-    <context>
-      ${configInfo}
-    </content>
+      ${SEARCHING_GUIDANCE}
 
-    <todaysDate>${todaysDate}</todaysDate>
-  `;
+      ${CONVENTIONS_GUIDANCE}
+    `;
     contextStore.setInitialContextLoaded();
     return {
       content: [
@@ -5786,85 +5711,2481 @@ function createJobTools(config) {
   };
 }
 
-// src/ContentfulMcpTools.ts
-var ContentfulMcpTools = class {
-  config;
-  constructor(config) {
-    this.config = {
-      ...config,
-      host: config.host ?? "api.contentful.com",
-      environmentId: config.environmentId ?? "master"
-    };
-  }
-  /**
-   * Update the configuration after initialization
-   * 
-   * @param updates - Partial configuration to merge with existing config
-   */
-  updateConfig(updates) {
-    this.config = { ...this.config, ...updates };
-  }
-  /**
-   * Get AI action tools
-   */
-  getAiActionTools() {
-    return createAiActionTools(this.config);
-  }
-  /**
-   * Get asset tools
-   */
-  getAssetTools() {
-    return createAssetTools(this.config);
-  }
-  /**
-   * Get content type tools
-   */
-  getContentTypeTools() {
-    return createContentTypeTools(this.config);
+// src/tools/exo/components/getComponent.ts
+import { z as z83 } from "zod";
+var GetComponentToolParams = BaseToolSchema.extend({
+  componentId: z83.string().describe("The ID of the component to retrieve details for")
+});
+function getComponentTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const component = await contentfulClient.component.get({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      componentId: args.componentId
+    });
+    return createSuccessResponse("Component retrieved successfully", {
+      component
+    });
   }
-  /**
-   * Get context tools
-   */
-  getContextTools() {
-    return createContextTools(this.config);
+  return withErrorHandling(tool2, "Error retrieving component");
+}
+
+// src/tools/exo/components/listComponents.ts
+import { z as z84 } from "zod";
+var ListComponentsToolParams = BaseToolSchema.extend({
+  limit: z84.number().optional().describe("Maximum number of components to return (max 10)"),
+  pageNext: z84.string().optional().describe("Cursor token to fetch the next page of results"),
+  pagePrev: z84.string().optional().describe("Cursor token to fetch the previous page of results"),
+  order: z84.string().optional().describe("Order components by this field (e.g. sys.createdAt)")
+});
+function listComponentsTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const cursorParam = args.pageNext ? { pageNext: args.pageNext } : args.pagePrev ? { pagePrev: args.pagePrev } : {};
+    const components = await contentfulClient.component.getMany({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      query: {
+        limit: Math.min(args.limit || 10, 10),
+        ...args.order && { order: args.order },
+        ...cursorParam
+      }
+    });
+    const summarized = summarizeData(components, {
+      maxItems: 10,
+      remainingMessage: "To see more components, ask me to retrieve the next page using the pageNext cursor."
+    });
+    return createSuccessResponse("Components retrieved successfully", {
+      components: summarized,
+      total: components.total,
+      limit: components.limit,
+      pages: components.pages
+    });
   }
-  /**
-   * Get editor interface tools
-   */
-  getEditorInterfaceTools() {
-    return createEditorInterfaceTools(this.config);
+  return withErrorHandling(tool2, "Error listing components");
+}
+
+// src/tools/exo/components/createComponent.ts
+import { z as z86 } from "zod";
+
+// src/types/exoSchemas.ts
+import { z as z85 } from "zod";
+var URN_EXAMPLES = {
+  "Contentful:Component": "crn:contentful:::experience:spaces/{spaceId}/environments/{envId}/components/{id}",
+  "Contentful:ExperienceFragment": "crn:contentful:::experience:spaces/{spaceId}/environments/{envId}/experienceFragments/{id}",
+  "Contentful:ExperienceTemplate": "crn:contentful:::experience:spaces/{spaceId}/environments/{envId}/experienceTemplates/{id}",
+  "Contentful:DataAssembly": "crn:contentful:::experience:spaces/{spaceId}/environments/{envId}/dataAssemblies/{id}"
+};
+var resourceLinkSchema2 = (linkType) => {
+  const example = URN_EXAMPLES[linkType];
+  const urnDesc = example ? `URN of the linked resource (e.g. "${example}")` : "URN of the linked resource";
+  return z85.object({
+    sys: z85.object({
+      type: z85.literal("ResourceLink"),
+      linkType: z85.literal(linkType),
+      urn: z85.string().describe(urnDesc)
+    })
+  });
+};
+var linkSchema2 = (linkType) => z85.object({
+  sys: z85.object({
+    type: z85.literal("Link"),
+    linkType: z85.literal(linkType),
+    id: z85.string()
+  })
+});
+var ComponentResourceLinkSchema = resourceLinkSchema2(
+  "Contentful:Component"
+);
+var ExperienceFragmentResourceLinkSchema = resourceLinkSchema2(
+  "Contentful:ExperienceFragment"
+);
+var ExperienceTemplateResourceLinkSchema = resourceLinkSchema2(
+  "Contentful:ExperienceTemplate"
+);
+var ViewportSchema = z85.object({
+  id: z85.string().describe("Viewport identifier"),
+  query: z85.string().describe("CSS media query string"),
+  displayName: z85.string().describe("Human-readable viewport name"),
+  previewSize: z85.string().describe('Preview size (e.g. "1024px")')
+});
+var DataTypeDefinitionSchema = z85.lazy(
+  () => z85.discriminatedUnion("type", [
+    z85.object({
+      type: z85.enum(["String", "Number", "Integer", "Boolean"]),
+      name: z85.string().optional(),
+      required: z85.boolean().optional()
+    }),
+    z85.object({
+      type: z85.literal("RichText"),
+      name: z85.string().optional(),
+      required: z85.boolean().optional()
+    }),
+    z85.object({
+      type: z85.literal("Array"),
+      name: z85.string().optional(),
+      required: z85.boolean().optional(),
+      items: DataTypeDefinitionSchema
+    }),
+    z85.object({
+      type: z85.literal("Record"),
+      name: z85.string().optional(),
+      required: z85.boolean().optional(),
+      fields: z85.record(z85.string(), DataTypeDefinitionSchema)
+    }),
+    z85.object({
+      type: z85.literal("TypeRef"),
+      name: z85.string().optional(),
+      required: z85.boolean().optional(),
+      ref: z85.object({
+        sys: z85.object({
+          type: z85.literal("ResourceLink"),
+          linkType: z85.string(),
+          urn: z85.string()
+        })
+      })
+    }),
+    z85.object({
+      type: z85.literal("Literal"),
+      name: z85.string().optional(),
+      required: z85.boolean().optional(),
+      value: z85.custom().describe("JSON literal value"),
+      valueType: DataTypeDefinitionSchema
+    }),
+    z85.object({
+      type: z85.literal("DiscriminatedUnion"),
+      name: z85.string().optional(),
+      required: z85.boolean().optional(),
+      discriminator: z85.string(),
+      members: z85.array(DataTypeDefinitionSchema)
+    })
+  ])
+);
+var ContentPropertySchema = z85.intersection(
+  DataTypeDefinitionSchema,
+  z85.object({
+    id: z85.string().describe("Content property identifier"),
+    name: z85.string().describe("Human-readable name"),
+    required: z85.boolean().describe("Whether the property is required"),
+    defaultValue: z85.unknown().optional().describe("Default value")
+  })
+);
+var DTCG_DESIGN_PROPERTY_TYPES = [
+  "DTCG.Color",
+  "DTCG.Dimension",
+  "DTCG.FontFamily",
+  "DTCG.FontWeight",
+  "DTCG.Duration",
+  "DTCG.CubicBezier",
+  "DTCG.Number",
+  "DTCG.StrokeStyle",
+  "DTCG.Border",
+  "DTCG.Transition",
+  "DTCG.Shadow",
+  "DTCG.Gradient",
+  "DTCG.Typography"
+];
+var DesignPropertyCommonFieldsSchema = z85.object({
+  id: z85.string().describe("Design property identifier"),
+  name: z85.string().describe("Human-readable name"),
+  description: z85.string().optional().describe("Optional description")
+});
+var StringDesignPropertySchema = DesignPropertyCommonFieldsSchema.extend({
+  type: z85.literal("String"),
+  fallbackValue: z85.object({
+    type: z85.literal("ManualDesignValue"),
+    value: z85.string()
+  }).optional().describe("Manual fallback value for this design property"),
+  validations: z85.array(
+    z85.object({
+      regexp: z85.object({
+        pattern: z85.string().describe("Regular expression pattern")
+      })
+    })
+  ).optional().describe("Regexp validations constraining allowed string values")
+});
+var BooleanDesignPropertySchema = DesignPropertyCommonFieldsSchema.extend({
+  type: z85.literal("Boolean"),
+  fallbackValue: z85.object({
+    type: z85.literal("ManualDesignValue"),
+    value: z85.boolean()
+  }).optional().describe("Manual fallback value for this design property")
+});
+var DesignTokenValueSchema = z85.object({
+  type: z85.literal("DesignToken"),
+  value: z85.string().min(1).describe("Design token reference (non-empty)")
+});
+var TokenBackedDesignPropertySchema = DesignPropertyCommonFieldsSchema.extend(
+  {
+    type: z85.enum(DTCG_DESIGN_PROPERTY_TYPES),
+    fallbackValue: DesignTokenValueSchema.optional().describe(
+      "Design-token-backed fallback value for this design property"
+    ),
+    allowedResources: z85.array(
+      z85.object({
+        type: z85.literal("DesignToken"),
+        value: z85.string(),
+        name: z85.string().optional()
+      })
+    ).optional().describe("Allowed design token resources")
   }
-  /**
-   * Get entry tools
-   */
-  getEntryTools() {
-    return createEntryTools(this.config);
+);
+var DesignPropertySchema = z85.union([
+  StringDesignPropertySchema,
+  BooleanDesignPropertySchema,
+  TokenBackedDesignPropertySchema
+]);
+var ManualDesignValueSchema = z85.object({
+  type: z85.literal("ManualDesignValue"),
+  value: z85.union([z85.string(), z85.number(), z85.boolean()])
+});
+var DesignPropertyValueSchema = z85.union([
+  ManualDesignValueSchema,
+  DesignTokenValueSchema
+]);
+var DesignPropertyPointerValueSchema = z85.custom(
+  (val) => typeof val === "string" && /^\$designProperties\//.test(val),
+  { message: 'Must be a "$designProperties/..." pointer' }
+);
+var DimensionedDesignPropertyValueSchema = z85.record(
+  z85.string(),
+  DesignPropertyValueSchema
+);
+var ComponentTreeDesignPropertyValueSchema = z85.union([
+  DesignPropertyValueSchema,
+  DesignPropertyPointerValueSchema,
+  DimensionedDesignPropertyValueSchema
+]);
+var COMPONENT_TYPE_ALLOWED_RESOURCE_SOURCE = "crn:contentful:::experience:spaces/$self/environments/$self";
+var SlotDefinitionSchema = z85.object({
+  id: z85.string().describe("Slot identifier"),
+  name: z85.string().describe("Human-readable name"),
+  required: z85.boolean().describe("Whether the slot must be filled"),
+  validations: z85.array(
+    z85.object({
+      size: z85.object({
+        min: z85.number().optional(),
+        max: z85.number().optional()
+      }).optional()
+    })
+  ).describe("Slot cardinality validations"),
+  allowedResources: z85.array(
+    z85.object({
+      type: z85.literal("Contentful:Component"),
+      source: z85.literal(COMPONENT_TYPE_ALLOWED_RESOURCE_SOURCE),
+      allowedTypes: z85.array(z85.string()).describe("IDs of components allowed in this slot")
+    })
+  ).optional().describe("Constrains which components may be placed in this slot")
+});
+var ExperienceFragmentNodeSchema = z85.object({
+  id: z85.string().describe("Node identifier"),
+  name: z85.string().optional().describe("Optional display name"),
+  nodeType: z85.literal("ExperienceFragment").describe('Must be "ExperienceFragment"'),
+  experienceFragment: ExperienceFragmentResourceLinkSchema.describe(
+    "Resource link to the referenced experience fragment"
+  )
+});
+var SlotNodeSchema = z85.object({
+  id: z85.string().describe("Node identifier"),
+  nodeType: z85.literal("Slot").describe('Must be "Slot"'),
+  slotId: z85.string().describe("ID of the slot definition to render")
+});
+var TreeNodeSchema = z85.lazy(
+  () => z85.union([ComponentNodeSchema, ExperienceFragmentNodeSchema, SlotNodeSchema])
+);
+var ComponentNodeSchema = z85.lazy(
+  () => z85.object({
+    id: z85.string().describe("Node identifier"),
+    name: z85.string().optional().describe("Optional display name"),
+    nodeType: z85.literal("Component").describe('Must be "Component"'),
+    component: ComponentResourceLinkSchema.describe(
+      "Resource link to the component to render"
+    ),
+    contentProperties: z85.union([
+      z85.record(z85.string(), z85.unknown()),
+      z85.string().describe('"$contentProperties/..." pointer')
+    ]).describe(
+      'Content property bindings \u2014 values or "$contentProperties/..." pointers'
+    ),
+    designProperties: z85.record(z85.string(), ComponentTreeDesignPropertyValueSchema).describe(
+      'Design property values \u2014 ManualDesignValue, DesignTokenValue, or "$designProperties/..." pointers'
+    ),
+    slots: z85.record(z85.string(), z85.array(TreeNodeSchema)).describe("Child tree nodes keyed by slot ID")
+  })
+);
+var TagLinkSchema = linkSchema2("Tag");
+var ConceptLinkSchema = linkSchema2("TaxonomyConcept");
+var ExoMetadataSchema = z85.object({
+  tags: z85.array(TagLinkSchema).optional().describe("Tags attached to this entity"),
+  concepts: z85.array(ConceptLinkSchema).optional().describe("Taxonomy concepts attached to this entity")
+});
+var ExperienceMetadataSchema = ExoMetadataSchema.extend({
+  name: z85.string().optional().describe("Variant label for this metadata entry")
+});
+var DataAssemblyResourceLinkSchema = resourceLinkSchema2(
+  "Contentful:DataAssembly"
+);
+var ExperienceContentBindingsSchema = z85.object({
+  sys: DataAssemblyResourceLinkSchema.shape.sys,
+  parameters: z85.record(
+    z85.string(),
+    z85.object({
+      sys: z85.object({
+        type: z85.literal("ResourceLink"),
+        linkType: z85.string(),
+        urn: z85.string()
+      })
+    })
+  ).describe("Parameter bindings keyed by parameter ID")
+});
+var InlineExperienceFragmentNodeSchema = z85.lazy(
+  () => z85.object({
+    id: z85.string().describe("Node identifier"),
+    nodeType: z85.literal("InlineExperienceFragment").describe('Must be "InlineExperienceFragment"'),
+    component: ComponentResourceLinkSchema.describe(
+      "Resource link to the component this inline experience fragment renders"
+    ),
+    designProperties: z85.record(z85.string(), DimensionedDesignPropertyValueSchema).describe("Design property values for this inline experience fragment"),
+    contentBindings: ExperienceContentBindingsSchema.optional().describe(
+      "Optional content bindings linking this inline experience fragment to a data assembly"
+    ),
+    slots: z85.record(z85.string(), z85.array(ExperienceSlotNodeSchema)).optional().describe("Child slot contents keyed by slot ID")
+  })
+);
+var ExperienceSlotNodeSchema = z85.lazy(
+  () => z85.union([ExperienceFragmentNodeSchema, InlineExperienceFragmentNodeSchema])
+);
+
+// src/tools/exo/components/createComponent.ts
+var CreateComponentToolParams = BaseToolSchema.extend({
+  name: z86.string().describe("The name of the component"),
+  description: z86.string().describe("Description of the component"),
+  viewports: z86.array(ViewportSchema).describe("Viewport definitions for the component (may be empty)"),
+  contentProperties: z86.array(ContentPropertySchema).describe("Content property definitions (may be empty)"),
+  designProperties: z86.array(DesignPropertySchema).describe("Design property definitions (may be empty)"),
+  componentTree: z86.array(TreeNodeSchema).optional().describe("Optional component tree node definitions"),
+  slots: z86.array(SlotDefinitionSchema).optional().describe("Optional slot definitions"),
+  metadata: ExoMetadataSchema.optional().describe(
+    "Optional ExO metadata (tags, concepts)"
+  )
+});
+function createComponentTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const contentfulClient = createToolClient(config, args);
+    const component = await contentfulClient.component.create(
+      { spaceId: args.spaceId, environmentId: args.environmentId },
+      {
+        name: args.name,
+        description: args.description,
+        viewports: args.viewports,
+        contentProperties: args.contentProperties,
+        designProperties: args.designProperties,
+        ...args.componentTree && { componentTree: args.componentTree },
+        ...args.slots && { slots: args.slots },
+        ...args.metadata && { metadata: args.metadata }
+      }
+    );
+    return createSuccessResponse("Component created successfully", {
+      component
+    });
   }
-  /**
-   * Get environment tools
-   */
-  getEnvironmentTools() {
-    return createEnvironmentTools(this.config);
+  return withErrorHandling(tool2, "Error creating component");
+}
+
+// src/tools/exo/components/upsertComponent.ts
+import { z as z87 } from "zod";
+var UpsertComponentToolParams = BaseToolSchema.extend({
+  componentId: z87.string().describe("The ID of the component to update"),
+  version: z87.number().describe(
+    "REQUIRED. The component's sys.version as returned by get_component. You must call get_component first to read the current state and version. The update is rejected if this does not match the current version, which means the component changed since you read it."
+  ),
+  name: z87.string().optional().describe("The name of the component"),
+  description: z87.string().optional().describe("Description of the component"),
+  viewports: z87.array(ViewportSchema).optional().describe("Viewport definitions; replaces existing viewports if provided"),
+  contentProperties: z87.array(ContentPropertySchema).optional().describe("Content property definitions; replaces existing if provided"),
+  designProperties: z87.array(DesignPropertySchema).optional().describe("Design property definitions; replaces existing if provided"),
+  componentTree: z87.array(TreeNodeSchema).optional().describe("Component tree node definitions; replaces existing if provided"),
+  slots: z87.array(SlotDefinitionSchema).optional().describe("Slot definitions; replaces existing if provided"),
+  metadata: ExoMetadataSchema.optional().describe(
+    "ExO metadata (tags, concepts); replaces existing if provided"
+  )
+});
+function upsertComponentTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      componentId: args.componentId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.component.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the component has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the component with get_component and retry the update with the latest sys.version.`
+      );
+    }
+    const component = await contentfulClient.component.upsert(params, {
+      sys: {
+        id: current.sys.id,
+        type: "Component",
+        version: current.sys.version
+      },
+      name: args.name ?? current.name,
+      description: args.description ?? current.description,
+      viewports: args.viewports ?? current.viewports,
+      contentProperties: args.contentProperties ?? current.contentProperties,
+      designProperties: args.designProperties ?? current.designProperties,
+      ...args.componentTree ?? current.componentTree ? { componentTree: args.componentTree ?? current.componentTree } : {},
+      ...args.slots ?? current.slots ? { slots: args.slots ?? current.slots } : {},
+      ...args.metadata ?? current.metadata ? { metadata: args.metadata ?? current.metadata } : {},
+      ...current.dataAssemblies ? { dataAssemblies: current.dataAssemblies } : {}
+    });
+    return createSuccessResponse("Component updated successfully", {
+      component
+    });
   }
-  /**
-   * Get locale tools
-   */
-  getLocaleTools() {
-    return createLocaleTools(this.config);
+  return withErrorHandling(tool2, "Error updating component");
+}
+
+// src/tools/exo/components/deleteComponent.ts
+import { z as z88 } from "zod";
+var DeleteComponentToolParams = BaseToolSchema.extend({
+  componentId: z88.string().describe("The ID of the component to delete"),
+  confirm: z88.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z88.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
+});
+function deleteComponentTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      componentId: args.componentId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const component = await contentfulClient.component.get(params);
+    const expectedToken = buildConfirmToken(
+      "component",
+      args.componentId,
+      component.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} component`,
+        buildConfirmationPreview(
+          "component",
+          args.componentId,
+          { component },
+          expectedToken
+        )
+      );
+    }
+    await contentfulClient.component.delete(params);
+    return createSuccessResponse("Component deleted successfully", {
+      componentId: args.componentId
+    });
   }
-  /**
-   * Get organization tools
-   */
-  getOrgTools() {
-    return createOrgTools(this.config);
+  return withErrorHandling(tool2, "Error deleting component");
+}
+
+// src/tools/exo/components/publishComponent.ts
+import { z as z89 } from "zod";
+var PublishComponentToolParams = BaseToolSchema.extend({
+  componentId: z89.string().describe("The ID of the component to publish"),
+  version: z89.number().describe(
+    "REQUIRED. The component's sys.version as returned by get_component. You must call get_component first to read the current state and version. The publish is rejected if this does not match the current version, which means the component changed since you read it."
+  )
+});
+function publishComponentTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      componentId: args.componentId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.component.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the component has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the component with get_component and retry with the latest sys.version.`
+      );
+    }
+    const component = await contentfulClient.component.publish({
+      ...params,
+      version: args.version
+    });
+    return createSuccessResponse("Component published successfully", {
+      component
+    });
   }
-  /**
-   * Get space tools
-   */
-  getSpaceTools() {
-    return createSpaceTools(this.config);
+  return withErrorHandling(tool2, "Error publishing component");
+}
+
+// src/tools/exo/components/unpublishComponent.ts
+import { z as z90 } from "zod";
+var UnpublishComponentToolParams = BaseToolSchema.extend({
+  componentId: z90.string().describe("The ID of the component to unpublish"),
+  version: z90.number().describe(
+    "REQUIRED. The component's sys.version as returned by get_component. You must call get_component first to read the current state and version. The unpublish is rejected if this does not match the current version, which means the component changed since you read it."
+  )
+});
+function unpublishComponentTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      componentId: args.componentId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.component.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the component has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the component with get_component and retry with the latest sys.version.`
+      );
+    }
+    const component = await contentfulClient.component.unpublish({
+      ...params,
+      version: args.version
+    });
+    return createSuccessResponse("Component unpublished successfully", {
+      component
+    });
   }
-  /**
+  return withErrorHandling(tool2, "Error unpublishing component");
+}
+
+// src/tools/exo/components/register.ts
+function createComponentTools(config) {
+  const getComponent = getComponentTool(config);
+  const listComponents = listComponentsTool(config);
+  const createComponent = createComponentTool(config);
+  const upsertComponent = upsertComponentTool(config);
+  const deleteComponent = deleteComponentTool(config);
+  const publishComponent = publishComponentTool(config);
+  const unpublishComponent = unpublishComponentTool(config);
+  return {
+    getComponent: {
+      title: "get_component",
+      description: "Get details about a specific ExO component (a reusable section/pattern template defining slots, content properties, and design properties).",
+      inputParams: GetComponentToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: getComponent
+    },
+    listComponents: {
+      title: "list_components",
+      description: "List ExO components in a space and environment. Returns a maximum of 10 items per request; use the pageNext cursor (returned in pages.next) to paginate.",
+      inputParams: ListComponentsToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: listComponents
+    },
+    createComponent: {
+      title: "create_component",
+      description: "Create a new ExO component.",
+      inputParams: CreateComponentToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: createComponent
+    },
+    upsertComponent: {
+      title: "upsert_component",
+      description: "Update an existing ExO component. You MUST call get_component first to read the current state, then pass the sys.version you received as the version parameter. The handler merges your updates with the existing component fields, so you only need to provide the fields you want to change. If the version is stale (the component changed since you read it), the update is rejected and you must re-fetch with get_component.",
+      inputParams: UpsertComponentToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: upsertComponent
+    },
+    deleteComponent: {
+      title: "delete_component",
+      description: "Delete an ExO component. Two-phase: the first call (without confirm/confirmToken) returns a preview and a confirmToken. To complete the deletion, call again with the same componentId, confirm: true, and the confirmToken from the preview.",
+      inputParams: DeleteComponentToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: deleteComponent
+    },
+    publishComponent: {
+      title: "publish_component",
+      description: "Publish an ExO component. You MUST call get_component first and pass the returned sys.version as the version parameter. If the version is stale the operation is rejected and you must re-fetch with get_component.",
+      inputParams: PublishComponentToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      tool: publishComponent
+    },
+    unpublishComponent: {
+      title: "unpublish_component",
+      description: "Unpublish an ExO component. You MUST call get_component first and pass the returned sys.version as the version parameter. If the version is stale the operation is rejected and you must re-fetch with get_component.",
+      inputParams: UnpublishComponentToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      tool: unpublishComponent
+    }
+  };
+}
+
+// src/tools/exo/experience-fragments/getExperienceFragment.ts
+import { z as z91 } from "zod";
+var GetExperienceFragmentToolParams = BaseToolSchema.extend({
+  experienceFragmentId: z91.string().describe("The ID of the experience fragment to retrieve details for")
+});
+function getExperienceFragmentTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const experienceFragment = await contentfulClient.experienceFragment.get({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      experienceFragmentId: args.experienceFragmentId
+    });
+    return createSuccessResponse("Experience fragment retrieved successfully", {
+      experienceFragment
+    });
+  }
+  return withErrorHandling(tool2, "Error retrieving experience fragment");
+}
+
+// src/tools/exo/experience-fragments/listExperienceFragments.ts
+import { z as z92 } from "zod";
+var ListExperienceFragmentsToolParams = BaseToolSchema.extend({
+  limit: z92.number().optional().describe("Maximum number of experience fragments to return (max 10)"),
+  pageNext: z92.string().optional().describe("Cursor token to fetch the next page of results"),
+  pagePrev: z92.string().optional().describe("Cursor token to fetch the previous page of results"),
+  order: z92.string().optional().describe("Order experience fragments by this field (e.g. sys.createdAt)")
+});
+function listExperienceFragmentsTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const experienceFragments = await contentfulClient.experienceFragment.getMany({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      query: {
+        limit: Math.min(args.limit || 10, 10),
+        ...args.pageNext && { pageNext: args.pageNext },
+        ...args.pagePrev && { pagePrev: args.pagePrev },
+        ...args.order && { order: args.order }
+      }
+    });
+    const summarized = summarizeData(experienceFragments, {
+      maxItems: 10,
+      remainingMessage: "To see more experience fragments, ask me to retrieve the next page using the pageNext cursor."
+    });
+    return createSuccessResponse("ExperienceFragments retrieved successfully", {
+      experienceFragments: summarized,
+      total: experienceFragments.total,
+      limit: experienceFragments.limit,
+      pages: experienceFragments.pages
+    });
+  }
+  return withErrorHandling(tool2, "Error listing experience fragments");
+}
+
+// src/tools/exo/experience-fragments/createExperienceFragment.ts
+import { z as z93 } from "zod";
+var CreateExperienceFragmentToolParams = BaseToolSchema.extend({
+  name: z93.string().describe("The name of the experience fragment"),
+  description: z93.string().describe("Description of the experience fragment"),
+  component: ComponentResourceLinkSchema.describe(
+    "Resource link to the component this experience fragment is based on"
+  ),
+  viewports: z93.array(ViewportSchema).describe("Viewport definitions (may be empty)"),
+  designProperties: z93.record(z93.string(), DimensionedDesignPropertyValueSchema).describe(
+    "Design property values keyed by property ID (may be empty object)"
+  ),
+  contentBindings: ExperienceContentBindingsSchema.optional().describe(
+    "Optional content bindings for the experience fragment"
+  ),
+  slots: z93.record(z93.string(), z93.array(ExperienceSlotNodeSchema)).optional().describe("Optional slot node definitions keyed by slot ID"),
+  metadata: ExperienceMetadataSchema.optional().describe(
+    "Optional ExO metadata (tags, concepts)"
+  )
+});
+function createExperienceFragmentTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const contentfulClient = createToolClient(config, args);
+    const experienceFragment = await contentfulClient.experienceFragment.create(
+      { spaceId: args.spaceId, environmentId: args.environmentId },
+      {
+        name: args.name,
+        description: args.description,
+        component: args.component,
+        viewports: args.viewports,
+        designProperties: args.designProperties,
+        ...args.contentBindings && { contentBindings: args.contentBindings },
+        ...args.slots && { slots: args.slots },
+        ...args.metadata && { metadata: args.metadata }
+      }
+    );
+    return createSuccessResponse("Experience fragment created successfully", {
+      experienceFragment
+    });
+  }
+  return withErrorHandling(tool2, "Error creating experience fragment");
+}
+
+// src/tools/exo/experience-fragments/updateExperienceFragment.ts
+import { z as z94 } from "zod";
+var UpdateExperienceFragmentToolParams = BaseToolSchema.extend({
+  experienceFragmentId: z94.string().describe("The ID of the experience fragment to update"),
+  version: z94.number().describe(
+    "REQUIRED. The experience fragment's sys.version as returned by get_experience_fragment. You must call get_experience_fragment first to read the current state and version. The update is rejected if this does not match the current version, which means the experience fragment changed since you read it."
+  ),
+  name: z94.string().optional().describe("The name of the experience fragment"),
+  description: z94.string().optional().describe("Description of the experience fragment"),
+  viewports: z94.array(ViewportSchema).optional().describe("Viewport definitions; replaces existing viewports if provided"),
+  designProperties: z94.record(z94.string(), DimensionedDesignPropertyValueSchema).optional().describe("Design property values; replaces existing if provided"),
+  contentBindings: ExperienceContentBindingsSchema.optional().describe(
+    "Content bindings; replaces existing if provided"
+  ),
+  slots: z94.record(z94.string(), z94.array(ExperienceSlotNodeSchema)).optional().describe("Slot node definitions; replaces existing if provided"),
+  metadata: ExperienceMetadataSchema.optional().describe(
+    "ExO metadata (tags, concepts); replaces existing if provided"
+  )
+});
+function updateExperienceFragmentTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      experienceFragmentId: args.experienceFragmentId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.experienceFragment.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the experience fragment has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the experience fragment with get_experience_fragment and retry the update with the latest sys.version.`
+      );
+    }
+    const experienceFragment = await contentfulClient.experienceFragment.upsert(
+      params,
+      {
+        sys: {
+          id: current.sys.id,
+          type: "ExperienceFragment",
+          version: current.sys.version
+        },
+        name: args.name ?? current.name,
+        description: args.description ?? current.description,
+        viewports: args.viewports ?? current.viewports,
+        designProperties: args.designProperties ?? current.designProperties,
+        ...args.contentBindings ?? current.contentBindings ? { contentBindings: args.contentBindings ?? current.contentBindings } : {},
+        ...args.slots ?? current.slots ? { slots: args.slots ?? current.slots } : {},
+        ...args.metadata ?? current.metadata ? { metadata: args.metadata ?? current.metadata } : {}
+      }
+    );
+    return createSuccessResponse("Experience fragment updated successfully", {
+      experienceFragment
+    });
+  }
+  return withErrorHandling(tool2, "Error updating experience fragment");
+}
+
+// src/tools/exo/experience-fragments/deleteExperienceFragment.ts
+import { z as z95 } from "zod";
+var DeleteExperienceFragmentToolParams = BaseToolSchema.extend({
+  experienceFragmentId: z95.string().describe("The ID of the experience fragment to delete"),
+  confirm: z95.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z95.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
+});
+function deleteExperienceFragmentTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      experienceFragmentId: args.experienceFragmentId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const experienceFragment = await contentfulClient.experienceFragment.get(params);
+    const expectedToken = buildConfirmToken(
+      "experienceFragment",
+      args.experienceFragmentId,
+      experienceFragment.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} experience fragment`,
+        buildConfirmationPreview(
+          "experienceFragment",
+          args.experienceFragmentId,
+          { experienceFragment },
+          expectedToken
+        )
+      );
+    }
+    await contentfulClient.experienceFragment.delete(params);
+    return createSuccessResponse("Experience fragment deleted successfully", {
+      experienceFragmentId: args.experienceFragmentId
+    });
+  }
+  return withErrorHandling(tool2, "Error deleting experience fragment");
+}
+
+// src/tools/exo/experience-fragments/publishExperienceFragment.ts
+import { z as z96 } from "zod";
+var PublishExperienceFragmentToolParams = BaseToolSchema.extend({
+  experienceFragmentId: z96.string().describe("The ID of the experience fragment to publish"),
+  version: z96.number().describe(
+    "REQUIRED. The experience fragment's sys.version as returned by get_experience_fragment. You must call get_experience_fragment first to read the current state and version. The publish is rejected if this does not match the current version, which means the experience fragment changed since you read it."
+  )
+});
+function publishExperienceFragmentTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      experienceFragmentId: args.experienceFragmentId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.experienceFragment.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the experience fragment has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the experience fragment with get_experience_fragment and retry with the latest sys.version.`
+      );
+    }
+    const experienceFragment = await contentfulClient.experienceFragment.publish({
+      ...params,
+      version: args.version
+    });
+    return createSuccessResponse("Experience fragment published successfully", {
+      experienceFragment
+    });
+  }
+  return withErrorHandling(tool2, "Error publishing experience fragment");
+}
+
+// src/tools/exo/experience-fragments/unpublishExperienceFragment.ts
+import { z as z97 } from "zod";
+var UnpublishExperienceFragmentToolParams = BaseToolSchema.extend({
+  experienceFragmentId: z97.string().describe("The ID of the experience fragment to unpublish"),
+  version: z97.number().describe(
+    "REQUIRED. The experience fragment's sys.version as returned by get_experience_fragment. You must call get_experience_fragment first to read the current state and version. The unpublish is rejected if this does not match the current version, which means the experience fragment changed since you read it."
+  )
+});
+function unpublishExperienceFragmentTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      experienceFragmentId: args.experienceFragmentId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.experienceFragment.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the experience fragment has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the experience fragment with get_experience_fragment and retry with the latest sys.version.`
+      );
+    }
+    const experienceFragment = await contentfulClient.experienceFragment.unpublish({
+      ...params,
+      version: args.version
+    });
+    return createSuccessResponse(
+      "Experience fragment unpublished successfully",
+      {
+        experienceFragment
+      }
+    );
+  }
+  return withErrorHandling(tool2, "Error unpublishing experience fragment");
+}
+
+// src/tools/exo/experience-fragments/register.ts
+function createExperienceFragmentTools(config) {
+  const getExperienceFragment = getExperienceFragmentTool(config);
+  const listExperienceFragments = listExperienceFragmentsTool(config);
+  const createExperienceFragment = createExperienceFragmentTool(config);
+  const updateExperienceFragment = updateExperienceFragmentTool(config);
+  const deleteExperienceFragment = deleteExperienceFragmentTool(config);
+  const publishExperienceFragment = publishExperienceFragmentTool(config);
+  const unpublishExperienceFragment = unpublishExperienceFragmentTool(config);
+  return {
+    getExperienceFragment: {
+      title: "get_experience_fragment",
+      description: "Get details about a specific ExO experience fragment (a reusable content unit that can be referenced across multiple Experiences and Components).",
+      inputParams: GetExperienceFragmentToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: getExperienceFragment
+    },
+    listExperienceFragments: {
+      title: "list_experience_fragments",
+      description: "List ExO experience fragments in a space and environment. Returns a maximum of 10 items per request; use the pageNext cursor (returned in pages.next) to paginate.",
+      inputParams: ListExperienceFragmentsToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: listExperienceFragments
+    },
+    createExperienceFragment: {
+      title: "create_experience_fragment",
+      description: "Create a new ExO experience fragment.",
+      inputParams: CreateExperienceFragmentToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: createExperienceFragment
+    },
+    updateExperienceFragment: {
+      title: "update_experience_fragment",
+      description: "Update an existing ExO experience fragment. You MUST call get_experience_fragment first to read the current state, then pass the sys.version you received as the version parameter. The handler merges your updates with the existing experience fragment fields, so you only need to provide the fields you want to change. If the version is stale (the experience fragment changed since you read it), the update is rejected and you must re-fetch with get_experience_fragment.",
+      inputParams: UpdateExperienceFragmentToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: updateExperienceFragment
+    },
+    deleteExperienceFragment: {
+      title: "delete_experience_fragment",
+      description: "Delete an ExO experience fragment. Two-phase: the first call (without confirm/confirmToken) returns a preview and a confirmToken. To complete the deletion, call again with the same experienceFragmentId, confirm: true, and the confirmToken from the preview.",
+      inputParams: DeleteExperienceFragmentToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: deleteExperienceFragment
+    },
+    publishExperienceFragment: {
+      title: "publish_experience_fragment",
+      description: "Publish an ExO experience fragment. You MUST call get_experience_fragment first and pass the returned sys.version as the version parameter. If the version is stale the operation is rejected and you must re-fetch with get_experience_fragment.",
+      inputParams: PublishExperienceFragmentToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      tool: publishExperienceFragment
+    },
+    unpublishExperienceFragment: {
+      title: "unpublish_experience_fragment",
+      description: "Unpublish an ExO experience fragment. You MUST call get_experience_fragment first and pass the returned sys.version as the version parameter. If the version is stale the operation is rejected and you must re-fetch with get_experience_fragment.",
+      inputParams: UnpublishExperienceFragmentToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      tool: unpublishExperienceFragment
+    }
+  };
+}
+
+// src/tools/exo/experience-templates/getExperienceTemplate.ts
+import { z as z98 } from "zod";
+var GetExperienceTemplateToolParams = BaseToolSchema.extend({
+  experienceTemplateId: z98.string().describe("The ID of the experience template to retrieve details for")
+});
+function getExperienceTemplateTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const experienceTemplate = await contentfulClient.experienceTemplate.get({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      experienceTemplateId: args.experienceTemplateId
+    });
+    return createSuccessResponse("Experience template retrieved successfully", {
+      experienceTemplate
+    });
+  }
+  return withErrorHandling(tool2, "Error retrieving experience template");
+}
+
+// src/tools/exo/experience-templates/listExperienceTemplates.ts
+import { z as z99 } from "zod";
+var ListExperienceTemplatesToolParams = BaseToolSchema.extend({
+  limit: z99.number().optional().describe("Maximum number of experience templates to return (max 10)"),
+  pageNext: z99.string().optional().describe("Cursor token to fetch the next page of results"),
+  pagePrev: z99.string().optional().describe("Cursor token to fetch the previous page of results"),
+  order: z99.string().optional().describe("Order experience templates by this field (e.g. sys.createdAt)")
+});
+function listExperienceTemplatesTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const experienceTemplates = await contentfulClient.experienceTemplate.getMany({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      query: {
+        limit: Math.min(args.limit || 10, 10),
+        ...args.pageNext && { pageNext: args.pageNext },
+        ...args.pagePrev && { pagePrev: args.pagePrev },
+        ...args.order && { order: args.order }
+      }
+    });
+    const summarized = summarizeData(experienceTemplates, {
+      maxItems: 10,
+      remainingMessage: "To see more experience templates, ask me to retrieve the next page using the pageNext cursor."
+    });
+    return createSuccessResponse("ExperienceTemplates retrieved successfully", {
+      experienceTemplates: summarized,
+      total: experienceTemplates.total,
+      limit: experienceTemplates.limit,
+      pages: experienceTemplates.pages
+    });
+  }
+  return withErrorHandling(tool2, "Error listing experience templates");
+}
+
+// src/tools/exo/experience-templates/createExperienceTemplate.ts
+import { z as z100 } from "zod";
+var CreateExperienceTemplateToolParams = BaseToolSchema.extend({
+  name: z100.string().describe("The name of the experience template"),
+  description: z100.string().describe("Description of the experience template"),
+  viewports: z100.array(ViewportSchema).describe(
+    "Viewport definitions for the experience template (may be empty)"
+  ),
+  contentProperties: z100.array(ContentPropertySchema).describe("Content property definitions (may be empty)"),
+  designProperties: z100.array(DesignPropertySchema).describe("Design property definitions (may be empty)"),
+  componentTree: z100.array(TreeNodeSchema).optional().describe("Optional component tree node definitions"),
+  slots: z100.array(SlotDefinitionSchema).optional().describe("Optional slot definitions"),
+  metadata: ExoMetadataSchema.optional().describe(
+    "Optional ExO metadata (tags, concepts)"
+  )
+});
+function createExperienceTemplateTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const contentfulClient = createToolClient(config, args);
+    const experienceTemplate = await contentfulClient.experienceTemplate.create(
+      { spaceId: args.spaceId, environmentId: args.environmentId },
+      {
+        name: args.name,
+        description: args.description,
+        viewports: args.viewports,
+        contentProperties: args.contentProperties,
+        designProperties: args.designProperties,
+        ...args.componentTree && { componentTree: args.componentTree },
+        ...args.slots && { slots: args.slots },
+        ...args.metadata && { metadata: args.metadata }
+      }
+    );
+    return createSuccessResponse("Experience template created successfully", {
+      experienceTemplate
+    });
+  }
+  return withErrorHandling(tool2, "Error creating experience template");
+}
+
+// src/tools/exo/experience-templates/upsertExperienceTemplate.ts
+import { z as z101 } from "zod";
+var UpsertExperienceTemplateToolParams = BaseToolSchema.extend({
+  experienceTemplateId: z101.string().describe("The ID of the experience template to update"),
+  version: z101.number().describe(
+    "REQUIRED. The experience template's sys.version as returned by get_experience_template. You must call get_experience_template first to read the current state and version. The update is rejected if this does not match the current version, which means the experience template changed since you read it."
+  ),
+  name: z101.string().optional().describe("The name of the experience template"),
+  description: z101.string().optional().describe("Description of the experience template"),
+  viewports: z101.array(ViewportSchema).optional().describe("Viewport definitions; replaces existing viewports if provided"),
+  contentProperties: z101.array(ContentPropertySchema).optional().describe("Content property definitions; replaces existing if provided"),
+  designProperties: z101.array(DesignPropertySchema).optional().describe("Design property definitions; replaces existing if provided"),
+  componentTree: z101.array(TreeNodeSchema).optional().describe("Component tree node definitions; replaces existing if provided"),
+  slots: z101.array(SlotDefinitionSchema).optional().describe("Slot definitions; replaces existing if provided"),
+  metadata: ExoMetadataSchema.optional().describe(
+    "ExO metadata (tags, concepts); replaces existing if provided"
+  )
+});
+function upsertExperienceTemplateTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      experienceTemplateId: args.experienceTemplateId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.experienceTemplate.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the experience template has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the experience template with get_experience_template and retry the update with the latest sys.version.`
+      );
+    }
+    const experienceTemplate = await contentfulClient.experienceTemplate.upsert(
+      params,
+      {
+        sys: {
+          id: current.sys.id,
+          type: "ExperienceTemplate",
+          version: current.sys.version
+        },
+        name: args.name ?? current.name,
+        description: args.description ?? current.description,
+        viewports: args.viewports ?? current.viewports,
+        contentProperties: args.contentProperties ?? current.contentProperties,
+        designProperties: args.designProperties ?? current.designProperties,
+        ...args.componentTree ?? current.componentTree ? { componentTree: args.componentTree ?? current.componentTree } : {},
+        ...args.slots ?? current.slots ? { slots: args.slots ?? current.slots } : {},
+        ...args.metadata ?? current.metadata ? { metadata: args.metadata ?? current.metadata } : {},
+        ...current.dataAssemblies ? { dataAssemblies: current.dataAssemblies } : {}
+      }
+    );
+    return createSuccessResponse("Experience template updated successfully", {
+      experienceTemplate
+    });
+  }
+  return withErrorHandling(tool2, "Error updating experience template");
+}
+
+// src/tools/exo/experience-templates/deleteExperienceTemplate.ts
+import { z as z102 } from "zod";
+var DeleteExperienceTemplateToolParams = BaseToolSchema.extend({
+  experienceTemplateId: z102.string().describe("The ID of the experience template to delete"),
+  confirm: z102.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z102.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
+});
+function deleteExperienceTemplateTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      experienceTemplateId: args.experienceTemplateId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const experienceTemplate = await contentfulClient.experienceTemplate.get(params);
+    const expectedToken = buildConfirmToken(
+      "experienceTemplate",
+      args.experienceTemplateId,
+      experienceTemplate.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} experience template`,
+        buildConfirmationPreview(
+          "experienceTemplate",
+          args.experienceTemplateId,
+          { experienceTemplate },
+          expectedToken
+        )
+      );
+    }
+    await contentfulClient.experienceTemplate.delete(params);
+    return createSuccessResponse("Experience template deleted successfully", {
+      experienceTemplateId: args.experienceTemplateId
+    });
+  }
+  return withErrorHandling(tool2, "Error deleting experience template");
+}
+
+// src/tools/exo/experience-templates/publishExperienceTemplate.ts
+import { z as z103 } from "zod";
+var PublishExperienceTemplateToolParams = BaseToolSchema.extend({
+  experienceTemplateId: z103.string().describe("The ID of the experience template to publish"),
+  version: z103.number().describe(
+    "REQUIRED. The experience template's sys.version as returned by get_experience_template. You must call get_experience_template first to read the current state and version. The publish is rejected if this does not match the current version, which means the experience template changed since you read it."
+  )
+});
+function publishExperienceTemplateTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      experienceTemplateId: args.experienceTemplateId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.experienceTemplate.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the experience template has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the experience template with get_experience_template and retry with the latest sys.version.`
+      );
+    }
+    const experienceTemplate = await contentfulClient.experienceTemplate.publish({
+      ...params,
+      version: args.version
+    });
+    return createSuccessResponse("Experience template published successfully", {
+      experienceTemplate
+    });
+  }
+  return withErrorHandling(tool2, "Error publishing experience template");
+}
+
+// src/tools/exo/experience-templates/unpublishExperienceTemplate.ts
+import { z as z104 } from "zod";
+var UnpublishExperienceTemplateToolParams = BaseToolSchema.extend({
+  experienceTemplateId: z104.string().describe("The ID of the experience template to unpublish"),
+  version: z104.number().describe(
+    "REQUIRED. The experience template's sys.version as returned by get_experience_template. You must call get_experience_template first to read the current state and version. The unpublish is rejected if this does not match the current version, which means the experience template changed since you read it."
+  )
+});
+function unpublishExperienceTemplateTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      experienceTemplateId: args.experienceTemplateId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.experienceTemplate.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the experience template has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the experience template with get_experience_template and retry with the latest sys.version.`
+      );
+    }
+    const experienceTemplate = await contentfulClient.experienceTemplate.unpublish({
+      ...params,
+      version: args.version
+    });
+    return createSuccessResponse(
+      "Experience template unpublished successfully",
+      {
+        experienceTemplate
+      }
+    );
+  }
+  return withErrorHandling(tool2, "Error unpublishing experience template");
+}
+
+// src/tools/exo/experience-templates/register.ts
+function createExperienceTemplateTools(config) {
+  const getExperienceTemplate = getExperienceTemplateTool(config);
+  const listExperienceTemplates = listExperienceTemplatesTool(config);
+  const createExperienceTemplate = createExperienceTemplateTool(config);
+  const upsertExperienceTemplate = upsertExperienceTemplateTool(config);
+  const deleteExperienceTemplate = deleteExperienceTemplateTool(config);
+  const publishExperienceTemplate = publishExperienceTemplateTool(config);
+  const unpublishExperienceTemplate = unpublishExperienceTemplateTool(config);
+  return {
+    getExperienceTemplate: {
+      title: "get_experience_template",
+      description: "Get details about a specific ExO experience template (a layout definition that backs experience-template-based Experiences).",
+      inputParams: GetExperienceTemplateToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: getExperienceTemplate
+    },
+    listExperienceTemplates: {
+      title: "list_experience_templates",
+      description: "List ExO experience templates in a space and environment. Returns a maximum of 10 items per request; use the pageNext cursor (returned in pages.next) to paginate.",
+      inputParams: ListExperienceTemplatesToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: listExperienceTemplates
+    },
+    createExperienceTemplate: {
+      title: "create_experience_template",
+      description: "Create a new ExO experience template.",
+      inputParams: CreateExperienceTemplateToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: createExperienceTemplate
+    },
+    upsertExperienceTemplate: {
+      title: "upsert_experience_template",
+      description: "Update an existing ExO experience template. You MUST call get_experience_template first to read the current state, then pass the sys.version you received as the version parameter. The handler merges your updates with the existing experience template fields, so you only need to provide the fields you want to change. If the version is stale (the experience template changed since you read it), the update is rejected and you must re-fetch with get_experience_template.",
+      inputParams: UpsertExperienceTemplateToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: upsertExperienceTemplate
+    },
+    deleteExperienceTemplate: {
+      title: "delete_experience_template",
+      description: "Delete an ExO experience template. Two-phase: the first call (without confirm/confirmToken) returns a preview and a confirmToken. To complete the deletion, call again with the same experienceTemplateId, confirm: true, and the confirmToken from the preview.",
+      inputParams: DeleteExperienceTemplateToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: deleteExperienceTemplate
+    },
+    publishExperienceTemplate: {
+      title: "publish_experience_template",
+      description: "Publish an ExO experience template. You MUST call get_experience_template first and pass the returned sys.version as the version parameter. If the version is stale the operation is rejected and you must re-fetch with get_experience_template.",
+      inputParams: PublishExperienceTemplateToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      tool: publishExperienceTemplate
+    },
+    unpublishExperienceTemplate: {
+      title: "unpublish_experience_template",
+      description: "Unpublish an ExO experience template. You MUST call get_experience_template first and pass the returned sys.version as the version parameter. If the version is stale the operation is rejected and you must re-fetch with get_experience_template.",
+      inputParams: UnpublishExperienceTemplateToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      tool: unpublishExperienceTemplate
+    }
+  };
+}
+
+// src/tools/exo/experiences/getExperience.ts
+import { z as z105 } from "zod";
+var GetExperienceToolParams = BaseToolSchema.extend({
+  experienceId: z105.string().describe("The ID of the experience to retrieve")
+});
+function getExperienceTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const experience = await contentfulClient.experience.get({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      experienceId: args.experienceId
+    });
+    return createSuccessResponse("Experience retrieved successfully", {
+      experience
+    });
+  }
+  return withErrorHandling(tool2, "Error retrieving experience");
+}
+
+// src/tools/exo/experiences/listExperiences.ts
+import { z as z106 } from "zod";
+var ListExperiencesToolParams = BaseToolSchema.extend({
+  limit: z106.number().optional().describe("Maximum number of experiences to return (max 10)"),
+  pageNext: z106.string().optional().describe("Cursor token to fetch the next page of results"),
+  pagePrev: z106.string().optional().describe("Cursor token to fetch the previous page of results"),
+  order: z106.string().optional().describe("Order experiences by this field (e.g. sys.createdAt)")
+});
+function listExperiencesTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const experiences = await contentfulClient.experience.getMany({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      query: {
+        limit: Math.min(args.limit || 10, 10),
+        ...args.pageNext && { pageNext: args.pageNext },
+        ...args.pagePrev && { pagePrev: args.pagePrev },
+        ...args.order && { order: args.order }
+      }
+    });
+    const summarized = summarizeData(experiences, {
+      maxItems: 10,
+      remainingMessage: "To see more experiences, ask me to retrieve the next page using the pageNext cursor."
+    });
+    return createSuccessResponse("Experiences retrieved successfully", {
+      experiences: summarized,
+      total: experiences.total,
+      limit: experiences.limit,
+      pages: experiences.pages
+    });
+  }
+  return withErrorHandling(tool2, "Error listing experiences");
+}
+
+// src/tools/exo/experiences/createExperience.ts
+import { z as z107 } from "zod";
+var CreateExperienceToolParams = BaseToolSchema.extend({
+  name: z107.string().describe("The name of the experience"),
+  description: z107.string().describe("Description of the experience"),
+  experienceTemplate: ExperienceTemplateResourceLinkSchema.describe(
+    "Resource link to the ExperienceTemplate this experience is backed by"
+  ),
+  viewports: z107.array(ViewportSchema).describe("Viewport definitions for the experience (may be empty)"),
+  designProperties: z107.record(z107.string(), DimensionedDesignPropertyValueSchema).describe(
+    "Design property values keyed by property ID. Each value is a dimensioned map (viewport ID \u2192 design value). May be an empty object."
+  ),
+  contentBindings: ExperienceContentBindingsSchema.optional().describe(
+    "Optional content bindings linking this experience to a data assembly"
+  ),
+  slots: z107.record(z107.string(), z107.array(ExperienceSlotNodeSchema)).optional().describe(
+    "Optional slot contents keyed by slot ID. Each value is an array of ExperienceFragmentNode or InlineExperienceFragmentNode."
+  ),
+  metadata: ExperienceMetadataSchema.optional().describe(
+    "Optional ExO metadata (tags, concepts)"
+  )
+});
+function createExperienceTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const contentfulClient = createToolClient(config, args);
+    const experience = await contentfulClient.experience.create(
+      { spaceId: args.spaceId, environmentId: args.environmentId },
+      {
+        name: args.name,
+        description: args.description,
+        experienceTemplate: args.experienceTemplate,
+        viewports: args.viewports,
+        designProperties: args.designProperties,
+        ...args.contentBindings && { contentBindings: args.contentBindings },
+        ...args.slots && { slots: args.slots },
+        ...args.metadata && { metadata: args.metadata }
+      }
+    );
+    return createSuccessResponse("Experience created successfully", {
+      experience
+    });
+  }
+  return withErrorHandling(tool2, "Error creating experience");
+}
+
+// src/tools/exo/experiences/upsertExperience.ts
+import { z as z108 } from "zod";
+var UpsertExperienceToolParams = BaseToolSchema.extend({
+  experienceId: z108.string().describe("The ID of the experience to update"),
+  version: z108.number().describe(
+    "REQUIRED. The experience's sys.version as returned by get_experience. You must call get_experience first to read the current state and version. The update is rejected if this does not match the current version, which means the experience changed since you read it."
+  ),
+  name: z108.string().optional().describe("The name of the experience"),
+  description: z108.string().optional().describe("Description of the experience"),
+  viewports: z108.array(ViewportSchema).optional().describe("Viewport definitions; replaces existing viewports if provided"),
+  designProperties: z108.record(z108.string(), DimensionedDesignPropertyValueSchema).optional().describe(
+    "Design property values keyed by property ID; replaces existing if provided"
+  ),
+  contentBindings: ExperienceContentBindingsSchema.optional().describe(
+    "Content bindings linking this experience to a data assembly; replaces existing if provided"
+  ),
+  slots: z108.record(z108.string(), z108.array(ExperienceSlotNodeSchema)).optional().describe("Slot contents keyed by slot ID; replaces existing if provided"),
+  metadata: ExperienceMetadataSchema.optional().describe(
+    "ExO metadata (tags, concepts); replaces existing if provided"
+  )
+});
+function upsertExperienceTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      experienceId: args.experienceId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.experience.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the experience has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the experience with get_experience and retry the update with the latest sys.version.`
+      );
+    }
+    const experience = await contentfulClient.experience.upsert(params, {
+      sys: {
+        id: current.sys.id,
+        type: "Experience",
+        version: current.sys.version
+      },
+      name: args.name ?? current.name,
+      description: args.description ?? current.description,
+      viewports: args.viewports ?? current.viewports,
+      designProperties: args.designProperties ?? current.designProperties,
+      ...args.contentBindings ?? current.contentBindings ? { contentBindings: args.contentBindings ?? current.contentBindings } : {},
+      ...args.slots ?? current.slots ? { slots: args.slots ?? current.slots } : {},
+      ...args.metadata ?? current.metadata ? { metadata: args.metadata ?? current.metadata } : {}
+    });
+    return createSuccessResponse("Experience updated successfully", {
+      experience
+    });
+  }
+  return withErrorHandling(tool2, "Error updating experience");
+}
+
+// src/tools/exo/experiences/deleteExperience.ts
+import { z as z109 } from "zod";
+var DeleteExperienceToolParams = BaseToolSchema.extend({
+  experienceId: z109.string().describe("The ID of the experience to delete"),
+  confirm: z109.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z109.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
+});
+function deleteExperienceTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      experienceId: args.experienceId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const experience = await contentfulClient.experience.get(params);
+    const expectedToken = buildConfirmToken(
+      "experience",
+      args.experienceId,
+      experience.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} experience`,
+        buildConfirmationPreview(
+          "experience",
+          args.experienceId,
+          { experience },
+          expectedToken
+        )
+      );
+    }
+    await contentfulClient.experience.delete(params);
+    return createSuccessResponse("Experience deleted successfully", {
+      experienceId: args.experienceId
+    });
+  }
+  return withErrorHandling(tool2, "Error deleting experience");
+}
+
+// src/tools/exo/experiences/publishExperience.ts
+import { z as z110 } from "zod";
+var PublishExperienceToolParams = BaseToolSchema.extend({
+  experienceId: z110.string().describe("The ID of the experience to publish"),
+  version: z110.number().describe(
+    "REQUIRED. The experience's sys.version as returned by get_experience. You must call get_experience first to read the current state and version. The publish is rejected if this does not match the current version, which means the experience changed since you read it."
+  )
+});
+function publishExperienceTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      experienceId: args.experienceId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.experience.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the experience has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the experience with get_experience and retry with the latest sys.version.`
+      );
+    }
+    const experience = await contentfulClient.experience.publish({
+      ...params,
+      version: args.version
+    });
+    return createSuccessResponse("Experience published successfully", {
+      experience
+    });
+  }
+  return withErrorHandling(tool2, "Error publishing experience");
+}
+
+// src/tools/exo/experiences/unpublishExperience.ts
+import { z as z111 } from "zod";
+var UnpublishExperienceToolParams = BaseToolSchema.extend({
+  experienceId: z111.string().describe("The ID of the experience to unpublish"),
+  version: z111.number().describe(
+    "REQUIRED. The experience's sys.version as returned by get_experience. You must call get_experience first to read the current state and version. The unpublish is rejected if this does not match the current version, which means the experience changed since you read it."
+  )
+});
+function unpublishExperienceTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      experienceId: args.experienceId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.experience.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the experience has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the experience with get_experience and retry with the latest sys.version.`
+      );
+    }
+    const experience = await contentfulClient.experience.unpublish({
+      ...params,
+      version: args.version
+    });
+    return createSuccessResponse("Experience unpublished successfully", {
+      experience
+    });
+  }
+  return withErrorHandling(tool2, "Error unpublishing experience");
+}
+
+// src/tools/exo/experiences/register.ts
+function createExperienceTools(config) {
+  const getExperience = getExperienceTool(config);
+  const listExperiences = listExperiencesTool(config);
+  const createExperience = createExperienceTool(config);
+  const upsertExperience = upsertExperienceTool(config);
+  const deleteExperience = deleteExperienceTool(config);
+  const publishExperience = publishExperienceTool(config);
+  const unpublishExperience = unpublishExperienceTool(config);
+  return {
+    getExperience: {
+      title: "get_experience",
+      description: "Get details about a specific ExO experience (a concrete page or screen that composes a root Component with content and design settings, backed by an ExperienceTemplate).",
+      inputParams: GetExperienceToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: getExperience
+    },
+    listExperiences: {
+      title: "list_experiences",
+      description: "List ExO experiences in a space and environment. Returns a maximum of 10 items per request; use the pageNext cursor (returned in pages.next) to paginate.",
+      inputParams: ListExperiencesToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: listExperiences
+    },
+    createExperience: {
+      title: "create_experience",
+      description: "Create a new ExO experience backed by an ExperienceTemplate.",
+      inputParams: CreateExperienceToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: createExperience
+    },
+    upsertExperience: {
+      title: "upsert_experience",
+      description: "Update an existing ExO experience. You MUST call get_experience first to read the current state, then pass the sys.version you received as the version parameter. The handler merges your updates with the existing experience fields, so you only need to provide the fields you want to change. If the version is stale (the experience changed since you read it), the update is rejected and you must re-fetch with get_experience.",
+      inputParams: UpsertExperienceToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: upsertExperience
+    },
+    deleteExperience: {
+      title: "delete_experience",
+      description: "Delete an ExO experience. Two-phase: the first call (without confirm/confirmToken) returns a preview and a confirmToken. To complete the deletion, call again with the same experienceId, confirm: true, and the confirmToken from the preview.",
+      inputParams: DeleteExperienceToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: deleteExperience
+    },
+    publishExperience: {
+      title: "publish_experience",
+      description: "Publish an ExO experience. You MUST call get_experience first and pass the returned sys.version as the version parameter. If the version is stale the operation is rejected and you must re-fetch with get_experience.",
+      inputParams: PublishExperienceToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      tool: publishExperience
+    },
+    unpublishExperience: {
+      title: "unpublish_experience",
+      description: "Unpublish an ExO experience. You MUST call get_experience first and pass the returned sys.version as the version parameter. If the version is stale the operation is rejected and you must re-fetch with get_experience.",
+      inputParams: UnpublishExperienceToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      tool: unpublishExperience
+    }
+  };
+}
+
+// src/tools/exo/data-assemblies/getDataAssembly.ts
+import { z as z112 } from "zod";
+var GetDataAssemblyToolParams = BaseToolSchema.extend({
+  dataAssemblyId: z112.string().describe("The ID of the data assembly to retrieve")
+});
+function getDataAssemblyTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const dataAssembly = await contentfulClient.dataAssembly.get({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      dataAssemblyId: args.dataAssemblyId
+    });
+    return createSuccessResponse("Data assembly retrieved successfully", {
+      dataAssembly
+    });
+  }
+  return withErrorHandling(tool2, "Error retrieving data assembly");
+}
+
+// src/tools/exo/data-assemblies/getPublishedDataAssembly.ts
+import { z as z113 } from "zod";
+var GetPublishedDataAssemblyToolParams = BaseToolSchema.extend({
+  dataAssemblyId: z113.string().describe("The ID of the published data assembly to retrieve")
+});
+function getPublishedDataAssemblyTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const dataAssembly = await contentfulClient.dataAssembly.getPublished({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      dataAssemblyId: args.dataAssemblyId
+    });
+    return createSuccessResponse("Published data assembly retrieved successfully", {
+      dataAssembly
+    });
+  }
+  return withErrorHandling(tool2, "Error retrieving published data assembly");
+}
+
+// src/tools/exo/data-assemblies/listDataAssemblies.ts
+import { z as z114 } from "zod";
+var ListDataAssembliesToolParams = BaseToolSchema.extend({
+  limit: z114.number().optional().describe("Maximum number of data assemblies to return (max 10)"),
+  pageNext: z114.string().optional().describe("Cursor token to fetch the next page of results"),
+  pagePrev: z114.string().optional().describe("Cursor token to fetch the previous page of results"),
+  sysIdIn: z114.string().optional().describe("Comma-separated list of data assembly IDs to filter by")
+});
+function listDataAssembliesTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const dataAssemblies = await contentfulClient.dataAssembly.getMany({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      query: {
+        limit: Math.min(args.limit || 10, 10),
+        ...args.pageNext && { pageNext: args.pageNext },
+        ...args.pagePrev && { pagePrev: args.pagePrev },
+        ...args.sysIdIn && { "sys.id[in]": args.sysIdIn }
+      }
+    });
+    const summarized = summarizeData(dataAssemblies, {
+      maxItems: 10,
+      remainingMessage: "To see more data assemblies, ask me to retrieve the next page using the pageNext cursor."
+    });
+    return createSuccessResponse("Data assemblies retrieved successfully", {
+      dataAssemblies: summarized,
+      total: dataAssemblies.total,
+      pages: dataAssemblies.pages
+    });
+  }
+  return withErrorHandling(tool2, "Error listing data assemblies");
+}
+
+// src/tools/exo/data-assemblies/listPublishedDataAssemblies.ts
+import { z as z115 } from "zod";
+var ListPublishedDataAssembliesToolParams = BaseToolSchema.extend({
+  limit: z115.number().optional().describe("Maximum number of published data assemblies to return (max 10)"),
+  pageNext: z115.string().optional().describe("Cursor token to fetch the next page of results"),
+  pagePrev: z115.string().optional().describe("Cursor token to fetch the previous page of results"),
+  sysIdIn: z115.string().optional().describe("Comma-separated list of data assembly IDs to filter by")
+});
+function listPublishedDataAssembliesTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const dataAssemblies = await contentfulClient.dataAssembly.getManyPublished({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      query: {
+        limit: Math.min(args.limit || 10, 10),
+        ...args.pageNext && { pageNext: args.pageNext },
+        ...args.pagePrev && { pagePrev: args.pagePrev },
+        ...args.sysIdIn && { "sys.id[in]": args.sysIdIn }
+      }
+    });
+    const summarized = summarizeData(dataAssemblies, {
+      maxItems: 10,
+      remainingMessage: "To see more published data assemblies, ask me to retrieve the next page using the pageNext cursor."
+    });
+    return createSuccessResponse("Published data assemblies retrieved successfully", {
+      dataAssemblies: summarized,
+      total: dataAssemblies.total,
+      pages: dataAssemblies.pages
+    });
+  }
+  return withErrorHandling(tool2, "Error listing published data assemblies");
+}
+
+// src/tools/exo/data-assemblies/createDataAssembly.ts
+import { z as z117 } from "zod";
+
+// src/types/dataAssemblySchemas.ts
+import { z as z116 } from "zod";
+var PointerExpressionValueSchema = z116.lazy(
+  () => z116.union([
+    z116.string(),
+    z116.object({
+      $from: z116.union([
+        z116.string(),
+        z116.object({
+          source: z116.string(),
+          select: PointerExpressionValueSchema.optional()
+        })
+      ])
+    }),
+    z116.object({ $literal: z116.custom() }),
+    z116.object({ $object: z116.record(z116.string(), PointerExpressionValueSchema) }),
+    z116.object({
+      $on: z116.object({
+        type: z116.record(z116.string(), PointerExpressionValueSchema),
+        default: PointerExpressionValueSchema.optional()
+      })
+    }),
+    z116.record(z116.string(), PointerExpressionValueSchema)
+  ])
+);
+var CanonicalDataTypeArmSchema = z116.object({
+  type: z116.enum([
+    "String",
+    "Number",
+    "Integer",
+    "Boolean",
+    "RichText",
+    "Array",
+    "Record",
+    "TypeRef",
+    "Literal",
+    "DiscriminatedUnion"
+  ]),
+  id: z116.string().describe("Data type field identifier"),
+  name: z116.string().describe("Human-readable name"),
+  required: z116.boolean().optional()
+}).catchall(z116.unknown());
+var LegacyDataTypeArmSchema = z116.object({
+  id: z116.string().describe("Data type field identifier"),
+  name: z116.string().describe("Human-readable name"),
+  type: z116.string(),
+  required: z116.boolean().optional(),
+  source: z116.string().optional(),
+  ref: z116.unknown().optional()
+});
+var DataAssemblyDataTypeFieldSchema = z116.union([
+  CanonicalDataTypeArmSchema,
+  LegacyDataTypeArmSchema
+]);
+var SAME_SPACE_CONTENT_SOURCE = "crn:contentful:::content:spaces/$self/environments/$self";
+var DataAssemblyResourceLinkParameterSchema = z116.object({
+  name: z116.string().optional(),
+  description: z116.string().optional(),
+  type: z116.literal("ResourceLink"),
+  linkType: z116.literal("Contentful:Entry"),
+  allowedResources: z116.array(
+    z116.object({
+      type: z116.literal("Contentful:Entry"),
+      source: z116.literal(SAME_SPACE_CONTENT_SOURCE),
+      allowedTypes: z116.array(z116.string())
+    })
+  )
+});
+var DataAssemblyParameterConfigSchema = z116.record(
+  z116.string(),
+  DataAssemblyResourceLinkParameterSchema
+);
+var DataAssemblyGraphQLResolverSchema = z116.object({
+  source: z116.literal("Contentful:GraphQL"),
+  query: z116.string().describe("GraphQL query string"),
+  parameters: PointerExpressionValueSchema.optional()
+});
+var DataAssemblyNestedResolverSchema = z116.object({
+  source: z116.literal("Contentful:DataAssembly"),
+  dataAssembly: z116.object({
+    sys: z116.object({
+      type: z116.literal("ResourceLink"),
+      linkType: z116.literal("Contentful:DataAssembly"),
+      urn: z116.string()
+    })
+  }),
+  parameters: PointerExpressionValueSchema.optional()
+});
+var DataAssemblyResolverDefinitionSchema = z116.union([
+  DataAssemblyGraphQLResolverSchema,
+  DataAssemblyNestedResolverSchema
+]);
+var DataAssemblyResolverConfigSchema = z116.record(
+  z116.string(),
+  DataAssemblyResolverDefinitionSchema
+);
+var DataAssemblyReturnMappingConfigSchema = PointerExpressionValueSchema;
+var DataAssemblyMetadataSchema = z116.object({
+  tags: z116.array(
+    z116.object({
+      sys: z116.object({
+        type: z116.literal("Link"),
+        linkType: z116.literal("Tag"),
+        id: z116.string()
+      })
+    })
+  )
+});
+
+// src/tools/exo/data-assemblies/createDataAssembly.ts
+var CreateDataAssemblyToolParams = BaseToolSchema.extend({
+  name: z117.string().describe("The name of the data assembly"),
+  description: z117.string().describe("Description of the data assembly"),
+  parameters: DataAssemblyParameterConfigSchema.describe(
+    "Parameter definitions keyed by parameter name (may be empty object)"
+  ),
+  resolvers: DataAssemblyResolverConfigSchema.describe(
+    "Resolver definitions keyed by resolver name (may be empty object)"
+  ),
+  return: DataAssemblyReturnMappingConfigSchema.describe(
+    "Return mapping configuration specifying how to map resolved data"
+  ),
+  dataType: z117.array(DataAssemblyDataTypeFieldSchema).describe("Data type field definitions for this data assembly (may be empty array)"),
+  variant: z117.string().optional().describe("Optional variant identifier for this data assembly"),
+  metadata: DataAssemblyMetadataSchema.optional().describe("Optional metadata (tags)")
+});
+function createDataAssemblyTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const contentfulClient = createToolClient(config, args);
+    const dataAssembly = await contentfulClient.dataAssembly.create(
+      { spaceId: args.spaceId, environmentId: args.environmentId },
+      {
+        sys: {
+          type: "DataAssembly",
+          dataType: args.dataType,
+          ...args.variant && { variant: args.variant }
+        },
+        name: args.name,
+        description: args.description,
+        parameters: args.parameters,
+        resolvers: args.resolvers,
+        return: args.return,
+        metadata: args.metadata ?? { tags: [] }
+      }
+    );
+    return createSuccessResponse("Data assembly created successfully", {
+      dataAssembly
+    });
+  }
+  return withErrorHandling(tool2, "Error creating data assembly");
+}
+
+// src/tools/exo/data-assemblies/updateDataAssembly.ts
+import { z as z118 } from "zod";
+var UpdateDataAssemblyToolParams = BaseToolSchema.extend({
+  dataAssemblyId: z118.string().describe("The ID of the data assembly to update"),
+  version: z118.number().describe(
+    "REQUIRED. The data assembly's sys.version as returned by get_data_assembly. You must call get_data_assembly first to read the current state and version. The update is rejected if this does not match the current version, which means the data assembly changed since you read it."
+  ),
+  name: z118.string().optional().describe("The name of the data assembly"),
+  description: z118.string().optional().describe("Description of the data assembly"),
+  parameters: DataAssemblyParameterConfigSchema.optional().describe(
+    "Parameter definitions; replaces existing if provided"
+  ),
+  resolvers: DataAssemblyResolverConfigSchema.optional().describe(
+    "Resolver definitions; replaces existing if provided"
+  ),
+  return: DataAssemblyReturnMappingConfigSchema.optional().describe(
+    "Return mapping configuration; replaces existing if provided"
+  ),
+  dataType: z118.array(DataAssemblyDataTypeFieldSchema).optional().describe("Data type field definitions; replaces existing if provided"),
+  variant: z118.string().optional().describe("Optional variant identifier; replaces existing if provided"),
+  metadata: DataAssemblyMetadataSchema.optional().describe(
+    "Metadata (tags); replaces existing if provided"
+  )
+});
+function updateDataAssemblyTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      dataAssemblyId: args.dataAssemblyId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.dataAssembly.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the data assembly has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the data assembly with get_data_assembly and retry the update with the latest sys.version.`
+      );
+    }
+    const dataAssembly = await contentfulClient.dataAssembly.update(params, {
+      sys: {
+        id: current.sys.id,
+        type: "DataAssembly",
+        version: current.sys.version,
+        dataType: args.dataType ?? current.sys.dataType,
+        ...args.variant !== void 0 ? { variant: args.variant } : current.sys.variant !== void 0 ? { variant: current.sys.variant } : {}
+      },
+      name: args.name ?? current.name,
+      description: args.description ?? current.description,
+      parameters: args.parameters ?? current.parameters,
+      resolvers: args.resolvers ?? current.resolvers,
+      return: args.return ?? current.return,
+      metadata: args.metadata ?? current.metadata
+    });
+    return createSuccessResponse("Data assembly updated successfully", {
+      dataAssembly
+    });
+  }
+  return withErrorHandling(tool2, "Error updating data assembly");
+}
+
+// src/tools/exo/data-assemblies/deleteDataAssembly.ts
+import { z as z119 } from "zod";
+var DeleteDataAssemblyToolParams = BaseToolSchema.extend({
+  dataAssemblyId: z119.string().describe("The ID of the data assembly to delete"),
+  confirm: z119.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z119.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
+});
+function deleteDataAssemblyTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      dataAssemblyId: args.dataAssemblyId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const dataAssembly = await contentfulClient.dataAssembly.get(params);
+    const expectedToken = buildConfirmToken(
+      "dataAssembly",
+      args.dataAssemblyId,
+      dataAssembly.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} data assembly`,
+        buildConfirmationPreview(
+          "dataAssembly",
+          args.dataAssemblyId,
+          { dataAssembly },
+          expectedToken
+        )
+      );
+    }
+    await contentfulClient.dataAssembly.delete(params);
+    return createSuccessResponse("Data assembly deleted successfully", {
+      dataAssemblyId: args.dataAssemblyId
+    });
+  }
+  return withErrorHandling(tool2, "Error deleting data assembly");
+}
+
+// src/tools/exo/data-assemblies/publishDataAssembly.ts
+import { z as z120 } from "zod";
+var PublishDataAssemblyToolParams = BaseToolSchema.extend({
+  dataAssemblyId: z120.string().describe("The ID of the data assembly to publish"),
+  version: z120.number().describe(
+    "REQUIRED. The data assembly's sys.version as returned by get_data_assembly. You must call get_data_assembly first to read the current state and version. The publish is rejected if this does not match the current version, which means the data assembly changed since you read it."
+  )
+});
+function publishDataAssemblyTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      dataAssemblyId: args.dataAssemblyId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.dataAssembly.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the data assembly has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the data assembly with get_data_assembly and retry with the latest sys.version.`
+      );
+    }
+    const dataAssembly = await contentfulClient.dataAssembly.publish({
+      ...params,
+      version: args.version
+    });
+    return createSuccessResponse("Data assembly published successfully", {
+      dataAssembly
+    });
+  }
+  return withErrorHandling(tool2, "Error publishing data assembly");
+}
+
+// src/tools/exo/data-assemblies/unpublishDataAssembly.ts
+import { z as z121 } from "zod";
+var UnpublishDataAssemblyToolParams = BaseToolSchema.extend({
+  dataAssemblyId: z121.string().describe("The ID of the data assembly to unpublish"),
+  version: z121.number().describe(
+    "REQUIRED. The data assembly's sys.version as returned by get_data_assembly. You must call get_data_assembly first to read the current state and version. The unpublish is rejected if this does not match the current version, which means the data assembly changed since you read it."
+  )
+});
+function unpublishDataAssemblyTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      dataAssemblyId: args.dataAssemblyId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.dataAssembly.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the data assembly has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the data assembly with get_data_assembly and retry with the latest sys.version.`
+      );
+    }
+    const dataAssembly = await contentfulClient.dataAssembly.unpublish({
+      ...params,
+      version: args.version
+    });
+    return createSuccessResponse("Data assembly unpublished successfully", {
+      dataAssembly
+    });
+  }
+  return withErrorHandling(tool2, "Error unpublishing data assembly");
+}
+
+// src/tools/exo/data-assemblies/register.ts
+function createDataAssemblyTools(config) {
+  const getDataAssembly = getDataAssemblyTool(config);
+  const getPublishedDataAssembly = getPublishedDataAssemblyTool(config);
+  const listDataAssemblies = listDataAssembliesTool(config);
+  const listPublishedDataAssemblies = listPublishedDataAssembliesTool(config);
+  const createDataAssembly = createDataAssemblyTool(config);
+  const updateDataAssembly = updateDataAssemblyTool(config);
+  const deleteDataAssembly = deleteDataAssemblyTool(config);
+  const publishDataAssembly = publishDataAssemblyTool(config);
+  const unpublishDataAssembly = unpublishDataAssemblyTool(config);
+  return {
+    getDataAssembly: {
+      title: "get_data_assembly",
+      description: "Get details about a specific ExO DataAssembly (a smart data recipe that specifies how to fetch and reshape data for a component or page in a single operation).",
+      inputParams: GetDataAssemblyToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: getDataAssembly
+    },
+    getPublishedDataAssembly: {
+      title: "get_published_data_assembly",
+      description: "Get details about a specific published ExO DataAssembly by ID.",
+      inputParams: GetPublishedDataAssemblyToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: getPublishedDataAssembly
+    },
+    listDataAssemblies: {
+      title: "list_data_assemblies",
+      description: "List ExO DataAssemblies in a space and environment. Returns a maximum of 10 items per request; use the pageNext cursor (returned in pages.next) to paginate.",
+      inputParams: ListDataAssembliesToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: listDataAssemblies
+    },
+    listPublishedDataAssemblies: {
+      title: "list_published_data_assemblies",
+      description: "List published ExO DataAssemblies in a space and environment. Returns a maximum of 10 items per request; use the pageNext cursor (returned in pages.next) to paginate.",
+      inputParams: ListPublishedDataAssembliesToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: listPublishedDataAssemblies
+    },
+    createDataAssembly: {
+      title: "create_data_assembly",
+      description: "Create a new ExO DataAssembly.",
+      inputParams: CreateDataAssemblyToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: createDataAssembly
+    },
+    updateDataAssembly: {
+      title: "update_data_assembly",
+      description: "Update an existing ExO DataAssembly. You MUST call get_data_assembly first to read the current state, then pass the sys.version you received as the version parameter. The handler merges your updates with the existing data assembly fields, so you only need to provide the fields you want to change. If the version is stale (the data assembly changed since you read it), the update is rejected and you must re-fetch with get_data_assembly.",
+      inputParams: UpdateDataAssemblyToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: updateDataAssembly
+    },
+    deleteDataAssembly: {
+      title: "delete_data_assembly",
+      description: "Delete an ExO DataAssembly. Two-phase: the first call (without confirm/confirmToken) returns a preview and a confirmToken. To complete the deletion, call again with the same dataAssemblyId, confirm: true, and the confirmToken from the preview.",
+      inputParams: DeleteDataAssemblyToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: deleteDataAssembly
+    },
+    publishDataAssembly: {
+      title: "publish_data_assembly",
+      description: "Publish an ExO DataAssembly. You MUST call get_data_assembly first and pass the returned sys.version as the version parameter. If the version is stale the operation is rejected and you must re-fetch with get_data_assembly.",
+      inputParams: PublishDataAssemblyToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      tool: publishDataAssembly
+    },
+    unpublishDataAssembly: {
+      title: "unpublish_data_assembly",
+      description: "Unpublish an ExO DataAssembly. You MUST call get_data_assembly first and pass the returned sys.version as the version parameter. If the version is stale the operation is rejected and you must re-fetch with get_data_assembly.",
+      inputParams: UnpublishDataAssemblyToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      tool: unpublishDataAssembly
+    }
+  };
+}
+
+// src/ContentfulMcpTools.ts
+var ContentfulMcpTools = class {
+  config;
+  constructor(config) {
+    this.config = {
+      ...config,
+      host: config.host ?? "api.contentful.com",
+      environmentId: config.environmentId ?? "master"
+    };
+  }
+  /**
+   * Update the configuration after initialization
+   *
+   * @param updates - Partial configuration to merge with existing config
+   */
+  updateConfig(updates) {
+    this.config = { ...this.config, ...updates };
+  }
+  /**
+   * Get AI action tools
+   */
+  getAiActionTools() {
+    return createAiActionTools(this.config);
+  }
+  /**
+   * Get asset tools
+   */
+  getAssetTools() {
+    return createAssetTools(this.config);
+  }
+  /**
+   * Get content type tools
+   */
+  getContentTypeTools() {
+    return createContentTypeTools(this.config);
+  }
+  /**
+   * Get ExO component tools
+   */
+  getComponentTools() {
+    return createComponentTools(this.config);
+  }
+  /**
+   * Get ExO experience template tools
+   */
+  getExperienceTemplateTools() {
+    return createExperienceTemplateTools(this.config);
+  }
+  /**
+   * Get ExO experience tools
+   */
+  getExperienceTools() {
+    return createExperienceTools(this.config);
+  }
+  /**
+   * Get context tools
+   */
+  getContextTools() {
+    return createContextTools(this.config);
+  }
+  /**
+   * Get editor interface tools
+   */
+  getEditorInterfaceTools() {
+    return createEditorInterfaceTools(this.config);
+  }
+  /**
+   * Get entry tools
+   */
+  getEntryTools() {
+    return createEntryTools(this.config);
+  }
+  /**
+   * Get environment tools
+   */
+  getEnvironmentTools() {
+    return createEnvironmentTools(this.config);
+  }
+  /**
+   * Get locale tools
+   */
+  getLocaleTools() {
+    return createLocaleTools(this.config);
+  }
+  /**
+   * Get organization tools
+   */
+  getOrgTools() {
+    return createOrgTools(this.config);
+  }
+  /**
+   * Get space tools
+   */
+  getSpaceTools() {
+    return createSpaceTools(this.config);
+  }
+  /**
    * Get tag tools
    */
   getTagTools() {
@@ -5876,6 +8197,18 @@ var ContentfulMcpTools = class {
   getTaxonomyTools() {
     return createTaxonomyTools(this.config);
   }
+  /**
+   * Get ExO experience fragment tools
+   */
+  getExperienceFragmentTools() {
+    return createExperienceFragmentTools(this.config);
+  }
+  /**
+   * Get ExO data assembly tools
+   */
+  getDataAssemblyTools() {
+    return createDataAssemblyTools(this.config);
+  }
   /**
    * Get job tools (space-to-space migration)
    */
@@ -5883,6 +8216,44 @@ var ContentfulMcpTools = class {
     return createJobTools(this.config);
   }
 };
+
+// src/utils/entitlements.ts
+import { createClient as createClient16 } from "contentful-management";
+var EXO_M1_FEATURE = "exoM1";
+function createPlainClient(config) {
+  return createClient16(createClientConfig(config), { type: "plain" });
+}
+async function orgHasExoM1(client, organizationId) {
+  try {
+    const entitlements = await client.raw.get(
+      `/organizations/${organizationId}/organization_entitlement_set`
+    );
+    return entitlements.features?.[EXO_M1_FEATURE]?.value === true;
+  } catch {
+    return false;
+  }
+}
+async function hasExoM1Entitlement(config) {
+  try {
+    const client = createPlainClient(config);
+    const orgs = await client.organization.getAll();
+    if (!orgs.items.length) {
+      return false;
+    }
+    const results = await Promise.all(
+      orgs.items.map((org) => orgHasExoM1(client, org.sys.id))
+    );
+    return results.some(Boolean);
+  } catch {
+    return false;
+  }
+}
 export {
-  ContentfulMcpTools
+  CONVENTIONS_GUIDANCE,
+  CORE_INVARIANTS,
+  ContentfulMcpTools,
+  EXO_DISPOSITION,
+  EXO_M1_FEATURE,
+  SEARCHING_GUIDANCE,
+  hasExoM1Entitlement
 };