@contentful/mcp-server 1.0.2 → 1.0.4

package/build/tools/assets/publishAsset.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+import { createAssetVersionedLinks, createEntitiesCollection, waitForBulkActionCompletion, } from '../../utils/bulkOperations.js';
+export const PublishAssetToolParams = BaseToolSchema.extend({
+    assetId: z
+        .union([z.string(), z.array(z.string()).max(100)])
+        .describe('The ID of the asset to publish (string) or an array of asset IDs (up to 100 assets)'),
+});
+async function tool(args) {
+    const baseParams = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Normalize input to always be an array
+    const assetIds = Array.isArray(args.assetId) ? args.assetId : [args.assetId];
+    // For single asset, use individual publish
+    if (assetIds.length === 1) {
+        try {
+            const assetId = assetIds[0];
+            const params = {
+                ...baseParams,
+                assetId,
+            };
+            // Get the asset first
+            const asset = await contentfulClient.asset.get(params);
+            // Publish the asset
+            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],
+            });
+        }
+    }
+    // For multiple assets, use bulk action API
+    // Get the current version of each asset
+    const entityVersions = await createAssetVersionedLinks(contentfulClient, baseParams, assetIds);
+    // Create the collection object
+    const entitiesCollection = createEntitiesCollection(entityVersions);
+    // Create the bulk action
+    const bulkAction = await contentfulClient.bulkAction.publish(baseParams, {
+        entities: entitiesCollection,
+    });
+    // Wait for the bulk action to complete
+    const action = await waitForBulkActionCompletion(contentfulClient, baseParams, bulkAction.sys.id);
+    return createSuccessResponse('Asset(s) published successfully', {
+        status: action.sys.status,
+        assetIds,
+    });
+}
+export const publishAssetTool = withErrorHandling(tool, 'Error publishing asset');

package/build/tools/assets/register.js

@@ -0,0 +1,16 @@
+import { uploadAssetTool, UploadAssetToolParams } from './uploadAsset.js';
+import { listAssetsTool, ListAssetsToolParams } from './listAssets.js';
+import { getAssetTool, GetAssetToolParams } from './getAsset.js';
+import { updateAssetTool, UpdateAssetToolParams } from './updateAsset.js';
+import { deleteAssetTool, DeleteAssetToolParams } from './deleteAsset.js';
+import { publishAssetTool, PublishAssetToolParams } from './publishAsset.js';
+import { unpublishAssetTool, UnpublishAssetToolParams, } from './unpublishAsset.js';
+export function registerAssetTools(server) {
+    server.tool('upload_asset', 'Upload a new asset', UploadAssetToolParams.shape, uploadAssetTool);
+    server.tool('list_assets', 'List assets in a space. Returns a maximum of 3 items per request. Use skip parameter to paginate through results.', ListAssetsToolParams.shape, listAssetsTool);
+    server.tool('get_asset', 'Retrieve an asset', GetAssetToolParams.shape, getAssetTool);
+    server.tool('update_asset', 'Update an asset', UpdateAssetToolParams.shape, updateAssetTool);
+    server.tool('delete_asset', 'Delete an asset', DeleteAssetToolParams.shape, deleteAssetTool);
+    server.tool('publish_asset', '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.', PublishAssetToolParams.shape, publishAssetTool);
+    server.tool('unpublish_asset', '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.', UnpublishAssetToolParams.shape, unpublishAssetTool);
+}

