@kontent-ai/mcp-server 0.4.2 → 0.6.0

package/build/tools/add-content-type-snippet-mapi.js

@@ -1,36 +1,38 @@
 import { z } from "zod";
-import { createMapiClient } from '../clients/kontentClients.js';
-import { snippetElementSchema, contentGroupSchema } from '../schemas/contentTypeSchemas.js';
+import { createMapiClient } from "../clients/kontentClients.js";
+import { snippetElementSchema } from "../schemas/contentTypeSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     server.tool("add-content-type-snippet-mapi", "Add a new content type snippet via Management API", {
         name: z.string().describe("Display name of the content type snippet"),
-        codename: z.string().optional().describe("Codename of the content type snippet (optional, will be generated if not provided)"),
-        external_id: z.string().optional().describe("External ID of the content type snippet (optional)"),
-        elements: z.array(snippetElementSchema).describe("Array of elements that define the structure of the content type snippet"),
-        content_groups: z.array(contentGroupSchema).optional().describe("Array of content groups (optional)"),
-    }, async ({ name, codename, external_id, elements, content_groups }) => {
+        codename: z
+            .string()
+            .optional()
+            .describe("Codename of the content type snippet (optional, will be generated if not provided)"),
+        external_id: z
+            .string()
+            .optional()
+            .describe("External ID of the content type snippet (optional)"),
+        elements: z
+            .array(snippetElementSchema)
+            .describe("Array of elements that define the structure of the content type snippet"),
+    }, async ({ name, codename, external_id, elements }) => {
         const client = createMapiClient();
-        const response = await client
-            .addContentTypeSnippet()
-            .withData(() => ({
-            name,
-            codename,
-            external_id,
-            elements,
-            content_groups: content_groups?.map(group => ({
-                name: group.name,
-                external_id: group.external_id,
-                codename: group.codename
-            })),
-        }))
-            .toPromise();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(response.rawData),
-                },
-            ],
-        };
+        try {
+            const response = await client
+                .addContentTypeSnippet()
+                .withData(() => ({
+                name,
+                codename,
+                external_id,
+                elements,
+            }))
+                .toPromise();
+            return createMcpToolSuccessResponse(response.rawData);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Content Type Snippet Creation");
+        }
     });
 };

package/build/tools/add-taxonomy-group-mapi.js

@@ -1,19 +1,19 @@
-import { createMapiClient } from '../clients/kontentClients.js';
-import { taxonomyGroupSchemas } from '../schemas/taxonomySchemas.js';
+import { createMapiClient } from "../clients/kontentClients.js";
+import { taxonomyGroupSchemas } from "../schemas/taxonomySchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     server.tool("add-taxonomy-group-mapi", "Add a new taxonomy group via Management API", taxonomyGroupSchemas, async (taxonomyGroup) => {
         const client = createMapiClient();
-        const response = await client
-            .addTaxonomy()
-            .withData(taxonomyGroup)
-            .toPromise();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(response.data),
-                },
-            ],
-        };
+        try {
+            const response = await client
+                .addTaxonomy()
+                .withData(taxonomyGroup)
+                .toPromise();
+            return createMcpToolSuccessResponse(response.data);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Taxonomy Group Creation");
+        }
     });
 };

package/build/tools/delete-content-item-mapi.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+export const registerTool = (server) => {
+    server.tool("delete-content-item-mapi", "Delete a content item by codename from Management API", {
+        codename: z.string().describe("Codename of the content item to delete"),
+    }, async ({ codename }) => {
+        const client = createMapiClient();
+        try {
+            const response = await client
+                .deleteContentItem()
+                .byItemCodename(codename)
+                .toPromise();
+            return createMcpToolSuccessResponse({
+                message: `Content item '${codename}' deleted successfully`,
+                deletedItem: response.data,
+            });
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Content Item Deletion");
+        }
+    });
+};

