@kontent-ai/mcp-server 0.4.2 → 0.6.0

package/build/schemas/contentTypeSchemas.js

@@ -1,13 +1,18 @@
 import { z } from "zod";
 // Define a reusable reference object schema
-const referenceObjectSchema = z.object({
+const referenceObjectSchema = z
+    .object({
     id: z.string().optional(),
     codename: z.string().optional(),
-});
+})
+    .describe("An object with an id or codename property referencing another item. Using codename is preferred for better readability.");
 // Common property schemas
 const baseElementSchema = {
     codename: z.string().optional(),
     external_id: z.string().optional(),
+};
+// Content group schema for content type elements only
+const contentGroupElementSchema = {
     content_group: referenceObjectSchema
         .describe("An object with an id or codename property referencing a content group.")
         .optional(),
@@ -20,174 +25,292 @@ const namedElementSchema = {
     is_non_localizable: z.boolean().optional(),
 };
 // Limit schemas
-const conditionEnum = z.enum(['at_most', 'exactly', 'at_least']);
-const countLimitSchema = z.object({
+const conditionEnum = z.enum(["at_most", "exactly", "at_least"]);
+const countLimitSchema = z
+    .object({
     value: z.number(),
-    condition: conditionEnum
-}).optional();
+    condition: conditionEnum,
+})
+    .optional();
 const imageLimitSchema = {
-    image_width_limit: z.object({
+    image_width_limit: z
+        .object({
         value: z.number(),
-        condition: conditionEnum
-    }).optional(),
-    image_height_limit: z.object({
+        condition: conditionEnum,
+    })
+        .optional(),
+    image_height_limit: z
+        .object({
         value: z.number(),
-        condition: conditionEnum
-    }).optional(),
+        condition: conditionEnum,
+    })
+        .optional(),
 };
 // Default value schemas
-const arrayDefaultSchema = (schema = referenceObjectSchema) => z.object({
+const arrayDefaultSchema = z
+    .object({
     global: z.object({
-        value: z.array(schema)
-    })
-}).optional();
-const stringDefaultSchema = z.object({
+        value: z.array(referenceObjectSchema),
+    }),
+})
+    .optional();
+const stringDefaultSchema = z
+    .object({
     global: z.object({
-        value: z.string()
-    })
-}).optional();
-const numberDefaultSchema = z.object({
+        value: z.string(),
+    }),
+})
+    .optional();
+const numberDefaultSchema = z
+    .object({
     global: z.object({
-        value: z.number()
-    })
-}).optional();
+        value: z.number(),
+    }),
+})
+    .optional();
 // Regex validation schema
-const regexValidationSchema = z.object({
+const regexValidationSchema = z
+    .object({
     is_active: z.boolean(),
     regex: z.string(),
     flags: z.string().optional(),
-    validation_message: z.string().optional()
-}).optional();
+    validation_message: z.string().optional(),
+})
+    .optional();
 // Text length limit schema
-const textLengthLimitSchema = z.object({
+const textLengthLimitSchema = z
+    .object({
     value: z.number(),
-    applies_to: z.enum(['words', 'characters'])
-}).optional();
+    applies_to: z.enum(["words", "characters"]),
+})
+    .optional();
 // Individual element type schemas
