@contentful/mcp-server 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Contentful
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -0,0 +1,165 @@
+# Contentful MCP Server
+
+A [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server that provides AI assistants with comprehensive tools to interact with [Contentful](https://www.contentful.com/) APIs.
+
+## 🚀 Example Use Cases
+
+This MCP server provides a comprehensive set of tools for content management, allowing AI to help you create, edit, organize, and publish content directly within Contentful. Once configured, you can use natural language in your AI assistant of choice to manage and interact with your Contentful spaces, including:
+
+- **Content Creation**: "Create a new blog post for our fall product launch"
+- **Content Management**: "Update all product entries to include the new pricing structure"
+- **Asset Organization**: "Upload and organize these marketing images by campaign"
+- **Workflow Automation**: "Create an AI action that translates content to Spanish"
+- **Content Modeling**: "Add a new field to the product content type for customer ratings"
+
+## 📓 Table of Contents
+
+- [⚙️ Getting Started](#-getting-started)
+  - [Prerequisites](#prerequisites)
+  - [Installation](#installation)
+  - [Environment Variables](#environment-variables)
+  - [Configuration](#configuration)
+- [🛠️ Available Tools](#️-available-tools)
+- [🔍 Development](#-development)
+  - [Testing with MCP Inspector](#testing-with-mcp-inspector)
+  - [Linting](#linting)
+- [📦 Releases](#-releases)
+- [🤝 Contributing](#-contributing)
+  - [Development Setup](#development-setup)
+- [📚 Documentation](#-documentation)
+- [❓ Help & Support](#-help--support)
+- [📄 License and Notices](#-license-and-notices)
+- [🛡️ Code of Conduct](#️-code-of-conduct)
+
+## ⚙️ Getting Started
+
+### Prerequisites
+
+- Node.js
+- npm
+- A Contentful account with a [Space ID](https://www.contentful.com/help/spaces/find-space-id/)
+- [Contentful Management API personal access token](https://www.contentful.com/help/token-management/personal-access-tokens/)
+
+### Installation
+
+#### Install from source
+
+```bash
+git clone https://github.com/contentful/contentful-mcp-server.git
+cd contentful-mcp-server
+npm install
+npm run build
+```
+
+### Environment Variables
+
+| Environment Variable                 | Required | Default Value        | Description                                          |
+| ------------------------------------ | -------- | -------------------- | ---------------------------------------------------- |
+| `CONTENTFUL_MANAGEMENT_ACCESS_TOKEN` | ✅ Yes   | -                    | Your Contentful Management API personal access token |
+| `SPACE_ID`                           | ✅ Yes   | -                    | Your Contentful Space ID                             |
+| `ENVIRONMENT_ID`                     | ❌ No    | `master`             | Target environment within your space                 |
+| `CONTENTFUL_HOST`                    | ❌ No    | `api.contentful.com` | Contentful API host                                  |
+
+### Configuration
+
+Refer to the documentation for your AI tool of choice for how to configure MCP servers. For example, see the documentation for [Cursor](https://docs.cursor.com/context/mcp), [VS Code](https://code.visualstudio.com/docs/copilot/chat/mcp-servers), or [Claude Desktop](https://modelcontextprotocol.io/quickstart/user).
+
+Below is a sample configuration for Cursor:
+
+```json
+{
+  "mcpServers": {
+    "contentful-mcp": {
+      "command": "npx",
+      "args": ["-y", "<your_full_path_to_the_package>/index.js"],
+      "env": {
+        "CONTENTFUL_MANAGEMENT_ACCESS_TOKEN": "your-CMA-token",
+        "SPACE_ID": "your-space-id",
+        "ENVIRONMENT_ID": "master",
+        "CONTENTFUL_HOST": "api.contentful.com"
+      }
+    }
+  }
+}
+```
+
+## 🛠️ Available Tools
+
+| Category                  | Tool Name                  | Description                                      |
+| ------------------------- | -------------------------- | ------------------------------------------------ |
+| **Context & Setup**       | `get_initial_context`      | Initialize connection and get usage instructions |
+| **Content Types**         | `list_content_types`       | List all content types                           |
+|                           | `get_content_type`         | Get detailed content type information            |
+|                           | `create_content_type`      | Create new content types                         |
+|                           | `update_content_type`      | Modify existing content types                    |
+|                           | `publish_content_type`     | Publish content type changes                     |
+|                           | `unpublish_content_type`   | Unpublish content types                          |
+|                           | `delete_content_type`      | Remove content types                             |
+| **Entries**               | `search_entries`           | Search and filter entries                        |
+|                           | `get_entry`                | Retrieve specific entries                        |
+|                           | `create_entry`             | Create new content entries                       |
+|                           | `update_entry`             | Modify existing entries                          |
+|                           | `publish_entry`            | Publish entries (single or bulk)                 |
+|                           | `unpublish_entry`          | Unpublish entries (single or bulk)               |
+|                           | `delete_entry`             | Remove entries                                   |
+| **Assets**                | `upload_asset`             | Upload new assets                                |
+|                           | `list_assets`              | List and browse assets                           |
+|                           | `get_asset`                | Retrieve specific assets                         |
+|                           | `update_asset`             | Modify asset metadata                            |
+|                           | `publish_asset`            | Publish assets (single or bulk)                  |
+|                           | `unpublish_asset`          | Unpublish assets (single or bulk)                |
+|                           | `delete_asset`             | Remove assets                                    |
+| **Spaces & Environments** | `list_spaces`              | List available spaces                            |
+|                           | `get_space`                | Get space details                                |
+|                           | `list_environments`        | List environments                                |
+|                           | `create_environment`       | Create new environments                          |
+|                           | `delete_environment`       | Remove environments                              |
+| **Locales**               | `list_locales`             | List all locales in your environment             |
+|                           | `get_locale`               | Retrieve specific locale information             |
+|                           | `create_locale`            | Create new locales for multi-language content    |
+|                           | `update_locale`            | Modify existing locale settings                  |
+|                           | `delete_locale`            | Remove locales from environment                  |
+| **Tags**                  | `list_tags`                | List all tags                                    |
+|                           | `create_tag`               | Create new tags                                  |
+| **AI Actions**            | `create_ai_action`         | Create custom AI-powered workflows               |
+|                           | `invoke_ai_action`         | Invoke an AI action with variables               |
+|                           | `get_ai_action_invocation` | Get AI action invocation details                 |
+|                           | `get_ai_action`            | Retrieve AI action details and configuration     |
+|                           | `list_ai_actions`          | List AI actions in a space                       |
+|                           | `update_ai_action`         | Update existing AI actions                       |
+|                           | `publish_ai_action`        | Publish AI actions for use                       |
+|                           | `unpublish_ai_action`      | Unpublish AI actions                             |
+|                           | `delete_ai_action`         | Remove AI actions                                |
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for local development setup and contribution guidelines.
+
+## 📦 Releases
+
+This project uses [Nx Release](https://nx.dev/features/manage-releases) for automated versioning and publishing. Releases are automatically generated based on [Conventional Commits](https://www.conventionalcommits.org/). See [Contributing Guide](CONTRIBUTING.md) for more information on release process.
+
+## 📚 Documentation
+
+- [Model Context Protocol Documentation](https://modelcontextprotocol.io/)
+- [Contentful Management API Documentation](https://www.contentful.com/developers/docs/references/content-management-api/)
+
+## ❓ Help & Support
+
+- [Contentful support resources](https://www.contentful.com/help/getting-started/how-to-get-help/)
+- [Report bugs or request features](https://github.com/contentful/contentful-mcp-server/issues)
+- [Contentful Community Discord](https://www.contentful.com/discord/)
+
+## 📄 License and Notices
+
+This project is licensed under the MIT License. See [LICENSE](./LICENSE) for details.
+
+It also includes open-source components licensed under MIT, BSD-2-Clause, and Apache-2.0. For details, see the [NOTICE](./NOTICE) file.
+
+This project includes an automated license management system that keeps track of all dependencies and their licenses. See the [AUTOMATION-FOR-LICENSES](./AUTOMATION-FOR-LICENSES.md) file for more information.
+
+## 🛡️ Code of Conduct
+
+We want to provide a safe, inclusive, welcoming, and harassment-free space and experience for all participants, regardless of gender identity and expression, sexual orientation, disability, physical appearance, socioeconomic status, body size, ethnicity, nationality, level of experience, age, religion (or lack thereof), or other identity markers.
+
+[Read our full Code of Conduct](https://www.contentful.com/developers/code-of-conduct/).

package/build/config/contentful.js

@@ -0,0 +1,19 @@
+import { env } from '../config/env.js';
+import { getVersion } from '../utils/getVersion.js';
+/**
+ * Creates a default Contentful client configuration without actually initializing it.
+ */
+export function getDefaultClientConfig() {
+    if (!env.success) {
+        throw new Error('Environment variables are not properly configured');
+    }
+    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;
+}

package/build/config/env.js

@@ -0,0 +1,25 @@
+import dotenv from 'dotenv';
+import { z } from 'zod';
+dotenv.config();
+const EnvSchema = z.object({
+    CONTENTFUL_MANAGEMENT_ACCESS_TOKEN: z
+        .string()
+        .describe('Contentul 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'),
+});
+export const env = EnvSchema.safeParse(process.env);
+if (!env.success) {
+    console.error('Invalid environment variables', env.error.format());
+    process.exit(1);
+}

package/build/config/version.js

@@ -0,0 +1,2 @@
+// Generated file - do not edit
+export const VERSION = '0.0.1';

package/build/index.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerAllPrompts } from './prompts/register.js';
+import { registerAllResources } from './resources/register.js';
+import { registerAllTools } from './tools/register.js';
+import { VERSION } from './config/version.js';
+if (process.env.NODE_ENV !== 'production') {
+    import('mcps-logger/console');
+}
+const MCP_SERVER_NAME = '@contentful/mcp-server';
+async function initializeServer() {
+    const server = new McpServer({
+        name: MCP_SERVER_NAME,
+        version: VERSION,
+    });
+    registerAllTools(server);
+    registerAllPrompts(server);
+    registerAllResources(server);
+    return server;
+}
+async function main() {
+    try {
+        const server = await initializeServer();
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+    }
+    catch (error) {
+        console.error('Fatal error:', error);
+        process.exit(1);
+    }
+}
+main();

package/build/prompts/register.js

@@ -0,0 +1 @@
+export function registerAllPrompts(_server) { }

package/build/resources/register.js

@@ -0,0 +1 @@
+export function registerAllResources(_server) { }

package/build/tools/ai-actions/createAiAction.js

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+import { VariableType } from '../../utils/ai-actions.js';
+export const CreateAiActionToolParams = BaseToolSchema.extend({
+    name: z.string().describe('The name of the AI action'),
+    description: z.string().describe('The description of the AI action'),
+    instruction: z
+        .object({
+        template: z.string().describe('The template for the AI action'),
+        variables: z
+            .array(z.object({
+            id: z.string().describe('The id of the variable'),
+            name: z.string().optional().describe('The name of the variable'),
+            type: z
+                .nativeEnum(VariableType)
+                .describe('The type of the variable'),
+            description: z
+                .string()
+                .optional()
+                .describe('The description of the variable'),
+        }))
+            .describe('Array of variables for the AI action'),
+    })
+        .describe('The instruction for the AI action'),
+    configuration: z
+        .object({
+        modelType: z.string().describe('The type of model to use'),
+        modelTemperature: z.number().describe('The temperature for the model'),
+    })
+        .describe('The configuration for the AI action'),
+    testCases: z
+        .array(z.any())
+        .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 });
+}
+export const createAiActionTool = withErrorHandling(tool, 'Error creating AI action');

package/build/tools/ai-actions/deleteAiAction.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const DeleteAiActionToolParams = BaseToolSchema.extend({
+    aiActionId: z.string().describe('The ID of the AI action to delete'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        aiActionId: args.aiActionId,
+    };
+    const contentfulClient = createToolClient(args);
+    // First, get the AI action to store info for return
+    const aiAction = await contentfulClient.aiAction.get(params);
+    // Delete the AI action
+    await contentfulClient.aiAction.delete(params);
+    return createSuccessResponse('AI action deleted successfully', { aiAction });
+}
+export const deleteAiActionTool = withErrorHandling(tool, 'Error deleting AI action');

package/build/tools/ai-actions/getAiAction.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const GetAiActionToolParams = BaseToolSchema.extend({
+    aiActionId: z.string().describe('The ID of the AI action to retrieve'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        aiActionId: args.aiActionId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Get the AI action
+    const aiAction = await contentfulClient.aiAction.get(params);
+    return createSuccessResponse('AI action retrieved successfully', {
+        aiAction,
+    });
+}
+export const getAiActionTool = withErrorHandling(tool, 'Error retrieving AI action');

package/build/tools/ai-actions/getAiActionInvocation.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const GetAiActionInvocationToolParams = BaseToolSchema.extend({
+    aiActionId: z.string().describe('The ID of the AI action'),
+    invocationId: z.string().describe('The ID of the invocation to retrieve'),
+});
+async function tool(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,
+    });
+}
+export const getAiActionInvocationTool = withErrorHandling(tool, 'Error retrieving AI action invocation');

package/build/tools/ai-actions/invokeAiAction.js

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+import { OutputFormat, VariableValue, } from '../../utils/ai-actions.js';
+export const InvokeAiActionToolParams = BaseToolSchema.extend({
+    aiActionId: z.string().describe('The ID of the AI action to invoke'),
+    fields: z.array(z.object({
+        outputFormat: z
+            .nativeEnum(OutputFormat)
+            .describe('The output format of the AI action'),
+        variables: z
+            .array(VariableValue)
+            .describe('The variable assignments within the AI action invocation'),
+    })),
+});
+async function pollForCompletion(contentfulClient, params, aiActions, pollInterval = 30000, maxAttempts = 10) {
+    const completedActions = 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)) //filter out actions that have already been completed
+            .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 tool(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);
+    }
+    // Poll for completion
+    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.`,
+    });
+}
+export const invokeAiActionTool = withErrorHandling(tool, 'Error invoking AI action');

package/build/tools/ai-actions/listAiActions.js

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+import { summarizeData } from '../../utils/summarizer.js';
+export const ListAiActionToolParams = BaseToolSchema.extend({
+    limit: z
+        .number()
+        .optional()
+        .describe('Maximum number of AI actions to return (max 3)'),
+    skip: z
+        .number()
+        .optional()
+        .describe('Skip this many AI actions for pagination'),
+    select: z
+        .string()
+        .optional()
+        .describe('Comma-separated list of fields to return'),
+    include: z
+        .number()
+        .optional()
+        .describe('Include this many levels of linked entries'),
+    order: z.string().optional().describe('Order AI actions by this field'),
+});
+async function tool(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,
+    });
+}
+export const listAiActionTool = withErrorHandling(tool, 'Error listing AI actions');

package/build/tools/ai-actions/publishAiAction.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const PublishAiActionToolParams = BaseToolSchema.extend({
+    aiActionId: z.string().describe('The ID of the AI action to publish'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        aiActionId: args.aiActionId,
+    };
+    const contentfulClient = createToolClient(args);
+    try {
+        // Get the AI action first
+        const aiAction = await contentfulClient.aiAction.get(params);
+        // Publish the AI action with the version parameter
+        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,
+        });
+    }
+}
+export const publishAiActionTool = withErrorHandling(tool, 'Error publishing AI action');

package/build/tools/ai-actions/register.js

@@ -0,0 +1,20 @@
+import { createAiActionTool, CreateAiActionToolParams, } from './createAiAction.js';
+import { invokeAiActionTool, InvokeAiActionToolParams, } from './invokeAiAction.js';
+import { getAiActionInvocationTool, GetAiActionInvocationToolParams, } from './getAiActionInvocation.js';
+import { deleteAiActionTool, DeleteAiActionToolParams, } from './deleteAiAction.js';
+import { getAiActionTool, GetAiActionToolParams } from './getAiAction.js';
+import { listAiActionTool, ListAiActionToolParams } from './listAiActions.js';
+import { publishAiActionTool, PublishAiActionToolParams, } from './publishAiAction.js';
+import { unpublishAiActionTool, UnpublishAiActionToolParams, } from './unpublishAiAction.js';
+import { updateAiActionTool, UpdateAiActionToolParams, } from './updateAiAction.js';
+export function registerAiActionsTools(server) {
+    server.tool('create_ai_action', '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.', CreateAiActionToolParams.shape, createAiActionTool);
+    server.tool('invoke_ai_action', '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.', InvokeAiActionToolParams.shape, invokeAiActionTool);
+    server.tool('get_ai_action_invocation', 'Retrieve information about a specific AI action invocation by its ID.', GetAiActionInvocationToolParams.shape, getAiActionInvocationTool);
+    server.tool('delete_ai_action', 'Delete a specific AI action from your Contentful space', DeleteAiActionToolParams.shape, deleteAiActionTool);
+    server.tool('get_ai_action', 'Retrieve details about a specific AI action including its configuration, instructions, and defined variables', GetAiActionToolParams.shape, getAiActionTool);
+    server.tool('list_ai_actions', 'List AI actions in a space. Returns a maximum of 3 items per request. Use skip parameter to paginate through results.', ListAiActionToolParams.shape, listAiActionTool);
+    server.tool('publish_ai_action', 'Publish an AI action to make it available for use in the Contentful web app', PublishAiActionToolParams.shape, publishAiActionTool);
+    server.tool('unpublish_ai_action', 'Unpublish an AI action to remove it from use in the Contentful web app', UnpublishAiActionToolParams.shape, unpublishAiActionTool);
+    server.tool('update_ai_action', '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.', UpdateAiActionToolParams.shape, updateAiActionTool);
+}

package/build/tools/ai-actions/unpublishAiAction.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const UnpublishAiActionToolParams = BaseToolSchema.extend({
+    aiActionId: z.string().describe('The ID of the AI action to unpublish'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        aiActionId: args.aiActionId,
+    };
+    const contentfulClient = createToolClient(args);
+    try {
+        // Unpublish the AI action
+        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,
+        });
+    }
+}
+export const unpublishAiActionTool = withErrorHandling(tool, 'Error unpublishing AI action');