@contentful/mcp-server 1.0.3 → 1.0.4

package/build/tools/entries/unpublishEntry.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+import { createEntryUnversionedLinks, createEntitiesCollection, waitForBulkActionCompletion, } from '../../utils/bulkOperations.js';
+export const UnpublishEntryToolParams = BaseToolSchema.extend({
+    entryId: z
+        .union([z.string(), z.array(z.string()).max(100)])
+        .describe('The ID of the entry to unpublish (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);
+            // Unpublish the entry
+            const unpublishedEntry = await contentfulClient.entry.unpublish(params, entry);
+            return createSuccessResponse('Entry unpublished successfully', {
+                status: unpublishedEntry.sys.status,
+                entryId,
+            });
+        }
+        catch (error) {
+            return createSuccessResponse('Entry unpublish failed', {
+                status: error,
+                entryId: entryIds[0],
+            });
+        }
+    }
+    // For multiple entries, use bulk action API
+    // Get the unversioned links for each entry (unpublish doesn't need version info)
+    const entityLinks = await createEntryUnversionedLinks(contentfulClient, baseParams, entryIds);
+    // Create the collection object
+    const entitiesCollection = createEntitiesCollection(entityLinks);
+    // 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('Entry(s) unpublished successfully', {
+        status: action.sys.status,
+        entryIds,
+    });
+}
+export const unpublishEntryTool = withErrorHandling(tool, 'Error unpublishing entry');

