@contentful/mcp-tools 0.12.2 → 0.12.3-next.1

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",
+  componentType: "component type",
+  experience: "experience",
+  fragment: "fragment",
+  template: "template",
+  dataAssembly: "data assembly"
 };
 function buildConfirmationPreview(resource, id, details, confirmToken) {
   const displayName = RESOURCE_DISPLAY_NAME[resource];
@@ -2303,141 +2308,59 @@ 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
+
+- **Content-type first.** Before finding or editing content, call \`list_content_types\` to see what content types exist, and \`get_content_type\` to inspect a type's fields. This prevents failed queries and reveals the right type (e.g. a \`pricingPage\` type when asked about pricing).
+- **Edit safely.** To modify an entry, call \`get_entry\` first, then pass the returned \`sys.version\` to \`update_entry\`. The version is required and prevents overwriting concurrent changes.
+- **Bulk cap.** The bulk operations \`publish_entry\`, \`unpublish_entry\`, \`archive_entry\`, and \`unarchive_entry\` accept at most 10 IDs per call by default. This cap does not apply to creating or updating entries.
+- **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
+
+- **Content-type first.** When users ask about specific content ("pricing page", "blog posts"), call \`list_content_types\` / \`get_content_type\` to discover the correct type before searching. This prevents wasted queries on wrong field names.
+- **Then search.** Use \`search_entries\` with the correct content type and field names. Use \`semantic_search\` when the user's 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 like "blog posts by Magnus", first inspect the content type to confirm the reference field, then query for the referenced entry (the author) to get its ID, then query the primary content filtering on that ID. If several entities 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: prefer Experience Orchestration
+
+Experience Orchestration (ExO) tools are enabled. Prefer ExO primitives \u2014 Component Types, Experiences, Templates \u2014 over classic content types and entries, unless the user explicitly asks for classic content types or entries instead.`;
 
 // 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}
 
-    This is the initial context for your Contentful instance:
+      ${CORE_INVARIANTS}
 
-    <context>
-      ${configInfo}
-    </content>
+      ${SEARCHING_GUIDANCE}
 
-    <todaysDate>${todaysDate}</todaysDate>
-  `;
+      ${CONVENTIONS_GUIDANCE}
+    ` + exoBlock;
     contextStore.setInitialContextLoaded();
     return {
       content: [
@@ -5679,88 +5602,2464 @@ 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);
-  }
-  /**
-   * Get context tools
-   */
-  getContextTools() {
-    return createContextTools(this.config);
+// src/tools/exo/component-types/getComponentType.ts
+import { z as z82 } from "zod";
+var GetComponentTypeToolParams = BaseToolSchema.extend({
+  componentTypeId: z82.string().describe("The ID of the component type to retrieve details for")
+});
+function getComponentTypeTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const componentType = await contentfulClient.componentType.get({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      componentTypeId: args.componentTypeId
+    });
+    return createSuccessResponse("Component type retrieved successfully", {
+      componentType
+    });
   }
-  /**
-   * Get editor interface tools
-   */
-  getEditorInterfaceTools() {
-    return createEditorInterfaceTools(this.config);
+  return withErrorHandling(tool2, "Error retrieving component type");
+}
+
+// src/tools/exo/component-types/listComponentTypes.ts
+import { z as z83 } from "zod";
+var ListComponentTypesToolParams = BaseToolSchema.extend({
+  limit: z83.number().optional().describe("Maximum number of component types to return (max 10)"),
+  pageNext: z83.string().optional().describe("Cursor token to fetch the next page of results"),
+  pagePrev: z83.string().optional().describe("Cursor token to fetch the previous page of results"),
+  order: z83.string().optional().describe("Order component types by this field (e.g. sys.createdAt)")
+});
+function listComponentTypesTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const componentTypes = await contentfulClient.componentType.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(componentTypes, {
+      maxItems: 10,
+      remainingMessage: "To see more component types, ask me to retrieve the next page using the pageNext cursor."
+    });
+    return createSuccessResponse("Component types retrieved successfully", {
+      componentTypes: summarized,
+      total: componentTypes.total,
+      limit: componentTypes.limit,
+      pages: componentTypes.pages
+    });
   }