package/build/tools/assets/unpublishAsset.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+import { createEntitiesCollection, waitForBulkActionCompletion, createAssetUnversionedLinks, } from '../../utils/bulkOperations.js';
+export const UnpublishAssetToolParams = BaseToolSchema.extend({
+    assetId: z
+        .union([z.string(), z.array(z.string()).max(100)])
+        .describe('The ID of the asset to unpublish (string) or an array of asset IDs (up to 100 assets)'),
+});
+async function tool(args) {
+    const baseParams = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Normalize input to always be an array
+    const assetIds = Array.isArray(args.assetId) ? args.assetId : [args.assetId];
+    // For single asset, use individual unpublish for simplicity
+    if (assetIds.length === 1) {
+        try {
+            const assetId = assetIds[0];
+            const params = {
+                ...baseParams,
+                assetId,
+            };
+            // Get the asset first
+            const asset = await contentfulClient.asset.get(params);
+            // Unpublish the asset
+            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],
+            });
+        }
+    }
+    // For multiple assets, use bulk action API
+    // Get the unversioned links for each asset (unpublish doesn't need version info)
+    const assetLinks = await createAssetUnversionedLinks(contentfulClient, baseParams, assetIds);
+    // Create the collection object
+    const entitiesCollection = createEntitiesCollection(assetLinks);
+    // Create the bulk action
+    const bulkAction = await contentfulClient.bulkAction.unpublish(baseParams, {
+        entities: entitiesCollection,
+    });
+    // Wait for the bulk action to complete
+    const action = await waitForBulkActionCompletion(contentfulClient, baseParams, bulkAction.sys.id);
+    return createSuccessResponse('Asset(s) unpublished successfully', {
+        status: action.sys.status,
+        assetIds,
+    });
+}
+export const unpublishAssetTool = withErrorHandling(tool, 'Error unpublishing asset');

package/build/tools/assets/updateAsset.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const UpdateAssetToolParams = BaseToolSchema.extend({
+    assetId: z.string().describe('The ID of the asset to update'),
+    fields: z
+        .record(z.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: z
+        .object({
+        tags: z.array(z.object({
+            sys: z.object({
+                type: z.literal('Link'),
+                linkType: z.literal('Tag'),
+                id: z.string(),
+            }),
+        })),
+    })
+        .optional(),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        assetId: args.assetId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Get existing asset, merge fields, and update
+    const existingAsset = await contentfulClient.asset.get(params);
+    const updatedAsset = await contentfulClient.asset.update(params, {
+        ...existingAsset,
+        fields: { ...existingAsset.fields, ...args.fields },
+        metadata: {
+            tags: [
+                ...(existingAsset.metadata?.tags || []),
+                ...(args.metadata?.tags || []),
+            ],
+        },
+    });
+    return createSuccessResponse('Asset updated successfully', { updatedAsset });
+}
+export const updateAssetTool = withErrorHandling(tool, 'Error updating asset');

package/build/tools/assets/uploadAsset.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+const FileSchema = z.object({
+    fileName: z.string().describe('The name of the file'),
+    contentType: z.string().describe('The MIME type of the file'),
+    upload: z.string().optional().describe('The upload URL or file data'),
+});
+export const UploadAssetToolParams = BaseToolSchema.extend({
+    title: z.string().describe('The title of the asset'),
+    description: z.string().optional().describe('The description of the asset'),
+    file: FileSchema.describe('The file information for the asset'),
+    metadata: z
+        .object({
+        tags: z.array(z.object({
+            sys: z.object({
+                type: z.literal('Link'),
+                linkType: z.literal('Tag'),
+                id: z.string(),
+            }),
+        })),
+    })
+        .optional(),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Prepare asset properties following Contentful's structure
+    const assetProps = {
+        fields: {
+            title: { 'en-US': args.title },
+            description: args.description ? { 'en-US': args.description } : undefined,
+            file: { 'en-US': args.file },
+        },
+        metadata: args.metadata,
+    };
+    // Create the asset
+    const asset = await contentfulClient.asset.create(params, assetProps);
+    // Process the asset for all locales
+    const processedAsset = await contentfulClient.asset.processForAllLocales(params, {
+        sys: asset.sys,
+        fields: asset.fields,
+    }, {});
+    return createSuccessResponse('Asset uploaded successfully', {
+        asset: processedAsset,
+    });
+}
+export const uploadAssetTool = withErrorHandling(tool, 'Error uploading asset');

package/build/tools/context/getInitialContextTool.js

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { outdent } from 'outdent';
+import { contextStore } from './store.js';
+import { withErrorHandling } from '../../utils/response.js';
+import { MCP_INSTRUCTIONS } from './instructions.js';
+import { env } from '../../config/env.js';
+export const GetInitialContextToolParams = z.object({});
+export function hasInitialContext() {
+    return contextStore.hasInitialContext();
+}
+async function tool(_params) {
+    const config = {
+        space: env.data?.SPACE_ID,
+        environment: env.data?.ENVIRONMENT_ID,
+    };
+    const configInfo = `Current Contentful Configuration:
+  - Space ID: ${config.space}
+  - Environment ID: ${config.environment}`;
+    const todaysDate = 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,
+            },
+        ],
+    };
+}
+export const getInitialContextTool = withErrorHandling(tool, 'Error getting initial context');