package/build/tools/entries/updateEntry.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const UpdateEntryToolParams = BaseToolSchema.extend({
+    entryId: z.string().describe('The ID of the entry 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,
+        entryId: args.entryId,
+    };
+    const contentfulClient = createToolClient(args);
+    // First, get the existing entry
+    const existingEntry = await contentfulClient.entry.get(params);
+    // Merge the provided fields with existing fields
+    const mergedFields = {
+        ...existingEntry.fields,
+        ...args.fields,
+    };
+    const allTags = [
+        ...(existingEntry.metadata?.tags || []),
+        ...(args.metadata?.tags || []),
+    ];
+    // Update the entry with merged fields
+    const updatedEntry = await contentfulClient.entry.update(params, {
+        ...existingEntry,
+        fields: mergedFields,
+        metadata: {
+            tags: allTags,
+        },
+    });
+    //return info about the entry that was updated
+    return createSuccessResponse('Entry updated successfully', { updatedEntry });
+}
+export const updateEntryTool = withErrorHandling(tool, 'Error updating entry');

package/build/tools/environments/createEnvironment.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 CreateEnvironmentToolParams = BaseToolSchema.extend({
+    environmentId: z.string().describe('The ID of the environment to create'),
+    name: z.string().describe('The name of the environment to create'),
+});
+async function tool(args) {
+    const contentfulClient = createToolClient(args);
+    // Create the environment
+    const environment = await contentfulClient.environment.createWithId({
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+    }, {
+        name: args.name,
+    });
+    return createSuccessResponse('Environment created successfully', {
+        environment,
+    });
+}
+export const createEnvironmentTool = withErrorHandling(tool, 'Error creating environment');

package/build/tools/environments/deleteEnvironment.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const DeleteEnvironmentToolParams = BaseToolSchema.extend({
+    environmentId: z.string().describe('The ID of the environment to delete'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Delete the environment
+    await contentfulClient.environment.delete(params);
+    return createSuccessResponse('Environment deleted successfully', {
+        environmentId: args.environmentId,
+    });
+}
+export const deleteEnvironmentTool = withErrorHandling(tool, 'Error deleting environment');

package/build/tools/environments/listEnvironments.js

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+import { summarizeData } from '../../utils/summarizer.js';
+// Extend BaseToolSchema but make environmentId optional since it's not needed for listing
+export const ListEnvironmentsToolParams = BaseToolSchema.extend({
+    environmentId: z
+        .string()
+        .optional()
+        .describe('The ID of the Contentful environment (not required for listing)'),
+    limit: z
+        .number()
+        .optional()
+        .describe('Maximum number of environments to return (max 10)'),
+    skip: z
+        .number()
+        .optional()
+        .describe('Skip this many environments for pagination'),
+    select: z
+        .string()
+        .optional()
+        .describe('Comma-separated list of fields to return'),
+    order: z.string().optional().describe('Order environments by this field'),
+});
+async function tool(args) {
+    // Provide a default environmentId if not specified
+    const clientArgs = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId || 'master',
+    };
+    const contentfulClient = createToolClient(clientArgs);
+    const environments = await contentfulClient.environment.getMany({
+        spaceId: args.spaceId,
+        query: {
+            limit: Math.min(args.limit || 10, 10),
+            skip: args.skip || 0,
+            ...(args.select && { select: args.select }),
+            ...(args.order && { order: args.order }),
+        },
+    });
+    const summarizedEnvironments = environments.items.map((environment) => ({
+        id: environment.sys.id,
+        name: environment.name,
+        status: environment.sys.status?.sys?.id || 'unknown',
+        createdAt: environment.sys.createdAt,
+        updatedAt: environment.sys.updatedAt,
+    }));
+    const summarized = summarizeData({
+        ...environments,
+        items: summarizedEnvironments,
+    }, {
+        maxItems: 10,
+        remainingMessage: 'To see more environments, please ask me to retrieve the next page using the skip parameter.',
+    });
+    return createSuccessResponse('Environments retrieved successfully', {
+        environments: summarized,
+        total: environments.total,
+        limit: environments.limit,
+        skip: environments.skip,
+    });
+}
+export const listEnvironmentsTool = withErrorHandling(tool, 'Error listing environments');

package/build/tools/environments/register.js

@@ -0,0 +1,8 @@
+import { createEnvironmentTool, CreateEnvironmentToolParams, } from './createEnvironment.js';
+import { listEnvironmentsTool, ListEnvironmentsToolParams, } from './listEnvironments.js';
+import { deleteEnvironmentTool, DeleteEnvironmentToolParams, } from './deleteEnvironment.js';
+export function registerEnvironmentTools(server) {
+    server.tool('create_environment', 'Create a new environment', CreateEnvironmentToolParams.shape, createEnvironmentTool);
+    server.tool('list_environments', 'List all environments in a space', ListEnvironmentsToolParams.shape, listEnvironmentsTool);
+    server.tool('delete_environment', 'Delete an environment', DeleteEnvironmentToolParams.shape, deleteEnvironmentTool);
+}

package/build/tools/locales/createLocale.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const CreateLocaleToolParams = BaseToolSchema.extend({
+    name: z.string().describe('The name of the locale'),
+    code: z.string().describe('The locale code (e.g., "en-US")'),
+    fallbackCode: z
+        .string()
+        .optional()
+        .describe('The locale code to fallback to when there is no content for the current locale'),
+    contentDeliveryApi: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('If the content under this locale should be available on the CDA (for public reading)'),
+    contentManagementApi: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('If the content under this locale should be available on the CMA (for editing)'),
+    default: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('If this is the default locale'),
+    optional: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('If the locale needs to be filled in on entries or not'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Create the locale
+    const newLocale = await contentfulClient.locale.create(params, {
+        name: args.name,
+        code: args.code,
+        fallbackCode: args.fallbackCode,
+        contentDeliveryApi: args.contentDeliveryApi,
+        contentManagementApi: args.contentManagementApi,
+        optional: args.optional,
+    });
+    return createSuccessResponse('Locale created successfully', { newLocale });
+}
+export const createLocaleTool = withErrorHandling(tool, 'Error creating locale');

package/build/tools/locales/deleteLocale.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 DeleteLocaleToolParams = BaseToolSchema.extend({
+    localeId: z.string().describe('The ID of the locale to delete'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        localeId: args.localeId,
+    };
+    const contentfulClient = createToolClient(args);
+    // First, get the locale to check its current state
+    const locale = await contentfulClient.locale.get(params);
+    // Delete the locale
+    await contentfulClient.locale.delete(params);
+    // Return info about the locale that was deleted
+    return createSuccessResponse('Locale deleted successfully', { locale });
+}
+export const deleteLocaleTool = withErrorHandling(tool, 'Error deleting locale');

package/build/tools/locales/getLocale.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 GetLocaleToolParams = BaseToolSchema.extend({
+    localeId: z.string().describe('The ID of the locale to retrieve'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        localeId: args.localeId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Get the locale
+    const locale = await contentfulClient.locale.get(params);
+    return createSuccessResponse('Locale retrieved successfully', { locale });
+}
+export const getLocaleTool = withErrorHandling(tool, 'Error retrieving locale');

package/build/tools/locales/listLocales.js

@@ -0,0 +1,61 @@
+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 ListLocaleToolParams = BaseToolSchema.extend({
+    limit: z.number().optional().describe('Maximum number of locales to return'),
+    skip: z.number().optional().describe('Skip this many locales 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 locales by this field'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+    };
+    const contentfulClient = createToolClient(args);
+    const locales = await contentfulClient.locale.getMany({
+        ...params,
+        query: {
+            limit: args.limit || 100,
+            skip: args.skip || 0,
+            ...(args.select && { select: args.select }),
+            ...(args.include && { include: args.include }),
+            ...(args.order && { order: args.order }),
+        },
+    });
+    const summarizedLocales = locales.items.map((locale) => ({
+        id: locale.sys.id,
+        name: locale.name,
+        code: locale.code,
+        fallbackCode: locale.fallbackCode || null,
+        contentDeliveryApi: locale.contentDeliveryApi,
+        contentManagementApi: locale.contentManagementApi,
+        default: locale.default,
+        optional: locale.optional,
+        createdAt: locale.sys.createdAt,
+        updatedAt: locale.sys.updatedAt,
+        version: locale.sys.version,
+    }));
+    const summarized = summarizeData({
+        ...locales,
+        items: summarizedLocales,
+    }, {
+        maxItems: 10,
+        remainingMessage: 'To see more locales, please ask me to retrieve the next page using the skip parameter.',
+    });
+    return createSuccessResponse('Locales retrieved successfully', {
+        locales: summarized,
+        total: locales.total,
+        limit: locales.limit,
+        skip: locales.skip,
+    });
+}
+export const listLocaleTool = withErrorHandling(tool, 'Error listing locales');

package/build/tools/locales/register.js

@@ -0,0 +1,12 @@
+import { getLocaleTool, GetLocaleToolParams } from './getLocale.js';
+import { createLocaleTool, CreateLocaleToolParams } from './createLocale.js';
+import { listLocaleTool, ListLocaleToolParams } from './listLocales.js';
+import { updateLocaleTool, UpdateLocaleToolParams } from './updateLocale.js';
+import { deleteLocaleTool, DeleteLocaleToolParams } from './deleteLocale.js';
+export function registerLocaleTools(server) {
+    server.tool('get_locale', 'Retrieve a specific locale from your Contentful environment', GetLocaleToolParams.shape, getLocaleTool);
+    server.tool('create_locale', 'Create a new locale in your Contentful environment. A locale defines a language-region pair (e.g., "en-US" for English United States). You can specify fallback behavior, API availability settings, and whether the locale is optional for content editors. Note: setting \'default\' is currently not supported.', CreateLocaleToolParams.shape, createLocaleTool);
+    server.tool('list_locales', 'List all locales in your Contentful environment. Returns locale information including language codes, fallback settings, and API availability.', ListLocaleToolParams.shape, listLocaleTool);
+    server.tool('update_locale', 'Update an existing locale in your Contentful environment. You can modify the locale name, code, fallback behavior, API availability settings, and whether the locale is optional for content editors. Only provide the fields you want to change. IMPORTANT: internal_code cannot be updated.', UpdateLocaleToolParams.shape, updateLocaleTool);
+    server.tool('delete_locale', 'Delete a specific locale from your Contentful environment. This operation permanently removes the locale and cannot be undone.', DeleteLocaleToolParams.shape, deleteLocaleTool);
+}

package/build/tools/locales/updateLocale.js

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const UpdateLocaleToolParams = BaseToolSchema.extend({
+    localeId: z.string().describe('The ID of the locale to update'),
+    fields: z.object({
+        name: z.string().optional().describe('The name of the locale'),
+        // NOTE: internal_code changes are not allowed
+        code: z.string().optional().describe('The code of the locale'),
+        fallbackCode: z
+            .string()
+            .optional()
+            .describe('The locale code to fallback to when there is no content for the current locale'),
+        contentDeliveryApi: z
+            .boolean()
+            .optional()
+            .describe('If the content under this locale should be available on the CDA (for public reading)'),
+        contentManagementApi: z
+            .boolean()
+            .optional()
+            .describe('If the content under this locale should be available on the CMA (for editing)'),
+        optional: z
+            .boolean()
+            .optional()
+            .describe('If the locale needs to be filled in on entries or not'),
+    }),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        localeId: args.localeId,
+    };
+    const contentfulClient = createToolClient(args);
+    // First, get the existing locale
+    const existingLocale = await contentfulClient.locale.get(params);
+    // Remove read-only fields (nternal_code cannot be updated)
+    delete existingLocale.internal_code;
+    // Build update data with only provided fields, merging with existing locale
+    const updateData = { ...existingLocale, ...args.fields };
+    // Update the locale with merged data
+    const updatedLocale = await contentfulClient.locale.update(params, updateData);
+    return createSuccessResponse('Locale updated successfully', {
+        updatedLocale,
+    });
+}
+export const updateLocaleTool = withErrorHandling(tool, 'Error updating locale');

package/build/tools/register.js

@@ -0,0 +1,20 @@
+import { registerContextTools } from './context/register.js';
+import { registerEntriesTools } from './entries/register.js';
+import { registerContentTypesTools } from './types/register.js';
+import { registerEnvironmentTools } from './environments/register.js';
+import { registerAssetTools } from './assets/register.js';
+import { registerSpaceTools } from './spaces/register.js';
+import { registerTagsTools } from './tags/register.js';
+import { registerAiActionsTools } from './ai-actions/register.js';
+import { registerLocaleTools } from './locales/register.js';
+export function registerAllTools(server) {
+    registerContextTools(server);
+    registerEntriesTools(server);
+    registerContentTypesTools(server);
+    registerEnvironmentTools(server);
+    registerAssetTools(server);
+    registerSpaceTools(server);
+    registerTagsTools(server);
+    registerAiActionsTools(server);
+    registerLocaleTools(server);
+}

package/build/tools/spaces/getSpace.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import ctfl from 'contentful-management';
+import { getDefaultClientConfig } from '../../config/contentful.js';
+export const GetSpaceToolParams = z.object({
+    spaceId: z.string().describe('The ID of the space to retrieve'),
+});
+async function tool(args) {
+    // Create a client without space-specific configuration
+    const clientConfig = getDefaultClientConfig();
+    // Remove space from config since we'll specify it in the get call
+    delete clientConfig.space;
+    const contentfulClient = ctfl.createClient(clientConfig, { type: 'plain' });
+    // Get the space
+    const space = await contentfulClient.space.get({
+        spaceId: args.spaceId,
+    });
+    return createSuccessResponse('Space retrieved successfully', { space });
+}
+export const getSpaceTool = withErrorHandling(tool, 'Error retrieving space');

package/build/tools/spaces/listSpaces.js

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import ctfl from 'contentful-management';
+import { getDefaultClientConfig } from '../../config/contentful.js';
+import { summarizeData } from '../../utils/summarizer.js';
+// For listing spaces, we don't need spaceId or environmentId parameters
+export const ListSpacesToolParams = z.object({
+    limit: z
+        .number()
+        .optional()
+        .describe('Maximum number of spaces to return (max 10)'),
+    skip: z.number().optional().describe('Skip this many spaces for pagination'),
+    select: z
+        .string()
+        .optional()
+        .describe('Comma-separated list of fields to return'),
+    order: z.string().optional().describe('Order spaces by this field'),
+});
+async function tool(args) {
+    // Create a client without space-specific configuration for listing all spaces
+    const clientConfig = getDefaultClientConfig();
+    // Remove space from config since we're listing all spaces
+    delete clientConfig.space;
+    const contentfulClient = ctfl.createClient(clientConfig, { type: 'plain' });
+    const spaces = await contentfulClient.space.getMany({
+        query: {
+            limit: Math.min(args.limit || 10, 10),
+            skip: args.skip || 0,
+            ...(args.select && { select: args.select }),
+            ...(args.order && { order: args.order }),
+        },
+    });
+    const summarizedSpaces = spaces.items.map((space) => ({
+        id: space.sys.id,
+        name: space.name,
+        createdAt: space.sys.createdAt,
+        updatedAt: space.sys.updatedAt,
+    }));
+    const summarized = summarizeData({
+        ...spaces,
+        items: summarizedSpaces,
+    }, {
+        maxItems: 10,
+        remainingMessage: 'To see more spaces, please ask me to retrieve the next page using the skip parameter.',
+    });
+    return createSuccessResponse('Spaces retrieved successfully', {
+        spaces: summarized,
+        total: spaces.total,
+        limit: spaces.limit,
+        skip: spaces.skip,
+    });
+}
+export const listSpacesTool = withErrorHandling(tool, 'Error listing spaces');

package/build/tools/spaces/register.js

@@ -0,0 +1,6 @@
+import { listSpacesTool, ListSpacesToolParams } from './listSpaces.js';
+import { getSpaceTool, GetSpaceToolParams } from './getSpace.js';
+export function registerSpaceTools(server) {
+    server.tool('list_spaces', 'List all available spaces', ListSpacesToolParams.shape, listSpacesTool);
+    server.tool('get_space', 'Get details of a space', GetSpaceToolParams.shape, getSpaceTool);
+}

package/build/tools/tags/createTag.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const CreateTagToolParams = BaseToolSchema.extend({
+    name: z.string().describe('The name of the tag'),
+    id: z.string().describe('The ID of the tag'),
+    visibility: z
+        .enum(['public', 'private'])
+        .describe('The visibility of the tag. Default to private if not specified'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        tagId: args.id,
+    };
+    const contentfulClient = createToolClient(args);
+    let newTag = await contentfulClient.tag.createWithId(params, {
+        name: args.name,
+        sys: { visibility: args.visibility },
+    });
+    return createSuccessResponse('Tag created successfully', { newTag });
+}
+export const createTagTool = withErrorHandling(tool, 'Error creating tag');

package/build/tools/tags/listTags.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 ListTagsToolParams = BaseToolSchema.extend({
+    limit: z.number().optional().describe('Maximum number of tags to return'),
+    skip: z.number().optional().describe('Skip this many tags for pagination'),
+    select: z
+        .string()
+        .optional()
+        .describe('Comma-separated list of fields to return'),
+    order: z.string().optional().describe('Order tags by this field'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+    };
+    const contentfulClient = createToolClient(args);
+    const tags = await contentfulClient.tag.getMany({
+        ...params,
+        query: {
+            limit: args.limit || 100,
+            skip: args.skip || 0,
+            ...(args.select && { select: args.select }),
+            ...(args.order && { order: args.order }),
+        },
+    });
+    const summarizedTags = tags.items.map((tag) => ({
+        id: tag.sys.id,
+        name: tag.name,
+        visibility: tag.sys.visibility,
+        createdAt: tag.sys.createdAt,
+        updatedAt: tag.sys.updatedAt,
+    }));
+    const summarized = summarizeData({
+        ...tags,
+        items: summarizedTags,
+    }, {
+        maxItems: 100,
+        remainingMessage: 'To see more tags, please ask me to retrieve the next page using the skip parameter.',
+    });
+    return createSuccessResponse('Tags retrieved successfully', {
+        tags: summarized,
+        total: tags.total,
+        limit: tags.limit,
+        skip: tags.skip,
+    });
+}
+export const listTagsTool = withErrorHandling(tool, 'Error listing tags');

package/build/tools/tags/register.js

@@ -0,0 +1,6 @@
+import { listTagsTool, ListTagsToolParams } from './listTags.js';
+import { createTagTool, CreateTagToolParams } from './createTag.js';
+export function registerTagsTools(server) {
+    server.tool('list_tags', 'List all tags in a space. Returns all tags that exist in a given environment.', ListTagsToolParams.shape, listTagsTool);
+    server.tool('create_tag', 'Creates a new tag and returns it. Both name and ID must be unique to each environment. Tag names can be modified after creation, but the tag ID cannot. The tag visibility can be set to public or private, defaulting to private if not specified.', CreateTagToolParams.shape, createTagTool);
+}