package/build/tools/delete-language-variant-mapi.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+export const registerTool = (server) => {
+    server.tool("delete-language-variant-mapi", "Delete a language variant of a content item from Management API", {
+        itemCodename: z.string().describe("Codename of the content item"),
+        languageCodename: z
+            .string()
+            .describe("Codename of the language variant to delete"),
+    }, async ({ itemCodename, languageCodename }) => {
+        const client = createMapiClient();
+        try {
+            const response = await client
+                .deleteLanguageVariant()
+                .byItemCodename(itemCodename)
+                .byLanguageCodename(languageCodename)
+                .toPromise();
+            return createMcpToolSuccessResponse({
+                message: `Language variant '${languageCodename}' of content item '${itemCodename}' deleted successfully`,
+                deletedVariant: response.data,
+            });
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Language Variant Deletion");
+        }
+    });
+};

package/build/tools/get-asset-mapi.js

@@ -1,21 +1,21 @@
 import { z } from "zod";
-import { createMapiClient } from '../clients/kontentClients.js';
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     server.tool("get-asset-mapi", "Get a specific asset by codename from Management API", {
-        assetCodename: z.string().describe("Codename of the asset to retrieve")
+        assetCodename: z.string().describe("Codename of the asset to retrieve"),
     }, async ({ assetCodename }) => {
         const client = createMapiClient();
-        const response = await client
-            .viewAsset()
-            .byAssetCodename(assetCodename)
-            .toPromise();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(response.data),
-                },
-            ],
-        };
+        try {
+            const response = await client
+                .viewAsset()
+                .byAssetCodename(assetCodename)
+                .toPromise();
+            return createMcpToolSuccessResponse(response.data);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Asset Retrieval");
+        }
     });
 };

package/build/tools/get-item-dapi.js

@@ -1,23 +1,23 @@
+import { createDeliveryClient } from "@kontent-ai/delivery-sdk";
 import { z } from "zod";
-import { createDeliveryClient } from '@kontent-ai/delivery-sdk';
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     server.tool("get-item-dapi", "Get Kontent.ai item by codename from Delivery API", {
         codename: z.string().describe("Codename of the item to get"),
-        environmentId: z.string().describe("Environment ID of the item's environment"),
+        environmentId: z
+            .string()
+            .describe("Environment ID of the item's environment"),
     }, async ({ codename, environmentId }) => {
         const client = createDeliveryClient({
             environmentId,
         });
-        const response = await client
-            .item(codename)
-            .toPromise();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(response.data.item),
-                },
-            ],
-        };
+        try {
+            const response = await client.item(codename).toPromise();
+            return createMcpToolSuccessResponse(response.data.item);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Item Retrieval (Delivery API)");
+        }
     });
 };

package/build/tools/get-item-mapi.js

@@ -1,21 +1,21 @@
 import { z } from "zod";
-import { createMapiClient } from '../clients/kontentClients.js';
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     server.tool("get-item-mapi", "Get Kontent.ai item by codename from Management API", {
-        codename: z.string().describe("Codename of the item to get")
+        codename: z.string().describe("Codename of the item to get"),
     }, async ({ codename }) => {
         const client = createMapiClient();
-        const response = await client
-            .viewContentItem()
-            .byItemCodename(codename)
-            .toPromise();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(response.data),
-                },
-            ],
-        };
+        try {
+            const response = await client
+                .viewContentItem()
+                .byItemCodename(codename)
+                .toPromise();
+            return createMcpToolSuccessResponse(response.data);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Item Retrieval");
+        }
     });
 };

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

@@ -1,21 +1,21 @@
 import { z } from "zod";
-import { createMapiClient } from '../clients/kontentClients.js';
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     server.tool("get-taxonomy-group-mapi", "Get taxonomy group by codename from Management API", {
-        codename: z.string().describe("Codename of the taxonomy group to get")
+        codename: z.string().describe("Codename of the taxonomy group to get"),
     }, async ({ codename }) => {
         const client = createMapiClient();
-        const response = await client
-            .getTaxonomy()
-            .byTaxonomyCodename(codename)
-            .toPromise();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(response.data),
-                },
-            ],
-        };
+        try {
+            const response = await client
+                .getTaxonomy()
+                .byTaxonomyCodename(codename)
+                .toPromise();
+            return createMcpToolSuccessResponse(response.data);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Taxonomy Group Retrieval");
+        }
     });
 };