package/build/tools/context/instructions.js

@@ -0,0 +1,111 @@
+export const 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
+
+
+# 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.`;

package/build/tools/context/middleware.js

@@ -0,0 +1,8 @@
+import { contextStore } from './store.js';
+export function enforceInitialContextMiddleware(toolName) {
+    if (toolName === 'get_initial_context')
+        return;
+    if (!contextStore.hasInitialContext()) {
+        throw new Error('Initial context has not been retrieved. Please call get_initial_context tool first to get the initial context.');
+    }
+}

package/build/tools/context/register.js

@@ -0,0 +1,4 @@
+import { getInitialContextTool, GetInitialContextToolParams, } from './getInitialContextTool.js';
+export function registerContextTools(server) {
+    server.tool('get_initial_context', 'IMPORTANT: This tool must be called before using any other tools. It will get initial context and usage instructions for this MCP server. ', GetInitialContextToolParams.shape, getInitialContextTool);
+}

package/build/tools/context/store.js

@@ -0,0 +1,15 @@
+class ContextStore {
+    context = {
+        hasGlobalContext: false,
+    };
+    setInitialContextLoaded() {
+        this.context.hasGlobalContext = true;
+    }
+    hasInitialContext() {
+        return this.context.hasGlobalContext;
+    }
+    resetInitialContext() {
+        this.context.hasGlobalContext = false;
+    }
+}
+export const contextStore = new ContextStore();

package/build/tools/entries/createEntry.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const CreateEntryToolParams = BaseToolSchema.extend({
+    contentTypeId: z
+        .string()
+        .describe('The ID of the content type to create an entry for'),
+    fields: z
+        .record(z.any())
+        .describe('The field values for the new entry. Keys should be field IDs and values should be the field content.'),
+    metadata: z
+        .object({
+        tags: z.array(z.object({
+            sys: z.object({
+                type: z.literal('Link'),
+                linkType: z.literal('Tag'),
+                id: z.string(),
+            }),
+        })),
+    })
+        .optional(),
+});
+async function tool(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,
+        metadata: args.metadata,
+    });
+    //return info about the entry that was created
+    return createSuccessResponse('Entry created successfully', { newEntry });
+}
+export const createEntryTool = withErrorHandling(tool, 'Error creating entry');