-  /**
-   * Get entry tools
-   */
-  getEntryTools() {
-    return createEntryTools(this.config);
+  return withErrorHandling(tool2, "Error listing component types");
+}
+
+// src/tools/exo/component-types/createComponentType.ts
+import { z as z85 } from "zod";
+
+// src/types/componentTypeSchemas.ts
+import { z as z84 } from "zod";
+var URN_EXAMPLES = {
+  "Contentful:ComponentType": "crn:contentful:::experience:spaces/{spaceId}/environments/{envId}/componentTypes/{id}",
+  "Contentful:Fragment": "crn:contentful:::experience:spaces/{spaceId}/environments/{envId}/fragments/{id}",
+  "Contentful:Template": "crn:contentful:::experience:spaces/{spaceId}/environments/{envId}/templates/{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 z84.object({
+    sys: z84.object({
+      type: z84.literal("ResourceLink"),
+      linkType: z84.literal(linkType),
+      urn: z84.string().describe(urnDesc)
+    })
+  });
+};
+var linkSchema2 = (linkType) => z84.object({
+  sys: z84.object({
+    type: z84.literal("Link"),
+    linkType: z84.literal(linkType),
+    id: z84.string()
+  })
+});
+var ComponentTypeResourceLinkSchema = resourceLinkSchema2("Contentful:ComponentType");
+var FragmentResourceLinkSchema = resourceLinkSchema2("Contentful:Fragment");
+var ViewportSchema = z84.object({
+  id: z84.string().describe("Viewport identifier"),
+  query: z84.string().describe("CSS media query string"),
+  displayName: z84.string().describe("Human-readable viewport name"),
+  previewSize: z84.string().describe('Preview size (e.g. "1024px")')
+});
+var DataTypeDefinitionSchema = z84.lazy(
+  () => z84.discriminatedUnion("type", [
+    z84.object({
+      type: z84.enum(["String", "Number", "Integer", "Boolean"]),
+      name: z84.string().optional(),
+      required: z84.boolean().optional()
+    }),
+    z84.object({
+      type: z84.literal("RichText"),
+      name: z84.string().optional(),
+      required: z84.boolean().optional()
+    }),
+    z84.object({
+      type: z84.literal("Array"),
+      name: z84.string().optional(),
+      required: z84.boolean().optional(),
+      items: DataTypeDefinitionSchema
+    }),
+    z84.object({
+      type: z84.literal("Record"),
+      name: z84.string().optional(),
+      required: z84.boolean().optional(),
+      fields: z84.record(z84.string(), DataTypeDefinitionSchema)
+    }),
+    z84.object({
+      type: z84.literal("TypeRef"),
+      name: z84.string().optional(),
+      required: z84.boolean().optional(),
+      ref: z84.object({
+        sys: z84.object({
+          type: z84.literal("ResourceLink"),
+          linkType: z84.string(),
+          urn: z84.string()
+        })
+      })
+    }),
+    z84.object({
+      type: z84.literal("Literal"),
+      name: z84.string().optional(),
+      required: z84.boolean().optional(),
+      value: z84.custom().describe("JSON literal value"),
+      valueType: DataTypeDefinitionSchema
+    }),
+    z84.object({
+      type: z84.literal("DiscriminatedUnion"),
+      name: z84.string().optional(),
+      required: z84.boolean().optional(),
+      discriminator: z84.string(),
+      members: z84.array(DataTypeDefinitionSchema)
+    })
+  ])
+);
+var ContentPropertySchema = z84.intersection(
+  DataTypeDefinitionSchema,
+  z84.object({
+    id: z84.string().describe("Content property identifier"),
+    name: z84.string().describe("Human-readable name"),
+    required: z84.boolean().describe("Whether the property is required"),
+    defaultValue: z84.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 = z84.object({
+  id: z84.string().describe("Design property identifier"),
+  name: z84.string().describe("Human-readable name"),
+  description: z84.string().optional().describe("Optional description")
+});
+var StringDesignPropertySchema = DesignPropertyCommonFieldsSchema.extend({
+  type: z84.literal("String"),
+  fallbackValue: z84.object({
+    type: z84.literal("ManualDesignValue"),
+    value: z84.string()
+  }).optional().describe("Manual fallback value for this design property"),
+  validations: z84.array(
+    z84.object({
+      regexp: z84.object({
+        pattern: z84.string().describe("Regular expression pattern")
+      })
+    })
+  ).optional().describe("Regexp validations constraining allowed string values")
+});
+var BooleanDesignPropertySchema = DesignPropertyCommonFieldsSchema.extend({
+  type: z84.literal("Boolean"),
+  fallbackValue: z84.object({
+    type: z84.literal("ManualDesignValue"),
+    value: z84.boolean()
+  }).optional().describe("Manual fallback value for this design property")
+});
+var DesignTokenValueSchema = z84.object({
+  type: z84.literal("DesignToken"),
+  value: z84.string().min(1).describe("Design token reference (non-empty)")
+});
+var TokenBackedDesignPropertySchema = DesignPropertyCommonFieldsSchema.extend({
+  type: z84.enum(DTCG_DESIGN_PROPERTY_TYPES),
+  fallbackValue: DesignTokenValueSchema.optional().describe(
+    "Design-token-backed fallback value for this design property"
+  ),
+  allowedResources: z84.array(
+    z84.object({
+      type: z84.literal("DesignToken"),
+      value: z84.string(),
+      name: z84.string().optional()
+    })
+  ).optional().describe("Allowed design token resources")
+});
+var DesignPropertySchema = z84.union([
+  StringDesignPropertySchema,
+  BooleanDesignPropertySchema,
+  TokenBackedDesignPropertySchema
+]);
+var ManualDesignValueSchema = z84.object({
+  type: z84.literal("ManualDesignValue"),
+  value: z84.union([z84.string(), z84.number(), z84.boolean()])
+});
+var DesignPropertyValueSchema = z84.union([
+  ManualDesignValueSchema,
+  DesignTokenValueSchema
+]);
+var DesignPropertyPointerValueSchema = z84.custom(
+  (val) => typeof val === "string" && /^\$designProperties\//.test(val),
+  { message: 'Must be a "$designProperties/..." pointer' }
+);
+var DimensionedDesignPropertyValueSchema = z84.record(
+  z84.string(),
+  DesignPropertyValueSchema
+);
+var ComponentTreeDesignPropertyValueSchema = z84.union([
+  DesignPropertyValueSchema,
+  DesignPropertyPointerValueSchema,
+  DimensionedDesignPropertyValueSchema
+]);
+var COMPONENT_TYPE_ALLOWED_RESOURCE_SOURCE = "crn:contentful:::experience:spaces/$self/environments/$self";
+var SlotDefinitionSchema = z84.object({
+  id: z84.string().describe("Slot identifier"),
+  name: z84.string().describe("Human-readable name"),
+  required: z84.boolean().describe("Whether the slot must be filled"),
+  validations: z84.array(
+    z84.object({
+      size: z84.object({
+        min: z84.number().optional(),
+        max: z84.number().optional()
+      }).optional()
+    })
+  ).describe("Slot cardinality validations"),
+  allowedResources: z84.array(
+    z84.object({
+      type: z84.literal("Contentful:ComponentType"),
+      source: z84.literal(COMPONENT_TYPE_ALLOWED_RESOURCE_SOURCE),
+      allowedTypes: z84.array(z84.string()).describe("IDs of component types allowed in this slot")
+    })
+  ).optional().describe("Constrains which component types may be placed in this slot")
+});
+var FragmentNodeSchema = z84.object({
+  id: z84.string().describe("Node identifier"),
+  name: z84.string().optional().describe("Optional display name"),
+  nodeType: z84.literal("Fragment").describe('Must be "Fragment"'),
+  fragment: FragmentResourceLinkSchema.describe("Resource link to the referenced fragment")
+});
+var SlotNodeSchema = z84.object({
+  id: z84.string().describe("Node identifier"),
+  nodeType: z84.literal("Slot").describe('Must be "Slot"'),
+  slotId: z84.string().describe("ID of the slot definition to render")
+});
+var TreeNodeSchema = z84.lazy(
+  () => z84.union([ComponentNodeSchema, FragmentNodeSchema, SlotNodeSchema])
+);
+var ComponentNodeSchema = z84.lazy(
+  () => z84.object({
+    id: z84.string().describe("Node identifier"),
+    name: z84.string().optional().describe("Optional display name"),
+    nodeType: z84.literal("Component").describe('Must be "Component"'),
+    componentType: ComponentTypeResourceLinkSchema.describe(
+      "Resource link to the component type to render"
+    ),
+    contentProperties: z84.union([
+      z84.record(z84.string(), z84.unknown()),
+      z84.string().describe('"$contentProperties/..." pointer')
+    ]).describe(
+      'Content property bindings \u2014 values or "$contentProperties/..." pointers'
+    ),
+    designProperties: z84.record(z84.string(), ComponentTreeDesignPropertyValueSchema).describe(
+      'Design property values \u2014 ManualDesignValue, DesignTokenValue, or "$designProperties/..." pointers'
+    ),
+    slots: z84.record(z84.string(), z84.array(TreeNodeSchema)).describe("Child tree nodes keyed by slot ID")
+  })
+);
+var TagLinkSchema = linkSchema2("Tag");
+var ConceptLinkSchema = linkSchema2("TaxonomyConcept");
+var ExoMetadataSchema = z84.object({
+  tags: z84.array(TagLinkSchema).optional().describe("Tags attached to this entity"),
+  concepts: z84.array(ConceptLinkSchema).optional().describe("Taxonomy concepts attached to this entity")
+});
+var ExperienceMetadataSchema = ExoMetadataSchema.extend({
+  name: z84.string().optional().describe("Variant label for this metadata entry")
+});
+var DataAssemblyResourceLinkSchema = resourceLinkSchema2("Contentful:DataAssembly");
+var ExperienceContentBindingsSchema = z84.object({
+  sys: DataAssemblyResourceLinkSchema.shape.sys,
+  parameters: z84.record(
+    z84.string(),
+    z84.object({
+      sys: z84.object({
+        type: z84.literal("ResourceLink"),
+        linkType: z84.string(),
+        urn: z84.string()
+      })
+    })
+  ).describe("Parameter bindings keyed by parameter ID")
+});
+var InlineFragmentNodeSchema = z84.lazy(
+  () => z84.object({
+    id: z84.string().describe("Node identifier"),
+    nodeType: z84.literal("InlineFragment").describe('Must be "InlineFragment"'),
+    componentType: ComponentTypeResourceLinkSchema.describe(
+      "Resource link to the component type this inline fragment renders"
+    ),
+    designProperties: z84.record(z84.string(), DimensionedDesignPropertyValueSchema).describe("Design property values for this inline fragment"),
+    contentBindings: ExperienceContentBindingsSchema.optional().describe(
+      "Optional content bindings linking this inline fragment to a data assembly"
+    ),
+    slots: z84.record(z84.string(), z84.array(ExperienceSlotNodeSchema)).optional().describe("Child slot contents keyed by slot ID")
+  })
+);
+var ExperienceSlotNodeSchema = z84.lazy(
+  () => z84.union([FragmentNodeSchema, InlineFragmentNodeSchema])
+);
+
+// src/tools/exo/component-types/createComponentType.ts
+var CreateComponentTypeToolParams = BaseToolSchema.extend({
+  name: z85.string().describe("The name of the component type"),
+  description: z85.string().describe("Description of the component type"),
+  viewports: z85.array(ViewportSchema).describe("Viewport definitions for the component type (may be empty)"),
+  contentProperties: z85.array(ContentPropertySchema).describe("Content property definitions (may be empty)"),
+  designProperties: z85.array(DesignPropertySchema).describe("Design property definitions (may be empty)"),
+  componentTree: z85.array(TreeNodeSchema).optional().describe("Optional component tree node definitions"),
+  slots: z85.array(SlotDefinitionSchema).optional().describe("Optional slot definitions"),
+  metadata: ExoMetadataSchema.optional().describe(
+    "Optional ExO metadata (tags, concepts)"
+  )
+});
+function createComponentTypeTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const contentfulClient = createToolClient(config, args);
+    const componentType = await contentfulClient.componentType.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 type created successfully", {
+      componentType
+    });
   }