-const assetElementSchema = z.object({
-    type: z.literal('asset'),
+const assetElementSchema = {
+    type: z.literal("asset"),
     ...namedElementSchema,
     asset_count_limit: countLimitSchema,
     maximum_file_size: z.number().optional(),
-    allowed_file_types: z.enum(['adjustable', 'any']).optional(),
+    allowed_file_types: z.enum(["adjustable", "any"]).optional(),
     ...imageLimitSchema,
-    default: arrayDefaultSchema(),
-});
-const customElementSchema = z.object({
-    type: z.literal('custom'),
+    default: arrayDefaultSchema.describe("Default value of the asset element. Reference an existing asset by its id or codename."),
+};
+const customElementSchema = {
+    type: z.literal("custom"),
     ...namedElementSchema,
     source_url: z.string(),
     json_parameters: z.string().optional(),
-    allowed_elements: z.array(referenceObjectSchema
-        .describe("An object with an id or codename property referencing an element.")).optional(),
-});
-const dateTimeElementSchema = z.object({
-    type: z.literal('date_time'),
+    allowed_elements: z
+        .array(referenceObjectSchema.describe("An object with an id or codename property referencing an element."))
+        .optional()
+        .describe("Specifies which elements from the content type can be used within this custom element."),
+};
+const dateTimeElementSchema = {
+    type: z.literal("date_time"),
     ...namedElementSchema,
     default: stringDefaultSchema,
-});
-const guidelinesElementSchema = z.object({
-    type: z.literal('guidelines'),
-    guidelines: z.string(),
+};
+const guidelinesElementSchema = {
+    type: z.literal("guidelines"),
     ...baseElementSchema,
-});
-const modularContentElementSchema = z.object({
-    type: z.literal('modular_content'),
+    guidelines: z
+        .string()
+        .describe("Value of the guidelines element. This is rich text and can include HTML formatting. Check the documentation here https://kontent.ai/learn/docs/apis/openapi/management-api-v2/#section/HTML5-elements-allowed-in-rich-text for the supported format, but keep in mind that content items and components are not supported in guidelines. Use empty `<p>` tag for empty guidelines."),
+};
+const modularContentElementSchema = {
+    type: z.literal("modular_content"),
     ...namedElementSchema,
-    allowed_content_types: z.array(referenceObjectSchema
-        .describe("An object with an id or codename property referencing a content type.")).optional(),
+    allowed_content_types: z
+        .array(referenceObjectSchema.describe("An object with an id or codename property referencing a content type. Use an empty array to allow all content types."))
+        .optional(),
     item_count_limit: countLimitSchema,
-    default: arrayDefaultSchema(),
-});
-const subpagesElementSchema = z.object({
-    type: z.literal('subpages'),
+    default: arrayDefaultSchema.describe("Default value of the modular content element. Reference an existing content item by its id or codename."),
+};
+const subpagesElementSchema = {
+    type: z.literal("subpages"),
     ...namedElementSchema,
-    allowed_content_types: z.array(referenceObjectSchema
-        .describe("An object with an id or codename property referencing a content type.")).optional(),
+    allowed_content_types: z
+        .array(referenceObjectSchema.describe("An object with an id or codename property referencing a content type. Use an empty array to allow all content types."))
+        .optional(),
     item_count_limit: countLimitSchema,
-});
-const multipleChoiceElementSchema = z.object({
-    type: z.literal('multiple_choice'),
+};
+const multipleChoiceElementSchema = {
+    type: z.literal("multiple_choice"),
     ...namedElementSchema,
-    mode: z.enum(['single', 'multiple']),
+    mode: z.enum(["single", "multiple"]),
     options: z.array(z.object({
         name: z.string(),
         codename: z.string().optional(),
         external_id: z.string().optional(),
     })),
-    default: arrayDefaultSchema(),
-});
-const numberElementSchema = z.object({
-    type: z.literal('number'),
+    default: arrayDefaultSchema.describe("Default value of the multiple choice element. Reference one of the options by its codename."),
+};
+const numberElementSchema = {
+    type: z.literal("number"),
     ...namedElementSchema,
     default: numberDefaultSchema,
-});
-const richTextElementSchema = z.object({
-    type: z.literal('rich_text'),
+};
+const richTextElementSchema = {
+    type: z.literal("rich_text"),
     ...namedElementSchema,
-    allowed_blocks: z.array(z.enum(['images', 'text', 'tables', 'components-and-items'])).optional(),
-    allowed_formatting: z.array(z.enum(['unstyled', 'bold', 'italic', 'code', 'link', 'subscript', 'superscript'])).optional(),
-    allowed_text_blocks: z.array(z.enum(['paragraph', 'heading-one', 'heading-two', 'heading-three', 'heading-four', 'heading-five', 'heading-six', 'ordered-list', 'unordered-list'])).optional(),
-    allowed_table_blocks: z.array(z.enum(['images', 'text'])).optional(),
-    allowed_table_formatting: z.array(z.enum(['unstyled', 'bold', 'italic', 'code', 'link', 'subscript', 'superscript'])).optional(),
-    allowed_table_text_blocks: z.array(z.enum(['paragraph', 'heading-one', 'heading-two', 'heading-three', 'heading-four', 'heading-five', 'heading-six', 'ordered-list', 'unordered-list'])).optional(),
-    allowed_content_types: z.array(referenceObjectSchema
-        .describe("An object with an id or codename property referencing a content type.")).optional(),
-    allowed_item_link_types: z.array(referenceObjectSchema
-        .describe("An object with an id or codename property referencing a content type.")).optional(),
+    allowed_blocks: z
+        .array(z.enum(["images", "text", "tables", "components-and-items"]))
+        .optional()
+        .describe("Specifies allowed blocks. Use an empty array to allow all options."),
+    allowed_formatting: z
+        .array(z.enum([
+        "unstyled",
+        "bold",
+        "italic",
+        "code",
+        "link",
+        "subscript",
+        "superscript",
+    ]))
+        .optional()
+        .describe("Specifies allowed formatting options. Use an empty array to allow all options."),
+    allowed_text_blocks: z
+        .array(z.enum([
+        "paragraph",
+        "heading-one",
+        "heading-two",
+        "heading-three",
+        "heading-four",
+        "heading-five",
+        "heading-six",
+        "ordered-list",
+        "unordered-list",
+    ]))
+        .optional()
+        .describe("Specifies allowed text blocks. Use an empty array to allow all options."),
+    allowed_table_blocks: z
+        .array(z.enum(["images", "text"]))
+        .optional()
+        .describe("Specifies allowed table blocks. Use an empty array to allow all options."),
+    allowed_table_formatting: z
+        .array(z.enum([
+        "unstyled",
+        "bold",
+        "italic",
+        "code",
+        "link",
+        "subscript",
+        "superscript",
+    ]))
+        .optional()
+        .describe("Specifies allowed table formatting options. Use an empty array to allow all options."),
+    allowed_table_text_blocks: z
+        .array(z.enum([
+        "paragraph",
+        "heading-one",
+        "heading-two",
+        "heading-three",
+        "heading-four",
+        "heading-five",
+        "heading-six",
+        "ordered-list",
+        "unordered-list",
+    ]))
+        .optional()
+        .describe("Specifies allowed table text blocks. Use an empty array to allow all options."),
+    allowed_content_types: z
+        .array(referenceObjectSchema.describe("An object with an id or codename property referencing a content type."))
+        .optional()
+        .describe("Specifies allowed content types. Use an empty array to allow all content types."),
+    allowed_item_link_types: z
+        .array(referenceObjectSchema.describe("An object with an id or codename property referencing a content type."))
+        .optional()
+        .describe("Specifies allowed item link types. Use an empty array to allow all link types."),
     ...imageLimitSchema,
-    allowed_image_types: z.enum(['adjustable', 'any']).optional(),
+    allowed_image_types: z.enum(["adjustable", "any"]).optional(),
     maximum_image_size: z.number().optional(),
     maximum_text_length: textLengthLimitSchema,
-});
-const snippetElement = z.object({
-    type: z.literal('snippet'),
-    snippet: referenceObjectSchema
-        .describe("An object with an id or codename property referencing a snippet."),
+};
+const snippetElement = {
+    type: z.literal("snippet"),
+    snippet: referenceObjectSchema.describe("An object with an id or codename property referencing a snippet."),
     ...baseElementSchema,
-});
-const taxonomyElementSchema = z.object({
-    type: z.literal('taxonomy'),
-    taxonomy_group: referenceObjectSchema
-        .describe("An object with an id or codename property referencing a taxonomy group."),
+};
+const taxonomyElementSchema = {
+    type: z.literal("taxonomy"),
+    taxonomy_group: referenceObjectSchema.describe("An object with an id or codename property referencing a taxonomy group."),
     ...namedElementSchema,
     term_count_limit: countLimitSchema,
-    default: arrayDefaultSchema(),
-});
-const textElementSchema = z.object({
-    type: z.literal('text'),
+    default: arrayDefaultSchema.describe("Default value of the taxonomy element. Reference one of the terms from the specified taxonomy group by its codename."),
+};
+const textElementSchema = {
+    type: z.literal("text"),
     ...namedElementSchema,
     maximum_text_length: textLengthLimitSchema,
     validation_regex: regexValidationSchema,
     default: stringDefaultSchema,
-});
-const urlSlugElementSchema = z.object({
-    type: z.literal('url_slug'),
+};
+const urlSlugElementSchema = {
+    type: z.literal("url_slug"),
     ...namedElementSchema,
-    depends_on: z.object({
-        element: referenceObjectSchema
-            .describe("An object with an id or codename property referencing an element."),
+    depends_on: z
+        .object({
+        element: referenceObjectSchema.describe("An object with an id or codename property referencing an element."),
         snippet: referenceObjectSchema
             .describe("An object with an id or codename property referencing a content type snippet.")
             .optional(),
-    }),
+    })
+        .describe("The element the URL slug depends on. If this element is within a snippet, the snippet must also be specified."),
     validation_regex: regexValidationSchema,
-});
+};
 // Define a union type of all possible element types for content types