package/build/tools/entries/deleteEntry.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 DeleteEntryToolParams = BaseToolSchema.extend({
+    entryId: z.string().describe('The ID of the entry to delete'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        entryId: args.entryId,
+    };
+    const contentfulClient = createToolClient(args);
+    // First, get the entry to check its status
+    const entry = await contentfulClient.entry.get(params);
+    // Delete the entry
+    await contentfulClient.entry.delete(params);
+    //return info about the entry that was deleted
+    return createSuccessResponse('Entry deleted successfully', { entry });
+}
+export const deleteEntryTool = withErrorHandling(tool, 'Error deleting entry');

package/build/tools/entries/getEntry.js

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

package/build/tools/entries/publishEntry.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+import { createEntryVersionedLinks, createEntitiesCollection, waitForBulkActionCompletion, } from '../../utils/bulkOperations.js';
+export const PublishEntryToolParams = BaseToolSchema.extend({
+    entryId: z
+        .union([z.string(), z.array(z.string()).max(100)])
+        .describe('The ID of the entry to publish (string) or an array of entry IDs (up to 100 entries)'),
+});
+async function tool(args) {
+    const baseParams = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Normalize input to always be an array
+    const entryIds = Array.isArray(args.entryId) ? args.entryId : [args.entryId];
+    // For single entry, use individual publish for simplicity
+    if (entryIds.length === 1) {
+        try {
+            const entryId = entryIds[0];
+            const params = {
+                ...baseParams,
+                entryId,
+            };
+            // Get the entry first
+            const entry = await contentfulClient.entry.get(params);
+            // Publish the entry
+            const publishedEntry = await contentfulClient.entry.publish(params, entry);
+            return createSuccessResponse('Entry published successfully', {
+                status: publishedEntry.sys.status,
+                entryId,
+            });
+        }
+        catch (error) {
+            return createSuccessResponse('Entry publish failed', {
+                status: error,
+                entryId: entryIds[0],
+            });
+        }
+    }
+    // For multiple entries, use bulk action API
+    // Get the current version of each entry
+    const entityVersions = await createEntryVersionedLinks(contentfulClient, baseParams, entryIds);
+    // Create the collection object
+    const entitiesCollection = createEntitiesCollection(entityVersions);
+    // Create the bulk action
+    const bulkAction = await contentfulClient.bulkAction.publish(baseParams, {
+        entities: entitiesCollection,
+    });
+    // Wait for the bulk action to complete
+    const action = await waitForBulkActionCompletion(contentfulClient, baseParams, bulkAction.sys.id);
+    return createSuccessResponse('Entry(s) published successfully', {
+        status: action.sys.status,
+        entryIds,
+    });
+}
+export const publishEntryTool = withErrorHandling(tool, 'Error publishing entry');

package/build/tools/entries/register.js

@@ -0,0 +1,16 @@
+import { searchEntriesTool, SearchEntriesToolParams } from './searchEntries.js';
+import { createEntryTool, CreateEntryToolParams } from './createEntry.js';
+import { deleteEntryTool, DeleteEntryToolParams } from './deleteEntry.js';
+import { updateEntryTool, UpdateEntryToolParams } from './updateEntry.js';
+import { getEntryTool, GetEntryToolParams } from './getEntry.js';
+import { publishEntryTool, PublishEntryToolParams } from './publishEntry.js';
+import { unpublishEntryTool, UnpublishEntryToolParams, } from './unpublishEntry.js';
+export function registerEntriesTools(server) {
+    server.tool('search_entries', 'Search for specific entries in your Contentful space', SearchEntriesToolParams.shape, searchEntriesTool);
+    server.tool('create_entry', "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' } }] } }.", CreateEntryToolParams.shape, createEntryTool);
+    server.tool('get_entry', 'Retrieve an existing entry', GetEntryToolParams.shape, getEntryTool);
+    server.tool('update_entry', "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: {} }.", UpdateEntryToolParams.shape, updateEntryTool);
+    server.tool('delete_entry', 'Delete a specific content entry from your Contentful space', DeleteEntryToolParams.shape, deleteEntryTool);
+    server.tool('publish_entry', '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.', PublishEntryToolParams.shape, publishEntryTool);
+    server.tool('unpublish_entry', '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.', UnpublishEntryToolParams.shape, unpublishEntryTool);
+}

package/build/tools/entries/searchEntries.js

@@ -0,0 +1,50 @@
+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 SearchEntriesToolParams = BaseToolSchema.extend({
+    query: z.object({
+        content_type: z.string().optional().describe('Filter by content type'),
+        include: z
+            .number()
+            .optional()
+            .describe('Include this many levels of linked entries'),
+        select: z
+            .string()
+            .optional()
+            .describe('Comma-separated list of fields to return'),
+        links_to_entry: z
+            .string()
+            .optional()
+            .describe('Find entries that link to the specified entry ID'),
+        limit: z
+            .number()
+            .optional()
+            .describe('Maximum number of entries to return'),
+        skip: z.number().optional().describe('Skip this many entries'),
+        order: z.string().optional().describe('Order entries by this field'),
+    }),
+});
+async function tool(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,
+    });
+}
+export const searchEntriesTool = withErrorHandling(tool, 'Error deleting dataset');