-  /**
-   * Get environment tools
-   */
-  getEnvironmentTools() {
-    return createEnvironmentTools(this.config);
+  return withErrorHandling(tool2, "Error creating component type");
+}
+
+// src/tools/exo/component-types/upsertComponentType.ts
+import { z as z86 } from "zod";
+var UpsertComponentTypeToolParams = BaseToolSchema.extend({
+  componentTypeId: z86.string().describe("The ID of the component type to update"),
+  version: z86.number().describe(
+    "REQUIRED. The component type's sys.version as returned by get_component_type. You must call get_component_type first to read the current state and version. The update is rejected if this does not match the current version, which means the component type changed since you read it."
+  ),
+  name: z86.string().optional().describe("The name of the component type"),
+  description: z86.string().optional().describe("Description of the component type"),
+  viewports: z86.array(ViewportSchema).optional().describe("Viewport definitions; replaces existing viewports if provided"),
+  contentProperties: z86.array(ContentPropertySchema).optional().describe("Content property definitions; replaces existing if provided"),
+  designProperties: z86.array(DesignPropertySchema).optional().describe("Design property definitions; replaces existing if provided"),
+  componentTree: z86.array(TreeNodeSchema).optional().describe("Component tree node definitions; replaces existing if provided"),
+  slots: z86.array(SlotDefinitionSchema).optional().describe("Slot definitions; replaces existing if provided"),
+  metadata: ExoMetadataSchema.optional().describe(
+    "ExO metadata (tags, concepts); replaces existing if provided"
+  )
+});
+function upsertComponentTypeTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      componentTypeId: args.componentTypeId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.componentType.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the component type has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the component type with get_component_type and retry the update with the latest sys.version.`
+      );
+    }
+    const componentType = await contentfulClient.componentType.upsert(params, {
+      sys: {
+        id: current.sys.id,
+        type: "ComponentType",
+        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 type updated successfully", {
+      componentType
+    });
   }
-  /**
-   * Get locale tools
-   */
-  getLocaleTools() {
-    return createLocaleTools(this.config);
+  return withErrorHandling(tool2, "Error updating component type");
+}
+
+// src/tools/exo/component-types/deleteComponentType.ts
+import { z as z87 } from "zod";
+var DeleteComponentTypeToolParams = BaseToolSchema.extend({
+  componentTypeId: z87.string().describe("The ID of the component type to delete"),
+  confirm: z87.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z87.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
+});
+function deleteComponentTypeTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      componentTypeId: args.componentTypeId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const componentType = await contentfulClient.componentType.get(params);
+    const expectedToken = buildConfirmToken(
+      "componentType",
+      args.componentTypeId,
+      componentType.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} component type`,
+        buildConfirmationPreview(
+          "componentType",
+          args.componentTypeId,
+          { componentType },
+          expectedToken
+        )
+      );
+    }
+    await contentfulClient.componentType.delete(params);
+    return createSuccessResponse("Component type deleted successfully", {
+      componentTypeId: args.componentTypeId
+    });
   }
