@contentful/mcp-server 1.0.3 → 1.0.5

package/README.md

@@ -31,7 +31,7 @@ This MCP server provides a comprehensive set of tools for content management, al
 - [📄 License and Notices](#-license-and-notices)
 - [🛡️ Code of Conduct](#️-code-of-conduct)
 
-## ⚙️ Getting Started
+## ⚙️ Getting started
 
 ### Prerequisites
 
@@ -48,6 +48,10 @@ This MCP server provides a comprehensive set of tools for content management, al
 
 _Note: This requires [Cursor](https://cursor.com/) to be installed. If the link doesn't work, try the manual installation below._
 
+**Claude Desktop:**
+
+Download the .dxt configuration file [here](https://github.com/contentful/contentful-mcp-server/releases) from the latest release and import it into Claude Desktop to automatically configure the MCP server with your environment variables.
+
 #### Install from source
 
 ```bash
@@ -65,6 +69,7 @@ npm run build
 | `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                                  |
+| `NODE_ENV`                           | ❌ No    | `production`         | Node Environment to run in                           |
 
 ### Configuration
 

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,38 @@
+#!/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 === 'development') {
+    try {
+        await import('mcps-logger/console');
+    }
+    catch {
+        console.warn('mcps-logger not available in production environment');
+    }
+}
+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');

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