@contentful/mcp-tools 0.1.0-dev-20251118T1827-8c57ea9.0 → 0.1.0-dev-20251118T1840-2e759f9.0

package/dist/index.js

@@ -0,0 +1,4448 @@
+// src/tools/ai-actions/createAiAction.ts
+import { z as z5 } from "zod";
+
+// src/utils/formatters.ts
+import { XMLBuilder } from "fast-xml-parser";
+function formatResponse(message, object = {}) {
+  const formattedObject = {};
+  for (const [key, value] of Object.entries(object)) {
+    if (!value) continue;
+    formattedObject[key] = value;
+  }
+  const builder = new XMLBuilder({
+    format: true,
+    indentBy: "  ",
+    suppressEmptyNode: true,
+    ignoreAttributes: false,
+    processEntities: false
+  });
+  const contextString = builder.build(formattedObject);
+  return `${message}: 
+${contextString}
+`;
+}
+
+// src/utils/response.ts
+function createSuccessResponse(message, data) {
+  const text = data ? formatResponse(message, data) : message;
+  return {
+    content: [
+      {
+        type: "text",
+        text
+      }
+    ]
+  };
+}
+function withErrorHandling(handler, errorPrefix = "Error") {
+  return async (params, extra) => {
+    try {
+      return await handler(params, extra);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `${errorPrefix}: ${errorMessage}`
+          }
+        ]
+      };
+    }
+  };
+}
+
+// src/utils/tools.ts
+import ctfl from "contentful-management";
+
+// src/config/env.ts
+import dotenv from "dotenv";
+import { z } from "zod";
+dotenv.config();
+var EnvSchema = z.object({
+  CONTENTFUL_MANAGEMENT_ACCESS_TOKEN: z.string().describe("Contentful CMA token"),
+  CONTENTFUL_HOST: z.string().optional().default("api.contentful.com").describe("Contentful API host"),
+  APP_ID: z.string().optional().describe("Contentful App ID"),
+  SPACE_ID: z.string().optional().describe("Contentful Space ID"),
+  ENVIRONMENT_ID: z.string().optional().default("master").describe("Contentful environment ID"),
+  ORGANIZATION_ID: z.string().optional().describe("Contentful organization ID")
+});
+var env = EnvSchema.safeParse(process.env);
+if (!env.success && process.env["TEST_TYPE"] !== "unit") {
+  console.error("Invalid environment variables", env.error.format());
+  process.exit(1);
+}
+
+// src/utils/getVersion.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+var getVersion = () => {
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname2 = dirname(__filename2);
+  const possiblePaths = [
+    join(__dirname2, "../package.json"),
+    // For bundled code (dist/index.js -> package.json)
+    join(__dirname2, "../../package.json")
+    // For source code (src/utils/getVersion.ts -> package.json)
+  ];
+  for (const packageJsonPath of possiblePaths) {
+    if (existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      return packageJson.version;
+    }
+  }
+  throw new Error("Could not find package.json");
+};
+
+// src/config/contentful.ts
+function getDefaultClientConfig() {
+  if (!env.success && process.env["TEST_TYPE"] !== "unit") {
+    throw new Error("Environment variables are not properly configured");
+  }
+  if (!env.data) {
+    throw new Error("Environment data is not available");
+  }
+  const clientConfig = {
+    accessToken: env.data.CONTENTFUL_MANAGEMENT_ACCESS_TOKEN,
+    host: env.data.CONTENTFUL_HOST,
+    space: env.data.SPACE_ID,
+    headers: {
+      "X-Contentful-User-Agent-Tool": `contentful-mcp/${getVersion()}`
+      //Include user agent header for telemetry tracking
+    }
+  };
+  return clientConfig;
+}
+
+// src/utils/tools.ts
+import { z as z2 } from "zod";
+var BaseToolSchema = z2.object({
+  spaceId: z2.string().describe("The ID of the Contentful space"),
+  environmentId: z2.string().describe("The ID of the Contentful environment")
+});
+function createToolClient(params) {
+  const clientConfig = getDefaultClientConfig();
+  if (params.spaceId) {
+    clientConfig.space = params.spaceId;
+  }
+  return ctfl.createClient(clientConfig, { type: "plain" });
+}
+
+// src/utils/ai-actions.ts
+import { z as z3 } from "zod";
+var VariableType = /* @__PURE__ */ ((VariableType2) => {
+  VariableType2["RESOURCE_LINK"] = "ResourceLink";
+  VariableType2["TEXT"] = "Text";
+  VariableType2["STANDARD_INPUT"] = "StandardInput";
+  VariableType2["LOCALE"] = "Locale";
+  VariableType2["MEDIA_REFERENCE"] = "MediaReference";
+  VariableType2["REFERENCE"] = "Reference";
+  VariableType2["SMART_CONTEXT"] = "SmartContext";
+  return VariableType2;
+})(VariableType || {});
+var EntityType = /* @__PURE__ */ ((EntityType2) => {
+  EntityType2["ENTRY"] = "Entry";
+  EntityType2["ASSET"] = "Asset";
+  EntityType2["RESOURCE_LINK"] = "ResourceLink";
+  return EntityType2;
+})(EntityType || {});
+var VariableValue = z3.union([
+  z3.object({
+    id: z3.string(),
+    value: z3.string()
+  }),
+  z3.object({
+    id: z3.string(),
+    value: z3.object({
+      entityType: z3.nativeEnum(EntityType),
+      entityId: z3.string(),
+      entityPath: z3.string()
+    })
+  }),
+  z3.object({
+    id: z3.string(),
+    value: z3.object({
+      entityType: z3.literal("Entry" /* ENTRY */),
+      entityId: z3.string(),
+      entityPaths: z3.array(z3.string())
+    })
+  })
+]);
+var OutputFormat = /* @__PURE__ */ ((OutputFormat2) => {
+  OutputFormat2["RICH_TEXT"] = "RichText";
+  OutputFormat2["MARKDOWN"] = "Markdown";
+  OutputFormat2["PLAIN_TEXT"] = "PlainText";
+  return OutputFormat2;
+})(OutputFormat || {});
+
+// src/types/aiActionTestCaseSchema.ts
+import { z as z4 } from "zod";
+var TextTestCase = z4.object({
+  type: z4.literal("Text").optional(),
+  value: z4.string().optional()
+});
+var ReferenceTestCase = z4.object({
+  type: z4.literal("Reference").optional(),
+  value: z4.object({
+    entityPath: z4.string().optional(),
+    entityType: z4.literal("Entry").optional(),
+    entityId: z4.string().optional()
+  }).optional()
+});
+var AiActionTestCaseSchema = z4.union([
+  TextTestCase,
+  ReferenceTestCase
+]);
+
+// src/tools/ai-actions/createAiAction.ts
+var CreateAiActionToolParams = BaseToolSchema.extend({
+  name: z5.string().describe("The name of the AI action"),
+  description: z5.string().describe("The description of the AI action"),
+  instruction: z5.object({
+    template: z5.string().describe("The template for the AI action"),
+    variables: z5.array(
+      z5.object({
+        id: z5.string().describe("The id of the variable"),
+        name: z5.string().optional().describe("The name of the variable"),
+        type: z5.nativeEnum(VariableType).describe("The type of the variable"),
+        description: z5.string().optional().describe("The description of the variable")
+      })
+    ).describe("Array of variables for the AI action")
+  }).describe("The instruction for the AI action"),
+  configuration: z5.object({
+    modelType: z5.string().describe("The type of model to use"),
+    modelTemperature: z5.number().describe("The temperature for the model")
+  }).describe("The configuration for the AI action"),
+  testCases: z5.array(AiActionTestCaseSchema).optional().describe("Test cases for the AI action")
+});
+async function tool(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId || "master"
+  };
+  const contentfulClient = createToolClient({
+    ...args,
+    environmentId: args.environmentId || "master"
+  });
+  const aiAction = await contentfulClient.aiAction.create(params, {
+    name: args.name,
+    description: args.description,
+    instruction: args.instruction,
+    configuration: args.configuration,
+    testCases: args.testCases
+  });
+  return createSuccessResponse("AI action created successfully", { aiAction });
+}
+var createAiActionTool = withErrorHandling(
+  tool,
+  "Error creating AI action"
+);
+
+// src/tools/ai-actions/invokeAiAction.ts
+import { z as z6 } from "zod";
+var InvokeAiActionToolParams = BaseToolSchema.extend({
+  aiActionId: z6.string().describe("The ID of the AI action to invoke"),
+  fields: z6.array(
+    z6.object({
+      outputFormat: z6.nativeEnum(OutputFormat).describe("The output format of the AI action"),
+      variables: z6.array(VariableValue).describe("The variable assignments within the AI action invocation")
+    })
+  )
+});
+async function pollForCompletion(contentfulClient, params, aiActions, pollInterval = 3e4, maxAttempts = 10) {
+  const completedActions = /* @__PURE__ */ new Map();
+  for (let attempt = 0; attempt < maxAttempts && completedActions.size < aiActions.length; attempt++) {
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    await Promise.allSettled(
+      aiActions.filter((action) => !completedActions.has(action.sys.id)).map(async (action) => {
+        try {
+          const invocationStatus = await contentfulClient.aiActionInvocation.get({
+            ...params,
+            invocationId: action.sys.id
+          });
+          const status = invocationStatus.sys.status;
+          if (status === "COMPLETED" && invocationStatus.result) {
+            completedActions.set(
+              action.sys.id,
+              invocationStatus.result.content
+            );
+          } else if (status === "FAILED" || status === "CANCELLED") {
+            throw new Error(
+              `AI action ${action.sys.id} failed with status ${status}`
+            );
+          }
+        } catch (error) {
+          console.warn(
+            `Error checking status for invocation ${action.sys.id}:`,
+            error
+          );
+        }
+      })
+    );
+  }
+  if (completedActions.size < aiActions.length) {
+    throw new Error(
+      `Polling timeout: ${completedActions.size}/${aiActions.length} actions completed after ${maxAttempts} attempts`
+    );
+  }
+  return Array.from(completedActions.entries()).map(([actionId, content]) => ({
+    actionId,
+    content
+  }));
+}
+async function tool2(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const aiActions = [];
+  for (const field of args.fields) {
+    const aiAction = await contentfulClient.aiAction.invoke(
+      {
+        ...params,
+        aiActionId: args.aiActionId
+      },
+      {
+        outputFormat: field.outputFormat,
+        variables: field.variables
+      }
+    );
+    aiActions.push(aiAction);
+  }
+  const completedActions = await pollForCompletion(
+    contentfulClient,
+    { ...params, aiActionId: args.aiActionId },
+    aiActions
+  );
+  return createSuccessResponse("AI action invoked and completed successfully", {
+    aiActions: completedActions,
+    nextStepsGuidance: `Required next step: Now that the invocation is complete, you will take the next step to complete the workflow. This will involve a CRUD operation that will take action on each of the action returned in the aiActions variable. You will need to use the appropriate tool to do this, choose a tool depending on the type of entity the action was executed on and the description of the Ai Action.`
+  });
+}
+var invokeAiActionTool = withErrorHandling(
+  tool2,
+  "Error invoking AI action"
+);
+
+// src/tools/ai-actions/getAiActionInvocation.ts
+import { z as z7 } from "zod";
+var GetAiActionInvocationToolParams = BaseToolSchema.extend({
+  aiActionId: z7.string().describe("The ID of the AI action"),
+  invocationId: z7.string().describe("The ID of the invocation to retrieve")
+});
+async function tool3(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    aiActionId: args.aiActionId,
+    invocationId: args.invocationId
+  };
+  const contentfulClient = createToolClient(args);
+  const aiActionInvocation = await contentfulClient.aiActionInvocation.get(params);
+  return createSuccessResponse("AI action invocation retrieved successfully", {
+    aiActionInvocation
+  });
+}
+var getAiActionInvocationTool = withErrorHandling(
+  tool3,
+  "Error retrieving AI action invocation"
+);
+
+// src/tools/ai-actions/deleteAiAction.ts
+import { z as z8 } from "zod";
+var DeleteAiActionToolParams = BaseToolSchema.extend({
+  aiActionId: z8.string().describe("The ID of the AI action to delete")
+});
+async function tool4(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    aiActionId: args.aiActionId
+  };
+  const contentfulClient = createToolClient(args);
+  const aiAction = await contentfulClient.aiAction.get(params);
+  await contentfulClient.aiAction.delete(params);
+  return createSuccessResponse("AI action deleted successfully", { aiAction });
+}
+var deleteAiActionTool = withErrorHandling(
+  tool4,
+  "Error deleting AI action"
+);
+
+// src/tools/ai-actions/getAiAction.ts
+import { z as z9 } from "zod";
+var GetAiActionToolParams = BaseToolSchema.extend({
+  aiActionId: z9.string().describe("The ID of the AI action to retrieve")
+});
+async function tool5(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    aiActionId: args.aiActionId
+  };
+  const contentfulClient = createToolClient(args);
+  const aiAction = await contentfulClient.aiAction.get(params);
+  return createSuccessResponse("AI action retrieved successfully", {
+    aiAction
+  });
+}
+var getAiActionTool = withErrorHandling(
+  tool5,
+  "Error retrieving AI action"
+);
+
+// src/tools/ai-actions/listAiActions.ts
+import { z as z10 } from "zod";
+
+// src/utils/summarizer.ts
+var summarizeData = (data, options = {}) => {
+  const {
+    maxItems = 3,
+    remainingMessage = "To see more items, please ask me to retrieve the next page."
+  } = options;
+  if (data && typeof data === "object" && "items" in data && "total" in data) {
+    const items = data.items;
+    const total = data.total;
+    if (!Array.isArray(items) || typeof total !== "number") {
+      return data;
+    }
+    if (items.length <= maxItems) {
+      return data;
+    }
+    return {
+      items: items.slice(0, maxItems),
+      total,
+      showing: maxItems,
+      remaining: total - maxItems,
+      message: remainingMessage,
+      skip: maxItems
+      // Add skip value for next page
+    };
+  }
+  if (Array.isArray(data)) {
+    if (data.length <= maxItems) {
+      return data;
+    }
+    return {
+      items: data.slice(0, maxItems),
+      total: data.length,
+      showing: maxItems,
+      remaining: data.length - maxItems,
+      message: remainingMessage,
+      skip: maxItems
+      // Add skip value for next page
+    };
+  }
+  return data;
+};
+
+// src/tools/ai-actions/listAiActions.ts
+var ListAiActionToolParams = BaseToolSchema.extend({
+  limit: z10.number().optional().describe("Maximum number of AI actions to return (max 3)"),
+  skip: z10.number().optional().describe("Skip this many AI actions for pagination"),
+  select: z10.string().optional().describe("Comma-separated list of fields to return"),
+  include: z10.number().optional().describe("Include this many levels of linked entries"),
+  order: z10.string().optional().describe("Order AI actions by this field")
+});
+async function tool6(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const aiActions = await contentfulClient.aiAction.getMany({
+    ...params,
+    query: {
+      limit: Math.min(args.limit || 3, 3),
+      skip: args.skip || 0,
+      ...args.select && { select: args.select },
+      ...args.include && { include: args.include },
+      ...args.order && { order: args.order }
+    }
+  });
+  const summarizedAiActions = aiActions.items.map((aiAction) => ({
+    id: aiAction.sys.id,
+    name: aiAction.name || "Untitled",
+    description: aiAction.description || null,
+    instruction: aiAction.instruction || null,
+    configuration: aiAction.configuration || null,
+    testCases: aiAction.testCases || null,
+    createdAt: aiAction.sys.createdAt,
+    updatedAt: aiAction.sys.updatedAt,
+    publishedVersion: aiAction.sys.publishedVersion
+  }));
+  const summarized = summarizeData(
+    {
+      ...aiActions,
+      items: summarizedAiActions
+    },
+    {
+      maxItems: 3,
+      remainingMessage: "To see more AI actions, please ask me to retrieve the next page using the skip parameter."
+    }
+  );
+  return createSuccessResponse("AI actions retrieved successfully", {
+    aiActions: summarized,
+    total: aiActions.total,
+    limit: aiActions.limit,
+    skip: aiActions.skip
+  });
+}
+var listAiActionTool = withErrorHandling(
+  tool6,
+  "Error listing AI actions"
+);
+
+// src/tools/ai-actions/publishAiAction.ts
+import { z as z11 } from "zod";
+var PublishAiActionToolParams = BaseToolSchema.extend({
+  aiActionId: z11.string().describe("The ID of the AI action to publish")
+});
+async function tool7(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    aiActionId: args.aiActionId
+  };
+  const contentfulClient = createToolClient(args);
+  try {
+    const aiAction = await contentfulClient.aiAction.get(params);
+    const publishedAiAction = await contentfulClient.aiAction.publish(
+      {
+        ...params,
+        version: aiAction.sys.version
+      },
+      aiAction
+    );
+    return createSuccessResponse("AI action published successfully", {
+      version: publishedAiAction.sys.publishedVersion,
+      aiActionId: args.aiActionId
+    });
+  } catch (error) {
+    return createSuccessResponse("AI action publish failed", {
+      status: error,
+      aiActionId: args.aiActionId
+    });
+  }
+}
+var publishAiActionTool = withErrorHandling(
+  tool7,
+  "Error publishing AI action"
+);
+
+// src/tools/ai-actions/unpublishAiAction.ts
+import { z as z12 } from "zod";
+var UnpublishAiActionToolParams = BaseToolSchema.extend({
+  aiActionId: z12.string().describe("The ID of the AI action to unpublish")
+});
+async function tool8(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    aiActionId: args.aiActionId
+  };
+  const contentfulClient = createToolClient(args);
+  try {
+    await contentfulClient.aiAction.unpublish(params);
+    return createSuccessResponse("AI action unpublished successfully", {
+      aiActionId: args.aiActionId
+    });
+  } catch (error) {
+    return createSuccessResponse("AI action unpublish failed", {
+      status: error,
+      aiActionId: args.aiActionId
+    });
+  }
+}
+var unpublishAiActionTool = withErrorHandling(
+  tool8,
+  "Error unpublishing AI action"
+);
+
+// src/tools/ai-actions/updateAiAction.ts
+import { z as z13 } from "zod";
+var UpdateAiActionToolParams = BaseToolSchema.extend({
+  aiActionId: z13.string().describe("The ID of the AI action to update"),
+  name: z13.string().optional().describe("The name of the AI action"),
+  description: z13.string().optional().describe("The description of the AI action"),
+  instruction: z13.object({
+    template: z13.string().describe("The template for the AI action"),
+    variables: z13.array(
+      z13.object({
+        id: z13.string().describe("The id of the variable"),
+        name: z13.string().optional().describe("The name of the variable"),
+        type: z13.nativeEnum(VariableType).describe("The type of the variable"),
+        description: z13.string().optional().describe("The description of the variable")
+      })
+    ).describe("Array of variables for the AI action")
+  }).optional().describe("The instruction for the AI action"),
+  configuration: z13.object({
+    modelType: z13.string().describe("The type of model to use"),
+    modelTemperature: z13.number().describe("The temperature for the model")
+  }).optional().describe("The configuration for the AI action"),
+  testCases: z13.array(AiActionTestCaseSchema).optional().describe("Test cases for the AI action")
+});
+async function tool9(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    aiActionId: args.aiActionId
+  };
+  const contentfulClient = createToolClient(args);
+  const existingAiAction = await contentfulClient.aiAction.get(params);
+  const updatedAiAction = await contentfulClient.aiAction.update(params, {
+    ...existingAiAction,
+    ...args.name && { name: args.name },
+    ...args.description && { description: args.description },
+    ...args.instruction && { instruction: args.instruction },
+    ...args.configuration && { configuration: args.configuration },
+    ...args.testCases && { testCases: args.testCases }
+  });
+  return createSuccessResponse("AI action updated successfully", {
+    updatedAiAction
+  });
+}
+var updateAiActionTool = withErrorHandling(
+  tool9,
+  "Error updating AI action"
+);
+
+// src/tools/ai-actions/register.ts
+var aiActionTools = {
+  createAiAction: {
+    title: "create_ai_action",
+    description: `Create a new AI action with clear instructions and well-defined variables. Best practices: (1) Use descriptive names that indicate the action's purpose, (2) Write specific, actionable instructions in the template, (3) Define meaningful variables with clear names like "sourceContent", "targetLocale", "entryId", or "contentType", (4) Embed variables into the template using the format {{var.{variableId}}}, (5) Consider the content editor's workflow and make the action intuitive to use. Example variables: content fields to process, locales for translation, reference entries, formatting preferences, or validation rules.`,
+    inputParams: CreateAiActionToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: createAiActionTool
+  },
+  invokeAiAction: {
+    title: "invoke_ai_action",
+    description: 'Invoke an AI action with variables. MANDATORY BULK OPERATIONS: You MUST ALWAYS use bulk operations when processing multiple content pieces by adding multiple items to the fields array - never make separate calls. VARIABLES: Can be (1) String values for simple text input, or (2) Entity references to read from specific entry fields using {"entityId": "entryId", "entityPath": "fields.fieldName.locale", "entityType": "Entry"}. POLLING: Automatically polls every 3 seconds for up to 60 seconds. CRITICAL FOLLOW-UP: After invoking AI actions, you MUST immediately take the next step to complete the workflow. The tool response will provide specific guidance on required next steps - you must follow this guidance.',
+    inputParams: InvokeAiActionToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+      // Interacts with external AI services
+    },
+    tool: invokeAiActionTool
+  },
+  getAiActionInvocation: {
+    title: "get_ai_action_invocation",
+    description: "Retrieve information about a specific AI action invocation by its ID.",
+    inputParams: GetAiActionInvocationToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: getAiActionInvocationTool
+  },
+  deleteAiAction: {
+    title: "delete_ai_action",
+    description: "Delete a specific AI action from your Contentful space",
+    inputParams: DeleteAiActionToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      // Deleting same item multiple times has same effect
+      openWorldHint: false
+    },
+    tool: deleteAiActionTool
+  },
+  getAiAction: {
+    title: "get_ai_action",
+    description: "Retrieve details about a specific AI action including its configuration, instructions, and defined variables",
+    inputParams: GetAiActionToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: getAiActionTool
+  },
+  listAiActions: {
+    title: "list_ai_actions",
+    description: "List AI actions in a space. Returns a maximum of 3 items per request. Use skip parameter to paginate through results.",
+    inputParams: ListAiActionToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: listAiActionTool
+  },
+  publishAiAction: {
+    title: "publish_ai_action",
+    description: "Publish an AI action to make it available for use in the Contentful web app",
+    inputParams: PublishAiActionToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      // Publishing same item multiple times has same effect
+      openWorldHint: false
+    },
+    tool: publishAiActionTool
+  },
+  unpublishAiAction: {
+    title: "unpublish_ai_action",
+    description: "Unpublish an AI action to remove it from use in the Contentful web app",
+    inputParams: UnpublishAiActionToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      // Unpublishing same item multiple times has same effect
+      openWorldHint: false
+    },
+    tool: unpublishAiActionTool
+  },
+  updateAiAction: {
+    title: "update_ai_action",
+    description: "Update an existing AI action. Your updates will be merged with the existing AI action data, so you only need to provide the fields you want to change.",
+    inputParams: UpdateAiActionToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: updateAiActionTool
+  }
+};
+
+// src/tools/assets/uploadAsset.ts
+import { z as z15 } from "zod";
+
+// src/types/taxonomySchema.ts
+import { z as z14 } from "zod";
+var TaxonomyConceptValidationLinkSchema = z14.object({
+  sys: z14.object({
+    type: z14.literal("Link"),
+    linkType: z14.literal("TaxonomyConcept"),
+    id: z14.string().describe("The ID of the taxonomy concept")
+  }),
+  required: z14.boolean().optional()
+});
+var TaxonomyConceptSchemeValidationLinkSchema = z14.object({
+  sys: z14.object({
+    type: z14.literal("Link"),
+    linkType: z14.literal("TaxonomyConceptScheme"),
+    id: z14.string().describe("The ID of the taxonomy concept scheme")
+  }),
+  required: z14.boolean().optional()
+});
+var TaxonomyValidationLinkSchema = z14.union([
+  TaxonomyConceptValidationLinkSchema,
+  TaxonomyConceptSchemeValidationLinkSchema
+]);
+var ContentTypeMetadataSchema = z14.object({
+  taxonomy: z14.array(TaxonomyValidationLinkSchema).optional()
+}).optional();
+var EntryMetadataSchema = z14.object({
+  tags: z14.array(
+    z14.object({
+      sys: z14.object({
+        type: z14.literal("Link"),
+        linkType: z14.literal("Tag"),
+        id: z14.string()
+      })
+    })
+  ),
+  concepts: z14.array(
+    z14.object({
+      sys: z14.object({
+        type: z14.literal("Link"),
+        linkType: z14.literal("TaxonomyConcept"),
+        id: z14.string()
+      })
+    })
+  ).optional()
+}).optional();
+var AssetMetadataSchema = z14.object({
+  tags: z14.array(
+    z14.object({
+      sys: z14.object({
+        type: z14.literal("Link"),
+        linkType: z14.literal("Tag"),
+        id: z14.string()
+      })
+    })
+  ),
+  concepts: z14.array(
+    z14.object({
+      sys: z14.object({
+        type: z14.literal("Link"),
+        linkType: z14.literal("TaxonomyConcept"),
+        id: z14.string()
+      })
+    })
+  ).optional()
+}).optional();
+
+// src/tools/assets/uploadAsset.ts
+var FileSchema = z15.object({
+  fileName: z15.string().describe("The name of the file"),
+  contentType: z15.string().describe("The MIME type of the file"),
+  upload: z15.string().optional().describe("The upload URL or file data")
+});
+var UploadAssetToolParams = BaseToolSchema.extend({
+  title: z15.string().describe("The title of the asset"),
+  description: z15.string().optional().describe("The description of the asset"),
+  file: FileSchema.describe("The file information for the asset"),
+  metadata: AssetMetadataSchema
+});
+async function tool10(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const assetProps = {
+    fields: {
+      title: { "en-US": args.title },
+      description: args.description ? { "en-US": args.description } : void 0,
+      file: { "en-US": args.file }
+    },
+    metadata: args.metadata
+  };
+  const asset = await contentfulClient.asset.create(params, assetProps);
+  const processedAsset = await contentfulClient.asset.processForAllLocales(
+    params,
+    {
+      sys: asset.sys,
+      fields: asset.fields
+    },
+    {}
+  );
+  return createSuccessResponse("Asset uploaded successfully", {
+    asset: processedAsset
+  });
+}
+var uploadAssetTool = withErrorHandling(tool10, "Error uploading asset");
+
+// src/tools/assets/listAssets.ts
+import { z as z16 } from "zod";
+var ListAssetsToolParams = BaseToolSchema.extend({
+  limit: z16.number().optional().describe("Maximum number of assets to return (max 3)"),
+  skip: z16.number().optional().describe("Skip this many assets for pagination"),
+  select: z16.string().optional().describe("Comma-separated list of fields to return"),
+  include: z16.number().optional().describe("Include this many levels of linked entries"),
+  order: z16.string().optional().describe("Order assets by this field"),
+  links_to_entry: z16.string().optional().describe("Find assets that link to the specified entry ID")
+});
+async function tool11(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const assets = await contentfulClient.asset.getMany({
+    ...params,
+    query: {
+      limit: Math.min(args.limit || 3, 3),
+      skip: args.skip || 0,
+      ...args.select && { select: args.select },
+      ...args.include && { include: args.include },
+      ...args.order && { order: args.order },
+      ...args.links_to_entry && { links_to_entry: args.links_to_entry }
+    }
+  });
+  const summarizedAssets = assets.items.map((asset) => ({
+    id: asset.sys.id,
+    title: asset.fields.title?.["en-US"] || "Untitled",
+    description: asset.fields.description?.["en-US"] || null,
+    fileName: asset.fields.file?.["en-US"]?.fileName || null,
+    contentType: asset.fields.file?.["en-US"]?.contentType || null,
+    url: asset.fields.file?.["en-US"]?.url || null,
+    size: asset.fields.file?.["en-US"]?.details?.["size"] || null,
+    createdAt: asset.sys.createdAt,
+    updatedAt: asset.sys.updatedAt,
+    publishedVersion: asset.sys.publishedVersion
+  }));
+  const summarized = summarizeData(
+    {
+      ...assets,
+      items: summarizedAssets
+    },
+    {
+      maxItems: 3,
+      remainingMessage: "To see more assets, please ask me to retrieve the next page using the skip parameter."
+    }
+  );
+  return createSuccessResponse("Assets retrieved successfully", {
+    assets: summarized,
+    total: assets.total,
+    limit: assets.limit,
+    skip: assets.skip
+  });
+}
+var listAssetsTool = withErrorHandling(tool11, "Error listing assets");
+
+// src/tools/assets/getAsset.ts
+import { z as z17 } from "zod";
+var GetAssetToolParams = BaseToolSchema.extend({
+  assetId: z17.string().describe("The ID of the asset to retrieve")
+});
+async function tool12(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    assetId: args.assetId
+  };
+  const contentfulClient = createToolClient(args);
+  const asset = await contentfulClient.asset.get(params);
+  return createSuccessResponse("Asset retrieved successfully", { asset });
+}
+var getAssetTool = withErrorHandling(tool12, "Error retrieving asset");
+
+// src/tools/assets/updateAsset.ts
+import { z as z18 } from "zod";
+var UpdateAssetToolParams = BaseToolSchema.extend({
+  assetId: z18.string().describe("The ID of the asset to update"),
+  fields: z18.record(z18.any()).describe(
+    "The field values to update. Keys should be field IDs and values should be the field content. Will be merged with existing fields."
+  ),
+  metadata: AssetMetadataSchema
+});
+async function tool13(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    assetId: args.assetId
+  };
+  const contentfulClient = createToolClient(args);
+  const existingAsset = await contentfulClient.asset.get(params);
+  const allTags = [
+    ...existingAsset.metadata?.tags || [],
+    ...args.metadata?.tags || []
+  ];
+  const allConcepts = [
+    ...existingAsset.metadata?.concepts || [],
+    ...args.metadata?.concepts || []
+  ];
+  const updatedAsset = await contentfulClient.asset.update(params, {
+    ...existingAsset,
+    fields: { ...existingAsset.fields, ...args.fields },
+    metadata: {
+      tags: allTags,
+      concepts: allConcepts
+    }
+  });
+  return createSuccessResponse("Asset updated successfully", { updatedAsset });
+}
+var updateAssetTool = withErrorHandling(tool13, "Error updating asset");
+
+// src/tools/assets/deleteAsset.ts
+import { z as z19 } from "zod";
+var DeleteAssetToolParams = BaseToolSchema.extend({
+  assetId: z19.string().describe("The ID of the asset to delete")
+});
+async function tool14(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    assetId: args.assetId
+  };
+  const contentfulClient = createToolClient(args);
+  const asset = await contentfulClient.asset.get(params);
+  await contentfulClient.asset.delete(params);
+  return createSuccessResponse("Asset deleted successfully", { asset });
+}
+var deleteAssetTool = withErrorHandling(tool14, "Error deleting asset");
+
+// src/tools/assets/publishAsset.ts
+import { z as z20 } from "zod";
+
+// src/utils/bulkOperations.ts
+async function waitForBulkActionCompletion(contentfulClient, baseParams, bulkActionId) {
+  let action = await contentfulClient.bulkAction.get({
+    ...baseParams,
+    bulkActionId
+  });
+  while (action.sys.status === "inProgress" || action.sys.status === "created") {
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    action = await contentfulClient.bulkAction.get({
+      ...baseParams,
+      bulkActionId
+    });
+  }
+  return action;
+}
+async function createEntryVersionedLinks(contentfulClient, baseParams, entryIds) {
+  return Promise.all(
+    entryIds.map(async (entryId) => {
+      const currentEntry = await contentfulClient.entry.get({
+        ...baseParams,
+        entryId
+      });
+      return {
+        sys: {
+          type: "Link",
+          linkType: "Entry",
+          id: entryId,
+          version: currentEntry.sys.version
+        }
+      };
+    })
+  );
+}
+async function createEntryUnversionedLinks(contentfulClient, baseParams, entryIds) {
+  await Promise.all(
+    entryIds.map(async (entryId) => {
+      await contentfulClient.entry.get({
+        ...baseParams,
+        entryId
+      });
+    })
+  );
+  return entryIds.map((entryId) => ({
+    sys: {
+      type: "Link",
+      linkType: "Entry",
+      id: entryId
+    }
+  }));
+}
+async function createAssetVersionedLinks(contentfulClient, baseParams, assetIds) {
+  return Promise.all(
+    assetIds.map(async (assetId) => {
+      const currentAsset = await contentfulClient.asset.get({
+        ...baseParams,
+        assetId
+      });
+      return {
+        sys: {
+          type: "Link",
+          linkType: "Asset",
+          id: assetId,
+          version: currentAsset.sys.version
+        }
+      };
+    })
+  );
+}
+async function createAssetUnversionedLinks(contentfulClient, baseParams, assetIds) {
+  await Promise.all(
+    assetIds.map(async (assetId) => {
+      await contentfulClient.asset.get({
+        ...baseParams,
+        assetId
+      });
+    })
+  );
+  return assetIds.map((assetId) => ({
+    sys: {
+      type: "Link",
+      linkType: "Asset",
+      id: assetId
+    }
+  }));
+}
+function createEntitiesCollection(entities) {
+  return {
+    sys: {
+      type: "Array"
+    },
+    items: entities
+  };
+}
+
+// src/tools/assets/publishAsset.ts
+var PublishAssetToolParams = BaseToolSchema.extend({
+  assetId: z20.union([z20.string(), z20.array(z20.string()).max(100)]).describe(
+    "The ID of the asset to publish (string) or an array of asset IDs (up to 100 assets)"
+  )
+});
+async function tool15(args) {
+  const baseParams = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const assetIds = Array.isArray(args.assetId) ? args.assetId : [args.assetId];
+  if (assetIds.length === 1) {
+    try {
+      const assetId = assetIds[0];
+      const params = {
+        ...baseParams,
+        assetId
+      };
+      const asset = await contentfulClient.asset.get(params);
+      const publishedAsset = await contentfulClient.asset.publish(
+        params,
+        asset
+      );
+      return createSuccessResponse("Asset published successfully", {
+        status: publishedAsset.sys.status,
+        assetId
+      });
+    } catch (error) {
+      return createSuccessResponse("Asset publish failed", {
+        status: error,
+        assetId: assetIds[0]
+      });
+    }
+  }
+  const entityVersions = await createAssetVersionedLinks(
+    contentfulClient,
+    baseParams,
+    assetIds
+  );
+  const entitiesCollection = createEntitiesCollection(entityVersions);
+  const bulkAction = await contentfulClient.bulkAction.publish(baseParams, {
+    entities: entitiesCollection
+  });
+  const action = await waitForBulkActionCompletion(
+    contentfulClient,
+    baseParams,
+    bulkAction.sys.id
+  );
+  return createSuccessResponse("Asset(s) published successfully", {
+    status: action.sys.status,
+    assetIds
+  });
+}
+var publishAssetTool = withErrorHandling(
+  tool15,
+  "Error publishing asset"
+);
+
+// src/tools/assets/unpublishAsset.ts
+import { z as z21 } from "zod";
+var UnpublishAssetToolParams = BaseToolSchema.extend({
+  assetId: z21.union([z21.string(), z21.array(z21.string()).max(100)]).describe(
+    "The ID of the asset to unpublish (string) or an array of asset IDs (up to 100 assets)"
+  )
+});
+async function tool16(args) {
+  const baseParams = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const assetIds = Array.isArray(args.assetId) ? args.assetId : [args.assetId];
+  if (assetIds.length === 1) {
+    try {
+      const assetId = assetIds[0];
+      const params = {
+        ...baseParams,
+        assetId
+      };
+      const asset = await contentfulClient.asset.get(params);
+      const unpublishedAsset = await contentfulClient.asset.unpublish(
+        params,
+        asset
+      );
+      return createSuccessResponse("Asset unpublished successfully", {
+        status: unpublishedAsset.sys.status,
+        assetId
+      });
+    } catch (error) {
+      return createSuccessResponse("Asset unpublish failed", {
+        status: error,
+        assetId: assetIds[0]
+      });
+    }
+  }
+  const assetLinks = await createAssetUnversionedLinks(
+    contentfulClient,
+    baseParams,
+    assetIds
+  );
+  const entitiesCollection = createEntitiesCollection(assetLinks);
+  const bulkAction = await contentfulClient.bulkAction.unpublish(baseParams, {
+    entities: entitiesCollection
+  });
+  const action = await waitForBulkActionCompletion(
+    contentfulClient,
+    baseParams,
+    bulkAction.sys.id
+  );
+  return createSuccessResponse("Asset(s) unpublished successfully", {
+    status: action.sys.status,
+    assetIds
+  });
+}
+var unpublishAssetTool = withErrorHandling(
+  tool16,
+  "Error unpublishing asset"
+);
+
+// src/tools/assets/archiveAsset.ts
+import { z as z22 } from "zod";
+var ArchiveAssetToolParams = BaseToolSchema.extend({
+  assetId: z22.union([z22.string(), z22.array(z22.string()).max(100)]).describe(
+    "The ID of the asset to archive (string) or an array of asset IDs (up to 100 assets)"
+  )
+});
+async function tool17(args) {
+  const baseParams = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const assetIds = Array.isArray(args.assetId) ? args.assetId : [args.assetId];
+  const successfullyArchived = [];
+  for (const assetId of assetIds) {
+    try {
+      const params = {
+        ...baseParams,
+        assetId
+      };
+      await contentfulClient.asset.archive(params);
+      successfullyArchived.push(assetId);
+    } catch (error) {
+      const errorMessage = successfullyArchived.length > 0 ? `Failed to archive asset '${assetId}' after successfully archiving ${successfullyArchived.length} asset(s): [${successfullyArchived.join(", ")}]. Original error: ${error instanceof Error ? error.message : String(error)}` : `Failed to archive asset '${assetId}': ${error instanceof Error ? error.message : String(error)}`;
+      throw new Error(errorMessage);
+    }
+  }
+  if (assetIds.length === 1) {
+    return createSuccessResponse("Asset archived successfully", {
+      assetId: assetIds[0]
+    });
+  } else {
+    return createSuccessResponse(
+      `Successfully archived ${assetIds.length} assets`,
+      {
+        archivedCount: assetIds.length,
+        assetIds
+      }
+    );
+  }
+}
+var archiveAssetTool = withErrorHandling(
+  tool17,
+  "Error archiving asset"
+);
+
+// src/tools/assets/unarchiveAsset.ts
+import { z as z23 } from "zod";
+var UnarchiveAssetToolParams = BaseToolSchema.extend({
+  assetId: z23.union([z23.string(), z23.array(z23.string()).max(100)]).describe(
+    "The ID of the asset to unarchive (string) or an array of asset IDs (up to 100 assets)"
+  )
+});
+async function tool18(args) {
+  const baseParams = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const assetIds = Array.isArray(args.assetId) ? args.assetId : [args.assetId];
+  const successfullyUnarchived = [];
+  for (const assetId of assetIds) {
+    try {
+      const params = {
+        ...baseParams,
+        assetId
+      };
+      await contentfulClient.asset.unarchive(params);
+      successfullyUnarchived.push(assetId);
+    } catch (error) {
+      const errorMessage = successfullyUnarchived.length > 0 ? `Failed to unarchive asset '${assetId}' after successfully unarchiving ${successfullyUnarchived.length} asset(s): [${successfullyUnarchived.join(", ")}]. Original error: ${error instanceof Error ? error.message : String(error)}` : `Failed to unarchive asset '${assetId}': ${error instanceof Error ? error.message : String(error)}`;
+      throw new Error(errorMessage);
+    }
+  }
+  if (assetIds.length === 1) {
+    return createSuccessResponse("Asset unarchived successfully", {
+      assetId: assetIds[0]
+    });
+  } else {
+    return createSuccessResponse(
+      `Successfully unarchived ${assetIds.length} assets`,
+      {
+        unarchivedCount: assetIds.length,
+        assetIds
+      }
+    );
+  }
+}
+var unarchiveAssetTool = withErrorHandling(
+  tool18,
+  "Error unarchiving asset"
+);
+
+// src/tools/assets/register.ts
+var assetTools = {
+  uploadAsset: {
+    title: "upload_asset",
+    description: "Upload a new asset",
+    inputParams: UploadAssetToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: uploadAssetTool
+  },
+  listAssets: {
+    title: "list_assets",
+    description: "List assets in a space. Returns a maximum of 3 items per request. Use skip parameter to paginate through results.",
+    inputParams: ListAssetsToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: listAssetsTool
+  },
+  getAsset: {
+    title: "get_asset",
+    description: "Retrieve an asset",
+    inputParams: GetAssetToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: getAssetTool
+  },
+  updateAsset: {
+    title: "update_asset",
+    description: "Update an asset",
+    inputParams: UpdateAssetToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: updateAssetTool
+  },
+  deleteAsset: {
+    title: "delete_asset",
+    description: "Delete an asset",
+    inputParams: DeleteAssetToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: deleteAssetTool
+  },
+  publishAsset: {
+    title: "publish_asset",
+    description: "Publish an asset or multiple assets. Accepts either a single assetId (string) or an array of assetIds (up to 100 assets). For a single asset, it uses the standard publish operation. For multiple assets, it automatically uses bulk publishing.",
+    inputParams: PublishAssetToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: publishAssetTool
+  },
+  unpublishAsset: {
+    title: "unpublish_asset",
+    description: "Unpublish an asset or multiple assets. Accepts either a single assetId (string) or an array of assetIds (up to 100 assets). For a single asset, it uses the standard unpublish operation. For multiple assets, it automatically uses bulk unpublishing.",
+    inputParams: UnpublishAssetToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: unpublishAssetTool
+  },
+  archiveAsset: {
+    title: "archive_asset",
+    description: "Archive an asset or multiple assets. Archives assets that are no longer needed but should be preserved. Assets must be unpublished before they can be archived. Accepts either a single assetId (string) or an array of assetIds (up to 100 assets). For multiple assets, processes each one sequentially as a pseudo-bulk operation.",
+    inputParams: ArchiveAssetToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: archiveAssetTool
+  },
+  unarchiveAsset: {
+    title: "unarchive_asset",
+    description: "Unarchive an asset or multiple assets. Restores archived assets, making them available for editing and publishing again. Accepts either a single assetId (string) or an array of assetIds (up to 100 assets). For multiple assets, processes each one sequentially as a pseudo-bulk operation.",
+    inputParams: UnarchiveAssetToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: unarchiveAssetTool
+  }
+};
+
+// src/tools/content-types/getContentType.ts
+import { z as z24 } from "zod";
+var GetContentTypeToolParams = BaseToolSchema.extend({
+  contentTypeId: z24.string().describe("The ID of the content type to retrieve details for")
+});
+async function tool19(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const contentType = await contentfulClient.contentType.get({
+    ...params,
+    contentTypeId: args.contentTypeId
+  });
+  return createSuccessResponse("Content type retrieved successfully", {
+    contentType
+  });
+}
+var getContentTypeTool = withErrorHandling(
+  tool19,
+  "Error retrieving content type"
+);
+
+// src/tools/content-types/listContentTypes.ts
+import { z as z25 } from "zod";
+var ListContentTypesToolParams = BaseToolSchema.extend({
+  limit: z25.number().optional().describe("Maximum number of content types to return (max 10)"),
+  skip: z25.number().optional().describe("Skip this many content types for pagination"),
+  select: z25.string().optional().describe("Comma-separated list of fields to return"),
+  include: z25.number().optional().describe("Include this many levels of linked entries"),
+  order: z25.string().optional().describe("Order content types by this field")
+});
+async function tool20(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const contentTypes = await contentfulClient.contentType.getMany({
+    ...params,
+    query: {
+      limit: Math.min(args.limit || 10, 10),
+      skip: args.skip || 0,
+      ...args.select && { select: args.select },
+      ...args.include && { include: args.include },
+      ...args.order && { order: args.order }
+    }
+  });
+  const summarizedContentTypes = contentTypes.items.map((contentType) => ({
+    ...contentType,
+    id: contentType.sys.id,
+    fieldsCount: contentType.fields.length
+  }));
+  const summarized = summarizeData(
+    {
+      ...contentTypes,
+      items: summarizedContentTypes
+    },
+    {
+      maxItems: 10,
+      remainingMessage: "To see more content types, please ask me to retrieve the next page using the skip parameter."
+    }
+  );
+  return createSuccessResponse("Content types retrieved successfully", {
+    contentTypes: summarized,
+    total: contentTypes.total,
+    limit: contentTypes.limit,
+    skip: contentTypes.skip
+  });
+}
+var listContentTypesTool = withErrorHandling(
+  tool20,
+  "Error listing content types"
+);
+
+// src/tools/content-types/createContentType.ts
+import { z as z28 } from "zod";
+
+// src/types/fieldSchema.ts
+import { z as z27 } from "zod";
+
+// src/types/contentTypeFieldValidationSchema.ts
+import { z as z26 } from "zod";
+import { INLINES, BLOCKS } from "@contentful/rich-text-types";
+var NumRange = z26.object({
+  min: z26.number().optional(),
+  max: z26.number().optional()
+});
+var DateRange = z26.object({
+  min: z26.string().optional(),
+  max: z26.string().optional()
+});
+var RegExpSchema = z26.object({
+  pattern: z26.string(),
+  flags: z26.string()
+});
+var AssetImageDimensions = z26.object({
+  width: NumRange.optional(),
+  height: NumRange.optional()
+});
+var ExternalResource = z26.object({
+  type: z26.string()
+});
+var ContentfulEntryResource = z26.object({
+  type: z26.literal("Contentful:Entry"),
+  source: z26.string(),
+  contentTypes: z26.array(z26.string())
+});
+var ContentTypeAllowedResources = z26.union([
+  ContentfulEntryResource,
+  ExternalResource
+]);
+var NodesValidation = z26.record(
+  z26.array(
+    z26.object({
+      // subset of ContentTypeFieldValidation used for node validations
+      size: NumRange.optional(),
+      linkContentType: z26.array(z26.string()).optional(),
+      message: z26.string().nullable().optional()
+    })
+  ).or(
+    z26.object({
+      validations: z26.array(
+        z26.object({
+          size: NumRange.optional(),
+          message: z26.string().nullable().optional()
+        })
+      ),
+      allowedResources: z26.array(ContentTypeAllowedResources)
+    })
+  )
+);
+var ContentTypeFieldValidationSchema = z26.object({
+  linkContentType: z26.array(z26.string()).optional(),
+  in: z26.array(z26.union([z26.string(), z26.number()])).optional(),
+  linkMimetypeGroup: z26.array(z26.string()).optional(),
+  enabledNodeTypes: z26.array(z26.union([z26.nativeEnum(BLOCKS), z26.nativeEnum(INLINES)])).optional(),
+  enabledMarks: z26.array(z26.string()).optional(),
+  unique: z26.boolean().optional(),
+  size: NumRange.optional(),
+  range: NumRange.optional(),
+  dateRange: DateRange.optional(),
+  regexp: RegExpSchema.optional(),
+  message: z26.string().nullable().optional(),
+  prohibitRegexp: RegExpSchema.optional(),
+  assetImageDimensions: AssetImageDimensions.optional(),
+  assetFileSize: NumRange.optional(),
+  nodes: NodesValidation.optional()
+});
+
+// src/types/fieldSchema.ts
+var FieldSchema = z27.object({
+  id: z27.string().describe("The field ID"),
+  name: z27.string().describe("The field name"),
+  type: z27.string().describe(
+    'The field type (e.g., "Symbol", "Text", "Integer", "Boolean", "Date", "Location", "Link", "Array", "Object")'
+  ),
+  required: z27.boolean().describe("Whether the field is required"),
+  localized: z27.boolean().describe("Whether the field is localized"),
+  disabled: z27.boolean().optional().describe("Whether the field is disabled"),
+  omitted: z27.boolean().optional().describe("Whether the field is omitted from the API response"),
+  validations: z27.array(ContentTypeFieldValidationSchema).optional().describe("Field validations"),
+  settings: z27.record(z27.any()).optional().describe("Field-specific settings"),
+  defaultValue: z27.any().optional().describe("Default value for the field"),
+  linkType: z27.string().optional().describe('Link type for Link fields (e.g., "Entry", "Asset")'),
+  items: z27.object({
+    type: z27.string(),
+    linkType: z27.string().optional(),
+    validations: z27.array(ContentTypeFieldValidationSchema).optional()
+  }).optional().describe("Items configuration for Array fields")
+});
+
+// src/tools/content-types/createContentType.ts
+var CreateContentTypeToolParams = BaseToolSchema.extend({
+  name: z28.string().describe("The name of the content type"),
+  displayField: z28.string().describe("The field ID to use as the display field"),
+  description: z28.string().optional().describe("Description of the content type"),
+  contentTypeId: z28.string().optional().describe(
+    "Optional ID for the content type. If provided, will use createWithId method"
+  ),
+  fields: z28.array(FieldSchema).describe("Array of field definitions for the content type"),
+  metadata: ContentTypeMetadataSchema
+});
+async function tool21(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const contentTypeData = {
+    name: args.name,
+    displayField: args.displayField,
+    description: args.description,
+    fields: args.fields,
+    metadata: args.metadata
+  };
+  const contentType = args.contentTypeId ? await contentfulClient.contentType.createWithId(
+    { ...params, contentTypeId: args.contentTypeId },
+    contentTypeData
+  ) : await contentfulClient.contentType.create(params, contentTypeData);
+  return createSuccessResponse("Content type created successfully", {
+    contentType
+  });
+}
+var createContentTypeTool = withErrorHandling(
+  tool21,
+  "Error creating content type"
+);
+
+// src/tools/content-types/updateContentType.ts
+import { z as z29 } from "zod";
+var UpdateContentTypeToolParams = BaseToolSchema.extend({
+  contentTypeId: z29.string().describe("The ID of the content type to update"),
+  name: z29.string().optional().describe("The name of the content type"),
+  displayField: z29.string().optional().describe("The field ID to use as the display field"),
+  description: z29.string().optional().describe("Description of the content type"),
+  fields: z29.array(FieldSchema).optional().describe(
+    "Array of field definitions for the content type. Will be merged with existing fields."
+  ),
+  metadata: ContentTypeMetadataSchema
+});
+async function tool22(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    contentTypeId: args.contentTypeId
+  };
+  const contentfulClient = createToolClient(args);
+  const currentContentType = await contentfulClient.contentType.get(params);
+  const fields = args.fields || currentContentType.fields;
+  if (args.fields) {
+    const existingFieldsMap = currentContentType.fields.reduce(
+      (acc, field) => {
+        acc[field.id] = field;
+        return acc;
+      },
+      {}
+    );
+    fields.forEach((field) => {
+      const existingField = existingFieldsMap[field.id];
+      if (existingField) {
+        field.validations = field.validations || existingField.validations;
+        field.required = field.required !== void 0 ? field.required : existingField.required || false;
+        if (field.type === "Link" && !field.linkType && existingField.linkType) {
+          field.linkType = existingField.linkType;
+        }
+        if (field.type === "Array" && !field.items && existingField.items) {
+          field.items = existingField.items;
+        }
+      } else {
+        field.required = field.required || false;
+      }
+    });
+  }
+  const contentType = await contentfulClient.contentType.update(params, {
+    ...currentContentType,
+    name: args.name || currentContentType.name,
+    description: args.description || currentContentType.description,
+    displayField: args.displayField || currentContentType.displayField,
+    fields,
+    metadata: args.metadata || currentContentType.metadata
+  });
+  return createSuccessResponse("Content type updated successfully", {
+    contentType
+  });
+}
+var updateContentTypeTool = withErrorHandling(
+  tool22,
+  "Error updating content type"
+);
+
+// src/tools/content-types/deleteContentType.ts
+import { z as z30 } from "zod";
+var DeleteContentTypeToolParams = BaseToolSchema.extend({
+  contentTypeId: z30.string().describe("The ID of the content type to delete")
+});
+async function tool23(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    contentTypeId: args.contentTypeId
+  };
+  const contentfulClient = createToolClient(args);
+  await contentfulClient.contentType.delete(params);
+  return createSuccessResponse("Content type deleted successfully", {
+    contentTypeId: args.contentTypeId
+  });
+}
+var deleteContentTypeTool = withErrorHandling(
+  tool23,
+  "Error deleting content type"
+);
+
+// src/tools/content-types/publishContentType.ts
+import { z as z31 } from "zod";
+var PublishContentTypeToolParams = BaseToolSchema.extend({
+  contentTypeId: z31.string().describe("The ID of the content type to publish")
+});
+async function tool24(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    contentTypeId: args.contentTypeId
+  };
+  const contentfulClient = createToolClient(args);
+  const currentContentType = await contentfulClient.contentType.get(params);
+  const contentType = await contentfulClient.contentType.publish(
+    params,
+    currentContentType
+  );
+  return createSuccessResponse("Content type published successfully", {
+    contentType
+  });
+}
+var publishContentTypeTool = withErrorHandling(
+  tool24,
+  "Error publishing content type"
+);
+
+// src/tools/content-types/unpublishContentType.ts
+import { z as z32 } from "zod";
+var UnpublishContentTypeToolParams = BaseToolSchema.extend({
+  contentTypeId: z32.string().describe("The ID of the content type to unpublish")
+});
+async function tool25(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    contentTypeId: args.contentTypeId
+  };
+  const contentfulClient = createToolClient(args);
+  const contentType = await contentfulClient.contentType.unpublish(params);
+  return createSuccessResponse("Content type unpublished successfully", {
+    contentType
+  });
+}
+var unpublishContentTypeTool = withErrorHandling(
+  tool25,
+  "Error unpublishing content type"
+);
+
+// src/tools/content-types/register.ts
+var contentTypeTools = {
+  getContentType: {
+    title: "get_content_type",
+    description: "Get details about a specific Contentful content type",
+    inputParams: GetContentTypeToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: getContentTypeTool
+  },
+  listContentTypes: {
+    title: "list_content_types",
+    description: "List content types in a space. Returns a maximum of 10 items per request. Use skip parameter to paginate through results.",
+    inputParams: ListContentTypesToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: listContentTypesTool
+  },
+  createContentType: {
+    title: "create_content_type",
+    description: "Create a new content type",
+    inputParams: CreateContentTypeToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: createContentTypeTool
+  },
+  updateContentType: {
+    title: "update_content_type",
+    description: "Update an existing content type. The handler will merge your field updates with existing content type data, so you only need to provide the fields and properties you want to change.",
+    inputParams: UpdateContentTypeToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: updateContentTypeTool
+  },
+  deleteContentType: {
+    title: "delete_content_type",
+    description: "Delete a content type",
+    inputParams: DeleteContentTypeToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: deleteContentTypeTool
+  },
+  publishContentType: {
+    title: "publish_content_type",
+    description: "Publish a content type",
+    inputParams: PublishContentTypeToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: publishContentTypeTool
+  },
+  unpublishContentType: {
+    title: "unpublish_content_type",
+    description: "Unpublish a content type",
+    inputParams: UnpublishContentTypeToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: unpublishContentTypeTool
+  }
+};
+
+// src/tools/context/getInitialContextTool.ts
+import { z as z33 } from "zod";
+import { outdent } from "outdent";
+
+// src/tools/context/store.ts
+var ContextStore = class {
+  context = {
+    hasGlobalContext: false
+  };
+  setInitialContextLoaded() {
+    this.context.hasGlobalContext = true;
+  }
+  hasInitialContext() {
+    return this.context.hasGlobalContext;
+  }
+  resetInitialContext() {
+    this.context.hasGlobalContext = false;
+  }
+};
+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
+- 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.`;
+
+// src/tools/context/getInitialContextTool.ts
+var GetInitialContextToolParams = z33.object({});
+async function tool26(_params) {
+  const config = {
+    space: env.data?.SPACE_ID,
+    environment: env.data?.ENVIRONMENT_ID,
+    organization: env.data?.ORGANIZATION_ID
+  };
+  const configInfo = `Current Contentful Configuration:
+  - Space ID: ${config.space}
+  - Environment ID: ${config.environment}
+  - Organization ID: ${config.organization}`;
+  const todaysDate = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US");
+  const message = outdent`
+    ${MCP_INSTRUCTIONS}
+
+    This is the initial context for your Contentful instance:
+
+    <context>
+      ${configInfo}
+    </content>
+
+    <todaysDate>${todaysDate}</todaysDate>
+  `;
+  contextStore.setInitialContextLoaded();
+  return {
+    content: [
+      {
+        type: "text",
+        text: message
+      }
+    ]
+  };
+}
+var getInitialContextTool = withErrorHandling(
+  tool26,
+  "Error getting initial context"
+);
+
+// src/tools/context/register.ts
+var contextTools = {
+  getInitialContext: {
+    title: "get_initial_context",
+    description: "IMPORTANT: This tool must be called before using any other tools. It will get initial context and usage instructions for this MCP server. ",
+    inputParams: GetInitialContextToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: getInitialContextTool
+  }
+};
+
+// src/tools/editor-interfaces/listEditorInterfaces.ts
+var ListEditorInterfacesToolParams = BaseToolSchema.extend({});
+async function tool27(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const editorInterfaces = await contentfulClient.editorInterface.getMany(params);
+  const summarizedInterfaces = editorInterfaces.items.map(
+    (editorInterface) => ({
+      contentTypeId: editorInterface.sys.contentType.sys.id,
+      version: editorInterface.sys.version,
+      controlsCount: editorInterface.controls?.length || 0
+    })
+  );
+  const summarized = summarizeData(
+    {
+      ...editorInterfaces,
+      items: summarizedInterfaces
+    },
+    {
+      maxItems: 20,
+      remainingMessage: "This list includes all editor interfaces in the environment."
+    }
+  );
+  return createSuccessResponse("Editor interfaces retrieved successfully", {
+    editorInterfaces: summarized,
+    total: editorInterfaces.total,
+    limit: editorInterfaces.limit,
+    skip: editorInterfaces.skip
+  });
+}
+var listEditorInterfacesTool = withErrorHandling(
+  tool27,
+  "Error listing editor interfaces"
+);
+
+// src/tools/editor-interfaces/getEditorInterface.ts
+import { z as z34 } from "zod";
+var GetEditorInterfaceToolParams = BaseToolSchema.extend({
+  contentTypeId: z34.string().describe(
+    "The ID of the content type to retrieve the editor interface for"
+  )
+});
+async function tool28(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    contentTypeId: args.contentTypeId
+  };
+  const contentfulClient = createToolClient(args);
+  const editorInterface = await contentfulClient.editorInterface.get(params);
+  return createSuccessResponse("Editor interface retrieved successfully", {
+    editorInterface
+  });
+}
+var getEditorInterfaceTool = withErrorHandling(
+  tool28,
+  "Error retrieving editor interface"
+);
+
+// src/tools/editor-interfaces/updateEditorInterface.ts
+import { z as z35 } from "zod";
+var ControlSchema = z35.object({
+  fieldId: z35.string().describe("The field ID this control applies to"),
+  widgetId: z35.string().describe("The widget ID to use for this field"),
+  widgetNamespace: z35.enum(["builtin", "extension", "app", "editor-builtin"]).optional().describe(
+    "The namespace of the widget (builtin, extension, app, or editor-builtin)"
+  ),
+  settings: z35.record(z35.any()).optional().describe("Settings object for the widget")
+});
+var SidebarItemSchema = z35.object({
+  widgetId: z35.string().describe("The widget ID for the sidebar item"),
+  widgetNamespace: z35.enum(["sidebar-builtin", "extension", "app"]).describe("The namespace of the sidebar widget"),
+  settings: z35.record(z35.any()).optional().describe("Settings object for the sidebar widget"),
+  disabled: z35.boolean().optional().describe("Whether the sidebar item is disabled")
+});
+var EditorLayoutItemSchema = z35.object({
+  fieldId: z35.string().describe("The field ID"),
+  settings: z35.record(z35.any()).optional().describe("Layout settings for the field")
+});
+var EditorLayoutSchema = z35.object({
+  items: z35.array(EditorLayoutItemSchema).optional().describe("Array of editor layout items")
+});
+var GroupControlSchema = z35.object({
+  groupId: z35.string().describe("The group ID"),
+  widgetId: z35.string().describe("The widget ID for the group control"),
+  widgetNamespace: z35.enum(["builtin", "extension", "app"]).optional().describe("The namespace of the group control widget"),
+  settings: z35.record(z35.any()).optional().describe("Settings object for the group control")
+});
+var UpdateEditorInterfaceToolParams = BaseToolSchema.extend({
+  contentTypeId: z35.string().describe("The ID of the content type to update the editor interface for"),
+  controls: z35.array(ControlSchema).optional().describe(
+    "Array of control definitions for fields in the content type. Each control defines which widget to use for a field."
+  ),
+  sidebar: z35.array(SidebarItemSchema).optional().describe("Array of sidebar widget configurations"),
+  editorLayout: z35.array(EditorLayoutSchema).optional().describe("Editor layout configuration for organizing fields"),
+  groupControls: z35.array(GroupControlSchema).optional().describe("Array of group control definitions for field groups")
+});
+async function tool29(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    contentTypeId: args.contentTypeId
+  };
+  const contentfulClient = createToolClient(args);
+  const currentEditorInterface = await contentfulClient.editorInterface.get(params);
+  const updatePayload = {
+    ...currentEditorInterface
+  };
+  if (args.controls !== void 0) {
+    updatePayload["controls"] = args.controls;
+  }
+  if (args.sidebar !== void 0) {
+    updatePayload["sidebar"] = args.sidebar;
+  }
+  if (args.editorLayout !== void 0) {
+    updatePayload["editorLayout"] = args.editorLayout;
+  }
+  if (args.groupControls !== void 0) {
+    updatePayload["groupControls"] = args.groupControls;
+  }
+  const editorInterface = await contentfulClient.editorInterface.update(
+    params,
+    updatePayload
+  );
+  return createSuccessResponse("Editor interface updated successfully", {
+    editorInterface
+  });
+}
+var updateEditorInterfaceTool = withErrorHandling(
+  tool29,
+  "Error updating editor interface"
+);
+
+// src/tools/editor-interfaces/register.ts
+var editorInterfaceTools = {
+  listEditorInterfaces: {
+    title: "list_editor_interfaces",
+    description: "Get all editor interfaces of a space. Returns configuration for how content types are displayed and edited in the Contentful web app, including field controls, sidebars, and layout settings.",
+    inputParams: ListEditorInterfacesToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: listEditorInterfacesTool
+  },
+  getEditorInterface: {
+    title: "get_editor_interface",
+    description: "Get the editor interface for a specific content type. Returns detailed configuration including field controls (widgets), sidebar widgets, editor layout, and group controls that define how the content type is displayed and edited in the Contentful web app.",
+    inputParams: GetEditorInterfaceToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: getEditorInterfaceTool
+  },
+  updateEditorInterface: {
+    title: "update_editor_interface",
+    description: "Update the editor interface for a content type. Allows customization of field controls (widgets), sidebar widgets, editor layout, and group controls. Only provide the properties you want to change - existing values will be preserved for unprovided fields.",
+    inputParams: UpdateEditorInterfaceToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: updateEditorInterfaceTool
+  }
+};
+
+// src/tools/entries/searchEntries.ts
+import { z as z36 } from "zod";
+var SearchEntriesToolParams = BaseToolSchema.extend({
+  query: z36.object({
+    content_type: z36.string().optional().describe("Filter by content type"),
+    include: z36.number().optional().describe("Include this many levels of linked entries"),
+    select: z36.string().optional().describe("Comma-separated list of fields to return"),
+    links_to_entry: z36.string().optional().describe("Find entries that link to the specified entry ID"),
+    limit: z36.number().optional().describe("Maximum number of entries to return"),
+    skip: z36.number().optional().describe("Skip this many entries"),
+    order: z36.string().optional().describe("Order entries by this field")
+  })
+});
+async function tool30(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const entries = await contentfulClient.entry.getMany({
+    ...params,
+    query: {
+      ...args.query,
+      limit: Math.min(args.query.limit || 3, 3),
+      skip: args.query.skip || 0
+    }
+  });
+  const summarized = summarizeData(entries, {
+    maxItems: 3,
+    remainingMessage: "To see more entries, please ask me to retrieve the next page."
+  });
+  return createSuccessResponse("Entries retrieved successfully", {
+    entries: summarized
+  });
+}
+var searchEntriesTool = withErrorHandling(
+  tool30,
+  "Error deleting dataset"
+);
+
+// src/tools/entries/createEntry.ts
+import { z as z37 } from "zod";
+var CreateEntryToolParams = BaseToolSchema.extend({
+  contentTypeId: z37.string().describe("The ID of the content type to create an entry for"),
+  fields: z37.record(z37.any()).describe(
+    "The field values for the new entry. Keys should be field IDs and values should be the field content."
+  ),
+  metadata: EntryMetadataSchema
+});
+async function tool31(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const newEntry = await contentfulClient.entry.create(
+    {
+      ...params,
+      contentTypeId: args.contentTypeId
+    },
+    {
+      fields: args.fields,
+      ...args.metadata ? { metadata: args.metadata } : {}
+    }
+  );
+  return createSuccessResponse("Entry created successfully", { newEntry });
+}
+var createEntryTool = withErrorHandling(tool31, "Error creating entry");
+
+// src/tools/entries/deleteEntry.ts
+import { z as z38 } from "zod";
+var DeleteEntryToolParams = BaseToolSchema.extend({
+  entryId: z38.string().describe("The ID of the entry to delete")
+});
+async function tool32(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    entryId: args.entryId
+  };
+  const contentfulClient = createToolClient(args);
+  const entry = await contentfulClient.entry.get(params);
+  await contentfulClient.entry.delete(params);
+  return createSuccessResponse("Entry deleted successfully", { entry });
+}
+var deleteEntryTool = withErrorHandling(tool32, "Error deleting entry");
+
+// src/tools/entries/updateEntry.ts
+import { z as z39 } from "zod";
+var UpdateEntryToolParams = BaseToolSchema.extend({
+  entryId: z39.string().describe("The ID of the entry to update"),
+  fields: z39.record(z39.any()).describe(
+    "The field values to update. Keys should be field IDs and values should be the field content. Will be merged with existing fields."
+  ),
+  metadata: EntryMetadataSchema
+});
+async function tool33(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    entryId: args.entryId
+  };
+  const contentfulClient = createToolClient(args);
+  const existingEntry = await contentfulClient.entry.get(params);
+  const mergedFields = {
+    ...existingEntry.fields,
+    ...args.fields
+  };
+  const allTags = [
+    ...existingEntry.metadata?.tags || [],
+    ...args.metadata?.tags || []
+  ];
+  const allConcepts = [
+    ...existingEntry.metadata?.concepts || [],
+    ...args.metadata?.concepts || []
+  ];
+  const updatedEntry = await contentfulClient.entry.update(params, {
+    ...existingEntry,
+    fields: mergedFields,
+    metadata: {
+      tags: allTags,
+      concepts: allConcepts
+    }
+  });
+  return createSuccessResponse("Entry updated successfully", { updatedEntry });
+}
+var updateEntryTool = withErrorHandling(tool33, "Error updating entry");
+
+// src/tools/entries/getEntry.ts
+import { z as z40 } from "zod";
+var GetEntryToolParams = BaseToolSchema.extend({
+  entryId: z40.string().describe("The ID of the entry to retrieve")
+});
+async function tool34(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    entryId: args.entryId
+  };
+  const contentfulClient = createToolClient(args);
+  const entry = await contentfulClient.entry.get(params);
+  return createSuccessResponse("Entry retrieved successfully", { entry });
+}
+var getEntryTool = withErrorHandling(tool34, "Error retrieving entry");
+
+// src/tools/entries/publishEntry.ts
+import { z as z41 } from "zod";
+var PublishEntryToolParams = BaseToolSchema.extend({
+  entryId: z41.union([z41.string(), z41.array(z41.string()).max(100)]).describe(
+    "The ID of the entry to publish (string) or an array of entry IDs (up to 100 entries)"
+  )
+});
+async function tool35(args) {
+  const baseParams = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const entryIds = Array.isArray(args.entryId) ? args.entryId : [args.entryId];
+  if (entryIds.length === 1) {
+    const entryId = entryIds[0];
+    const params = {
+      ...baseParams,
+      entryId
+    };
+    const entry = await contentfulClient.entry.get(params);
+    const publishedEntry = await contentfulClient.entry.publish(params, entry);
+    return createSuccessResponse("Entry published successfully", {
+      status: publishedEntry.sys.status,
+      entryId
+    });
+  }
+  const entityVersions = await createEntryVersionedLinks(
+    contentfulClient,
+    baseParams,
+    entryIds
+  );
+  const entitiesCollection = createEntitiesCollection(entityVersions);
+  const bulkAction = await contentfulClient.bulkAction.publish(baseParams, {
+    entities: entitiesCollection
+  });
+  const action = await waitForBulkActionCompletion(
+    contentfulClient,
+    baseParams,
+    bulkAction.sys.id
+  );
+  return createSuccessResponse("Entry(s) published successfully", {
+    status: action.sys.status,
+    entryIds
+  });
+}
+var publishEntryTool = withErrorHandling(
+  tool35,
+  "Error publishing entry"
+);
+
+// src/tools/entries/unpublishEntry.ts
+import { z as z42 } from "zod";
+var UnpublishEntryToolParams = BaseToolSchema.extend({
+  entryId: z42.union([z42.string(), z42.array(z42.string()).max(100)]).describe(
+    "The ID of the entry to unpublish (string) or an array of entry IDs (up to 100 entries)"
+  )
+});
+async function tool36(args) {
+  const baseParams = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const entryIds = Array.isArray(args.entryId) ? args.entryId : [args.entryId];
+  if (entryIds.length === 1) {
+    const entryId = entryIds[0];
+    const params = {
+      ...baseParams,
+      entryId
+    };
+    const entry = await contentfulClient.entry.get(params);
+    const unpublishedEntry = await contentfulClient.entry.unpublish(
+      params,
+      entry
+    );
+    return createSuccessResponse("Entry unpublished successfully", {
+      status: unpublishedEntry.sys.status,
+      entryId
+    });
+  }
+  const entityLinks = await createEntryUnversionedLinks(
+    contentfulClient,
+    baseParams,
+    entryIds
+  );
+  const entitiesCollection = createEntitiesCollection(entityLinks);
+  const bulkAction = await contentfulClient.bulkAction.unpublish(baseParams, {
+    entities: entitiesCollection
+  });
+  const action = await waitForBulkActionCompletion(
+    contentfulClient,
+    baseParams,
+    bulkAction.sys.id
+  );
+  return createSuccessResponse("Entry(s) unpublished successfully", {
+    status: action.sys.status,
+    entryIds
+  });
+}
+var unpublishEntryTool = withErrorHandling(
+  tool36,
+  "Error unpublishing entry"
+);
+
+// src/tools/entries/archiveEntry.ts
+import { z as z43 } from "zod";
+var ArchiveEntryToolParams = BaseToolSchema.extend({
+  entryId: z43.union([z43.string(), z43.array(z43.string()).max(100)]).describe(
+    "The ID of the entry to archive (string) or an array of entry IDs (up to 100 entries)"
+  )
+});
+async function tool37(args) {
+  const baseParams = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const entryIds = Array.isArray(args.entryId) ? args.entryId : [args.entryId];
+  const successfullyArchived = [];
+  for (const entryId of entryIds) {
+    try {
+      const params = {
+        ...baseParams,
+        entryId
+      };
+      await contentfulClient.entry.archive(params);
+      successfullyArchived.push(entryId);
+    } catch (error) {
+      const errorMessage = successfullyArchived.length > 0 ? `Failed to archive entry '${entryId}' after successfully archiving ${successfullyArchived.length} entry(s): [${successfullyArchived.join(", ")}]. Original error: ${error instanceof Error ? error.message : String(error)}` : `Failed to archive entry '${entryId}': ${error instanceof Error ? error.message : String(error)}`;
+      throw new Error(errorMessage);
+    }
+  }
+  if (entryIds.length === 1) {
+    return createSuccessResponse("Entry archived successfully", {
+      entryId: entryIds[0]
+    });
+  } else {
+    return createSuccessResponse(
+      `Successfully archived ${entryIds.length} entries`,
+      {
+        archivedCount: entryIds.length,
+        entryIds
+      }
+    );
+  }
+}
+var archiveEntryTool = withErrorHandling(
+  tool37,
+  "Error archiving entry"
+);
+
+// src/tools/entries/unarchiveEntry.ts
+import { z as z44 } from "zod";
+var UnarchiveEntryToolParams = BaseToolSchema.extend({
+  entryId: z44.union([z44.string(), z44.array(z44.string()).max(100)]).describe(
+    "The ID of the entry to unarchive (string) or an array of entry IDs (up to 100 entries)"
+  )
+});
+async function tool38(args) {
+  const baseParams = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const entryIds = Array.isArray(args.entryId) ? args.entryId : [args.entryId];
+  const successfullyUnarchived = [];
+  for (const entryId of entryIds) {
+    try {
+      const params = {
+        ...baseParams,
+        entryId
+      };
+      await contentfulClient.entry.unarchive(params);
+      successfullyUnarchived.push(entryId);
+    } catch (error) {
+      const errorMessage = successfullyUnarchived.length > 0 ? `Failed to unarchive entry '${entryId}' after successfully unarchiving ${successfullyUnarchived.length} entry(s): [${successfullyUnarchived.join(", ")}]. Original error: ${error instanceof Error ? error.message : String(error)}` : `Failed to unarchive entry '${entryId}': ${error instanceof Error ? error.message : String(error)}`;
+      throw new Error(errorMessage);
+    }
+  }
+  if (entryIds.length === 1) {
+    return createSuccessResponse("Entry unarchived successfully", {
+      entryId: entryIds[0]
+    });
+  } else {
+    return createSuccessResponse(
+      `Successfully unarchived ${entryIds.length} entries`,
+      {
+        unarchivedCount: entryIds.length,
+        entryIds
+      }
+    );
+  }
+}
+var unarchiveEntryTool = withErrorHandling(
+  tool38,
+  "Error unarchiving entry"
+);
+
+// src/tools/entries/register.ts
+var entryTools = {
+  searchEntries: {
+    title: "search_entries",
+    description: "Search for specific entries in your Contentful space",
+    inputParams: SearchEntriesToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: searchEntriesTool
+  },
+  createEntry: {
+    title: "create_entry",
+    description: "Create a new entry in Contentful. Before executing this function, you need to know the contentTypeId (not the content type NAME) and the fields of that contentType. You can get the fields definition by using the GET_CONTENT_TYPE tool. IMPORTANT: All field values MUST include a locale key (e.g., 'en-US') for each value, like: { title: { 'en-US': 'My Title' } }. Every field in Contentful requires a locale even for single-language content. TAGS: To add tags to an entry, include a metadata object with a tags array. Each tag should be an object with sys.type='Link', sys.linkType='Tag', and sys.id='tagId'. Example: { metadata: { tags: [{ sys: { type: 'Link', linkType: 'Tag', id: 'myTagId' } }] } }.",
+    inputParams: CreateEntryToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: createEntryTool
+  },
+  getEntry: {
+    title: "get_entry",
+    description: "Retrieve an existing entry",
+    inputParams: GetEntryToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: getEntryTool
+  },
+  updateEntry: {
+    title: "update_entry",
+    description: "Update an existing entry. The handler will merge your field updates with the existing entry fields, so you only need to provide the fields you want to change. However, for multiple-locale fields, all existing locales must be included in the update. IMPORTANT: All field values MUST include a locale key (e.g., 'en-US') for each value, like: { title: { 'en-US': 'My Updated Title' } }. Every field in Contentful requires a locale even for single-language content. When updating entries with multiple locales, always include all existing locales in the update to prevent overwriting with empty values. RICH TEXT FIELDS: When updating rich text fields, ALL text nodes MUST include a 'marks' property (can be empty array [] for no formatting). Text nodes with formatting need appropriate marks: { nodeType: 'text', value: 'Bold text', marks: [{ type: 'bold' }], data: {} }.",
+    inputParams: UpdateEntryToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: updateEntryTool
+  },
+  deleteEntry: {
+    title: "delete_entry",
+    description: "Delete a specific content entry from your Contentful space",
+    inputParams: DeleteEntryToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: deleteEntryTool
+  },
+  publishEntry: {
+    title: "publish_entry",
+    description: "Publish an entry or multiple entries. Accepts either a single entryId (string) or an array of entryIds (up to 100 entries). For a single entry, it uses the standard publish operation. For multiple entries, it automatically uses bulk publishing.",
+    inputParams: PublishEntryToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: publishEntryTool
+  },
+  unpublishEntry: {
+    title: "unpublish_entry",
+    description: "Unpublish an entry or multiple entries. Accepts either a single entryId (string) or an array of entryIds (up to 100 entries). For a single entry, it uses the standard unpublish operation. For multiple entries, it automatically uses bulk unpublishing.",
+    inputParams: UnpublishEntryToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: unpublishEntryTool
+  },
+  archiveEntry: {
+    title: "archive_entry",
+    description: "Archive an entry or multiple entries. Archives entries that are no longer needed but should be preserved. Entries must be unpublished before they can be archived. Accepts either a single entryId (string) or an array of entryIds (up to 100 entries). For multiple entries, processes each one sequentially as a pseudo-bulk operation.",
+    inputParams: ArchiveEntryToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: archiveEntryTool
+  },
+  unarchiveEntry: {
+    title: "unarchive_entry",
+    description: "Unarchive an entry or multiple entries. Restores archived entries, making them available for editing and publishing again. Accepts either a single entryId (string) or an array of entryIds (up to 100 entries). For multiple entries, processes each one sequentially as a pseudo-bulk operation.",
+    inputParams: UnarchiveEntryToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: unarchiveEntryTool
+  }
+};
+
+// src/tools/environments/createEnvironment.ts
+import { z as z45 } from "zod";
+var CreateEnvironmentToolParams = BaseToolSchema.extend({
+  environmentId: z45.string().describe("The ID of the environment to create"),
+  name: z45.string().describe("The name of the environment to create")
+});
+async function tool39(args) {
+  const contentfulClient = createToolClient(args);
+  const environment = await contentfulClient.environment.createWithId(
+    {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId
+    },
+    {
+      name: args.name
+    }
+  );
+  return createSuccessResponse("Environment created successfully", {
+    environment
+  });
+}
+var createEnvironmentTool = withErrorHandling(
+  tool39,
+  "Error creating environment"
+);
+
+// src/tools/environments/listEnvironments.ts
+import { z as z46 } from "zod";
+var ListEnvironmentsToolParams = BaseToolSchema.extend({
+  environmentId: z46.string().optional().describe(
+    "The ID of the Contentful environment (not required for listing)"
+  ),
+  limit: z46.number().optional().describe("Maximum number of environments to return (max 10)"),
+  skip: z46.number().optional().describe("Skip this many environments for pagination"),
+  select: z46.string().optional().describe("Comma-separated list of fields to return"),
+  order: z46.string().optional().describe("Order environments by this field")
+});
+async function tool40(args) {
+  const clientArgs = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId || "master"
+  };
+  const contentfulClient = createToolClient(clientArgs);
+  const environments = await contentfulClient.environment.getMany({
+    spaceId: args.spaceId,
+    query: {
+      limit: Math.min(args.limit || 10, 10),
+      skip: args.skip || 0,
+      ...args.select && { select: args.select },
+      ...args.order && { order: args.order }
+    }
+  });
+  const summarizedEnvironments = environments.items.map((environment) => ({
+    id: environment.sys.id,
+    name: environment.name,
+    status: environment.sys.status?.sys?.id || "unknown",
+    createdAt: environment.sys.createdAt,
+    updatedAt: environment.sys.updatedAt
+  }));
+  const summarized = summarizeData(
+    {
+      ...environments,
+      items: summarizedEnvironments
+    },
+    {
+      maxItems: 10,
+      remainingMessage: "To see more environments, please ask me to retrieve the next page using the skip parameter."
+    }
+  );
+  return createSuccessResponse("Environments retrieved successfully", {
+    environments: summarized,
+    total: environments.total,
+    limit: environments.limit,
+    skip: environments.skip
+  });
+}
+var listEnvironmentsTool = withErrorHandling(
+  tool40,
+  "Error listing environments"
+);
+
+// src/tools/environments/deleteEnvironment.ts
+import { z as z47 } from "zod";
+var DeleteEnvironmentToolParams = BaseToolSchema.extend({
+  environmentId: z47.string().describe("The ID of the environment to delete")
+});
+async function tool41(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  await contentfulClient.environment.delete(params);
+  return createSuccessResponse("Environment deleted successfully", {
+    environmentId: args.environmentId
+  });
+}
+var deleteEnvironmentTool = withErrorHandling(
+  tool41,
+  "Error deleting environment"
+);
+
+// src/tools/environments/register.ts
+var environmentTools = {
+  createEnvironment: {
+    title: "create_environment",
+    description: "Create a new environment",
+    inputParams: CreateEnvironmentToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: createEnvironmentTool
+  },
+  listEnvironments: {
+    title: "list_environments",
+    description: "List all environments in a space",
+    inputParams: ListEnvironmentsToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: listEnvironmentsTool
+  },
+  deleteEnvironment: {
+    title: "delete_environment",
+    description: "Delete an environment",
+    inputParams: DeleteEnvironmentToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: deleteEnvironmentTool
+  }
+};
+
+// src/tools/jobs/space-to-space-migration/exportSpace.ts
+import { z as z49 } from "zod";
+
+// src/types/querySchema.ts
+import { z as z48 } from "zod";
+var EntryQuerySchema = z48.object({
+  content_type: z48.string().optional().describe("Filter by content type"),
+  include: z48.number().optional().describe("Include this many levels of linked entries"),
+  select: z48.string().optional().describe("Comma-separated list of fields to return"),
+  links_to_entry: z48.string().optional().describe("Find entries that link to the specified entry ID"),
+  limit: z48.number().optional().describe("Maximum number of entries to return"),
+  skip: z48.number().optional().describe("Skip this many entries"),
+  order: z48.string().optional().describe("Order entries by this field")
+});
+var AssetQuerySchema = z48.object({
+  mimetype_group: z48.string().optional().describe("Filter by MIME type group"),
+  select: z48.string().optional().describe("Comma-separated list of fields to return"),
+  limit: z48.number().optional().describe("Maximum number of assets to return"),
+  skip: z48.number().optional().describe("Skip this many assets"),
+  order: z48.string().optional().describe("Order assets by this field")
+});
+
+// src/tools/jobs/space-to-space-migration/exportSpace.ts
+import path from "path";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var contentfulExport = require2("contentful-export");
+var ExportSpaceToolParams = BaseToolSchema.extend({
+  exportDir: z49.string().optional().describe(
+    "Directory to save the exported space data (optional, defaults to current directory)"
+  ),
+  saveFile: z49.boolean().optional().default(true).describe("Save the exported space data to a file"),
+  contentFile: z49.string().optional().describe("Custom filename for the exported space data (optional)"),
+  includeDrafts: z49.boolean().optional().default(false).describe("Include draft entries in the export"),
+  includeArchived: z49.boolean().optional().default(false).describe("Include archived entries in the export"),
+  skipContentModel: z49.boolean().optional().default(false).describe("Skip exporting content types"),
+  skipEditorInterfaces: z49.boolean().optional().default(false).describe("Skip exporting editor interfaces"),
+  skipContent: z49.boolean().optional().default(false).describe("Skip exporting entries and assets"),
+  skipRoles: z49.boolean().optional().default(false).describe("Skip exporting roles and permissions"),
+  skipTags: z49.boolean().optional().default(false).describe("Skip exporting tags"),
+  skipWebhooks: z49.boolean().optional().default(false).describe("Skip exporting webhooks"),
+  stripTags: z49.boolean().optional().default(false).describe("Untag assets and entries"),
+  contentOnly: z49.boolean().optional().default(false).describe("Only export assets and entries"),
+  queryEntries: EntryQuerySchema.optional().describe(
+    "Export only entries that match query parameters"
+  ),
+  queryAssets: AssetQuerySchema.optional().describe(
+    "Export only assets that match query parameters"
+  ),
+  downloadAssets: z49.boolean().optional().default(false).describe("Download actual asset files"),
+  maxAllowedLimit: z49.number().optional().default(1e3).describe("Maximum number of items per request"),
+  deliveryToken: z49.string().optional().describe("CDA token to export only published content (excludes tags)"),
+  host: z49.string().optional().describe("Management API host"),
+  hostDelivery: z49.string().optional().describe("Delivery API host"),
+  proxy: z49.string().optional().describe("HTTP/HTTPS proxy config"),
+  rawProxy: z49.boolean().optional().describe("Pass raw proxy config directly to Axios"),
+  headers: z49.record(z49.string()).optional().describe("Additional headers to include in requests"),
+  errorLogFile: z49.string().optional().describe("Path to error log output file"),
+  useVerboseRenderer: z49.boolean().optional().describe("Line-by-line logging, useful for CI"),
+  config: z49.string().optional().describe("Path to a JSON config file with all options")
+});
+async function tool42(args) {
+  const clientConfig = getDefaultClientConfig();
+  const managementToken = clientConfig.accessToken;
+  if (!managementToken) {
+    throw new Error("Contentful management token is not configured");
+  }
+  const exportOptions = {
+    ...args,
+    managementToken,
+    environmentId: args.environmentId || "master",
+    exportDir: args.exportDir || process.cwd(),
+    contentFile: args.contentFile || `contentful-export-${args.spaceId}.json`
+  };
+  try {
+    const result = await contentfulExport(exportOptions);
+    const exportPath = path.join(
+      exportOptions.exportDir,
+      exportOptions.contentFile
+    );
+    return createSuccessResponse("Space exported successfully", {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId || "master",
+      exportPath,
+      contentTypes: result.contentTypes?.length || 0,
+      entries: result.entries?.length || 0,
+      assets: result.assets?.length || 0,
+      locales: result.locales?.length || 0,
+      tags: result.tags?.length || 0,
+      webhooks: result.webhooks?.length || 0,
+      roles: result.roles?.length || 0,
+      editorInterfaces: result.editorInterfaces?.length || 0
+    });
+  } catch (error) {
+    throw new Error(
+      `Failed to export space: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+var createExportSpaceTool = withErrorHandling(
+  tool42,
+  "Error exporting space"
+);
+
+// src/tools/jobs/space-to-space-migration/paramCollection.ts
+import { z as z50 } from "zod";
+var ParamCollectionToolParams = BaseToolSchema.extend({
+  confirmation: z50.boolean().optional().describe(
+    "User confirmation that they are ready to proceed with the workflow"
+  ),
+  export: z50.object({
+    spaceId: z50.string().optional().describe("ID of the space with source data"),
+    environmentId: z50.string().optional().describe("ID of the environment in the source space"),
+    deliveryToken: z50.string().optional().describe("CDA token to export only published content (excludes tags)"),
+    exportDir: z50.string().optional().describe("Path to export JSON output"),
+    saveFile: z50.boolean().optional().describe("Save the export as a JSON file"),
+    contentFile: z50.string().optional().describe("Filename for exported data"),
+    includeDrafts: z50.boolean().optional().describe("Include drafts in exported entries"),
+    includeArchived: z50.boolean().optional().describe("Include archived entries"),
+    skipContentModel: z50.boolean().optional().describe("Skip exporting content models"),
+    skipEditorInterfaces: z50.boolean().optional().describe("Skip exporting editor interfaces"),
+    skipContent: z50.boolean().optional().describe("Skip exporting entries and assets"),
+    skipRoles: z50.boolean().optional().describe("Skip exporting roles and permissions"),
+    skipTags: z50.boolean().optional().describe("Skip exporting tags"),
+    skipWebhooks: z50.boolean().optional().describe("Skip exporting webhooks"),
+    stripTags: z50.boolean().optional().describe("Remove tags from entries and assets"),
+    contentOnly: z50.boolean().optional().describe("Export only entries and assets"),
+    queryEntries: EntryQuerySchema.optional().describe(
+      "Export only entries that match query parameters"
+    ),
+    queryAssets: AssetQuerySchema.optional().describe(
+      "Export only assets that match query parameters"
+    ),
+    downloadAssets: z50.boolean().optional().describe("Download asset files to disk"),
+    host: z50.string().optional().describe("Management API host"),
+    hostDelivery: z50.string().optional().describe("Delivery API host"),
+    proxy: z50.string().optional().describe("HTTP/HTTPS proxy config"),
+    rawProxy: z50.boolean().optional().describe("Pass raw proxy config directly to Axios"),
+    maxAllowedLimit: z50.number().optional().describe("Page size for requests"),
+    headers: z50.record(z50.any()).optional().describe("Additional headers to include in requests"),
+    errorLogFile: z50.string().optional().describe("Path to error log output file"),
+    useVerboseRenderer: z50.boolean().optional().describe("Line-by-line logging, useful for CI"),
+    config: z50.string().optional().describe("Path to a JSON config file with all options")
+  }).optional(),
+  import: z50.object({
+    spaceId: z50.string().optional().describe("ID of the space to import into"),
+    environmentId: z50.string().optional().describe("Target environment in destination space"),
+    contentFile: z50.string().optional().describe("Path to JSON file containing the content to import"),
+    content: z50.record(z50.any()).optional().describe(
+      "JS object containing import content (must match expected structure)"
+    ),
+    contentModelOnly: z50.boolean().optional().describe("Import only content types"),
+    skipContentModel: z50.boolean().optional().describe("Skip importing content types and locales"),
+    skipLocales: z50.boolean().optional().describe("Skip importing locales"),
+    skipContentUpdates: z50.boolean().optional().describe("Do not update existing content"),
+    skipContentPublishing: z50.boolean().optional().describe("Create but do not publish content"),
+    uploadAssets: z50.boolean().optional().describe("Upload asset files (requires assetsDirectory)"),
+    skipAssetUpdates: z50.boolean().optional().describe("Do not update existing assets"),
+    assetsDirectory: z50.string().optional().describe("Path to directory containing exported asset files"),
+    timeout: z50.number().optional().describe("Time between retries during asset processing (ms)"),
+    retryLimit: z50.number().optional().describe("Max retries for asset processing"),
+    host: z50.string().optional().describe("Management API host"),
+    proxy: z50.string().optional().describe("HTTP/HTTPS proxy string (host:port or user:pass@host:port)"),
+    rawProxy: z50.boolean().optional().describe("Pass proxy config directly to Axios"),
+    rateLimit: z50.number().optional().describe("Max requests per second to the API"),
+    headers: z50.record(z50.any()).optional().describe("Additional headers to attach to requests"),
+    errorLogFile: z50.string().optional().describe("Path to error log file"),
+    useVerboseRenderer: z50.boolean().optional().describe("Line-by-line progress output (good for CI)"),
+    config: z50.string().optional().describe("Path to config JSON file (merged with CLI args)")
+  }).optional()
+});
+var paramCollectionConfig = {
+  export: {
+    requiredParams: `
+spaceId                 // [string] [required] - ID of the space with source data
+    `,
+    optionalParams: `
+environmentId           // [string] [default: 'master'] - ID of the environment in the source space
+deliveryToken           // [string] - CDA token to export only published content (excludes tags)
+
+exportDir               // [string] [default: process.cwd()] - Path to export JSON output
+saveFile                // [boolean] [default: true] - Save the export as a JSON file
+contentFile             // [string] - Filename for exported data
+
+includeDrafts           // [boolean] [default: false] - Include drafts in exported entries
+includeArchived         // [boolean] [default: false] - Include archived entries
+skipContentModel        // [boolean] [default: false] - Skip exporting content models
+skipEditorInterfaces    // [boolean] [default: false] - Skip exporting editor interfaces
+skipContent             // [boolean] [default: false] - Skip exporting entries and assets
+skipRoles               // [boolean] [default: false] - Skip exporting roles and permissions
+skipTags                // [boolean] [default: false] - Skip exporting tags
+skipWebhooks            // [boolean] [default: false] - Skip exporting webhooks
+stripTags               // [boolean] [default: false] - Remove tags from entries and assets
+contentOnly             // [boolean] [default: false] - Export only entries and assets
+
+queryEntries            // [array] - Export only entries that match query parameters
+queryAssets             // [array] - Export only assets that match query parameters
+downloadAssets          // [boolean] - Download asset files to disk
+
+host                    // [string] [default: 'api.contentful.com'] - Management API host
+hostDelivery            // [string] [default: 'cdn.contentful.com'] - Delivery API host
+proxy                   // [string] - HTTP/HTTPS proxy config
+rawProxy                // [boolean] - Pass raw proxy config directly to Axios
+maxAllowedLimit         // [number] [default: 1000] - Page size for requests
+headers                 // [object] - Additional headers to include in requests
+
+errorLogFile            // [string] - Path to error log output file
+useVerboseRenderer      // [boolean] [default: false] - Line-by-line logging, useful for CI
+config                  // [string] - Path to a JSON config file with all options
+    `
+  },
+  import: {
+    requiredParams: `
+spaceId                 // [string] [required] - ID of the space to import into
+managementToken         // [string] [required] - Contentful Management API token
+    `,
+    optionalParams: `
+environmentId           // [string] [default: 'master'] - Target environment in destination space
+contentFile             // [string] - Path to JSON file containing the content to import
+content                 // [object] - JS object containing import content (must match expected structure)
+
+contentModelOnly        // [boolean] [default: false] - Import only content types
+skipContentModel        // [boolean] [default: false] - Skip importing content types and locales
+skipLocales             // [boolean] [default: false] - Skip importing locales
+skipContentUpdates      // [boolean] [default: false] - Do not update existing content
+skipContentPublishing   // [boolean] [default: false] - Create but do not publish content
+
+uploadAssets            // [boolean] [default: false] - Upload asset files (requires assetsDirectory)
+skipAssetUpdates        // [boolean] [default: false] - Do not update existing assets
+assetsDirectory         // [string] - Path to directory containing exported asset files
+timeout                 // [number] [default: 3000] - Time between retries during asset processing (ms)
+retryLimit              // [number] [default: 10] - Max retries for asset processing
+
+host                    // [string] [default: 'api.contentful.com'] - Management API host
+proxy                   // [string] - HTTP/HTTPS proxy string (host:port or user:pass@host:port)
+rawProxy                // [boolean] - Pass proxy config directly to Axios
+rateLimit               // [number] [default: 7] - Max requests per second to the API
+headers                 // [object] - Additional headers to attach to requests
+
+errorLogFile            // [string] - Path to error log file
+useVerboseRenderer      // [boolean] [default: false] - Line-by-line progress output (good for CI)
+config                  // [string] - Path to config JSON file (merged with CLI args)
+    `
+  }
+};
+async function tool43(args) {
+  const exportParams = args.export ? Object.fromEntries(
+    Object.entries(args.export).filter(([, value]) => value !== void 0)
+  ) : {};
+  const importParams = args.import ? Object.fromEntries(
+    Object.entries(args.import).filter(([, value]) => value !== void 0)
+  ) : {};
+  const params = {
+    export: Object.keys(exportParams).length > 0 ? exportParams : void 0,
+    import: Object.keys(importParams).length > 0 ? importParams : void 0
+  };
+  if (args.confirmation === true) {
+    return createSuccessResponse("User ready to proceed with workflow", {
+      message: "User has confirmed they are ready to proceed with the space-to-space migration workflow.",
+      workflowParams: params,
+      nextStep: "Proceed with the migration workflow using the collected parameters."
+    });
+  }
+  return createSuccessResponse("Param collection tool", {
+    instructions: `
+    Help the user collect the correct parameters for the space to space migration workflow.
+    Call this tool repeatedly until the user feels they are ready to start the workflow.
+
+    Help them understand the required and optional parameters for the export and import tools.
+    Help them understand the instructions for the export and import tools.
+    Help them understand the available params for the export and import tools, ensure you list at all the optional params not just the required ones.
+
+    Continue to build the parameters passed into this tool until the user passes a confirmation that they are ready to start the workflow.
+    `,
+    availableParams: paramCollectionConfig,
+    currentParams: params
+  });
+}
+var createParamCollectionTool = withErrorHandling(
+  tool43,
+  "Error creating param collection tool"
+);
+
+// src/tools/jobs/space-to-space-migration/importSpace.ts
+import { z as z51 } from "zod";
+import { createRequire as createRequire2 } from "module";
+var require3 = createRequire2(import.meta.url);
+var contentfulImport = require3("contentful-import");
+var ImportSpaceToolParams = BaseToolSchema.extend({
+  contentFile: z51.string().optional().describe("Path to JSON file containing the content to import"),
+  content: z51.record(z51.any()).optional().describe(
+    "JS object containing import content (must match expected structure)"
+  ),
+  contentModelOnly: z51.boolean().optional().default(false).describe("Import only content types"),
+  skipContentModel: z51.boolean().optional().default(false).describe("Skip importing content types and locales"),
+  skipLocales: z51.boolean().optional().default(false).describe("Skip importing locales"),
+  skipContentUpdates: z51.boolean().optional().default(false).describe("Do not update existing content"),
+  skipContentPublishing: z51.boolean().optional().default(false).describe("Create but do not publish content"),
+  uploadAssets: z51.boolean().optional().default(false).describe("Upload asset files (requires assetsDirectory)"),
+  skipAssetUpdates: z51.boolean().optional().default(false).describe("Do not update existing assets"),
+  assetsDirectory: z51.string().optional().describe("Path to directory containing exported asset files"),
+  timeout: z51.number().optional().default(3e3).describe("Time between retries during asset processing (ms)"),
+  retryLimit: z51.number().optional().default(10).describe("Max retries for asset processing"),
+  host: z51.string().optional().describe("Management API host"),
+  proxy: z51.string().optional().describe("HTTP/HTTPS proxy string (host:port or user:pass@host:port)"),
+  rawProxy: z51.boolean().optional().describe("Pass proxy config directly to Axios"),
+  rateLimit: z51.number().optional().default(7).describe("Max requests per second to the API"),
+  headers: z51.record(z51.any()).optional().describe("Additional headers to attach to requests"),
+  errorLogFile: z51.string().optional().describe("Path to error log file"),
+  useVerboseRenderer: z51.boolean().optional().describe("Line-by-line progress output (good for CI)"),
+  config: z51.string().optional().describe("Path to config JSON file (merged with CLI args)")
+});
+async function tool44(args) {
+  const clientConfig = getDefaultClientConfig();
+  const managementToken = clientConfig.accessToken;
+  if (!managementToken) {
+    throw new Error("Contentful management token is not configured");
+  }
+  const importOptions = {
+    ...args,
+    managementToken,
+    environmentId: args.environmentId || "master"
+  };
+  try {
+    const result = await contentfulImport(importOptions);
+    return createSuccessResponse("Space imported successfully", {
+      spaceId: args.spaceId,
+      environmentId: args.environmentId || "master",
+      contentTypes: result.contentTypes?.length || 0,
+      entries: result.entries?.length || 0,
+      assets: result.assets?.length || 0,
+      locales: result.locales?.length || 0,
+      tags: result.tags?.length || 0,
+      webhooks: result.webhooks?.length || 0,
+      roles: result.roles?.length || 0,
+      editorInterfaces: result.editorInterfaces?.length || 0
+    });
+  } catch (error) {
+    throw new Error(
+      `Failed to import space: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+var createImportSpaceTool = withErrorHandling(
+  tool44,
+  "Error importing space"
+);
+
+// src/tools/jobs/space-to-space-migration/migrationHandler.ts
+import { z as z52 } from "zod";
+
+// src/tools/jobs/space-to-space-migration/instructions.ts
+var S2S_MIGRATION_INSTRUCTIONS = `
+You are a helpful assistant that can help with space to space migration.
+
+You will be given a list of tools that can be used to migrate a space to another space.
+
+## Workflow Management:
+The space to space migration workflow is managed by a single unified tool: **space_to_space_migration_handler**
+
+- To **start** the workflow: Call space_to_space_migration_handler with enableWorkflow=true
+- To **conclude** the workflow: Call space_to_space_migration_handler with enableWorkflow=false
+
+Once the workflow is started, you will need to call the tools in the following order:
+
+1. space_to_space_migration_handler with enableWorkflow=true (already confirmed by the user)
+2. IMPORTANT: After starting the workflow, you MUST ask the user for confirmation before proceeding to the next step. The enabled tools will not appear until the agent is reprompted by the user.
+3. space_to_space_param_collection (only call after user confirms they are ready to proceed)
+4. export_space 
+5. import_space
+6. space_to_space_migration_handler with enableWorkflow=false (to conclude the workflow)
+
+## Path Configuration Best Practices:
+- ALWAYS use consistent path formats throughout the workflow
+
+### Asset Handling Paths:
+- When downloadAssets=true, the export tool creates an assets directory structure like: exportDir/images.ctfassets.net/
+- The import tool expects assetsDirectory to point to the images.ctfassets.net directory, not the parent export directory
+
+Troubleshooting:
+- If the start_space_to_space_migration is not found, try to call it again on behalf of the user.
+- If space_to_space_param_collection or other tools are not found, ask the user to confirm they are ready to proceed, as the tools need to be enabled first.
+- If import fails with path errors, verify that exportDir and assetsDirectory paths are correctly aligned and accessible.
+`;
+
+// src/tools/jobs/space-to-space-migration/migrationHandler.ts
+var S2S_TEARDOWN_INSTRUCTIONS = `
+The space to space migration workflow has been concluded and all related tools have been disabled.
+
+The workflow is now complete. You can start a new migration workflow by calling space_to_space_migration_handler with enableWorkflow=true if needed.
+`;
+var SpaceToSpaceMigrationHandlerToolParams = BaseToolSchema.extend({
+  enableWorkflow: z52.boolean().describe(
+    "Set to true to enable the workflow tools, false to disable them and conclude the workflow"
+  )
+});
+var makeSpaceToSpaceMigrationHandlerTool = (tools) => {
+  async function tool66(args) {
+    const { enableWorkflow } = args;
+    if (enableWorkflow) {
+      tools.forEach((tool67) => {
+        if (tool67) {
+          tool67.enable();
+        }
+      });
+      return createSuccessResponse(
+        "Space to space migration workflow started.",
+        {
+          enableWorkflow,
+          instructions: S2S_MIGRATION_INSTRUCTIONS
+        }
+      );
+    } else {
+      tools.forEach((tool67) => {
+        if (tool67) {
+          tool67.disable();
+        }
+      });
+      return createSuccessResponse(
+        "Space to space migration workflow concluded.",
+        {
+          enableWorkflow,
+          instructions: S2S_TEARDOWN_INSTRUCTIONS
+        }
+      );
+    }
+  }
+  return withErrorHandling(
+    tool66,
+    "Error managing space to space migration workflow"
+  );
+};
+
+// src/tools/jobs/space-to-space-migration/register.ts
+var jobTools = {
+  spaceToSpaceParamCollection: {
+    title: "space_to_space_param_collection",
+    description: "Collect parameters for the space to space migration workflow. This tool should ALWAYS start with confirmation false, until the user confirms they are ready to proceed with the workflow. Do not assume they use wants to proceed with the workflow until they explicitly say so.",
+    inputParams: ParamCollectionToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: createParamCollectionTool
+  },
+  exportSpace: {
+    title: "export_space",
+    description: "Export a space to a file",
+    inputParams: ExportSpaceToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: createExportSpaceTool
+  },
+  importSpace: {
+    title: "import_space",
+    description: "Import a space from a file. Step 4 of the space to space migration workflow.",
+    inputParams: ImportSpaceToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: createImportSpaceTool
+  },
+  spaceToSpaceMigrationHandler: {
+    title: "space_to_space_migration_handler",
+    description: "Enable or disable the space to space migration workflow tools. Set enableWorkflow=true to start, false to conclude the workflow.",
+    inputParams: SpaceToSpaceMigrationHandlerToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: makeSpaceToSpaceMigrationHandlerTool
+  }
+};
+
+// src/tools/locales/getLocale.ts
+import { z as z53 } from "zod";
+var GetLocaleToolParams = BaseToolSchema.extend({
+  localeId: z53.string().describe("The ID of the locale to retrieve")
+});
+async function tool45(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    localeId: args.localeId
+  };
+  const contentfulClient = createToolClient(args);
+  const locale = await contentfulClient.locale.get(params);
+  return createSuccessResponse("Locale retrieved successfully", { locale });
+}
+var getLocaleTool = withErrorHandling(tool45, "Error retrieving locale");
+
+// src/tools/locales/createLocale.ts
+import { z as z54 } from "zod";
+var CreateLocaleToolParams = BaseToolSchema.extend({
+  name: z54.string().describe("The name of the locale"),
+  code: z54.string().describe('The locale code (e.g., "en-US")'),
+  fallbackCode: z54.string().nullable().describe(
+    "The locale code to fallback to when there is no content for the current locale"
+  ),
+  contentDeliveryApi: z54.boolean().optional().default(true).describe(
+    "If the content under this locale should be available on the CDA (for public reading)"
+  ),
+  contentManagementApi: z54.boolean().optional().default(true).describe(
+    "If the content under this locale should be available on the CMA (for editing)"
+  ),
+  default: z54.boolean().optional().default(false).describe("If this is the default locale"),
+  optional: z54.boolean().optional().default(false).describe("If the locale needs to be filled in on entries or not")
+});
+async function tool46(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const newLocale = await contentfulClient.locale.create(params, {
+    name: args.name,
+    code: args.code,
+    fallbackCode: args.fallbackCode,
+    contentDeliveryApi: args.contentDeliveryApi,
+    contentManagementApi: args.contentManagementApi,
+    optional: args.optional
+  });
+  return createSuccessResponse("Locale created successfully", { newLocale });
+}
+var createLocaleTool = withErrorHandling(
+  tool46,
+  "Error creating locale"
+);
+
+// src/tools/locales/listLocales.ts
+import { z as z55 } from "zod";
+var ListLocaleToolParams = BaseToolSchema.extend({
+  limit: z55.number().optional().describe("Maximum number of locales to return"),
+  skip: z55.number().optional().describe("Skip this many locales for pagination"),
+  select: z55.string().optional().describe("Comma-separated list of fields to return"),
+  include: z55.number().optional().describe("Include this many levels of linked entries"),
+  order: z55.string().optional().describe("Order locales by this field")
+});
+async function tool47(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const locales = await contentfulClient.locale.getMany({
+    ...params,
+    query: {
+      limit: args.limit || 100,
+      skip: args.skip || 0,
+      ...args.select && { select: args.select },
+      ...args.include && { include: args.include },
+      ...args.order && { order: args.order }
+    }
+  });
+  const summarizedLocales = locales.items.map((locale) => ({
+    id: locale.sys.id,
+    name: locale.name,
+    code: locale.code,
+    fallbackCode: locale.fallbackCode || null,
+    contentDeliveryApi: locale.contentDeliveryApi,
+    contentManagementApi: locale.contentManagementApi,
+    default: locale.default,
+    optional: locale.optional,
+    createdAt: locale.sys.createdAt,
+    updatedAt: locale.sys.updatedAt,
+    version: locale.sys.version
+  }));
+  const summarized = summarizeData(
+    {
+      ...locales,
+      items: summarizedLocales
+    },
+    {
+      maxItems: 10,
+      remainingMessage: "To see more locales, please ask me to retrieve the next page using the skip parameter."
+    }
+  );
+  return createSuccessResponse("Locales retrieved successfully", {
+    locales: summarized,
+    total: locales.total,
+    limit: locales.limit,
+    skip: locales.skip
+  });
+}
+var listLocaleTool = withErrorHandling(tool47, "Error listing locales");
+
+// src/tools/locales/updateLocale.ts
+import { z as z56 } from "zod";
+var UpdateLocaleToolParams = BaseToolSchema.extend({
+  localeId: z56.string().describe("The ID of the locale to update"),
+  fields: z56.object({
+    name: z56.string().optional().describe("The name of the locale"),
+    // NOTE: internal_code changes are not allowed
+    code: z56.string().optional().describe("The code of the locale"),
+    fallbackCode: z56.string().optional().describe(
+      "The locale code to fallback to when there is no content for the current locale"
+    ),
+    contentDeliveryApi: z56.boolean().optional().describe(
+      "If the content under this locale should be available on the CDA (for public reading)"
+    ),
+    contentManagementApi: z56.boolean().optional().describe(
+      "If the content under this locale should be available on the CMA (for editing)"
+    ),
+    optional: z56.boolean().optional().describe("If the locale needs to be filled in on entries or not")
+  })
+});
+async function tool48(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    localeId: args.localeId
+  };
+  const contentfulClient = createToolClient(args);
+  const existingLocale = await contentfulClient.locale.get(params);
+  delete existingLocale.internal_code;
+  const updateData = { ...existingLocale, ...args.fields };
+  const updatedLocale = await contentfulClient.locale.update(
+    params,
+    updateData
+  );
+  return createSuccessResponse("Locale updated successfully", {
+    updatedLocale
+  });
+}
+var updateLocaleTool = withErrorHandling(
+  tool48,
+  "Error updating locale"
+);
+
+// src/tools/locales/deleteLocale.ts
+import { z as z57 } from "zod";
+var DeleteLocaleToolParams = BaseToolSchema.extend({
+  localeId: z57.string().describe("The ID of the locale to delete")
+});
+async function tool49(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    localeId: args.localeId
+  };
+  const contentfulClient = createToolClient(args);
+  const locale = await contentfulClient.locale.get(params);
+  await contentfulClient.locale.delete(params);
+  return createSuccessResponse("Locale deleted successfully", { locale });
+}
+var deleteLocaleTool = withErrorHandling(
+  tool49,
+  "Error deleting locale"
+);
+
+// src/tools/locales/register.ts
+var localeTools = {
+  getLocale: {
+    title: "get_locale",
+    description: "Retrieve a specific locale from your Contentful environment",
+    inputParams: GetLocaleToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: getLocaleTool
+  },
+  createLocale: {
+    title: "create_locale",
+    description: `Create a new locale in your Contentful environment. A locale defines a language-region pair (e.g., "en-US" for English United States). You can specify fallback behavior, API availability settings, and whether the locale is optional for content editors. Note: setting 'default' is currently not supported.`,
+    inputParams: CreateLocaleToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: createLocaleTool
+  },
+  listLocales: {
+    title: "list_locales",
+    description: "List all locales in your Contentful environment. Returns locale information including language codes, fallback settings, and API availability.",
+    inputParams: ListLocaleToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: listLocaleTool
+  },
+  updateLocale: {
+    title: "update_locale",
+    description: "Update an existing locale in your Contentful environment. You can modify the locale name, code, fallback behavior, API availability settings, and whether the locale is optional for content editors. Only provide the fields you want to change. IMPORTANT: internal_code cannot be updated.",
+    inputParams: UpdateLocaleToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: updateLocaleTool
+  },
+  deleteLocale: {
+    title: "delete_locale",
+    description: "Delete a specific locale from your Contentful environment. This operation permanently removes the locale and cannot be undone.",
+    inputParams: DeleteLocaleToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: deleteLocaleTool
+  }
+};
+
+// src/tools/orgs/listOrgs.ts
+import { z as z58 } from "zod";
+import ctfl2 from "contentful-management";
+var ListOrgsToolParams = z58.object({
+  limit: z58.number().optional().describe("Maximum number of organizations to return (max 10)"),
+  skip: z58.number().optional().describe("Skip this many organizations for pagination"),
+  select: z58.string().optional().describe("Comma-separated list of fields to return"),
+  order: z58.string().optional().describe("Order organizations by this field")
+});
+async function tool50(args) {
+  const clientConfig = getDefaultClientConfig();
+  delete clientConfig.space;
+  const contentfulClient = ctfl2.createClient(clientConfig, { type: "plain" });
+  const organizations = await contentfulClient.organization.getAll({
+    query: {
+      limit: Math.min(args.limit || 10, 10),
+      skip: args.skip || 0,
+      ...args.select && { select: args.select },
+      ...args.order && { order: args.order }
+    }
+  });
+  const summarizedOrganizations = organizations.items.map((org) => ({
+    id: org.sys.id,
+    name: org.name,
+    createdAt: org.sys.createdAt,
+    updatedAt: org.sys.updatedAt
+  }));
+  const summarized = summarizeData(
+    {
+      ...organizations,
+      items: summarizedOrganizations
+    },
+    {
+      maxItems: 10,
+      remainingMessage: "To see more organizations, please ask me to retrieve the next page using the skip parameter."
+    }
+  );
+  return createSuccessResponse("Organizations retrieved successfully", {
+    organizations: summarized,
+    total: organizations.total,
+    limit: organizations.limit,
+    skip: organizations.skip
+  });
+}
+var listOrgsTool = withErrorHandling(
+  tool50,
+  "Error listing organizations"
+);
+
+// src/tools/orgs/getOrg.ts
+import { z as z59 } from "zod";
+import ctfl3 from "contentful-management";
+var GetOrgToolParams = z59.object({
+  organizationId: z59.string().describe("The ID of the organization to retrieve")
+});
+async function tool51(args) {
+  const clientConfig = getDefaultClientConfig();
+  delete clientConfig.space;
+  const contentfulClient = ctfl3.createClient(clientConfig, { type: "plain" });
+  const organization = await contentfulClient.organization.get({
+    organizationId: args.organizationId
+  });
+  return createSuccessResponse("Organization retrieved successfully", {
+    organization
+  });
+}
+var getOrgTool = withErrorHandling(
+  tool51,
+  "Error retrieving organization"
+);
+
+// src/tools/orgs/register.ts
+var orgTools = {
+  listOrgs: {
+    title: "list_orgs",
+    description: "List all organizations that the user has access to",
+    inputParams: ListOrgsToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: listOrgsTool
+  },
+  getOrg: {
+    title: "get_org",
+    description: "Get details of a specific organization",
+    inputParams: GetOrgToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: getOrgTool
+  }
+};
+
+// src/tools/spaces/listSpaces.ts
+import { z as z60 } from "zod";
+import ctfl4 from "contentful-management";
+var ListSpacesToolParams = z60.object({
+  limit: z60.number().optional().describe("Maximum number of spaces to return (max 10)"),
+  skip: z60.number().optional().describe("Skip this many spaces for pagination"),
+  select: z60.string().optional().describe("Comma-separated list of fields to return"),
+  order: z60.string().optional().describe("Order spaces by this field")
+});
+async function tool52(args) {
+  const clientConfig = getDefaultClientConfig();
+  delete clientConfig.space;
+  const contentfulClient = ctfl4.createClient(clientConfig, { type: "plain" });
+  const spaces = await contentfulClient.space.getMany({
+    query: {
+      limit: Math.min(args.limit || 10, 10),
+      skip: args.skip || 0,
+      ...args.select && { select: args.select },
+      ...args.order && { order: args.order }
+    }
+  });
+  const summarizedSpaces = spaces.items.map((space) => ({
+    id: space.sys.id,
+    name: space.name,
+    createdAt: space.sys.createdAt,
+    updatedAt: space.sys.updatedAt
+  }));
+  const summarized = summarizeData(
+    {
+      ...spaces,
+      items: summarizedSpaces
+    },
+    {
+      maxItems: 10,
+      remainingMessage: "To see more spaces, please ask me to retrieve the next page using the skip parameter."
+    }
+  );
+  return createSuccessResponse("Spaces retrieved successfully", {
+    spaces: summarized,
+    total: spaces.total,
+    limit: spaces.limit,
+    skip: spaces.skip
+  });
+}
+var listSpacesTool = withErrorHandling(tool52, "Error listing spaces");
+
+// src/tools/spaces/getSpace.ts
+import { z as z61 } from "zod";
+import ctfl5 from "contentful-management";
+var GetSpaceToolParams = z61.object({
+  spaceId: z61.string().describe("The ID of the space to retrieve")
+});
+async function tool53(args) {
+  const clientConfig = getDefaultClientConfig();
+  delete clientConfig.space;
+  const contentfulClient = ctfl5.createClient(clientConfig, { type: "plain" });
+  const space = await contentfulClient.space.get({
+    spaceId: args.spaceId
+  });
+  return createSuccessResponse("Space retrieved successfully", { space });
+}
+var getSpaceTool = withErrorHandling(tool53, "Error retrieving space");
+
+// src/tools/spaces/register.ts
+var spaceTools = {
+  listSpaces: {
+    title: "list_spaces",
+    description: "List all available spaces",
+    inputParams: ListSpacesToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: listSpacesTool
+  },
+  getSpace: {
+    title: "get_space",
+    description: "Get details of a space",
+    inputParams: GetSpaceToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: getSpaceTool
+  }
+};
+
+// src/tools/tags/listTags.ts
+import { z as z62 } from "zod";
+var ListTagsToolParams = BaseToolSchema.extend({
+  limit: z62.number().optional().describe("Maximum number of tags to return"),
+  skip: z62.number().optional().describe("Skip this many tags for pagination"),
+  select: z62.string().optional().describe("Comma-separated list of fields to return"),
+  order: z62.string().optional().describe("Order tags by this field")
+});
+async function tool54(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId
+  };
+  const contentfulClient = createToolClient(args);
+  const tags = await contentfulClient.tag.getMany({
+    ...params,
+    query: {
+      limit: args.limit || 100,
+      skip: args.skip || 0,
+      ...args.select && { select: args.select },
+      ...args.order && { order: args.order }
+    }
+  });
+  const summarizedTags = tags.items.map((tag) => ({
+    id: tag.sys.id,
+    name: tag.name,
+    visibility: tag.sys.visibility,
+    createdAt: tag.sys.createdAt,
+    updatedAt: tag.sys.updatedAt
+  }));
+  const summarized = summarizeData(
+    {
+      ...tags,
+      items: summarizedTags
+    },
+    {
+      maxItems: 100,
+      remainingMessage: "To see more tags, please ask me to retrieve the next page using the skip parameter."
+    }
+  );
+  return createSuccessResponse("Tags retrieved successfully", {
+    tags: summarized,
+    total: tags.total,
+    limit: tags.limit,
+    skip: tags.skip
+  });
+}
+var listTagsTool = withErrorHandling(tool54, "Error listing tags");
+
+// src/tools/tags/createTag.ts
+import { z as z63 } from "zod";
+var CreateTagToolParams = BaseToolSchema.extend({
+  name: z63.string().describe("The name of the tag"),
+  id: z63.string().describe("The ID of the tag"),
+  visibility: z63.enum(["public", "private"]).describe("The visibility of the tag. Default to private if not specified")
+});
+async function tool55(args) {
+  const params = {
+    spaceId: args.spaceId,
+    environmentId: args.environmentId,
+    tagId: args.id
+  };
+  const contentfulClient = createToolClient(args);
+  const newTag = await contentfulClient.tag.createWithId(params, {
+    name: args.name,
+    sys: { visibility: args.visibility }
+  });
+  return createSuccessResponse("Tag created successfully", { newTag });
+}
+var createTagTool = withErrorHandling(tool55, "Error creating tag");
+
+// src/tools/tags/register.ts
+var tagTools = {
+  listTags: {
+    title: "list_tags",
+    description: "List all tags in a space. Returns all tags that exist in a given environment.",
+    inputParams: ListTagsToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: listTagsTool
+  },
+  createTag: {
+    title: "create_tag",
+    description: "Creates a new tag and returns it. Both name and ID must be unique to each environment. Tag names can be modified after creation, but the tag ID cannot. The tag visibility can be set to public or private, defaulting to private if not specified.",
+    inputParams: CreateTagToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: createTagTool
+  }
+};
+
+// src/tools/taxonomies/concept-schemes/createConceptScheme.ts
+import { z as z65 } from "zod";
+import ctfl6 from "contentful-management";
+
+// src/types/conceptPayloadTypes.ts
+import { z as z64 } from "zod";
+var TaxonomyConceptLinkSchema = z64.object({
+  sys: z64.object({
+    type: z64.literal("Link"),
+    linkType: z64.literal("TaxonomyConcept"),
+    id: z64.string()
+  })
+});
+
+// src/tools/taxonomies/concept-schemes/createConceptScheme.ts
+var CreateConceptSchemeToolParams = z65.object({
+  organizationId: z65.string().describe("The ID of the Contentful organization"),
+  conceptSchemeId: z65.string().optional().describe(
+    "Optional user-defined ID for the concept scheme. If not provided, Contentful will generate one automatically."
+  ),
+  prefLabel: z65.record(z65.string()).describe("The preferred label for the concept scheme (localized)"),
+  uri: z65.string().nullable().optional().describe("The URI for the concept scheme"),
+  definition: z65.record(z65.string().nullable()).optional().describe("Definition of the concept scheme (localized)"),
+  editorialNote: z65.record(z65.string().nullable()).optional().describe("Editorial note for the concept scheme (localized)"),
+  historyNote: z65.record(z65.string().nullable()).optional().describe("History note for the concept scheme (localized)"),
+  example: z65.record(z65.string().nullable()).optional().describe("Example for the concept scheme (localized)"),
+  note: z65.record(z65.string().nullable()).optional().describe("General note for the concept scheme (localized)"),
+  scopeNote: z65.record(z65.string().nullable()).optional().describe("Scope note for the concept scheme (localized)"),
+  topConcepts: z65.array(TaxonomyConceptLinkSchema).optional().describe("Links to top-level concepts in this scheme")
+});
+async function tool56(args) {
+  const clientConfig = getDefaultClientConfig();
+  delete clientConfig.space;
+  const contentfulClient = ctfl6.createClient(clientConfig, { type: "plain" });
+  const conceptSchemePayload = {
+    prefLabel: args.prefLabel,
+    ...Object.fromEntries(
+      Object.entries({
+        uri: args.uri,
+        definition: args.definition,
+        editorialNote: args.editorialNote,
+        historyNote: args.historyNote,
+        example: args.example,
+        note: args.note,
+        scopeNote: args.scopeNote,
+        topConcepts: args.topConcepts
+      }).filter(([, value]) => value !== void 0)
+    )
+  };
+  const newConceptScheme = args.conceptSchemeId ? await contentfulClient.conceptScheme.createWithId(
+    {
+      organizationId: args.organizationId,
+      conceptSchemeId: args.conceptSchemeId
+    },
+    conceptSchemePayload
+  ) : await contentfulClient.conceptScheme.create(
+    { organizationId: args.organizationId },
+    conceptSchemePayload
+  );
+  return createSuccessResponse("Concept scheme created successfully", {
+    newConceptScheme
+  });
+}
+var createConceptSchemeTool = withErrorHandling(
+  tool56,
+  "Error creating concept scheme"
+);
+
+// src/tools/taxonomies/concept-schemes/getConceptScheme.ts
+import { z as z66 } from "zod";
+import ctfl7 from "contentful-management";
+var GetConceptSchemeToolParams = z66.object({
+  organizationId: z66.string().describe("The ID of the Contentful organization"),
+  conceptSchemeId: z66.string().describe("The ID of the concept scheme to retrieve")
+});
+async function tool57(args) {
+  const clientConfig = getDefaultClientConfig();
+  delete clientConfig.space;
+  const contentfulClient = ctfl7.createClient(clientConfig, { type: "plain" });
+  const params = {
+    organizationId: args.organizationId,
+    conceptSchemeId: args.conceptSchemeId
+  };
+  const conceptScheme = await contentfulClient.conceptScheme.get(params);
+  return createSuccessResponse("Concept scheme retrieved successfully", {
+    conceptScheme
+  });
+}
+var getConceptSchemeTool = withErrorHandling(
+  tool57,
+  "Error retrieving concept scheme"
+);
+
+// src/tools/taxonomies/concept-schemes/listConceptSchemes.ts
+import { z as z67 } from "zod";
+import ctfl8 from "contentful-management";
+var ListConceptSchemesToolParams = z67.object({
+  organizationId: z67.string().describe("The ID of the Contentful organization"),
+  limit: z67.number().optional().describe("Maximum number of concept schemes to return"),
+  skip: z67.number().optional().describe("Skip this many concept schemes for pagination"),
+  select: z67.string().optional().describe("Comma-separated list of fields to return"),
+  include: z67.number().optional().describe("Include this many levels of linked entries"),
+  order: z67.string().optional().describe("Order concept schemes by this field")
+});
+async function tool58(args) {
+  const clientConfig = getDefaultClientConfig();
+  delete clientConfig.space;
+  const contentfulClient = ctfl8.createClient(clientConfig, { type: "plain" });
+  const conceptSchemes = await contentfulClient.conceptScheme.getMany({
+    organizationId: args.organizationId,
+    query: {
+      limit: args.limit || 10,
+      skip: args.skip || 0,
+      ...args.select && { select: args.select },
+      ...args.include && { include: args.include },
+      ...args.order && { order: args.order }
+    }
+  });
+  const summarizedConceptSchemes = conceptSchemes.items.map(
+    (conceptScheme) => ({
+      id: conceptScheme.sys.id,
+      prefLabel: conceptScheme.prefLabel || {},
+      uri: conceptScheme.uri || null,
+      definition: conceptScheme.definition || null,
+      topConcepts: conceptScheme.topConcepts || [],
+      createdAt: conceptScheme.sys.createdAt,
+      updatedAt: conceptScheme.sys.updatedAt,
+      version: conceptScheme.sys.version
+    })
+  );
+  const summarized = summarizeData(
+    {
+      ...conceptSchemes,
+      items: summarizedConceptSchemes
+    },
+    {
+      maxItems: 10,
+      remainingMessage: "To see more concept schemes, please ask me to retrieve the next page using the skip parameter."
+    }
+  );
+  return createSuccessResponse("Concept schemes retrieved successfully", {
+    conceptSchemes: summarized,
+    total: conceptSchemes.total || conceptSchemes.items.length,
+    limit: conceptSchemes.limit || args.limit || 10,
+    skip: conceptSchemes.skip || args.skip || 0
+  });
+}
+var listConceptSchemesTool = withErrorHandling(
+  tool58,
+  "Error listing concept schemes"
+);
+
+// src/tools/taxonomies/concept-schemes/updateConceptScheme.ts
+import { z as z68 } from "zod";
+import ctfl9 from "contentful-management";
+var UpdateConceptSchemeToolParams = z68.object({
+  organizationId: z68.string().describe("The ID of the Contentful organization"),
+  conceptSchemeId: z68.string().describe("The ID of the concept scheme to update"),
+  version: z68.number().describe("The current version of the concept scheme"),
+  prefLabel: z68.record(z68.string()).optional().describe("The preferred label for the concept scheme (localized)"),
+  uri: z68.string().nullable().optional().describe("The URI for the concept scheme"),
+  definition: z68.record(z68.string().nullable()).optional().describe("Definition of the concept scheme (localized)"),
+  editorialNote: z68.record(z68.string().nullable()).optional().describe("Editorial note for the concept scheme (localized)"),
+  historyNote: z68.record(z68.string().nullable()).optional().describe("History note for the concept scheme (localized)"),
+  example: z68.record(z68.string().nullable()).optional().describe("Example for the concept scheme (localized)"),
+  note: z68.record(z68.string().nullable()).optional().describe("General note for the concept scheme (localized)"),
+  scopeNote: z68.record(z68.string().nullable()).optional().describe("Scope note for the concept scheme (localized)"),
+  topConcepts: z68.array(TaxonomyConceptLinkSchema).optional().describe("Links to top-level concepts in this scheme"),
+  addConcept: z68.string().optional().describe(
+    "ID of a concept to add to this scheme (adds to both concepts and topConcepts)"
+  )
+});
+async function tool59(args) {
+  const clientConfig = getDefaultClientConfig();
+  delete clientConfig.space;
+  const contentfulClient = ctfl9.createClient(clientConfig, { type: "plain" });
+  const params = {
+    organizationId: args.organizationId,
+    conceptSchemeId: args.conceptSchemeId
+  };
+  const fieldMappings = {
+    prefLabel: "/prefLabel",
+    definition: "/definition",
+    editorialNote: "/editorialNote",
+    historyNote: "/historyNote",
+    example: "/example",
+    note: "/note",
+    scopeNote: "/scopeNote",
+    topConcepts: "/topConcepts"
+  };
+  const patchOperations = [];
+  Object.entries(fieldMappings).forEach(([field, path2]) => {
+    const value = args[field];
+    if (value !== void 0) {
+      patchOperations.push({
+        op: "replace",
+        path: path2,
+        value
+      });
+    }
+  });
+  if (args.uri !== void 0) {
+    patchOperations.push({
+      op: args.uri === null ? "remove" : "replace",
+      path: "/uri",
+      ...args.uri !== null && { value: args.uri }
+    });
+  }
+  if (args.addConcept) {
+    const conceptLink = {
+      sys: {
+        id: args.addConcept,
+        linkType: "TaxonomyConcept",
+        type: "Link"
+      }
+    };
+    patchOperations.push({
+      op: "add",
+      path: "/concepts/-",
+      value: conceptLink
+    });
+    patchOperations.push({
+      op: "add",
+      path: "/topConcepts/-",
+      value: conceptLink
+    });
+  }
+  const updatedConceptScheme = await contentfulClient.conceptScheme.update(
+    {
+      ...params,
+      version: args.version
+    },
+    patchOperations
+  );
+  return createSuccessResponse("Concept scheme updated successfully", {
+    updatedConceptScheme
+  });
+}
+var updateConceptSchemeTool = withErrorHandling(
+  tool59,
+  "Error updating concept scheme"
+);
+
+// src/tools/taxonomies/concept-schemes/deleteConceptScheme.ts
+import { z as z69 } from "zod";
+import ctfl10 from "contentful-management";
+var DeleteConceptSchemeToolParams = z69.object({
+  organizationId: z69.string().describe("The ID of the Contentful organization"),
+  conceptSchemeId: z69.string().describe("The ID of the concept scheme to delete"),
+  version: z69.number().describe("The version of the concept scheme to delete")
+});
+async function tool60(args) {
+  const clientConfig = getDefaultClientConfig();
+  delete clientConfig.space;
+  const contentfulClient = ctfl10.createClient(clientConfig, { type: "plain" });
+  await contentfulClient.conceptScheme.delete({
+    organizationId: args.organizationId,
+    conceptSchemeId: args.conceptSchemeId,
+    version: args.version
+  });
+  return createSuccessResponse("Concept scheme deleted successfully", {
+    conceptSchemeId: args.conceptSchemeId
+  });
+}
+var deleteConceptSchemeTool = withErrorHandling(
+  tool60,
+  "Error deleting concept scheme"
+);
+
+// src/tools/taxonomies/concept-schemes/register.ts
+var conceptSchemeTools = {
+  createConceptScheme: {
+    title: "create_concept_scheme",
+    description: "Create a new taxonomy concept scheme in Contentful. Concept schemes organize related concepts and provide hierarchical structure for taxonomy management. The prefLabel is required and should be localized. You can optionally provide a conceptSchemeId for a user-defined ID, or let Contentful generate one automatically. You can also include definitions, notes, and references to top-level concepts.",
+    inputParams: CreateConceptSchemeToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: createConceptSchemeTool
+  },
+  getConceptScheme: {
+    title: "get_concept_scheme",
+    description: "Retrieve a specific taxonomy concept scheme from Contentful. Returns the complete concept scheme with all its properties including prefLabel, definition, topConcepts, and other metadata.",
+    inputParams: GetConceptSchemeToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: getConceptSchemeTool
+  },
+  listConceptSchemes: {
+    title: "list_concept_schemes",
+    description: "List taxonomy concept schemes in a Contentful organization. Supports pagination and filtering options. Returns a summarized view of concept schemes with essential information.",
+    inputParams: ListConceptSchemesToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: listConceptSchemesTool
+  },
+  updateConceptScheme: {
+    title: "update_concept_scheme",
+    description: "Update a taxonomy concept scheme in Contentful. Requires the concept scheme ID and version number for optimistic concurrency control. You can update any combination of fields - only the fields you provide will be changed, while others remain unchanged. Use this to modify labels, definitions, relationships, and other concept scheme properties.",
+    inputParams: UpdateConceptSchemeToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: updateConceptSchemeTool
+  },
+  deleteConceptScheme: {
+    title: "delete_concept_scheme",
+    description: "Delete a taxonomy concept scheme from Contentful. Requires the concept scheme ID and version number for optimistic concurrency control. This operation permanently removes the concept scheme and cannot be undone.",
+    inputParams: DeleteConceptSchemeToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: deleteConceptSchemeTool
+  }
+};
+
+// src/tools/taxonomies/concepts/createConcept.ts
+import { z as z70 } from "zod";
+import ctfl11 from "contentful-management";
+var CreateConceptToolParams = z70.object({
+  organizationId: z70.string().describe("The ID of the Contentful organization"),
+  conceptId: z70.string().optional().describe(
+    "Optional user-defined ID for the concept. If not provided, Contentful will generate one automatically."
+  ),
+  prefLabel: z70.record(z70.string()).describe("The preferred label for the concept (localized)"),
+  uri: z70.string().nullable().optional().describe("The URI for the concept"),
+  altLabels: z70.record(z70.array(z70.string())).optional().describe("Alternative labels for the concept (localized)"),
+  hiddenLabels: z70.record(z70.array(z70.string())).optional().describe("Hidden labels for the concept (localized)"),
+  definition: z70.record(z70.string().nullable()).optional().describe("Definition of the concept (localized)"),
+  editorialNote: z70.record(z70.string().nullable()).optional().describe("Editorial note for the concept (localized)"),
+  historyNote: z70.record(z70.string().nullable()).optional().describe("History note for the concept (localized)"),
+  example: z70.record(z70.string().nullable()).optional().describe("Example for the concept (localized)"),
+  note: z70.record(z70.string().nullable()).optional().describe("General note for the concept (localized)"),
+  scopeNote: z70.record(z70.string().nullable()).optional().describe("Scope note for the concept (localized)"),
+  notations: z70.array(z70.string()).optional().describe("Notations for the concept"),
+  broader: z70.array(TaxonomyConceptLinkSchema).optional().describe("Links to broader concepts"),
+  related: z70.array(TaxonomyConceptLinkSchema).optional().describe("Links to related concepts")
+});
+async function tool61(args) {
+  const clientConfig = getDefaultClientConfig();
+  delete clientConfig.space;
+  const contentfulClient = ctfl11.createClient(clientConfig, { type: "plain" });
+  const conceptPayload = {
+    prefLabel: args.prefLabel,
+    ...args.uri !== void 0 && { uri: args.uri },
+    ...args.altLabels && { altLabels: args.altLabels },
+    ...args.hiddenLabels && { hiddenLabels: args.hiddenLabels },
+    ...args.definition && { definition: args.definition },
+    ...args.editorialNote && { editorialNote: args.editorialNote },
+    ...args.historyNote && { historyNote: args.historyNote },
+    ...args.example && { example: args.example },
+    ...args.note && { note: args.note },
+    ...args.scopeNote && { scopeNote: args.scopeNote },
+    ...args.notations && { notations: args.notations },
+    ...args.broader && { broader: args.broader },
+    ...args.related && { related: args.related }
+  };
+  const newConcept = args.conceptId ? await contentfulClient.concept.createWithId(
+    { organizationId: args.organizationId, conceptId: args.conceptId },
+    conceptPayload
+  ) : await contentfulClient.concept.create(
+    { organizationId: args.organizationId },
+    conceptPayload
+  );
+  return createSuccessResponse("Concept created successfully", { newConcept });
+}
+var createConceptTool = withErrorHandling(
+  tool61,
+  "Error creating concept"
+);
+
+// src/tools/taxonomies/concepts/deleteConcept.ts
+import { z as z71 } from "zod";
+import ctfl12 from "contentful-management";
+var DeleteConceptToolParams = z71.object({
+  organizationId: z71.string().describe("The ID of the Contentful organization"),
+  conceptId: z71.string().describe("The ID of the concept to delete"),
+  version: z71.number().describe("The version of the concept to delete")
+});
+async function tool62(args) {
+  const clientConfig = getDefaultClientConfig();
+  delete clientConfig.space;
+  const contentfulClient = ctfl12.createClient(clientConfig, { type: "plain" });
+  await contentfulClient.concept.delete({
+    organizationId: args.organizationId,
+    conceptId: args.conceptId,
+    version: args.version
+  });
+  return createSuccessResponse("Concept deleted successfully", {
+    conceptId: args.conceptId
+  });
+}
+var deleteConceptTool = withErrorHandling(
+  tool62,
+  "Error deleting concept"
+);
+
+// src/tools/taxonomies/concepts/updateConcept.ts
+import { z as z72 } from "zod";
+import ctfl13 from "contentful-management";
+var UpdateConceptToolParams = z72.object({
+  organizationId: z72.string().describe("The ID of the Contentful organization"),
+  conceptId: z72.string().describe("The ID of the concept to update"),
+  version: z72.number().describe("The current version of the concept"),
+  prefLabel: z72.record(z72.string()).optional().describe("The preferred label for the concept (localized)"),
+  uri: z72.string().nullable().optional().describe("The URI for the concept"),
+  altLabels: z72.record(z72.array(z72.string())).optional().describe("Alternative labels for the concept (localized)"),
+  hiddenLabels: z72.record(z72.array(z72.string())).optional().describe("Hidden labels for the concept (localized)"),
+  definition: z72.record(z72.string().nullable()).optional().describe("Definition of the concept (localized)"),
+  editorialNote: z72.record(z72.string().nullable()).optional().describe("Editorial note for the concept (localized)"),
+  historyNote: z72.record(z72.string().nullable()).optional().describe("History note for the concept (localized)"),
+  example: z72.record(z72.string().nullable()).optional().describe("Example for the concept (localized)"),
+  note: z72.record(z72.string().nullable()).optional().describe("General note for the concept (localized)"),
+  scopeNote: z72.record(z72.string().nullable()).optional().describe("Scope note for the concept (localized)"),
+  notations: z72.array(z72.string()).optional().describe("Notations for the concept"),
+  broader: z72.array(TaxonomyConceptLinkSchema).optional().describe("Links to broader concepts"),
+  related: z72.array(TaxonomyConceptLinkSchema).optional().describe("Links to related concepts")
+});
+async function tool63(args) {
+  const clientConfig = getDefaultClientConfig();
+  delete clientConfig.space;
+  const contentfulClient = ctfl13.createClient(clientConfig, { type: "plain" });
+  const existingConcept = await contentfulClient.concept.get({
+    organizationId: args.organizationId,
+    conceptId: args.conceptId
+  });
+  const updatedPayload = {
+    prefLabel: args.prefLabel ?? existingConcept.prefLabel,
+    uri: args.uri !== void 0 ? args.uri : existingConcept.uri,
+    altLabels: args.altLabels ?? existingConcept.altLabels,
+    hiddenLabels: args.hiddenLabels ?? existingConcept.hiddenLabels,
+    definition: args.definition ?? existingConcept.definition,
+    editorialNote: args.editorialNote ?? existingConcept.editorialNote,
+    historyNote: args.historyNote ?? existingConcept.historyNote,
+    example: args.example ?? existingConcept.example,
+    note: args.note ?? existingConcept.note,
+    scopeNote: args.scopeNote ?? existingConcept.scopeNote,
+    notations: args.notations ?? existingConcept.notations,
+    broader: args.broader ?? existingConcept.broader,
+    related: args.related ?? existingConcept.related
+  };
+  const updatedConcept = await contentfulClient.concept.updatePut(
+    {
+      organizationId: args.organizationId,
+      conceptId: args.conceptId,
+      version: args.version
+    },
+    updatedPayload
+  );
+  return createSuccessResponse("Concept updated successfully", {
+    updatedConcept
+  });
+}
+var updateConceptTool = withErrorHandling(
+  tool63,
+  "Error updating concept"
+);
+
+// src/tools/taxonomies/concepts/getConcept.ts
+import { z as z73 } from "zod";
+import ctfl14 from "contentful-management";
+var GetConceptToolParams = z73.object({
+  organizationId: z73.string().describe("The ID of the Contentful organization"),
+  conceptId: z73.string().describe("The ID of the concept to retrieve")
+});
+async function tool64(args) {
+  const clientConfig = getDefaultClientConfig();
+  delete clientConfig.space;
+  const contentfulClient = ctfl14.createClient(clientConfig, { type: "plain" });
+  const concept = await contentfulClient.concept.get({
+    organizationId: args.organizationId,
+    conceptId: args.conceptId
+  });
+  return createSuccessResponse("Concept retrieved successfully", { concept });
+}
+var getConceptTool = withErrorHandling(
+  tool64,
+  "Error retrieving concept"
+);
+
+// src/tools/taxonomies/concepts/listConcepts.ts
+import { z as z74 } from "zod";
+import ctfl15 from "contentful-management";
+var ListConceptsToolParams = z74.object({
+  organizationId: z74.string().describe("The ID of the Contentful organization"),
+  conceptId: z74.string().optional().describe("The ID of the concept (required for descendants/ancestors)"),
+  limit: z74.number().optional().describe("Maximum number of concepts to return"),
+  skip: z74.number().optional().describe("Skip this many concepts for pagination"),
+  select: z74.string().optional().describe("Comma-separated list of fields to return"),
+  include: z74.number().optional().describe("Include this many levels of linked entries"),
+  order: z74.string().optional().describe("Order concepts by this field"),
+  getDescendants: z74.boolean().optional().describe("Get descendants of the specified concept (requires conceptId)"),
+  getAncestors: z74.boolean().optional().describe("Get ancestors of the specified concept (requires conceptId)"),
+  getTotalOnly: z74.boolean().optional().describe("Get only the total number of concepts without full data")
+});
+async function tool65(args) {
+  const clientConfig = getDefaultClientConfig();
+  delete clientConfig.space;
+  const contentfulClient = ctfl15.createClient(clientConfig, { type: "plain" });
+  if ((args.getDescendants || args.getAncestors) && !args.conceptId) {
+    throw new Error(
+      "conceptId is required when getting descendants or ancestors"
+    );
+  }
+  if (args.getTotalOnly) {
+    const total = await contentfulClient.concept.getTotal({
+      organizationId: args.organizationId
+    });
+    return createSuccessResponse("Total concepts retrieved successfully", {
+      total
+    });
+  }
+  if (args.getDescendants) {
+    const descendants = await contentfulClient.concept.getDescendants({
+      organizationId: args.organizationId,
+      conceptId: args.conceptId,
+      ...args.limit && { limit: args.limit },
+      ...args.skip && { skip: args.skip },
+      ...args.select && { select: args.select },
+      ...args.include && { include: args.include },
+      ...args.order && { order: args.order }
+    });
+    const summarizedDescendants = descendants.items.map((concept) => ({
+      sys: concept.sys,
+      prefLabel: concept.prefLabel,
+      uri: concept.uri,
+      broader: concept.broader,
+      related: concept.related
+    }));
+    const responseData2 = summarizeData({
+      ...descendants,
+      items: summarizedDescendants
+    });
+    return createSuccessResponse(
+      "Concept descendants retrieved successfully",
+      responseData2
+    );
+  }
+  if (args.getAncestors) {
+    const ancestors = await contentfulClient.concept.getAncestors({
+      organizationId: args.organizationId,
+      conceptId: args.conceptId,
+      ...args.limit && { limit: args.limit },
+      ...args.skip && { skip: args.skip },
+      ...args.select && { select: args.select },
+      ...args.include && { include: args.include },
+      ...args.order && { order: args.order }
+    });
+    const summarizedAncestors = ancestors.items.map((concept) => ({
+      sys: concept.sys,
+      prefLabel: concept.prefLabel,
+      uri: concept.uri,
+      broader: concept.broader,
+      related: concept.related
+    }));
+    const responseData2 = summarizeData({
+      ...ancestors,
+      items: summarizedAncestors
+    });
+    return createSuccessResponse(
+      "Concept ancestors retrieved successfully",
+      responseData2
+    );
+  }
+  const concepts = await contentfulClient.concept.getMany({
+    organizationId: args.organizationId,
+    query: {
+      limit: args.limit || 10,
+      skip: args.skip || 0,
+      ...args.select && { select: args.select },
+      ...args.include && { include: args.include },
+      ...args.order && { order: args.order }
+    }
+  });
+  const summarizedConcepts = concepts.items.map((concept) => ({
+    sys: concept.sys,
+    prefLabel: concept.prefLabel,
+    uri: concept.uri,
+    broader: concept.broader,
+    related: concept.related
+  }));
+  const responseData = summarizeData({
+    ...concepts,
+    items: summarizedConcepts
+  });
+  return createSuccessResponse(
+    "Concepts retrieved successfully",
+    responseData
+  );
+}
+var listConceptsTool = withErrorHandling(
+  tool65,
+  "Error retrieving concepts"
+);
+
+// src/tools/taxonomies/concepts/register.ts
+var conceptTools = {
+  createConcept: {
+    title: "create_concept",
+    description: "Create a new taxonomy concept in Contentful. Concepts are used to organize and categorize content within taxonomies. The prefLabel is required and should be localized. You can optionally provide a conceptId for a user-defined ID, or let Contentful generate one automatically. You can also include definitions, notes, relationships to other concepts, and various metadata fields.",
+    inputParams: CreateConceptToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: createConceptTool
+  },
+  getConcept: {
+    title: "get_concept",
+    description: "Retrieve a specific taxonomy concept from Contentful. Returns the complete concept with all its properties including prefLabel, definition, relationships, and other metadata.",
+    inputParams: GetConceptToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: getConceptTool
+  },
+  listConcepts: {
+    title: "list_concepts",
+    description: "List taxonomy concepts in a Contentful organization. Supports multiple modes: (1) Default - list all concepts with pagination and filtering, (2) getTotalOnly - return only the total count of concepts, (3) getDescendants - get descendants of a specific concept (requires conceptId), (4) getAncestors - get ancestors of a specific concept (requires conceptId). Returns summarized view of concepts with essential information.",
+    inputParams: ListConceptsToolParams.shape,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    tool: listConceptsTool
+  },
+  updateConcept: {
+    title: "update_concept",
+    description: "Update a taxonomy concept in Contentful. Requires the concept ID and version number for optimistic concurrency control. You can update any combination of fields - only the fields you provide will be changed, while others remain unchanged. Use this to modify labels, definitions, relationships, and other concept properties.",
+    inputParams: UpdateConceptToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    tool: updateConceptTool
+  },
+  deleteConcept: {
+    title: "delete_concept",
+    description: "Delete a taxonomy concept from Contentful. Requires the concept ID and version number for optimistic concurrency control. This operation permanently removes the concept and cannot be undone.",
+    inputParams: DeleteConceptToolParams.shape,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    tool: deleteConceptTool
+  }
+};
+
+// src/tools/taxonomies/register.ts
+var taxonomyTools = {
+  ...conceptSchemeTools,
+  ...conceptTools
+};
+export {
+  aiActionTools,
+  assetTools,
+  contentTypeTools,
+  contextTools,
+  editorInterfaceTools,
+  entryTools,
+  environmentTools,
+  jobTools,
+  localeTools,
+  orgTools,
+  spaceTools,
+  tagTools,
+  taxonomyTools
+};
+//# sourceMappingURL=index.js.map