-  /**
-   * Get organization tools
-   */
-  getOrgTools() {
-    return createOrgTools(this.config);
+  return withErrorHandling(tool2, "Error deleting component type");
+}
+
+// src/tools/exo/component-types/publishComponentType.ts
+import { z as z88 } from "zod";
+var PublishComponentTypeToolParams = BaseToolSchema.extend({
+  componentTypeId: z88.string().describe("The ID of the component type to publish"),
+  version: z88.number().describe(
+    "REQUIRED. The component type's sys.version as returned by get_component_type. You must call get_component_type first to read the current state and version. The publish is rejected if this does not match the current version, which means the component type changed since you read it."
+  )
+});
+function publishComponentTypeTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      componentTypeId: args.componentTypeId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.componentType.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the component type has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the component type with get_component_type and retry with the latest sys.version.`
+      );
+    }
+    const componentType = await contentfulClient.componentType.publish({
+      ...params,
+      version: args.version
+    });
+    return createSuccessResponse("Component type published successfully", {
+      componentType
+    });
   }
-  /**
-   * Get space tools
-   */
-  getSpaceTools() {
-    return createSpaceTools(this.config);
+  return withErrorHandling(tool2, "Error publishing component type");
+}
+
+// src/tools/exo/component-types/unpublishComponentType.ts
+import { z as z89 } from "zod";
+var UnpublishComponentTypeToolParams = BaseToolSchema.extend({
+  componentTypeId: z89.string().describe("The ID of the component type to unpublish"),
+  version: z89.number().describe(
+    "REQUIRED. The component type's sys.version as returned by get_component_type. You must call get_component_type first to read the current state and version. The unpublish is rejected if this does not match the current version, which means the component type changed since you read it."
+  )
+});
+function unpublishComponentTypeTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      componentTypeId: args.componentTypeId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.componentType.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the component type has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the component type with get_component_type and retry with the latest sys.version.`
+      );
+    }
+    const componentType = await contentfulClient.componentType.unpublish({
+      ...params,
+      version: args.version
+    });
+    return createSuccessResponse("Component type unpublished successfully", {
+      componentType
+    });
   }
