@kontent-ai/mcp-server 0.30.1 → 0.33.0

package/build/tools/get-patch-guide.js

@@ -3,6 +3,8 @@ import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 import { pathBasedPatchGuide } from "./context/patch-guide-path-based.js";
 import { propertyBasedPatchGuide } from "./context/patch-guide-property-based.js";
 import { referenceBasedPatchGuide } from "./context/patch-guide-reference-based.js";
+import { getPatchGuideToolName } from "./referencedToolNames.js";
+import { defineTool } from "./toolDefinition.js";
 const entityTypeSchema = z.enum([
     "content-type",
     "snippet",
@@ -26,15 +28,13 @@ const getGuideForEntity = (entityType) => {
             return propertyBasedPatchGuide;
     }
 };
-export const registerTool = (server) => {
-    server.tool("get-patch-guide", "REQUIRED before any patch operation. Get patch operations guide for Kontent.ai Management API.", {
-        entityType: entityTypeSchema.describe("Entity type to get patch guide for: content-type, snippet, taxonomy, collection, asset-folder, space, language"),
-    }, async ({ entityType }) => {
-        try {
-            return createMcpToolSuccessResponse(getGuideForEntity(entityType));
-        }
-        catch (error) {
-            throw new Error(`Failed to read patch guide: ${error instanceof Error ? error.message : "Unknown error"}`);
-        }
-    });
-};
+export const getPatchGuide = defineTool(getPatchGuideToolName, "REQUIRED before any patch operation. Retrieve patch operations guide for modifying Kontent.ai content types, snippets, taxonomies, collections, asset folders, spaces, or languages.", {
+    entityType: entityTypeSchema.describe("Entity type to get patch guide for: content-type, snippet, taxonomy, collection, asset-folder, space, language"),
+}, async ({ entityType }) => {
+    try {
+        return createMcpToolSuccessResponse(getGuideForEntity(entityType));
+    }
+    catch (error) {
+        throw new Error(`Failed to read patch guide: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+});

package/build/tools/get-published-content-item-variant-version.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const getPublishedContentItemVariantVersion = defineTool("get-published-content-item-variant-version", "Retrieve the published version of a Kontent.ai content item variant (live content). Use when a newer draft version exists but you need the currently published content. Returns the variant snapshot that is live on the Delivery API.", {
+    itemId: z.string().describe("Content item ID"),
+    languageId: z.string().describe("Language ID"),
+}, async ({ itemId, languageId }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client
+            .viewLanguageVariant()
+            .byItemId(itemId)
+            .byLanguageId(languageId)
+            .published()
+            .toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Published Content Item Variant Version Retrieval");
+    }
+});

package/build/tools/get-taxonomy-group.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const getTaxonomyGroup = defineTool("get-taxonomy-group", "Retrieve Kontent.ai taxonomy group by ID or codename. Taxonomy groups provide a classification hierarchy of tree-structured terms (categories/tags) that can be nested to any depth for content categorization.", {
+    id: z.guid().describe("Taxonomy group ID"),
+}, async ({ id }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client.getTaxonomy().byTaxonomyId(id).toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Taxonomy Group Retrieval");
+    }
+});

package/build/tools/index.js

@@ -0,0 +1,106 @@
+import { bulkGetContentItemVariants } from "./bulk-get-content-item-variants.js";
+import { changeContentItemVariantWorkflowStep } from "./change-content-item-variant-workflow-step.js";
+import { createContentItem } from "./create-content-item.js";
+import { createContentItemVariant } from "./create-content-item-variant.js";
+import { createContentType } from "./create-content-type.js";
+import { createContentTypeSnippet } from "./create-content-type-snippet.js";
+import { createLanguage } from "./create-language.js";
+import { createNewContentItemVariantVersion } from "./create-new-content-item-variant-version.js";
+import { createSpace } from "./create-space.js";
+import { createTaxonomyGroup } from "./create-taxonomy-group.js";
+import { createWorkflow } from "./create-workflow.js";
+import { deleteContentItem } from "./delete-content-item.js";
+import { deleteContentItemVariant } from "./delete-content-item-variant.js";
+import { deleteContentType } from "./delete-content-type.js";
+import { deleteContentTypeSnippet } from "./delete-content-type-snippet.js";
+import { deleteSpace } from "./delete-space.js";
+import { deleteTaxonomyGroup } from "./delete-taxonomy-group.js";
+import { deleteWorkflow } from "./delete-workflow.js";
+import { getAsset } from "./get-asset.js";
+import { getContentItem } from "./get-content-item.js";
+import { getContentItemTranslations } from "./get-content-item-translations.js";
+import { getContentItemVariant } from "./get-content-item-variant.js";
+import { getContentType } from "./get-content-type.js";
+import { getContentTypeSnippet } from "./get-content-type-snippet.js";
+import { getPatchGuide } from "./get-patch-guide.js";
+import { getPublishedContentItemVariantVersion } from "./get-published-content-item-variant-version.js";
+import { getTaxonomyGroup } from "./get-taxonomy-group.js";
+import { listAssetFolders } from "./list-asset-folders.js";
+import { listAssets } from "./list-assets.js";
+import { listCollections } from "./list-collections.js";
+import { listContentItemVariants } from "./list-content-item-variants.js";
+import { listContentTypeSnippets } from "./list-content-type-snippets.js";
+import { listContentTypes } from "./list-content-types.js";
+import { listLanguages } from "./list-languages.js";
+import { listRoles } from "./list-roles.js";
+import { listSpaces } from "./list-spaces.js";
+import { listTaxonomyGroups } from "./list-taxonomy-groups.js";
+import { listWorkflows } from "./list-workflows.js";
+import { patchAssetFolders } from "./patch-asset-folders.js";
+import { patchCollections } from "./patch-collections.js";
+import { patchContentType } from "./patch-content-type.js";
+import { patchContentTypeSnippet } from "./patch-content-type-snippet.js";
+import { patchLanguage } from "./patch-language.js";
+import { patchSpace } from "./patch-space.js";
+import { patchTaxonomyGroup } from "./patch-taxonomy-group.js";
+import { publishContentItemVariant } from "./publish-content-item-variant.js";
+import { searchContentItemVariants } from "./search-content-item-variants.js";
+import { unpublishContentItemVariant } from "./unpublish-content-item-variant.js";
+import { updateAsset } from "./update-asset.js";
+import { updateContentItem } from "./update-content-item.js";
+import { updateContentItemVariant } from "./update-content-item-variant.js";
+import { updateWorkflow } from "./update-workflow.js";
+export const allTools = {
+    createContentItem,
+    createContentTypeSnippet,
+    createContentType,
+    createLanguage,
+    createSpace,
+    createTaxonomyGroup,
+    createWorkflow,
+    bulkGetContentItemVariants,
+    changeContentItemVariantWorkflowStep,
+    createContentItemVariant,
+    createNewContentItemVariantVersion,
+    deleteContentItem,
+    deleteContentTypeSnippet,
+    deleteContentType,
+    deleteContentItemVariant,
+    deleteSpace,
+    deleteTaxonomyGroup,
+    deleteWorkflow,
+    getAsset,
+    getContentItem,
+    getContentTypeSnippet,
+    getContentType,
+    getContentItemTranslations,
+    getContentItemVariant,
+    getPatchGuide,
+    getPublishedContentItemVariantVersion,
+    getTaxonomyGroup,
+    listAssetFolders,
+    listAssets,
+    listCollections,
+    listContentTypeSnippets,
+    listContentTypes,
+    listContentItemVariants,
+    listLanguages,
+    listRoles,
+    listSpaces,
+    listTaxonomyGroups,
+    listWorkflows,
+    patchAssetFolders,
+    patchCollections,
+    patchContentTypeSnippet,
+    patchContentType,
+    patchLanguage,
+    patchSpace,
+    patchTaxonomyGroup,
+    publishContentItemVariant,
+    searchContentItemVariants,
+    unpublishContentItemVariant,
+    updateAsset,
+    updateContentItem,
+    updateContentItemVariant,
+    updateWorkflow,
+};

package/build/tools/list-asset-folders.js

@@ -0,0 +1,14 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const listAssetFolders = defineTool("list-asset-folders", "List all Kontent.ai asset folders. Folders organize digital media files (images, videos, documents) into a hierarchical directory structure.", {}, async (_params, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client.listAssetFolders().toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Asset Folders Listing");
+    }
+});

package/build/tools/list-assets.js

@@ -0,0 +1,23 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { listAssetsSchema } from "../schemas/listSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const listAssets = defineTool("list-assets", "List all Kontent.ai assets (paginated). Assets are digital media files (images, videos, documents, PDFs) referenced in content items.", listAssetsSchema.shape, async ({ continuation_token }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const query = client.listAssets();
+        const response = await (continuation_token
+            ? query.xContinuationToken(continuation_token)
+            : query).toPromise();
+        return createMcpToolSuccessResponse({
+            data: response.rawData.assets,
+            pagination: {
+                continuation_token: response.data.pagination.continuationToken,
+            },
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Assets Listing");
+    }
+});

package/build/tools/list-collections.js

@@ -0,0 +1,14 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const listCollections = defineTool("list-collections", "List all Kontent.ai collections. Collections organize and group content items by team, brand, or project for access control and content separation.", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client.listCollections().toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Collections Listing");
+    }
+});

package/build/tools/list-content-item-variants.js

@@ -0,0 +1,50 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { filterVariantsSchema } from "../schemas/filterVariantSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { throwError } from "../utils/throwError.js";
+import { bulkGetContentItemVariantsToolName, listContentItemVariantsToolName, searchContentItemVariantsToolName, } from "./referencedToolNames.js";
+import { defineTool } from "./toolDefinition.js";
+export const listContentItemVariants = defineTool(listContentItemVariantsToolName, `List, find, filter Kontent.ai content items with content item variants (language versions/translations) returning references (item ID + language ID). Filter by content item content type, collection, space, workflow step, taxonomy, contained content component content type, or publishing state. Search items and variants by EXACT keyword matching (terms use OR). Use ${searchContentItemVariantsToolName} for semantic/topic search. Use ${bulkGetContentItemVariantsToolName} to retrieve full content of the content item variants.`, filterVariantsSchema.shape, async ({ search_phrase, content_types, contributors, has_no_contributors, completion_statuses, language, workflow_steps, taxonomy_groups, spaces, collections, component_types, publishing_states, order_by, order_direction, continuation_token, }, { authInfo: { token, clientId } = {} }) => {
+    try {
+        const environmentId = clientId ?? process.env.KONTENT_ENVIRONMENT_ID;
+        if (!environmentId) {
+            throwError("Missing required environment ID");
+        }
+        const client = createMapiClient(environmentId, token);
+        const query = client.filterItemsWithVariants().withData({
+            filters: {
+                search_phrase,
+                content_types,
+                contributors,
+                has_no_contributors,
+                completion_statuses,
+                language,
+                workflow_steps,
+                taxonomy_groups,
+                spaces,
+                collections,
+                component_types,
+                publishing_states,
+            },
+            order: order_by
+                ? {
+                    by: order_by,
+                    direction: order_direction || "asc",
+                }
+                : undefined,
+        });
+        const response = await (continuation_token
+            ? query.xContinuationToken(continuation_token)
+            : query).toPromise();
+        return createMcpToolSuccessResponse({
+            variants: response.rawData.variants,
+            pagination: {
+                continuation_token: response.data.pagination.continuationToken,
+            },
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Variant Filter");
+    }
+});

package/build/tools/list-content-type-snippets.js

@@ -0,0 +1,23 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { listContentTypeSnippetsSchema } from "../schemas/listSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const listContentTypeSnippets = defineTool("list-content-type-snippets", "List all Kontent.ai content type snippets (paginated). Retrieve every content type snippet — reusable, shared sets of elements included across multiple content types.", listContentTypeSnippetsSchema.shape, async ({ continuation_token }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const query = client.listContentTypeSnippets();
+        const response = await (continuation_token
+            ? query.xContinuationToken(continuation_token)
+            : query).toPromise();
+        return createMcpToolSuccessResponse({
+            data: response.rawData.snippets,
+            pagination: {
+                continuation_token: response.data.pagination.continuationToken,
+            },
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Content Type Snippets Listing");
+    }
+});

package/build/tools/list-content-types.js

@@ -0,0 +1,23 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { listContentTypesSchema } from "../schemas/listSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const listContentTypes = defineTool("list-content-types", "List all Kontent.ai content types (paginated). Retrieve every content type (schema/model) definition. Get an overview of all content type models, their elements, field validation rules, and content groups.", listContentTypesSchema.shape, async ({ continuation_token }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const query = client.listContentTypes();
+        const response = await (continuation_token
+            ? query.xContinuationToken(continuation_token)
+            : query).toPromise();
+        return createMcpToolSuccessResponse({
+            data: response.rawData.types,
+            pagination: {
+                continuation_token: response.data.pagination.continuationToken,
+            },
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Content Types Listing");
+    }
+});

package/build/tools/list-languages.js

@@ -0,0 +1,24 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { listLanguagesSchema } from "../schemas/listSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { listLanguagesToolName } from "./referencedToolNames.js";
+import { defineTool } from "./toolDefinition.js";
+export const listLanguages = defineTool(listLanguagesToolName, "List all Kontent.ai languages (paginated), including inactive ones - check is_active property. Languages define available locales for translations and localization; each can have fallback language for content inheritance.", listLanguagesSchema.shape, async ({ continuation_token }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const query = client.listLanguages();
+        const response = await (continuation_token
+            ? query.xContinuationToken(continuation_token)
+            : query).toPromise();
+        return createMcpToolSuccessResponse({
+            data: response.rawData.languages,
+            pagination: {
+                continuation_token: response.data.pagination.continuationToken,
+            },
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Languages Listing");
+    }
+});

package/build/tools/list-roles.js

@@ -0,0 +1,14 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const listRoles = defineTool("list-roles", "List all Kontent.ai roles. Roles define user permissions and access control within the environment.", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client.listRoles().toPromise();
+        return createMcpToolSuccessResponse(response.rawData.roles);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Roles Listing");
+    }
+});

package/build/tools/list-spaces.js

@@ -0,0 +1,14 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const listSpaces = defineTool("list-spaces", "List all Kontent.ai spaces. Spaces provide channel-specific site configuration for managing multiple websites/channels. Each space has its own domain and preview URLs; collections connect to spaces to organize content per channel.", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client.listSpaces().toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Spaces Listing");
+    }
+});

package/build/tools/list-taxonomy-groups.js

@@ -0,0 +1,23 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { listTaxonomyGroupsSchema } from "../schemas/listSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const listTaxonomyGroups = defineTool("list-taxonomy-groups", "List all Kontent.ai taxonomy groups (paginated). Taxonomy groups contain hierarchical tree-structured terms (categories/tags) that can be nested to any depth for content categorization and classification.", listTaxonomyGroupsSchema.shape, async ({ continuation_token }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const query = client.listTaxonomies();
+        const response = await (continuation_token
+            ? query.xContinuationToken(continuation_token)
+            : query).toPromise();
+        return createMcpToolSuccessResponse({
+            data: response.rawData.taxonomies,
+            pagination: {
+                continuation_token: response.data.pagination.continuationToken,
+            },
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Taxonomy Groups Listing");
+    }
+});

package/build/tools/list-workflows.js

@@ -0,0 +1,14 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const listWorkflows = defineTool("list-workflows", "List all Kontent.ai workflows and their steps. Workflows define content lifecycle stages: draft, review, approval, published, scheduled, archived.", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client.listWorkflows().toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Workflows Listing");
+    }
+});

package/build/tools/patch-asset-folders.js

@@ -0,0 +1,25 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { assetFolderPatchOperationsSchema } from "../schemas/assetFolderSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { getPatchGuideToolName } from "./referencedToolNames.js";
+import { defineTool } from "./toolDefinition.js";
+export const patchAssetFolders = defineTool("patch-asset-folders", `Update (modify/edit) Kontent.ai asset folders using patch operations (addInto, rename, remove). Call ${getPatchGuideToolName} first for operations reference.`, {
+    operations: assetFolderPatchOperationsSchema,
+}, async ({ operations }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client
+            .modifyAssetFolders()
+            .withData(operations)
+            .toPromise();
+        return createMcpToolSuccessResponse({
+            message: `Asset folders modified with ${operations.length} operation(s)`,
+            folders: response.rawData,
+            appliedOperations: operations,
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Asset Folders Modification");
+    }
+});

package/build/tools/patch-collections.js

@@ -0,0 +1,25 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { collectionPatchOperationsSchema } from "../schemas/collectionSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { getPatchGuideToolName, listCollectionsToolName, } from "./referencedToolNames.js";
+import { defineTool } from "./toolDefinition.js";
+export const patchCollections = defineTool("patch-collections", `Update (modify/edit) Kontent.ai collections using patch operations (addInto, move, rename, remove). Call ${getPatchGuideToolName} first for operations reference.`, {
+    operations: collectionPatchOperationsSchema.describe(`Patch operations array. Call ${listCollectionsToolName} first. Use addInto to add new collections, move to reorder, remove to delete empty collections, replace to rename.`),
+}, async ({ operations }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client
+            .setCollections()
+            .withData(operations)
+            .toPromise();
+        return createMcpToolSuccessResponse({
+            message: `Collections updated successfully with ${operations.length} operation(s)`,
+            collections: response.rawData,
+            appliedOperations: operations,
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Collections Patch");
+    }
+});

package/build/tools/patch-content-type-snippet.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { snippetPatchOperationsSchema } from "../schemas/patchSchemas/snippetPatchSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { getPatchGuideToolName } from "./referencedToolNames.js";
+import { defineTool } from "./toolDefinition.js";
+export const patchContentTypeSnippet = defineTool("patch-content-type-snippet", `Update (modify/edit) Kontent.ai content type snippet using patch operations (move, addInto, remove, replace elements). Call ${getPatchGuideToolName} first for operations reference.`, {
+    id: z.guid().describe("Content type snippet ID"),
+    operations: snippetPatchOperationsSchema.describe(`Patch operations array. CRITICAL: Always call get-content-type-snippet first.
+- Use addInto/remove for arrays, replace for primitives/objects
+- Snippets cannot contain: content_groups, snippet, or url_slug elements`),
+}, async ({ id, operations }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client
+            .modifyContentTypeSnippet()
+            .byTypeId(id)
+            .withData(operations)
+            .toPromise();
+        return createMcpToolSuccessResponse({
+            message: `Content type snippet updated successfully with ${operations.length} operation(s)`,
+            snippet: response.rawData,
+            appliedOperations: operations,
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Content Type Snippet Patch");
+    }
+});

package/build/tools/patch-content-type.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { patchOperationsSchema } from "../schemas/patchSchemas/contentTypePatchSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { getPatchGuideToolName } from "./referencedToolNames.js";
+import { defineTool } from "./toolDefinition.js";
+export const patchContentType = defineTool("patch-content-type", `Update (modify/edit) Kontent.ai content type schema using patch operations (add, move, remove, replace elements/fields). Add new fields, rearrange or remove existing elements. Call ${getPatchGuideToolName} first for operations reference.`, {
+    id: z.guid().describe("Content type ID"),
+    operations: patchOperationsSchema.describe(`Patch operations array. CRITICAL: Always call get-content-type first.
+- Use addInto/remove for arrays, replace for primitives/objects
+- Only one url_slug element allowed per content type
+- To remove content groups: set ALL elements' content_group to null AND remove ALL groups in one request
+- URL slug with snippet: add snippet element first, then url_slug with depends_on reference`),
+}, async ({ id, operations }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        // Apply patch operations using the modifyContentType method
+        const response = await client
+            .modifyContentType()
+            .byTypeId(id)
+            .withData(operations)
+            .toPromise();
+        return createMcpToolSuccessResponse({
+            message: `Content type updated successfully with ${operations.length} operation(s)`,
+            contentType: response.rawData,
+            appliedOperations: operations,
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, `Content Type Patch`);
+    }
+});

package/build/tools/patch-language.js

@@ -0,0 +1,24 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { patchLanguageSchema } from "../schemas/languageSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { getPatchGuideToolName } from "./referencedToolNames.js";
+import { defineTool } from "./toolDefinition.js";
+export const patchLanguage = defineTool("patch-language", `Update (modify/edit) Kontent.ai language properties using replace patch operations. Call ${getPatchGuideToolName} first. Only active languages can be edited - to activate/deactivate, use the Kontent.ai web UI.`, patchLanguageSchema.shape, async ({ languageId, operations }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client
+            .modifyLanguage()
+            .byLanguageId(languageId)
+            .withData(operations)
+            .toPromise();
+        return createMcpToolSuccessResponse({
+            message: `Language updated with ${operations.length} operation(s)`,
+            language: response.rawData,
+            appliedOperations: operations,
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Language Patch");
+    }
+});

package/build/tools/patch-space.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { spacePatchOperationsSchema } from "../schemas/spaceSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { getPatchGuideToolName } from "./referencedToolNames.js";
+import { defineTool } from "./toolDefinition.js";
+export const patchSpace = defineTool("patch-space", `Update (modify/edit) Kontent.ai space properties using replace patch operations. Call ${getPatchGuideToolName} first for operations reference.`, {
+    id: z.guid().describe("Space ID"),
+    operations: spacePatchOperationsSchema,
+}, async ({ id, operations }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client
+            .modifySpace()
+            .bySpaceId(id)
+            .withData(operations)
+            .toPromise();
+        return createMcpToolSuccessResponse({
+            message: `Space updated successfully with ${operations.length} operation(s)`,
+            space: response.rawData,
+            appliedOperations: operations,
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Space Modification");
+    }
+});

package/build/tools/patch-taxonomy-group.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { taxonomyPatchOperationsSchema } from "../schemas/patchSchemas/taxonomyPatchSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { getPatchGuideToolName, getTaxonomyGroupToolName, } from "./referencedToolNames.js";
+import { defineTool } from "./toolDefinition.js";
+export const patchTaxonomyGroup = defineTool("patch-taxonomy-group", `Update (modify/edit) and organize Kontent.ai taxonomy group terms using patch operations (addInto, move, remove, replace). Call ${getPatchGuideToolName} first for operations reference.`, {
+    id: z.guid().describe("Taxonomy group ID"),
+    operations: taxonomyPatchOperationsSchema.describe(`Patch operations array. Call ${getTaxonomyGroupToolName} first. Use addInto to add terms (with optional reference for parent), move to reorder/nest terms (before/after/under - mutually exclusive), remove to delete terms, replace for name/codename/terms.`),
+}, async ({ id, operations }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client
+            .modifyTaxonomy()
+            .byTaxonomyId(id)
+            .withData(operations)
+            .toPromise();
+        return createMcpToolSuccessResponse({
+            message: `Taxonomy group updated with ${operations.length} operation(s)`,
+            taxonomyGroup: response.rawData,
+            appliedOperations: operations,
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Taxonomy Group Patch");
+    }
+});