package/build/tools/get-type-mapi.js

@@ -1,21 +1,21 @@
 import { z } from "zod";
-import { createMapiClient } from '../clients/kontentClients.js';
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     server.tool("get-type-mapi", "Get content type by codename from Management API", {
-        codename: z.string().describe("Codename of the content type to get")
+        codename: z.string().describe("Codename of the content type to get"),
     }, async ({ codename }) => {
         const client = createMapiClient();
-        const response = await client
-            .viewContentType()
-            .byTypeCodename(codename)
-            .toPromise();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(response.data),
-                },
-            ],
-        };
+        try {
+            const response = await client
+                .viewContentType()
+                .byTypeCodename(codename)
+                .toPromise();
+            return createMcpToolSuccessResponse(response.data);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Content Type Retrieval");
+        }
     });
 };

package/build/tools/get-type-snippet-mapi.js

@@ -1,21 +1,23 @@
 import { z } from "zod";
-import { createMapiClient } from '../clients/kontentClients.js';
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     server.tool("get-type-snippet-mapi", "Get content type snippet by codename from Management API", {
-        codename: z.string().describe("Codename of the content type snippet to get")
+        codename: z
+            .string()
+            .describe("Codename of the content type snippet to get"),
     }, async ({ codename }) => {
         const client = createMapiClient();
-        const response = await client
-            .viewContentTypeSnippet()
-            .byTypeCodename(codename)
-            .toPromise();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(response.data),
-                },
-            ],
-        };
+        try {
+            const response = await client
+                .viewContentTypeSnippet()
+                .byTypeCodename(codename)
+                .toPromise();
+            return createMcpToolSuccessResponse(response.data);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Content Type Snippet Retrieval");
+        }
     });
 };

package/build/tools/get-variant-mapi.js

@@ -1,23 +1,25 @@
 import { z } from "zod";
-import { createMapiClient } from '../clients/kontentClients.js';
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     server.tool("get-variant-mapi", "Get language variant of a content item from Management API", {
         itemCodename: z.string().describe("Codename of the content item"),
-        languageCodename: z.string().describe("Codename of the language variant to get")
+        languageCodename: z
+            .string()
+            .describe("Codename of the language variant to get"),
     }, async ({ itemCodename, languageCodename }) => {
         const client = createMapiClient();
-        const response = await client
-            .viewLanguageVariant()
-            .byItemCodename(itemCodename)
-            .byLanguageCodename(languageCodename)
-            .toPromise();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(response.data),
-                },
-            ],
-        };
+        try {
+            const response = await client
+                .viewLanguageVariant()
+                .byItemCodename(itemCodename)
+                .byLanguageCodename(languageCodename)
+                .toPromise();
+            return createMcpToolSuccessResponse(response.data);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Language Variant Retrieval");
+        }
     });
 };

package/build/tools/list-assets-mapi.js

@@ -1,17 +1,15 @@
-import { createMapiClient } from '../clients/kontentClients.js';
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     server.tool("list-assets-mapi", "Get all assets from Management API", {}, async () => {
         const client = createMapiClient();
-        const response = await client
-            .listAssets()
-            .toAllPromise();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(response.data),
-                },
-            ],
-        };
+        try {
+            const response = await client.listAssets().toAllPromise();
+            return createMcpToolSuccessResponse(response.data);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Assets Listing");
+        }
     });
 };

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

