@contentful/mcp-server 1.0.0

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

@@ -0,0 +1,64 @@
+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 UpdateAiActionToolParams = BaseToolSchema.extend({
+    aiActionId: z.string().describe('The ID of the AI action to update'),
+    name: z.string().optional().describe('The name of the AI action'),
+    description: z
+        .string()
+        .optional()
+        .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'),
+    })
+        .optional()
+        .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'),
+    })
+        .optional()
+        .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,
+        aiActionId: args.aiActionId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Get existing AI action, merge fields, and update
+    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,
+    });
+}
+export const updateAiActionTool = withErrorHandling(tool, 'Error updating AI action');

package/build/tools/assets/deleteAsset.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 DeleteAssetToolParams = BaseToolSchema.extend({
+    assetId: z.string().describe('The ID of the asset to delete'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        assetId: args.assetId,
+    };
+    const contentfulClient = createToolClient(args);
+    // First, get the asset to store info for return
+    const asset = await contentfulClient.asset.get(params);
+    // Delete the asset
+    await contentfulClient.asset.delete(params);
+    return createSuccessResponse('Asset deleted successfully', { asset });
+}
+export const deleteAssetTool = withErrorHandling(tool, 'Error deleting asset');

package/build/tools/assets/getAsset.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 GetAssetToolParams = BaseToolSchema.extend({
+    assetId: z.string().describe('The ID of the asset to retrieve'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        assetId: args.assetId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Get the asset
+    const asset = await contentfulClient.asset.get(params);
+    return createSuccessResponse('Asset retrieved successfully', { asset });
+}
+export const getAssetTool = withErrorHandling(tool, 'Error retrieving asset');

package/build/tools/assets/listAssets.js

@@ -0,0 +1,68 @@
+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 ListAssetsToolParams = BaseToolSchema.extend({
+    limit: z
+        .number()
+        .optional()
+        .describe('Maximum number of assets to return (max 3)'),
+    skip: z.number().optional().describe('Skip this many assets 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 assets by this field'),
+    links_to_entry: z
+        .string()
+        .optional()
+        .describe('Find assets that link to the specified entry ID'),
+});
+async function tool(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,
+    });
+}
+export const listAssetsTool = withErrorHandling(tool, 'Error listing assets');

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');