-export const elementSchema = z.discriminatedUnion('type', [
-    assetElementSchema,
-    customElementSchema,
-    dateTimeElementSchema,
-    guidelinesElementSchema,
-    modularContentElementSchema,
-    subpagesElementSchema,
-    multipleChoiceElementSchema,
-    numberElementSchema,
-    richTextElementSchema,
-    snippetElement,
-    taxonomyElementSchema,
-    textElementSchema,
-    urlSlugElementSchema,
+export const elementSchema = z.discriminatedUnion("type", [
+    z.object({
+        ...assetElementSchema,
+        ...contentGroupElementSchema,
+    }),
+    z.object({
+        ...customElementSchema,
+        ...contentGroupElementSchema,
+    }),
+    z.object({
+        ...dateTimeElementSchema,
+        ...contentGroupElementSchema,
+    }),
+    z.object({
+        ...guidelinesElementSchema,
+        ...contentGroupElementSchema,
+    }),
+    z.object({
+        ...modularContentElementSchema,
+        ...contentGroupElementSchema,
+    }),
+    z.object({
+        ...subpagesElementSchema,
+        ...contentGroupElementSchema,
+    }),
+    z.object({
+        ...multipleChoiceElementSchema,
+        ...contentGroupElementSchema,
+    }),
+    z.object({
+        ...numberElementSchema,
+        ...contentGroupElementSchema,
+    }),
+    z.object({
+        ...richTextElementSchema,
+        ...contentGroupElementSchema,
+    }),
+    z.object({
+        ...snippetElement,
+        ...contentGroupElementSchema,
+    }),
+    z.object({
+        ...taxonomyElementSchema,
+        ...contentGroupElementSchema,
+    }),
+    z.object({
+        ...textElementSchema,
+        ...contentGroupElementSchema,
+    }),
+    z.object({
+        ...urlSlugElementSchema,
+        ...contentGroupElementSchema,
+    }),
 ]);
 // Define schema for content groups
 export const contentGroupSchema = z.object({
@@ -196,16 +319,16 @@ export const contentGroupSchema = z.object({
     codename: z.string().optional(),
 });
 // Define a union type for snippet elements (excluding url_slug and snippet elements)
-export const snippetElementSchema = z.discriminatedUnion('type', [
-    assetElementSchema,
-    customElementSchema,
-    dateTimeElementSchema,
-    guidelinesElementSchema,
-    modularContentElementSchema,
-    subpagesElementSchema,
-    multipleChoiceElementSchema,
-    numberElementSchema,
-    richTextElementSchema,
-    taxonomyElementSchema,
-    textElementSchema,
+export const snippetElementSchema = z.discriminatedUnion("type", [
+    z.object(assetElementSchema),
+    z.object(customElementSchema),
+    z.object(dateTimeElementSchema),
+    z.object(guidelinesElementSchema),
+    z.object(modularContentElementSchema),
+    z.object(subpagesElementSchema),
+    z.object(multipleChoiceElementSchema),
+    z.object(numberElementSchema),
+    z.object(richTextElementSchema),
+    z.object(taxonomyElementSchema),
+    z.object(textElementSchema),
 ]);

package/build/schemas/taxonomySchemas.js

@@ -9,7 +9,15 @@ const taxonomyTermSchema = z.object({
 // Schema for a taxonomy group
 export const taxonomyGroupSchemas = {
     name: z.string().describe("Display name of the taxonomy group"),
-    codename: z.string().optional().describe("Codename of the taxonomy group (optional, will be generated if not provided)"),
-    external_id: z.string().optional().describe("External ID of the taxonomy group (optional)"),
-    terms: z.array(taxonomyTermSchema).describe("Hierarchical structure of taxonomy terms"),
+    codename: z
+        .string()
+        .optional()
+        .describe("Codename of the taxonomy group (optional, will be generated if not provided)"),
+    external_id: z
+        .string()
+        .optional()
+        .describe("External ID of the taxonomy group (optional)"),
+    terms: z
+        .array(taxonomyTermSchema)
+        .describe("Hierarchical structure of taxonomy terms"),
 };

package/build/server.js

@@ -1,24 +1,30 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { registerTool as registerGetItemMapi } from "./tools/get-item-mapi.js";
-import { registerTool as registerGetItemDapi } from "./tools/get-item-dapi.js";
-import { registerTool as registerGetVariantMapi } from "./tools/get-variant-mapi.js";
-import { registerTool as registerGetTypeMapi } from "./tools/get-type-mapi.js";
-import { registerTool as registerListContentTypesMapi } from "./tools/list-content-types-mapi.js";
-import { registerTool as registerListLanguagesMapi } from "./tools/list-languages-mapi.js";
-import { registerTool as registerGetAssetMapi } from "./tools/get-asset-mapi.js";
-import { registerTool as registerListAssetsMapi } from "./tools/list-assets-mapi.js";
+import packageJson from "../package.json" with { type: "json" };
+import { registerTool as registerAddContentItemMapi } from "./tools/add-content-item-mapi.js";
 import { registerTool as registerAddContentTypeMapi } from "./tools/add-content-type-mapi.js";
 import { registerTool as registerAddContentTypeSnippetMapi } from "./tools/add-content-type-snippet-mapi.js";
+import { registerTool as registerAddTaxonomyGroupMapi } from "./tools/add-taxonomy-group-mapi.js";
+import { registerTool as registerDeleteContentItemMapi } from "./tools/delete-content-item-mapi.js";
+import { registerTool as registerDeleteLanguageVariantMapi } from "./tools/delete-language-variant-mapi.js";
+import { registerTool as registerGetAssetMapi } from "./tools/get-asset-mapi.js";
+import { registerTool as registerGetItemDapi } from "./tools/get-item-dapi.js";
+import { registerTool as registerGetItemMapi } from "./tools/get-item-mapi.js";
+import { registerTool as registerGetTaxonomyGroupMapi } from "./tools/get-taxonomy-group-mapi.js";
+import { registerTool as registerGetTypeMapi } from "./tools/get-type-mapi.js";
 import { registerTool as registerGetTypeSnippetMapi } from "./tools/get-type-snippet-mapi.js";
+import { registerTool as registerGetVariantMapi } from "./tools/get-variant-mapi.js";
+import { registerTool as registerListAssetsMapi } from "./tools/list-assets-mapi.js";
 import { registerTool as registerListContentTypeSnippetsMapi } from "./tools/list-content-type-snippets-mapi.js";
-import { registerTool as registerAddTaxonomyGroupMapi } from "./tools/add-taxonomy-group-mapi.js";
+import { registerTool as registerListContentTypesMapi } from "./tools/list-content-types-mapi.js";
+import { registerTool as registerListLanguagesMapi } from "./tools/list-languages-mapi.js";
 import { registerTool as registerListTaxonomyGroupsMapi } from "./tools/list-taxonomy-groups-mapi.js";
-import { registerTool as registerGetTaxonomyGroupMapi } from "./tools/get-taxonomy-group-mapi.js";
+import { registerTool as registerUpdateContentItemMapi } from "./tools/update-content-item-mapi.js";
+import { registerTool as registerUpsertLanguageVariantMapi } from "./tools/upsert-language-variant-mapi.js";
 // Create server instance
 export const createServer = () => {
     const server = new McpServer({
         name: "kontent-ai",
-        version: "1.0.0",
+        version: packageJson.version,
         capabilities: {
             resources: {},
             tools: {},
@@ -40,5 +46,10 @@ export const createServer = () => {
     registerAddTaxonomyGroupMapi(server);
     registerListTaxonomyGroupsMapi(server);
     registerGetTaxonomyGroupMapi(server);
+    registerAddContentItemMapi(server);
+    registerUpdateContentItemMapi(server);
+    registerDeleteContentItemMapi(server);
+    registerUpsertLanguageVariantMapi(server);
+    registerDeleteLanguageVariantMapi(server);
     return { server };
 };

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

@@ -0,0 +1,54 @@
+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("add-content-item-mapi", "Add a new content item via Management API. This creates the content item structure but does not add content to language variants. Use upsert-language-variant-mapi to add content to the item.", {
+        name: z
+            .string()
+            .min(1)
+            .max(200)
+            .describe("Display name of the content item (1-200 characters)"),
+        type: z
+            .object({
+            id: z.string().optional(),
+            codename: z.string().optional(),
+            external_id: z.string().optional(),
+        })
+            .describe("Reference to the content type by id, codename, or external_id. At least one property must be specified."),
+        codename: z
+            .string()
+            .optional()
+            .describe("Codename of the content item (optional, will be generated from name if not provided)"),
+        external_id: z
+            .string()
+            .optional()
+            .describe("External ID for the content item (optional, useful for external system integration)"),
+        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 ({ name, type, codename, external_id, collection }) => {
+        const client = createMapiClient();
+        try {
+            const response = await client
+                .addContentItem()
+                .withData({
+                name,
+                type,
+                codename,
+                external_id,
+                collection,
+            })
+                .toPromise();
+            return createMcpToolSuccessResponse(response.rawData);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Content Item Creation");
+        }
+    });
+};

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

@@ -1,36 +1,43 @@
 import { z } from "zod";
-import { createMapiClient } from '../clients/kontentClients.js';
-import { elementSchema, contentGroupSchema } from '../schemas/contentTypeSchemas.js';
+import { createMapiClient } from "../clients/kontentClients.js";
+import { contentGroupSchema, elementSchema, } 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-mapi", "Add a new content type via Management API", {
         name: z.string().describe("Display name of the content type"),
-        codename: z.string().optional().describe("Codename of the content type (optional, will be generated if not provided)"),
-        external_id: z.string().optional().describe("External ID of the content type (optional)"),
-        elements: z.array(elementSchema).describe("Array of elements that define the structure of the content type"),
-        content_groups: z.array(contentGroupSchema).optional().describe("Array of content groups (optional)"),
+        codename: z
+            .string()
+            .optional()
+            .describe("Codename of the content type (optional, will be generated if not provided)"),
+        external_id: z
+            .string()
+            .optional()
+            .describe("External ID of the content type (optional)"),
+        elements: z
+            .array(elementSchema)
+            .describe("Array of elements that define the structure of the content type"),
+        content_groups: z
+            .array(contentGroupSchema)
+            .optional()
+            .describe("Array of content groups (optional)"),
     }, async ({ name, codename, external_id, elements, content_groups }) => {
         const client = createMapiClient();
-        const response = await client
-            .addContentType()
-            .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
+                .addContentType()
+                .withData(() => ({
+                name,
+                codename,
+                external_id,
+                elements,
+                content_groups,
+            }))
+                .toPromise();
+            return createMcpToolSuccessResponse(response.rawData);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Content Type Creation");
+        }
     });
 };