-  /**
-   * Get tag tools
-   */
-  getTagTools() {
+  return withErrorHandling(tool2, "Error unpublishing component type");
+}
+
+// src/tools/exo/component-types/register.ts
+function createComponentTypeTools(config) {
+  const getComponentType = getComponentTypeTool(config);
+  const listComponentTypes = listComponentTypesTool(config);
+  const createComponentType = createComponentTypeTool(config);
+  const upsertComponentType = upsertComponentTypeTool(config);
+  const deleteComponentType = deleteComponentTypeTool(config);
+  const publishComponentType = publishComponentTypeTool(config);
+  const unpublishComponentType = unpublishComponentTypeTool(config);
+  return {
+    getComponentType: {
+      title: "get_component_type",
+      description: "Get details about a specific ExO component type (a reusable section/pattern template defining slots, content properties, and design properties).",
+      inputParams: GetComponentTypeToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: getComponentType
+    },
+    listComponentTypes: {
+      title: "list_component_types",
+      description: "List ExO component types in a space and environment. Returns a maximum of 10 items per request; use the pageNext cursor (returned in pages.next) to paginate.",
+      inputParams: ListComponentTypesToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: listComponentTypes
+    },
+    createComponentType: {
+      title: "create_component_type",
+      description: "Create a new ExO component type.",
+      inputParams: CreateComponentTypeToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: createComponentType
+    },
+    upsertComponentType: {
+      title: "upsert_component_type",
+      description: "Update an existing ExO component type. You MUST call get_component_type 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 type fields, so you only need to provide the fields you want to change. If the version is stale (the component type changed since you read it), the update is rejected and you must re-fetch with get_component_type.",
+      inputParams: UpsertComponentTypeToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: upsertComponentType
+    },
+    deleteComponentType: {
+      title: "delete_component_type",
+      description: "Delete an ExO component type. Two-phase: the first call (without confirm/confirmToken) returns a preview and a confirmToken. To complete the deletion, call again with the same componentTypeId, confirm: true, and the confirmToken from the preview.",
+      inputParams: DeleteComponentTypeToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: deleteComponentType
+    },
+    publishComponentType: {
+      title: "publish_component_type",
+      description: "Publish an ExO component type. You MUST call get_component_type 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_type.",
+      inputParams: PublishComponentTypeToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      tool: publishComponentType
+    },
+    unpublishComponentType: {
+      title: "unpublish_component_type",
+      description: "Unpublish an ExO component type. You MUST call get_component_type 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_type.",
+      inputParams: UnpublishComponentTypeToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      tool: unpublishComponentType
+    }
+  };
+}
+
+// src/tools/exo/fragments/getFragment.ts
+import { z as z90 } from "zod";
+var GetFragmentToolParams = BaseToolSchema.extend({
+  fragmentId: z90.string().describe("The ID of the fragment to retrieve details for")
+});
+function getFragmentTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const fragment = await contentfulClient.fragment.get({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      fragmentId: args.fragmentId
+    });
+    return createSuccessResponse("Fragment retrieved successfully", {
+      fragment
+    });
+  }
+  return withErrorHandling(tool2, "Error retrieving fragment");
+}
+
+// src/tools/exo/fragments/listFragments.ts
+import { z as z91 } from "zod";
+var ListFragmentsToolParams = BaseToolSchema.extend({
+  limit: z91.number().optional().describe("Maximum number of fragments to return (max 10)"),
+  pageNext: z91.string().optional().describe("Cursor token to fetch the next page of results"),
+  pagePrev: z91.string().optional().describe("Cursor token to fetch the previous page of results"),
+  order: z91.string().optional().describe("Order fragments by this field (e.g. sys.createdAt)")
+});
+function listFragmentsTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const fragments = await contentfulClient.fragment.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(fragments, {
+      maxItems: 10,
+      remainingMessage: "To see more fragments, ask me to retrieve the next page using the pageNext cursor."
+    });
+    return createSuccessResponse("Fragments retrieved successfully", {
+      fragments: summarized,
+      total: fragments.total,
+      limit: fragments.limit,
+      pages: fragments.pages
+    });
+  }
+  return withErrorHandling(tool2, "Error listing fragments");
+}
+
+// src/tools/exo/fragments/createFragment.ts
+import { z as z92 } from "zod";
+var CreateFragmentToolParams = BaseToolSchema.extend({
+  name: z92.string().describe("The name of the fragment"),
+  description: z92.string().describe("Description of the fragment"),
+  componentType: ComponentTypeResourceLinkSchema.describe(
+    "Resource link to the component type this fragment is based on"
+  ),
+  viewports: z92.array(ViewportSchema).describe("Viewport definitions (may be empty)"),
+  designProperties: z92.record(z92.string(), DimensionedDesignPropertyValueSchema).describe("Design property values keyed by property ID (may be empty object)"),
+  contentBindings: ExperienceContentBindingsSchema.optional().describe(
+    "Optional content bindings for the fragment"
+  ),
+  slots: z92.record(z92.string(), z92.array(ExperienceSlotNodeSchema)).optional().describe("Optional slot node definitions keyed by slot ID"),
+  metadata: ExperienceMetadataSchema.optional().describe(
+    "Optional ExO metadata (tags, concepts)"
+  )
+});
+function createFragmentTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const contentfulClient = createToolClient(config, args);
+    const fragment = await contentfulClient.fragment.create(
+      { spaceId: args.spaceId, environmentId: args.environmentId },
+      {
+        name: args.name,
+        description: args.description,
+        componentType: args.componentType,
+        viewports: args.viewports,
+        designProperties: args.designProperties,
+        ...args.contentBindings && { contentBindings: args.contentBindings },
+        ...args.slots && { slots: args.slots },
+        ...args.metadata && { metadata: args.metadata }
+      }
+    );
+    return createSuccessResponse("Fragment created successfully", {
+      fragment
+    });
+  }
+  return withErrorHandling(tool2, "Error creating fragment");
+}
+
+// src/tools/exo/fragments/updateFragment.ts
+import { z as z93 } from "zod";
+var UpdateFragmentToolParams = BaseToolSchema.extend({
+  fragmentId: z93.string().describe("The ID of the fragment to update"),
+  version: z93.number().describe(
+    "REQUIRED. The fragment's sys.version as returned by get_fragment. You must call get_fragment first to read the current state and version. The update is rejected if this does not match the current version, which means the fragment changed since you read it."
+  ),
+  name: z93.string().optional().describe("The name of the fragment"),
+  description: z93.string().optional().describe("Description of the fragment"),
+  viewports: z93.array(ViewportSchema).optional().describe("Viewport definitions; replaces existing viewports if provided"),
+  designProperties: z93.record(z93.string(), DimensionedDesignPropertyValueSchema).optional().describe("Design property values; replaces existing if provided"),
+  contentBindings: ExperienceContentBindingsSchema.optional().describe(
+    "Content bindings; replaces existing if provided"
+  ),
+  slots: z93.record(z93.string(), z93.array(ExperienceSlotNodeSchema)).optional().describe("Slot node definitions; replaces existing if provided"),
+  metadata: ExperienceMetadataSchema.optional().describe(
+    "ExO metadata (tags, concepts); replaces existing if provided"
+  )
+});
+function updateFragmentTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      fragmentId: args.fragmentId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.fragment.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the fragment has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the fragment with get_fragment and retry the update with the latest sys.version.`
+      );
+    }
+    const fragment = await contentfulClient.fragment.upsert(params, {
+      sys: {
+        id: current.sys.id,
+        type: "Fragment",
+        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("Fragment updated successfully", {
+      fragment
+    });
+  }
+  return withErrorHandling(tool2, "Error updating fragment");
+}
+
+// src/tools/exo/fragments/deleteFragment.ts
+import { z as z94 } from "zod";
+var DeleteFragmentToolParams = BaseToolSchema.extend({
+  fragmentId: z94.string().describe("The ID of the fragment to delete"),
+  confirm: z94.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z94.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
+});
+function deleteFragmentTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      fragmentId: args.fragmentId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const fragment = await contentfulClient.fragment.get(params);
+    const expectedToken = buildConfirmToken(
+      "fragment",
+      args.fragmentId,
+      fragment.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} fragment`,
+        buildConfirmationPreview(
+          "fragment",
+          args.fragmentId,
+          { fragment },
+          expectedToken
+        )
+      );
+    }
+    await contentfulClient.fragment.delete(params);
+    return createSuccessResponse("Fragment deleted successfully", {
+      fragmentId: args.fragmentId
+    });
+  }
+  return withErrorHandling(tool2, "Error deleting fragment");
+}
+
+// src/tools/exo/fragments/publishFragment.ts
+import { z as z95 } from "zod";
+var PublishFragmentToolParams = BaseToolSchema.extend({
+  fragmentId: z95.string().describe("The ID of the fragment to publish"),
+  version: z95.number().describe(
+    "REQUIRED. The fragment's sys.version as returned by get_fragment. You must call get_fragment first to read the current state and version. The publish is rejected if this does not match the current version, which means the fragment changed since you read it."
+  )
+});
+function publishFragmentTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      fragmentId: args.fragmentId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.fragment.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the fragment has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the fragment with get_fragment and retry with the latest sys.version.`
+      );
+    }
+    const fragment = await contentfulClient.fragment.publish({
+      ...params,
+      version: args.version
+    });
+    return createSuccessResponse("Fragment published successfully", {
+      fragment
+    });
+  }
+  return withErrorHandling(tool2, "Error publishing fragment");
+}
+
+// src/tools/exo/fragments/unpublishFragment.ts
+import { z as z96 } from "zod";
+var UnpublishFragmentToolParams = BaseToolSchema.extend({
+  fragmentId: z96.string().describe("The ID of the fragment to unpublish"),
+  version: z96.number().describe(
+    "REQUIRED. The fragment's sys.version as returned by get_fragment. You must call get_fragment first to read the current state and version. The unpublish is rejected if this does not match the current version, which means the fragment changed since you read it."
+  )
+});
+function unpublishFragmentTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      fragmentId: args.fragmentId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.fragment.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the fragment has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the fragment with get_fragment and retry with the latest sys.version.`
+      );
+    }
+    const fragment = await contentfulClient.fragment.unpublish({
+      ...params,
+      version: args.version
+    });
+    return createSuccessResponse("Fragment unpublished successfully", {
+      fragment
+    });
+  }
+  return withErrorHandling(tool2, "Error unpublishing fragment");
+}
+
+// src/tools/exo/fragments/register.ts
+function createFragmentTools(config) {
+  const getFragment = getFragmentTool(config);
+  const listFragments = listFragmentsTool(config);
+  const createFragment = createFragmentTool(config);
+  const updateFragment = updateFragmentTool(config);
+  const deleteFragment = deleteFragmentTool(config);
+  const publishFragment = publishFragmentTool(config);
+  const unpublishFragment = unpublishFragmentTool(config);
+  return {
+    getFragment: {
+      title: "get_fragment",
+      description: "Get details about a specific ExO fragment (a reusable content unit that can be referenced across multiple Experiences and ComponentTypes).",
+      inputParams: GetFragmentToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: getFragment
+    },
+    listFragments: {
+      title: "list_fragments",
+      description: "List ExO 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: ListFragmentsToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: listFragments
+    },
+    createFragment: {
+      title: "create_fragment",
+      description: "Create a new ExO fragment.",
+      inputParams: CreateFragmentToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: createFragment
+    },
+    updateFragment: {
+      title: "update_fragment",
+      description: "Update an existing ExO fragment. You MUST call get_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 fragment fields, so you only need to provide the fields you want to change. If the version is stale (the fragment changed since you read it), the update is rejected and you must re-fetch with get_fragment.",
+      inputParams: UpdateFragmentToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: updateFragment
+    },
+    deleteFragment: {
+      title: "delete_fragment",
+      description: "Delete an ExO fragment. Two-phase: the first call (without confirm/confirmToken) returns a preview and a confirmToken. To complete the deletion, call again with the same fragmentId, confirm: true, and the confirmToken from the preview.",
+      inputParams: DeleteFragmentToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: deleteFragment
+    },
+    publishFragment: {
+      title: "publish_fragment",
+      description: "Publish an ExO fragment. You MUST call get_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_fragment.",
+      inputParams: PublishFragmentToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      tool: publishFragment
+    },
+    unpublishFragment: {
+      title: "unpublish_fragment",
+      description: "Unpublish an ExO fragment. You MUST call get_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_fragment.",
+      inputParams: UnpublishFragmentToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      tool: unpublishFragment
+    }
+  };
+}
+
+// src/tools/exo/templates/getTemplate.ts
+import { z as z97 } from "zod";
+var GetTemplateToolParams = BaseToolSchema.extend({
+  templateId: z97.string().describe("The ID of the template to retrieve details for")
+});
+function getTemplateTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const template = await contentfulClient.template.get({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      templateId: args.templateId
+    });
+    return createSuccessResponse("Template retrieved successfully", {
+      template
+    });
+  }
+  return withErrorHandling(tool2, "Error retrieving template");
+}
+
+// src/tools/exo/templates/listTemplates.ts
+import { z as z98 } from "zod";
+var ListTemplatesToolParams = BaseToolSchema.extend({
+  limit: z98.number().optional().describe("Maximum number of templates to return (max 10)"),
+  pageNext: z98.string().optional().describe("Cursor token to fetch the next page of results"),
+  pagePrev: z98.string().optional().describe("Cursor token to fetch the previous page of results"),
+  order: z98.string().optional().describe("Order templates by this field (e.g. sys.createdAt)")
+});
+function listTemplatesTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const templates = await contentfulClient.template.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(templates, {
+      maxItems: 10,
+      remainingMessage: "To see more templates, ask me to retrieve the next page using the pageNext cursor."
+    });
+    return createSuccessResponse("Templates retrieved successfully", {
+      templates: summarized,
+      total: templates.total,
+      limit: templates.limit,
+      pages: templates.pages
+    });
+  }
+  return withErrorHandling(tool2, "Error listing templates");
+}
+
+// src/tools/exo/templates/createTemplate.ts
+import { z as z99 } from "zod";
+var CreateTemplateToolParams = BaseToolSchema.extend({
+  name: z99.string().describe("The name of the template"),
+  description: z99.string().describe("Description of the template"),
+  viewports: z99.array(ViewportSchema).describe("Viewport definitions for the template (may be empty)"),
+  contentProperties: z99.array(ContentPropertySchema).describe("Content property definitions (may be empty)"),
+  designProperties: z99.array(DesignPropertySchema).describe("Design property definitions (may be empty)"),
+  componentTree: z99.array(TreeNodeSchema).optional().describe("Optional component tree node definitions"),
+  slots: z99.array(SlotDefinitionSchema).optional().describe("Optional slot definitions"),
+  metadata: ExoMetadataSchema.optional().describe(
+    "Optional ExO metadata (tags, concepts)"
+  )
+});
+function createTemplateTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const contentfulClient = createToolClient(config, args);
+    const template = await contentfulClient.template.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("Template created successfully", {
+      template
+    });
+  }
+  return withErrorHandling(tool2, "Error creating template");
+}
+
+// src/tools/exo/templates/upsertTemplate.ts
+import { z as z100 } from "zod";
+var UpsertTemplateToolParams = BaseToolSchema.extend({
+  templateId: z100.string().describe("The ID of the template to update"),
+  version: z100.number().describe(
+    "REQUIRED. The template's sys.version as returned by get_template. You must call get_template first to read the current state and version. The update is rejected if this does not match the current version, which means the template changed since you read it."
+  ),
+  name: z100.string().optional().describe("The name of the template"),
+  description: z100.string().optional().describe("Description of the template"),
+  viewports: z100.array(ViewportSchema).optional().describe("Viewport definitions; replaces existing viewports if provided"),
+  contentProperties: z100.array(ContentPropertySchema).optional().describe("Content property definitions; replaces existing if provided"),
+  designProperties: z100.array(DesignPropertySchema).optional().describe("Design property definitions; replaces existing if provided"),
+  componentTree: z100.array(TreeNodeSchema).optional().describe("Component tree node definitions; replaces existing if provided"),
+  slots: z100.array(SlotDefinitionSchema).optional().describe("Slot definitions; replaces existing if provided"),
+  metadata: ExoMetadataSchema.optional().describe(
+    "ExO metadata (tags, concepts); replaces existing if provided"
+  )
+});
+function upsertTemplateTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      templateId: args.templateId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.template.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the template has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the template with get_template and retry the update with the latest sys.version.`
+      );
+    }
+    const template = await contentfulClient.template.upsert(params, {
+      sys: {
+        id: current.sys.id,
+        type: "Template",
+        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("Template updated successfully", {
+      template
+    });
+  }
+  return withErrorHandling(tool2, "Error updating template");
+}
+
+// src/tools/exo/templates/deleteTemplate.ts
+import { z as z101 } from "zod";
+var DeleteTemplateToolParams = BaseToolSchema.extend({
+  templateId: z101.string().describe("The ID of the template to delete"),
+  confirm: z101.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z101.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
+});
+function deleteTemplateTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      templateId: args.templateId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const template = await contentfulClient.template.get(params);
+    const expectedToken = buildConfirmToken(
+      "template",
+      args.templateId,
+      template.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} template`,
+        buildConfirmationPreview(
+          "template",
+          args.templateId,
+          { template },
+          expectedToken
+        )
+      );
+    }
+    await contentfulClient.template.delete(params);
+    return createSuccessResponse("Template deleted successfully", {
+      templateId: args.templateId
+    });
+  }
+  return withErrorHandling(tool2, "Error deleting template");
+}
+
+// src/tools/exo/templates/publishTemplate.ts
+import { z as z102 } from "zod";
+var PublishTemplateToolParams = BaseToolSchema.extend({
+  templateId: z102.string().describe("The ID of the template to publish"),
+  version: z102.number().describe(
+    "REQUIRED. The template's sys.version as returned by get_template. You must call get_template first to read the current state and version. The publish is rejected if this does not match the current version, which means the template changed since you read it."
+  )
+});
+function publishTemplateTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      templateId: args.templateId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.template.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the template has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the template with get_template and retry with the latest sys.version.`
+      );
+    }
+    const template = await contentfulClient.template.publish({
+      ...params,
+      version: args.version
+    });
+    return createSuccessResponse("Template published successfully", {
+      template
+    });
+  }
+  return withErrorHandling(tool2, "Error publishing template");
+}
+
+// src/tools/exo/templates/unpublishTemplate.ts
+import { z as z103 } from "zod";
+var UnpublishTemplateToolParams = BaseToolSchema.extend({
+  templateId: z103.string().describe("The ID of the template to unpublish"),
+  version: z103.number().describe(
+    "REQUIRED. The template's sys.version as returned by get_template. You must call get_template first to read the current state and version. The unpublish is rejected if this does not match the current version, which means the template changed since you read it."
+  )
+});
+function unpublishTemplateTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const params = {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      templateId: args.templateId
+    };
+    const contentfulClient = createToolClient(config, args);
+    const current = await contentfulClient.template.get(params);
+    if (args.version !== current.sys.version) {
+      throw new Error(
+        `Version conflict: the template has changed since you read it (your version: ${args.version}, current version: ${current.sys.version}). Re-fetch the template with get_template and retry with the latest sys.version.`
+      );
+    }
+    const template = await contentfulClient.template.unpublish({
+      ...params,
+      version: args.version
+    });
+    return createSuccessResponse("Template unpublished successfully", {
+      template
+    });
+  }
+  return withErrorHandling(tool2, "Error unpublishing template");
+}
+
+// src/tools/exo/templates/register.ts
+function createTemplateTools(config) {
+  const getTemplate = getTemplateTool(config);
+  const listTemplates = listTemplatesTool(config);
+  const createTemplate = createTemplateTool(config);
+  const upsertTemplate = upsertTemplateTool(config);
+  const deleteTemplate = deleteTemplateTool(config);
+  const publishTemplate = publishTemplateTool(config);
+  const unpublishTemplate = unpublishTemplateTool(config);
+  return {
+    getTemplate: {
+      title: "get_template",
+      description: "Get details about a specific ExO template (a layout definition that backs template-based Experiences).",
+      inputParams: GetTemplateToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: getTemplate
+    },
+    listTemplates: {
+      title: "list_templates",
+      description: "List ExO 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: ListTemplatesToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: listTemplates
+    },
+    createTemplate: {
+      title: "create_template",
+      description: "Create a new ExO template.",
+      inputParams: CreateTemplateToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: createTemplate
+    },
+    upsertTemplate: {
+      title: "upsert_template",
+      description: "Update an existing ExO template. You MUST call get_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 template fields, so you only need to provide the fields you want to change. If the version is stale (the template changed since you read it), the update is rejected and you must re-fetch with get_template.",
+      inputParams: UpsertTemplateToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: upsertTemplate
+    },
+    deleteTemplate: {
+      title: "delete_template",
+      description: "Delete an ExO template. Two-phase: the first call (without confirm/confirmToken) returns a preview and a confirmToken. To complete the deletion, call again with the same templateId, confirm: true, and the confirmToken from the preview.",
+      inputParams: DeleteTemplateToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: deleteTemplate
+    },
+    publishTemplate: {
+      title: "publish_template",
+      description: "Publish an ExO template. You MUST call get_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_template.",
+      inputParams: PublishTemplateToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      tool: publishTemplate
+    },
+    unpublishTemplate: {
+      title: "unpublish_template",
+      description: "Unpublish an ExO template. You MUST call get_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_template.",
+      inputParams: UnpublishTemplateToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      tool: unpublishTemplate
+    }
+  };
+}
+
+// src/tools/exo/experiences/getExperience.ts
+import { z as z104 } from "zod";
+var GetExperienceToolParams = BaseToolSchema.extend({
+  experienceId: z104.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 z105 } from "zod";
+var ListExperiencesToolParams = BaseToolSchema.extend({
+  limit: z105.number().optional().describe("Maximum number of experiences to return (max 10)"),
+  pageNext: z105.string().optional().describe("Cursor token to fetch the next page of results"),
+  pagePrev: z105.string().optional().describe("Cursor token to fetch the previous page of results"),
+  order: z105.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 z106 } from "zod";
+var TemplateResourceLinkSchema = z106.object({
+  sys: z106.object({
+    type: z106.literal("ResourceLink"),
+    linkType: z106.literal("Contentful:Template"),
+    urn: z106.string().describe("URN of the linked resource")
+  })
+});
+var CreateExperienceToolParams = BaseToolSchema.extend({
+  name: z106.string().describe("The name of the experience"),
+  description: z106.string().describe("Description of the experience"),
+  template: TemplateResourceLinkSchema.describe(
+    "Resource link to the Template this experience is backed by"
+  ),
+  viewports: z106.array(ViewportSchema).describe("Viewport definitions for the experience (may be empty)"),
+  designProperties: z106.record(z106.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: z106.record(z106.string(), z106.array(ExperienceSlotNodeSchema)).optional().describe(
+    "Optional slot contents keyed by slot ID. Each value is an array of FragmentNode or InlineFragmentNode."
+  ),
+  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,
+        template: args.template,
+        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 z107 } from "zod";
+var UpsertExperienceToolParams = BaseToolSchema.extend({
+  experienceId: z107.string().describe("The ID of the experience to update"),
+  version: z107.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: z107.string().optional().describe("The name of the experience"),
+  description: z107.string().optional().describe("Description of the experience"),
+  viewports: z107.array(ViewportSchema).optional().describe("Viewport definitions; replaces existing viewports if provided"),
+  designProperties: z107.record(z107.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: z107.record(z107.string(), z107.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 z108 } from "zod";
+var DeleteExperienceToolParams = BaseToolSchema.extend({
+  experienceId: z108.string().describe("The ID of the experience to delete"),
+  confirm: z108.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z108.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 z109 } from "zod";
+var PublishExperienceToolParams = BaseToolSchema.extend({
+  experienceId: z109.string().describe("The ID of the experience to publish"),
+  version: z109.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 z110 } from "zod";
+var UnpublishExperienceToolParams = BaseToolSchema.extend({
+  experienceId: z110.string().describe("The ID of the experience to unpublish"),
+  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 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 ComponentType with content and design settings, backed by a Template).",
+      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 a Template.",
+      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 z111 } from "zod";
+var GetDataAssemblyToolParams = BaseToolSchema.extend({
+  dataAssemblyId: z111.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 z112 } from "zod";
+var GetPublishedDataAssemblyToolParams = BaseToolSchema.extend({
+  dataAssemblyId: z112.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 z113 } from "zod";
+var ListDataAssembliesToolParams = BaseToolSchema.extend({
+  limit: z113.number().optional().describe("Maximum number of data assemblies to return (max 10)"),
+  pageNext: z113.string().optional().describe("Cursor token to fetch the next page of results"),
+  pagePrev: z113.string().optional().describe("Cursor token to fetch the previous page of results"),
+  sysIdIn: z113.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 z114 } from "zod";
+var ListPublishedDataAssembliesToolParams = BaseToolSchema.extend({
+  limit: z114.number().optional().describe("Maximum number of published 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 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 z116 } from "zod";
+
+// src/types/dataAssemblySchemas.ts
+import { z as z115 } from "zod";
+var PointerExpressionValueSchema = z115.lazy(
+  () => z115.union([
+    z115.string(),
+    z115.object({
+      $from: z115.union([
+        z115.string(),
+        z115.object({
+          source: z115.string(),
+          select: PointerExpressionValueSchema.optional()
+        })
+      ])
+    }),
+    z115.object({ $literal: z115.custom() }),
+    z115.object({ $object: z115.record(z115.string(), PointerExpressionValueSchema) }),
+    z115.object({
+      $on: z115.object({
+        type: z115.record(z115.string(), PointerExpressionValueSchema),
+        default: PointerExpressionValueSchema.optional()
+      })
+    }),
+    z115.record(z115.string(), PointerExpressionValueSchema)
+  ])
+);
+var CanonicalDataTypeArmSchema = z115.object({
+  type: z115.enum([
+    "String",
+    "Number",
+    "Integer",
+    "Boolean",
+    "RichText",
+    "Array",
+    "Record",
+    "TypeRef",
+    "Literal",
+    "DiscriminatedUnion"
+  ]),
+  id: z115.string().describe("Data type field identifier"),
+  name: z115.string().describe("Human-readable name"),
+  required: z115.boolean().optional()
+}).catchall(z115.unknown());
+var LegacyDataTypeArmSchema = z115.object({
+  id: z115.string().describe("Data type field identifier"),
+  name: z115.string().describe("Human-readable name"),
+  type: z115.string(),
+  required: z115.boolean().optional(),
+  source: z115.string().optional(),
+  ref: z115.unknown().optional()
+});
+var DataAssemblyDataTypeFieldSchema = z115.union([
+  CanonicalDataTypeArmSchema,
+  LegacyDataTypeArmSchema
+]);
+var SAME_SPACE_CONTENT_SOURCE = "crn:contentful:::content:spaces/$self/environments/$self";
+var DataAssemblyResourceLinkParameterSchema = z115.object({
+  name: z115.string().optional(),
+  description: z115.string().optional(),
+  type: z115.literal("ResourceLink"),
+  linkType: z115.literal("Contentful:Entry"),
+  allowedResources: z115.array(
+    z115.object({
+      type: z115.literal("Contentful:Entry"),
+      source: z115.literal(SAME_SPACE_CONTENT_SOURCE),
+      allowedTypes: z115.array(z115.string())
+    })
+  )
+});
+var DataAssemblyParameterConfigSchema = z115.record(
+  z115.string(),
+  DataAssemblyResourceLinkParameterSchema
+);
+var DataAssemblyGraphQLResolverSchema = z115.object({
+  source: z115.literal("Contentful:GraphQL"),
+  query: z115.string().describe("GraphQL query string"),
+  parameters: PointerExpressionValueSchema.optional()
+});
+var DataAssemblyNestedResolverSchema = z115.object({
+  source: z115.literal("Contentful:DataAssembly"),
+  dataAssembly: z115.object({
+    sys: z115.object({
+      type: z115.literal("ResourceLink"),
+      linkType: z115.literal("Contentful:DataAssembly"),
+      urn: z115.string()
+    })
+  }),
+  parameters: PointerExpressionValueSchema.optional()
+});
+var DataAssemblyResolverDefinitionSchema = z115.union([
+  DataAssemblyGraphQLResolverSchema,
+  DataAssemblyNestedResolverSchema
+]);
+var DataAssemblyResolverConfigSchema = z115.record(
+  z115.string(),
+  DataAssemblyResolverDefinitionSchema
+);
+var DataAssemblyReturnMappingConfigSchema = PointerExpressionValueSchema;
+var DataAssemblyMetadataSchema = z115.object({
+  tags: z115.array(
+    z115.object({
+      sys: z115.object({
+        type: z115.literal("Link"),
+        linkType: z115.literal("Tag"),
+        id: z115.string()
+      })
+    })
+  )
+});
+
+// src/tools/exo/data-assemblies/createDataAssembly.ts
+var CreateDataAssemblyToolParams = BaseToolSchema.extend({
+  name: z116.string().describe("The name of the data assembly"),
+  description: z116.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: z116.array(DataAssemblyDataTypeFieldSchema).describe("Data type field definitions for this data assembly (may be empty array)"),
+  variant: z116.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 z117 } from "zod";
+var UpdateDataAssemblyToolParams = BaseToolSchema.extend({
+  dataAssemblyId: z117.string().describe("The ID of the data assembly to update"),
+  version: z117.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: z117.string().optional().describe("The name of the data assembly"),
+  description: z117.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: z117.array(DataAssemblyDataTypeFieldSchema).optional().describe("Data type field definitions; replaces existing if provided"),
+  variant: z117.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 z118 } from "zod";
+var DeleteDataAssemblyToolParams = BaseToolSchema.extend({
+  dataAssemblyId: z118.string().describe("The ID of the data assembly to delete"),
+  confirm: z118.boolean().optional().describe(
+    "Set to true on the second call to actually perform the deletion. Required together with confirmToken."
+  ),
+  confirmToken: z118.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 z119 } from "zod";
+var PublishDataAssemblyToolParams = BaseToolSchema.extend({
+  dataAssemblyId: z119.string().describe("The ID of the data assembly to publish"),
+  version: z119.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 z120 } from "zod";
+var UnpublishDataAssemblyToolParams = BaseToolSchema.extend({
+  dataAssemblyId: z120.string().describe("The ID of the data assembly to unpublish"),
+  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 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 type tools
+   */
+  getComponentTypeTools() {
+    return createComponentTypeTools(this.config);
+  }
+  /**
+   * Get ExO template tools
+   */
+  getTemplateTools() {
+    return createTemplateTools(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() {
     return createTagTools(this.config);
   }
   /**
@@ -5769,6 +8068,18 @@ var ContentfulMcpTools = class {
   getTaxonomyTools() {
     return createTaxonomyTools(this.config);
   }
+  /**
+   * Get ExO fragment tools
+   */
+  getFragmentTools() {
+    return createFragmentTools(this.config);
+  }
+  /**
+   * Get ExO data assembly tools
+   */
+  getDataAssemblyTools() {
+    return createDataAssemblyTools(this.config);
+  }
   /**
    * Get job tools (space-to-space migration)
    */