@@ -1,17 +1,15 @@
-import { createMapiClient } from '../clients/kontentClients.js';
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     server.tool("list-content-type-snippets-mapi", "Get all content type snippets from Management API", {}, async () => {
         const client = createMapiClient();
-        const response = await client
-            .listContentTypeSnippets()
-            .toAllPromise();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(response.data),
-                },
-            ],
-        };
+        try {
+            const response = await client.listContentTypeSnippets().toAllPromise();
+            return createMcpToolSuccessResponse(response.data);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Content Type Snippets Listing");
+        }
     });
 };

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

@@ -1,17 +1,15 @@
-import { createMapiClient } from '../clients/kontentClients.js';
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     server.tool("list-content-types-mapi", "Get all content types from Management API", {}, async () => {
         const client = createMapiClient();
-        const response = await client
-            .listContentTypes()
-            .toAllPromise();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(response.data),
-                },
-            ],
-        };
+        try {
+            const response = await client.listContentTypes().toAllPromise();
+            return createMcpToolSuccessResponse(response.data);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Content Types Listing");
+        }
     });
 };

package/build/tools/list-languages-mapi.js

@@ -1,17 +1,15 @@
-import { createMapiClient } from '../clients/kontentClients.js';
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     server.tool("list-languages-mapi", "Get all languages from Management API", {}, async () => {
         const client = createMapiClient();
-        const response = await client
-            .listLanguages()
-            .toAllPromise();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(response.data),
-                },
-            ],
-        };
+        try {
+            const response = await client.listLanguages().toAllPromise();
+            return createMcpToolSuccessResponse(response.data);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Languages Listing");
+        }
     });
 };

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

@@ -1,17 +1,15 @@
-import { createMapiClient } from '../clients/kontentClients.js';
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
-    server.tool("list-taxonomy-groups-mapi", "Get all taxonomy groups from Management API", {}, async () => {
+    server.tool("list-taxonomy-groups-mapi", "Get all taxonomy groups from Management API", {}, {}, async () => {
         const client = createMapiClient();
-        const response = await client
-            .listTaxonomies()
-            .toPromise();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(response.data),
-                },
-            ],
-        };
+        try {
+            const response = await client.listTaxonomies().toPromise();
+            return createMcpToolSuccessResponse(response.data);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Taxonomy Groups Listing");
+        }
     });
 };

package/build/tools/update-content-item-mapi.js

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+export const registerTool = (server) => {
+    server.tool("update-content-item-mapi", "Update an existing content item by codename via Management API. The content item must already exist - this tool will not create new items.", {
+        codename: z.string().describe("Codename of the content item to update"),
+        name: z
+            .string()
+            .min(1)
+            .max(200)
+            .optional()
+            .describe("New display name of the content item (1-200 characters, optional)"),
+        collection: z
+            .object({
+            id: z.string().optional(),
+            codename: z.string().optional(),
+            external_id: z.string().optional(),
+        })
+            .optional()
+            .describe("Reference to a collection by id, codename, or external_id (optional)"),
+    }, async ({ codename, name, collection }) => {
+        const client = createMapiClient();
+        try {
+            // First, verify the item exists by trying to get it
+            await client.viewContentItem().byItemCodename(codename).toPromise();
+            // If we get here, the item exists, so we can update it
+            const updateData = {};
+            if (name !== undefined) {
+                updateData.name = name;
+            }
+            if (collection !== undefined) {
+                updateData.collection = collection;
+            }
+            // If no update data is provided, return an error
+            if (Object.keys(updateData).length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Update Content Item: No update data provided. At least one field (name or collection) must be specified.",
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const response = await client
+                .upsertContentItem()
+                .byItemCodename(codename)
+                .withData(updateData)
+                .toPromise();
+            return createMcpToolSuccessResponse({
+                message: `Content item '${codename}' updated successfully`,
+                updatedItem: response.rawData,
+            });
+        }
+        catch (error) {
+            // Check if the error is because the item doesn't exist
+            if (error?.response?.status === 404 ||
+                error?.message?.includes("not found")) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Update Content Item: Content item with codename '${codename}' does not exist. Use add-content-item-mapi to create new items.`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            return handleMcpToolError(error, "Content Item Update");
+        }
+    });
+};