@kontent-ai/mcp-server 0.23.2 → 0.24.0

package/README.md

@@ -63,7 +63,7 @@ npx @kontent-ai/mcp-server@latest shttp
 
 ### Patch Operations Guide
 
-* **get-patch-guide** – 🚨 **REQUIRED before any patch operation**. Get JSON Patch operations guide for Kontent.ai Management API
+* **get-patch-guide** – 🚨 **REQUIRED before any patch operation**. Get patch operations guide for Kontent.ai Management API by entity type
 
 ### Content Type Management
 
@@ -78,17 +78,20 @@ npx @kontent-ai/mcp-server@latest shttp
 * **get-type-snippet-mapi** – Get Kontent.ai content type snippet by internal ID from Management API
 * **list-content-type-snippets-mapi** – Get all Kontent.ai content type snippets from Management API
 * **add-content-type-snippet-mapi** – Add new Kontent.ai content type snippet via Management API
+* **patch-type-snippet-mapi** – Update an existing Kontent.ai content type snippet by internal ID using patch operations (move, addInto, remove, replace)
+* **delete-type-snippet-mapi** – Delete a Kontent.ai content type snippet by codename
 
 ### Taxonomy Management
 
 * **get-taxonomy-group-mapi** – Get Kontent.ai taxonomy group by internal ID from Management API
 * **list-taxonomy-groups-mapi** – Get all Kontent.ai taxonomy groups from Management API
 * **add-taxonomy-group-mapi** – Add new Kontent.ai taxonomy group via Management API
+* **patch-taxonomy-group-mapi** – Update Kontent.ai taxonomy group using patch operations (addInto, move, remove, replace) via Management API
+* **delete-taxonomy-group-mapi** – Delete Kontent.ai taxonomy group by internal ID
 
 ### Content Item Management
 
 * **get-item-mapi** – Get Kontent.ai item by internal ID from Management API
-* **get-item-dapi** – Get Kontent.ai item by codename from Delivery API
 * **get-latest-variant-mapi** – Get latest version of Kontent.ai language variant from Management API
 * **get-published-variant-mapi** – Get published version of Kontent.ai language variant from Management API
 * **list-variants-item-mapi** – List all Kontent.ai language variants of a content item from Management API
@@ -109,6 +112,12 @@ npx @kontent-ai/mcp-server@latest shttp
 
 * **get-asset-mapi** – Get a specific Kontent.ai asset by internal ID from Management API
 * **list-assets-mapi** – Get all Kontent.ai assets from Management API
+* **update-asset-mapi** – Update Kontent.ai asset by internal ID
+
+### Asset Folder Management
+
+* **list-asset-folders-mapi** – List all Kontent.ai asset folders
+* **patch-asset-folders-mapi** – Modify Kontent.ai asset folders using patch operations (addInto to add new folders, rename to change names, remove to delete folders)
 
 ### Language Management
 
@@ -124,6 +133,9 @@ npx @kontent-ai/mcp-server@latest shttp
 ### Space Management
 
 * **list-spaces-mapi** – Get all Kontent.ai spaces from Management API
+* **add-space-mapi** – Add Kontent.ai space to environment
+* **patch-space-mapi** – Patch Kontent.ai space using replace operations
+* **delete-space-mapi** – Delete Kontent.ai space
 
 ### Workflow Management
 

package/build/bin.js

@@ -152,7 +152,7 @@ Available endpoints:
 async function startStdio() {
     const { server } = createServer();
     const transport = new StdioServerTransport();
-    console.log(`Kontent.ai MCP Server v${version} (stdio) starting`);
+    console.error(`Kontent.ai MCP Server v${version} (stdio) starting`);
     await server.connect(transport);
 }
 async function main() {

package/build/schemas/assetFolderSchemas.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { referenceObjectSchema } from "./referenceObjectSchema.js";
+const assetFolderValueSchema = z.object({
+    name: z.string(),
+    codename: z.string().optional(),
+    external_id: z.string().optional(),
+    folders: z.lazy(() => z.array(assetFolderValueSchema)).optional(),
+});
+const addIntoBaseSchema = {
+    op: z.literal("addInto"),
+    reference: referenceObjectSchema
+        .optional()
+        .describe("Parent folder reference. Omit to add at root level."),
+    value: assetFolderValueSchema,
+};
+const addIntoBeforeOperationSchema = z.object({
+    ...addIntoBaseSchema,
+    before: referenceObjectSchema,
+});
+const addIntoAfterOperationSchema = z.object({
+    ...addIntoBaseSchema,
+    after: referenceObjectSchema,
+});
+const addIntoDefaultOperationSchema = z.object(addIntoBaseSchema);
+const renameOperationSchema = z.object({
+    op: z.literal("rename"),
+    reference: referenceObjectSchema,
+    value: z.string(),
+});
+const removeOperationSchema = z.object({
+    op: z.literal("remove"),
+    reference: referenceObjectSchema,
+});
+const assetFolderPatchOperationSchema = z.union([
+    addIntoBeforeOperationSchema,
+    addIntoAfterOperationSchema,
+    addIntoDefaultOperationSchema,
+    renameOperationSchema,
+    removeOperationSchema,
+]);
+export const assetFolderPatchOperationsSchema = z
+    .array(assetFolderPatchOperationSchema)
+    .min(1)
+    .describe("Patch operations array. Use addInto to add new folders (with optional reference for parent, before/after for positioning), rename to change folder names, remove to delete folders.");

package/build/schemas/assetSchemas.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { referenceObjectSchema } from "./referenceObjectSchema.js";
+const assetDescriptionSchema = z.object({
+    language: referenceObjectSchema,
+    description: z.string(),
+});
+const assetTaxonomyElementSchema = z.object({
+    element: referenceObjectSchema,
+    value: z.array(referenceObjectSchema),
+});
+const assetCollectionReferenceSchema = z.object({
+    reference: referenceObjectSchema,
+});
+export const updateAssetDataSchema = z
+    .object({
+    title: z.string().optional(),
+    codename: z.string().optional(),
+    collection: assetCollectionReferenceSchema.optional(),
+    folder: referenceObjectSchema.optional(),
+    descriptions: z.array(assetDescriptionSchema).optional(),
+    elements: z.array(assetTaxonomyElementSchema).optional(),
+})
+    .describe("Only include properties you want to update; omitted fields retain existing values.");

package/build/schemas/{contentTypeSchemas.js → contentTypeAndSnippetSchemas.js}

@@ -1,9 +1,5 @@
 import { z } from "zod";
-// Reference by id or codename (id preferred)
-export const referenceObjectSchema = z.object({
-    id: z.string().optional(),
-    codename: z.string().optional(),
-});
+import { referenceObjectSchema } from "./referenceObjectSchema.js";
 // Common property schemas
 const baseElementSchema = {
     codename: z.string().optional(),
@@ -16,7 +12,10 @@ const contentGroupElementSchema = {
 const namedElementSchema = {
     ...baseElementSchema,
     name: z.string(),
-    guidelines: z.string().optional(),
+    guidelines: z
+        .string()
+        .optional()
+        .describe("Plain text guidelines shown to editors"),
     is_required: z.boolean().optional(),
     is_non_localizable: z.boolean().optional(),
 };
@@ -93,7 +92,7 @@ const assetElementSchema = {
 const customElementSchema = {
     type: z.literal("custom"),
     ...namedElementSchema,
-    source_url: z.string(),
+    source_url: z.url(),
     json_parameters: z.string().optional(),
     allowed_elements: z.array(referenceObjectSchema).optional(),
 };
@@ -105,7 +104,9 @@ const dateTimeElementSchema = {
 const guidelinesElementSchema = {
     type: z.literal("guidelines"),
     ...baseElementSchema,
-    guidelines: z.string(),
+    guidelines: z
+        .string()
+        .describe("HTML content for guidelines element. Must be valid HTML."),
 };
 const modularContentElementSchema = {
     type: z.literal("modular_content"),
@@ -292,14 +293,12 @@ export const contentGroupSchema = z.object({
     external_id: z.string().optional(),
     codename: z.string().optional(),
 });
-// Define a union type for snippet elements (excluding url_slug and snippet elements)
 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),

package/build/schemas/patchSchemas/baseTypeAndSnippetPatchSchemas.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { allowedBlockSchema, allowedFormattingSchema, allowedTableBlockSchema, allowedTableFormattingSchema, allowedTableTextBlockSchema, allowedTextBlockSchema, arrayDefaultSchema, countLimitSchema, numberDefaultSchema, optionSchema, regexValidationSchema, stringDefaultSchema, textLengthLimitSchema, } from "../contentTypeAndSnippetSchemas.js";
+import { referenceObjectSchema } from "../referenceObjectSchema.js";
+export const moveOperationSchema = z.object({
+    op: z.literal("move"),
+    path: z.string().describe("Path to object (format: id:{uuid})"),
+    before: referenceObjectSchema.optional(),
+    after: referenceObjectSchema.optional(),
+});
+export const removeOperationSchema = z.object({
+    op: z.literal("remove"),
+    path: z.string().describe("Path to item to remove (format: id:{uuid})"),
+});
+export const sharedAddIntoValueSchemas = [
+    optionSchema,
+    referenceObjectSchema,
+    allowedBlockSchema,
+    allowedFormattingSchema,
+    allowedTextBlockSchema,
+    allowedTableBlockSchema,
+    allowedTableFormattingSchema,
+    allowedTableTextBlockSchema,
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.any(),
+];
+export const sharedReplaceValueSchemas = [
+    regexValidationSchema,
+    textLengthLimitSchema,
+    countLimitSchema,
+    arrayDefaultSchema,
+    stringDefaultSchema,
+    numberDefaultSchema,
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.any(),
+];

package/build/schemas/patchSchemas/contentTypePatchSchemas.js

@@ -1,66 +1,24 @@
-// Patch operation schemas for content type modifications
-// Based on: https://kontent.ai/learn/docs/apis/openapi/management-api-v2/#operation/modify-a-content-type
 import { z } from "zod";
-import { allowedBlockSchema, allowedFormattingSchema, allowedTableBlockSchema, allowedTableFormattingSchema, allowedTableTextBlockSchema, allowedTextBlockSchema, arrayDefaultSchema, contentGroupSchema, countLimitSchema, dependsOnSchema, elementSchema, numberDefaultSchema, optionSchema, referenceObjectSchema, regexValidationSchema, stringDefaultSchema, textLengthLimitSchema, } from "../contentTypeSchemas.js";
-// Move operation - Move elements within content type
-const moveOperationSchema = z.object({
-    op: z.literal("move"),
-    path: z.string().describe("Path to object (format: id:{uuid})"),
-    before: referenceObjectSchema.optional(),
-    after: referenceObjectSchema.optional(),
-});
-// AddInto operation - Add new elements to content type
+import { contentGroupSchema, dependsOnSchema, elementSchema, } from "../contentTypeAndSnippetSchemas.js";
+import { moveOperationSchema, removeOperationSchema, sharedAddIntoValueSchemas, sharedReplaceValueSchemas, } from "./baseTypeAndSnippetPatchSchemas.js";
 const addIntoOperationSchema = z.object({
     op: z.literal("addInto"),
     path: z.string().describe("Path where to add item (format: id:{uuid})"),
     value: z.union([
         elementSchema,
-        optionSchema,
         contentGroupSchema,
-        referenceObjectSchema,
-        allowedBlockSchema,
-        allowedFormattingSchema,
-        allowedTextBlockSchema,
-        allowedTableBlockSchema,
-        allowedTableFormattingSchema,
-        allowedTableTextBlockSchema,
-        z.string(),
-        z.number(),
-        z.boolean(),
-        z.null(),
-        z.any(),
+        ...sharedAddIntoValueSchemas,
     ]),
 });
-// Remove operation - Remove elements from content type
-const removeOperationSchema = z.object({
-    op: z.literal("remove"),
-    path: z.string().describe("Path to item to remove (format: id:{uuid})"),
-});
-// Replace operation - Replace/update existing elements in content type
 const replaceOperationSchema = z.object({
     op: z.literal("replace"),
     path: z.string().describe("Path to property to replace (format: id:{uuid})"),
-    value: z.union([
-        dependsOnSchema,
-        regexValidationSchema,
-        textLengthLimitSchema,
-        countLimitSchema,
-        arrayDefaultSchema,
-        stringDefaultSchema,
-        numberDefaultSchema,
-        z.string(),
-        z.number(),
-        z.boolean(),
-        z.null(),
-        z.any(),
-    ]),
+    value: z.union([dependsOnSchema, ...sharedReplaceValueSchemas]),
 });
-// Union type for all patch operations
 export const patchOperationSchema = z.discriminatedUnion("op", [
     moveOperationSchema,
     addIntoOperationSchema,
     removeOperationSchema,
     replaceOperationSchema,
 ]);
-// Schema for array of patch operations
 export const patchOperationsSchema = z.array(patchOperationSchema).min(1);

package/build/schemas/patchSchemas/snippetPatchSchemas.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { snippetElementSchema } from "../contentTypeAndSnippetSchemas.js";
+import { moveOperationSchema, removeOperationSchema, sharedAddIntoValueSchemas, sharedReplaceValueSchemas, } from "./baseTypeAndSnippetPatchSchemas.js";
+const addIntoOperationSchema = z.object({
+    op: z.literal("addInto"),
+    path: z.string().describe("Path where to add item (format: id:{uuid})"),
+    value: z.union([snippetElementSchema, ...sharedAddIntoValueSchemas]),
+});
+const replaceOperationSchema = z.object({
+    op: z.literal("replace"),
+    path: z.string().describe("Path to property to replace (format: id:{uuid})"),
+    value: z.union(sharedReplaceValueSchemas),
+});
+export const snippetPatchOperationSchema = z.discriminatedUnion("op", [
+    moveOperationSchema,
+    addIntoOperationSchema,
+    removeOperationSchema,
+    replaceOperationSchema,
+]);
+export const snippetPatchOperationsSchema = z
+    .array(snippetPatchOperationSchema)
+    .min(1);

package/build/schemas/patchSchemas/taxonomyPatchSchemas.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { referenceObjectSchema } from "../referenceObjectSchema.js";
+const taxonomyTermValueSchema = z.object({
+    name: z.string(),
+    codename: z.string().optional(),
+    external_id: z.string().optional(),
+    terms: z.lazy(() => z.array(taxonomyTermValueSchema)).optional(),
+});
+const addIntoBaseSchema = {
+    op: z.literal("addInto"),
+    reference: referenceObjectSchema
+        .optional()
+        .describe("Parent term reference. Omit to add at root level of taxonomy group."),
+    value: taxonomyTermValueSchema,
+};
+const addIntoBeforeOperationSchema = z.object({
+    ...addIntoBaseSchema,
+    before: referenceObjectSchema,
+});
+const addIntoAfterOperationSchema = z.object({
+    ...addIntoBaseSchema,
+    after: referenceObjectSchema,
+});
+const addIntoDefaultOperationSchema = z.object(addIntoBaseSchema);
+const moveBaseSchema = {
+    op: z.literal("move"),
+    reference: referenceObjectSchema,
+};
+const moveBeforeOperationSchema = z.object({
+    ...moveBaseSchema,
+    before: referenceObjectSchema,
+});
+const moveAfterOperationSchema = z.object({
+    ...moveBaseSchema,
+    after: referenceObjectSchema,
+});
+const moveUnderOperationSchema = z.object({
+    ...moveBaseSchema,
+    under: referenceObjectSchema.describe("Move as child of this term (tree nesting)"),
+});
+const removeOperationSchema = z.object({
+    op: z.literal("remove"),
+    reference: referenceObjectSchema,
+});
+const replaceOperationSchema = z.object({
+    op: z.literal("replace"),
+    reference: referenceObjectSchema
+        .optional()
+        .describe("Term reference. Omit when modifying group-level properties (name, codename). Required when modifying specific term."),
+    property_name: z.enum(["name", "codename", "terms"]),
+    value: z
+        .union([z.string(), z.array(taxonomyTermValueSchema)])
+        .describe("New value. String for name/codename, array for terms."),
+});
+export const taxonomyPatchOperationSchema = z.union([
+    addIntoBeforeOperationSchema,
+    addIntoAfterOperationSchema,
+    addIntoDefaultOperationSchema,
+    moveBeforeOperationSchema,
+    moveAfterOperationSchema,
+    moveUnderOperationSchema,
+    removeOperationSchema,
+    replaceOperationSchema,
+]);
+export const taxonomyPatchOperationsSchema = z
+    .array(taxonomyPatchOperationSchema)
+    .min(1);

package/build/schemas/spaceSchemas.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { referenceObjectSchema } from "./referenceObjectSchema.js";
+const nameReplaceOperationSchema = z.object({
+    op: z.literal("replace"),
+    property_name: z.literal("name"),
+    value: z.string(),
+});
+const codenameReplaceOperationSchema = z.object({
+    op: z.literal("replace"),
+    property_name: z.literal("codename"),
+    value: z.string(),
+});
+const collectionsReplaceOperationSchema = z.object({
+    op: z.literal("replace"),
+    property_name: z.literal("collections"),
+    value: z.array(referenceObjectSchema),
+});
+export const spacePatchOperationSchema = z.discriminatedUnion("property_name", [
+    nameReplaceOperationSchema,
+    codenameReplaceOperationSchema,
+    collectionsReplaceOperationSchema,
+]);
+export const spacePatchOperationsSchema = z
+    .array(spacePatchOperationSchema)
+    .min(1);
+export const addSpaceSchema = z.object({
+    name: z.string(),
+    codename: z.string().optional(),
+    collections: z.array(referenceObjectSchema).optional(),
+});

package/build/server.js

@@ -4,12 +4,16 @@ import { registerTool as registerAddContentItemMapi } from "./tools/add-content-
 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 registerAddLanguageMapi } from "./tools/add-language-mapi.js";
+import { registerTool as registerAddSpaceMapi } from "./tools/add-space-mapi.js";
 import { registerTool as registerAddTaxonomyGroupMapi } from "./tools/add-taxonomy-group-mapi.js";
 import { registerTool as registerChangeVariantWorkflowStepMapi } from "./tools/change-variant-workflow-step-mapi.js";
 import { registerTool as registerCreateVariantVersionMapi } from "./tools/create-variant-version-mapi.js";
 import { registerTool as registerDeleteContentItemMapi } from "./tools/delete-content-item-mapi.js";
 import { registerTool as registerDeleteContentTypeMapi } from "./tools/delete-content-type-mapi.js";
 import { registerTool as registerDeleteLanguageVariantMapi } from "./tools/delete-language-variant-mapi.js";
+import { registerTool as registerDeleteSpaceMapi } from "./tools/delete-space-mapi.js";
+import { registerTool as registerDeleteTaxonomyGroupMapi } from "./tools/delete-taxonomy-group-mapi.js";
+import { registerTool as registerDeleteTypeSnippetMapi } from "./tools/delete-type-snippet-mapi.js";
 import { registerTool as registerFilterVariantsMapi } from "./tools/filter-variants-mapi.js";
 import { registerTool as registerGetAssetMapi } from "./tools/get-asset-mapi.js";
 import { registerTool as registerGetItemMapi } from "./tools/get-item-mapi.js";
@@ -19,6 +23,7 @@ import { registerTool as registerGetPublishedVariantMapi } from "./tools/get-pub
 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 registerListAssetFoldersMapi } from "./tools/list-asset-folders-mapi.js";
 import { registerTool as registerListAssetsMapi } from "./tools/list-assets-mapi.js";
 import { registerTool as registerListCollectionsMapi } from "./tools/list-collections-mapi.js";
 import { registerTool as registerListContentTypeSnippetsMapi } from "./tools/list-content-type-snippets-mapi.js";
@@ -32,12 +37,17 @@ import { registerTool as registerListVariantsItemMapi } from "./tools/list-varia
 import { registerTool as registerListVariantsSpaceMapi } from "./tools/list-variants-space-mapi.js";
 import { registerTool as registerListVariantsTypeMapi } from "./tools/list-variants-type-mapi.js";
 import { registerTool as registerListWorkflowsMapi } from "./tools/list-workflows-mapi.js";
+import { registerTool as registerPatchAssetFoldersMapi } from "./tools/patch-asset-folders-mapi.js";
 import { registerTool as registerPatchCollectionsMapi } from "./tools/patch-collections-mapi.js";
 import { registerTool as registerPatchContentTypeMapi } from "./tools/patch-content-type-mapi.js";
 import { registerTool as registerPatchLanguageMapi } from "./tools/patch-language-mapi.js";
+import { registerTool as registerPatchSpaceMapi } from "./tools/patch-space-mapi.js";
+import { registerTool as registerPatchTaxonomyGroupMapi } from "./tools/patch-taxonomy-group-mapi.js";
+import { registerTool as registerPatchTypeSnippetMapi } from "./tools/patch-type-snippet-mapi.js";
 import { registerTool as registerPublishVariantMapi } from "./tools/publish-variant-mapi.js";
 import { registerTool as registerSearchVariantsMapi } from "./tools/search-variants-mapi.js";
 import { registerTool as registerUnpublishVariantMapi } from "./tools/unpublish-variant-mapi.js";
+import { registerTool as registerUpdateAssetMapi } from "./tools/update-asset-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
@@ -65,16 +75,26 @@ export const createServer = () => {
     registerListCollectionsMapi(server);
     registerPatchCollectionsMapi(server);
     registerListSpacesMapi(server);
+    registerAddSpaceMapi(server);
+    registerPatchSpaceMapi(server);
+    registerDeleteSpaceMapi(server);
     registerGetAssetMapi(server);
     registerListAssetsMapi(server);
+    registerUpdateAssetMapi(server);
+    registerListAssetFoldersMapi(server);
+    registerPatchAssetFoldersMapi(server);
     registerAddContentTypeMapi(server);
     registerPatchContentTypeMapi(server);
     registerAddContentTypeSnippetMapi(server);
     registerGetTypeSnippetMapi(server);
     registerListContentTypeSnippetsMapi(server);
+    registerPatchTypeSnippetMapi(server);
+    registerDeleteTypeSnippetMapi(server);
     registerAddTaxonomyGroupMapi(server);
     registerListTaxonomyGroupsMapi(server);
     registerGetTaxonomyGroupMapi(server);
+    registerPatchTaxonomyGroupMapi(server);
+    registerDeleteTaxonomyGroupMapi(server);
     registerAddContentItemMapi(server);
     registerUpdateContentItemMapi(server);
     registerDeleteContentItemMapi(server);

package/build/telemetry/applicationInsights.js

@@ -156,6 +156,6 @@ export function initializeApplicationInsights() {
         appInsights.defaultClient.addTelemetryProcessor(createTelemetryProcessor());
     }
     catch (error) {
-        console.log("Failed to initialize Application Insights:", error);
+        console.error("Failed to initialize Application Insights:", error);
     }
 }

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
-import { contentGroupSchema, elementSchema, } from "../schemas/contentTypeSchemas.js";
+import { contentGroupSchema, elementSchema, } from "../schemas/contentTypeAndSnippetSchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
-import { snippetElementSchema } from "../schemas/contentTypeSchemas.js";
+import { snippetElementSchema } from "../schemas/contentTypeAndSnippetSchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {

package/build/tools/add-space-mapi.js

@@ -0,0 +1,23 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { addSpaceSchema } from "../schemas/spaceSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+export const registerTool = (server) => {
+    server.tool("add-space-mapi", "Add Kontent.ai space", addSpaceSchema.shape, async ({ name, codename, collections }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            const response = await client
+                .addSpace()
+                .withData({
+                name,
+                codename,
+                collections,
+            })
+                .toPromise();
+            return createMcpToolSuccessResponse(response.rawData);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Space Creation");
+        }
+    });
+};

package/build/tools/context/patch-guide-path-based.js

@@ -0,0 +1,53 @@
+export const pathBasedPatchGuide = `
+# Patch Guide: Content Types & Snippets
+
+## Addressing
+Use JSON Pointer 'path' property with id:{uuid} format.
+
+## Path Formats
+- Element: /elements/id:{uuid}
+- Element property: /elements/id:{uuid}/name
+- Option: /elements/id:{uuid}/options/id:{uuid}
+- Content group: /content_groups/id:{uuid}
+- Array item: /elements/id:{uuid}/allowed_content_types/id:{uuid}
+
+## Operations
+
+**move** - Reorder elements/options/groups
+\`\`\`json
+{ "op": "move", "path": "/elements/id:{uuid}", "before": { "id": "{uuid}" } }
+{ "op": "move", "path": "/elements/id:{uuid}", "after": { "id": "{uuid}" } }
+\`\`\`
+
+**addInto** - Add to arrays (elements, options, allowed_blocks, etc.)
+\`\`\`json
+{ "op": "addInto", "path": "/elements", "value": { "name": "Title", "type": "text", ... } }
+{ "op": "addInto", "path": "/elements/id:{uuid}/allowed_content_types", "value": { "id": "{uuid}" } }
+\`\`\`
+
+**remove** - Delete items
+\`\`\`json
+{ "op": "remove", "path": "/elements/id:{uuid}" }
+{ "op": "remove", "path": "/elements/id:{uuid}/allowed_content_types/id:{uuid}" }
+\`\`\`
+
+**replace** - Update primitives/objects
+\`\`\`json
+{ "op": "replace", "path": "/elements/id:{uuid}/name", "value": "New Name" }
+{ "op": "replace", "path": "/elements/id:{uuid}/maximum_text_length", "value": { "value": 100, "applies_to": "characters" } }
+\`\`\`
+
+## Rules
+- Use addInto/remove for arrays, replace for primitives/objects
+- external_id and type cannot be modified after creation
+- Empty arrays enable all options (allowed_blocks, allowed_formatting, etc.)
+- 'unstyled' must be first when adding allowed_formatting
+
+## Content Type Specifics
+- 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
+
+## Snippet Specifics
+- Cannot contain: content_groups, snippet, or url_slug elements
+`;

package/build/tools/context/patch-guide-property-based.js

@@ -0,0 +1,42 @@
+export const propertyBasedPatchGuide = `
+# Patch Guide: Spaces & Languages
+
+## Addressing
+Use 'property_name' to specify which property to update. Only 'replace' operation is supported.
+
+## Space Operations
+
+**replace** - Update space properties
+\`\`\`json
+{ "op": "replace", "property_name": "name", "value": "New Space Name" }
+{ "op": "replace", "property_name": "codename", "value": "new_codename" }
+{ "op": "replace", "property_name": "collections", "value": [{ "id": "{uuid}" }, { "codename": "collection" }] }
+\`\`\`
+
+Available properties: name, codename, collections
+
+## Language Operations
+
+**replace** - Update language properties
+\`\`\`json
+{ "op": "replace", "property_name": "name", "value": "New Language Name" }
+{ "op": "replace", "property_name": "codename", "value": "new_codename" }
+{ "op": "replace", "property_name": "is_active", "value": true }
+{ "op": "replace", "property_name": "fallback_language", "value": { "codename": "en-US" } }
+\`\`\`
+
+Available properties: name, codename, is_active, fallback_language
+
+## Critical Rule for Languages
+If a language is deactivated, you must activate it first before making other changes:
+\`\`\`json
+[
+  { "op": "replace", "property_name": "is_active", "value": true },
+  { "op": "replace", "property_name": "name", "value": "New Name" }
+]
+\`\`\`
+
+## General Rules
+- external_id cannot be modified after creation
+- Operations are applied in order
+`;

package/build/tools/context/patch-guide-reference-based.js

@@ -0,0 +1,86 @@
+export const referenceBasedPatchGuide = `
+# Patch Guide: Taxonomy, Collections & Asset Folders
+
+## Addressing
+Use 'reference' objects: { id: "{uuid}" } or { codename: "codename" }
+
+## Taxonomy Group Operations
+
+**addInto** - Add terms
+\`\`\`json
+{ "op": "addInto", "value": { "name": "Term" } }
+{ "op": "addInto", "reference": { "id": "{parent-uuid}" }, "value": { "name": "Child Term" } }
+{ "op": "addInto", "value": { "name": "Term" }, "before": { "id": "{uuid}" } }
+{ "op": "addInto", "value": { "name": "Term" }, "after": { "id": "{uuid}" } }
+\`\`\`
+
+**move** - Reorder or nest terms (before/after/under are mutually exclusive)
+\`\`\`json
+{ "op": "move", "reference": { "id": "{uuid}" }, "before": { "id": "{uuid}" } }
+{ "op": "move", "reference": { "id": "{uuid}" }, "after": { "id": "{uuid}" } }
+{ "op": "move", "reference": { "id": "{uuid}" }, "under": { "id": "{parent-uuid}" } }
+\`\`\`
+
+**remove** - Delete terms
+\`\`\`json
+{ "op": "remove", "reference": { "id": "{uuid}" } }
+\`\`\`
+
+**replace** - Update properties
+\`\`\`json
+{ "op": "replace", "property_name": "name", "value": "New Group Name" }
+{ "op": "replace", "reference": { "id": "{uuid}" }, "property_name": "name", "value": "New Term Name" }
+{ "op": "replace", "reference": { "id": "{uuid}" }, "property_name": "terms", "value": [] }
+\`\`\`
+
+## Collection Operations
+
+**addInto** - Add collections
+\`\`\`json
+{ "op": "addInto", "value": { "name": "Collection", "codename": "collection" } }
+{ "op": "addInto", "value": { "name": "Collection" }, "before": { "id": "{uuid}" } }
+{ "op": "addInto", "value": { "name": "Collection" }, "after": { "id": "{uuid}" } }
+\`\`\`
+
+**move** - Reorder collections
+\`\`\`json
+{ "op": "move", "reference": { "id": "{uuid}" }, "before": { "id": "{uuid}" } }
+{ "op": "move", "reference": { "id": "{uuid}" }, "after": { "id": "{uuid}" } }
+\`\`\`
+
+**remove** - Delete empty collections only
+\`\`\`json
+{ "op": "remove", "reference": { "id": "{uuid}" } }
+\`\`\`
+
+**replace** - Rename collections
+\`\`\`json
+{ "op": "replace", "reference": { "id": "{uuid}" }, "property_name": "name", "value": "New Name" }
+\`\`\`
+
+## Asset Folder Operations
+
+**addInto** - Add folders
+\`\`\`json
+{ "op": "addInto", "value": { "name": "Folder" } }
+{ "op": "addInto", "reference": { "id": "{parent-uuid}" }, "value": { "name": "Subfolder" } }
+{ "op": "addInto", "value": { "name": "Folder" }, "before": { "id": "{uuid}" } }
+\`\`\`
+
+**rename** - Rename folders (not 'replace')
+\`\`\`json
+{ "op": "rename", "reference": { "id": "{uuid}" }, "value": "New Folder Name" }
+\`\`\`
+
+**remove** - Delete folders
+\`\`\`json
+{ "op": "remove", "reference": { "id": "{uuid}" } }
+\`\`\`
+
+Note: Asset folders do not support 'move' operation.
+
+## General Rules
+- Always fetch the entity first to get current IDs
+- external_id cannot be modified after creation
+- Operations are applied in order
+`;

package/build/tools/delete-space-mapi.js

@@ -0,0 +1,20 @@
+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-space-mapi", "Delete Kontent.ai space by ID", {
+        id: z.guid(),
+    }, async ({ id }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            await client.deleteSpace().bySpaceId(id).toPromise();
+            return createMcpToolSuccessResponse({
+                message: `Space '${id}' deleted successfully`,
+            });
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Space Deletion");
+        }
+    });
+};

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

@@ -0,0 +1,20 @@
+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-taxonomy-group-mapi", "Delete Kontent.ai taxonomy group by ID", {
+        id: z.guid(),
+    }, async ({ id }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            await client.deleteTaxonomy().byTaxonomyId(id).toPromise();
+            return createMcpToolSuccessResponse({
+                message: `Taxonomy group '${id}' deleted successfully`,
+            });
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Taxonomy Group Deletion");
+        }
+    });
+};

package/build/tools/delete-type-snippet-mapi.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";
+export const registerTool = (server) => {
+    server.tool("delete-type-snippet-mapi", "Delete Kontent.ai content type snippet by codename", {
+        codename: z.string(),
+    }, async ({ codename }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            await client
+                .deleteContentTypeSnippet()
+                .byTypeCodename(codename)
+                .toPromise();
+            return createMcpToolSuccessResponse({
+                message: `Content type snippet '${codename}' deleted successfully`,
+            });
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Content Type Snippet Deletion");
+        }
+    });
+};

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

@@ -1,9 +1,37 @@
+import { z } from "zod";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-import { patchOperationsGuide } from "./context/patch-operations-guide.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";
+const entityTypeSchema = z.enum([
+    "content-type",
+    "snippet",
+    "taxonomy",
+    "collection",
+    "asset-folder",
+    "space",
+    "language",
+]);
+const getGuideForEntity = (entityType) => {
+    switch (entityType) {
+        case "content-type":
+        case "snippet":
+            return pathBasedPatchGuide;
+        case "taxonomy":
+        case "collection":
+        case "asset-folder":
+            return referenceBasedPatchGuide;
+        case "space":
+        case "language":
+            return propertyBasedPatchGuide;
+    }
+};
 export const registerTool = (server) => {
-    server.tool("get-patch-guide", "REQUIRED before any patch operation. Get JSON Patch operations guide for Kontent.ai Management API.", {}, async () => {
+    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(patchOperationsGuide);
+            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-taxonomy-group-mapi.js

@@ -3,8 +3,8 @@ 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 Kontent.ai taxonomy group. Taxonomies provide hierarchical categorization for organizing and tagging content.", {
-        id: z.string().describe("Taxonomy group ID"),
+    server.tool("get-taxonomy-group-mapi", "Get Kontent.ai taxonomy group. Taxonomy groups are hierarchical with tree-structured terms that can be nested to any depth for flexible content categorization.", {
+        id: z.guid(),
     }, async ({ id }, { authInfo: { token, clientId } = {} }) => {
         const client = createMapiClient(clientId, token);
         try {

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

@@ -0,0 +1,15 @@
+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-asset-folders-mapi", "List all Kontent.ai asset folders", {}, 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-spaces-mapi.js

@@ -2,7 +2,7 @@ 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-spaces-mapi", "Get all Kontent.ai spaces from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+    server.tool("list-spaces-mapi", "List all Kontent.ai spaces. Spaces provide channel-specific context 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();

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

@@ -3,7 +3,7 @@ import { listTaxonomyGroupsSchema } from "../schemas/listSchemas.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 Kontent.ai taxonomy groups (paginated). Taxonomies provide hierarchical categorization for organizing and tagging content.", listTaxonomyGroupsSchema.shape, async ({ continuation_token }, { authInfo: { token, clientId } = {} }) => {
+    server.tool("list-taxonomy-groups-mapi", "List all Kontent.ai taxonomy groups (paginated). Taxonomy groups are hierarchical with tree-structured terms that can be nested to any depth for flexible content categorization.", listTaxonomyGroupsSchema.shape, async ({ continuation_token }, { authInfo: { token, clientId } = {} }) => {
         const client = createMapiClient(clientId, token);
         try {
             const query = client.listTaxonomies();

package/build/tools/patch-asset-folders-mapi.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";
+export const registerTool = (server) => {
+    server.tool("patch-asset-folders-mapi", "Modify Kontent.ai asset folders using patch operations (addInto, rename, remove). Call get-patch-guide 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-content-type-mapi.js

@@ -4,20 +4,24 @@ import { patchOperationsSchema } from "../schemas/patchSchemas/contentTypePatchS
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
-    server.tool("patch-content-type-mapi", "Update Kontent.ai content type using JSON Patch. Call get-patch-guide first for operations reference.", {
-        codename: z.string().describe("Content type codename"),
-        operations: patchOperationsSchema.describe("Patch operations array. CRITICAL: Always call get-type-mapi first. Use addInto/remove for arrays, replace for primitives/objects. See context for details."),
-    }, async ({ codename, operations }, { authInfo: { token, clientId } = {} }) => {
+    server.tool("patch-content-type-mapi", "Update Kontent.ai content type using patch operations. Call get-patch-guide first for operations reference.", {
+        id: z.guid(),
+        operations: patchOperationsSchema.describe(`Patch operations array. CRITICAL: Always call get-type-mapi 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()
-                .byTypeCodename(codename)
+                .byTypeId(id)
                 .withData(operations)
                 .toPromise();
             return createMcpToolSuccessResponse({
-                message: `Content type '${codename}' updated successfully with ${operations.length} operation(s)`,
+                message: `Content type updated successfully with ${operations.length} operation(s)`,
                 contentType: response.rawData,
                 appliedOperations: operations,
             });

package/build/tools/patch-space-mapi.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";
+export const registerTool = (server) => {
+    server.tool("patch-space-mapi", "Patch Kontent.ai space using replace operations. Call get-patch-guide first for operations reference.", {
+        id: z.guid(),
+        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-mapi.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";
+export const registerTool = (server) => {
+    server.tool("patch-taxonomy-group-mapi", "Update Kontent.ai taxonomy group using patch operations (addInto, move, remove, replace). Call get-patch-guide first for operations reference.", {
+        id: z.guid(),
+        operations: taxonomyPatchOperationsSchema.describe("Patch operations array. Call get-taxonomy-group-mapi 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");
+        }
+    });
+};

package/build/tools/patch-type-snippet-mapi.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";
+export const registerTool = (server) => {
+    server.tool("patch-type-snippet-mapi", "Update Kontent.ai content type snippet using patch operations (move, addInto, remove, replace). Call get-patch-guide first for operations reference.", {
+        id: z.guid(),
+        operations: snippetPatchOperationsSchema.describe(`Patch operations array. CRITICAL: Always call get-type-snippet-mapi 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/update-asset-mapi.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { updateAssetDataSchema } from "../schemas/assetSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+export const registerTool = (server) => {
+    server.tool("update-asset-mapi", "Update Kontent.ai asset by ID", {
+        id: z.guid(),
+        data: updateAssetDataSchema,
+    }, async ({ id, data }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            const response = await client
+                .upsertAsset()
+                .byAssetId(id)
+                .withData(() => data)
+                .toPromise();
+            return createMcpToolSuccessResponse(response.rawData);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Asset Update");
+        }
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kontent-ai/mcp-server",
-  "version": "0.23.2",
+  "version": "0.24.0",
   "type": "module",
   "mcpName": "io.github.kontent-ai/mcp-server",
   "repository": {

package/build/tools/context/patch-operations-guide.js

@@ -1,58 +0,0 @@
-export const patchOperationsGuide = `
-# Content Type Patch Operations Guide
-
-## Overview
-Modify content types using RFC 6902 JSON Patch operations: move, addInto, remove, replace.
-
-## Critical Requirements
-- **Always call get-type-mapi first** to get current schema
-- **Use addInto/remove for arrays** (elements, allowed_content_types, allowed_blocks, etc.)
-- **Never use replace for array properties** - use addInto/remove instead
-- **Use replace for primitives/objects** (name, maximum_text_length, validation_regex)
-- **external_id and type cannot be modified** after creation
-- **When adding allowed_formatting/allowed_table_formatting**, 'unstyled' must be first
-
-## Operation Types
-
-### move
-Reorganize elements, options, or content groups using 'before' or 'after' reference.
-
-### addInto
-Add new items to arrays. Use for all array operations (elements, options, allowed_blocks, etc.).
-
-### remove
-Delete items from arrays or remove elements/groups.
-
-### replace
-Update primitives and objects. Cannot modify external_id, id, or type.
-
-## Path Formats
-Use JSON Pointer with id:{uuid} format:
-- Element: /elements/id:{uuid}
-- Element property: /elements/id:{uuid}/name
-- Option: /elements/id:{uuid}/options/id:{uuid}
-- Content group: /content_groups/id:{uuid}
-- Array item: /elements/id:{uuid}/allowed_content_types/id:{uuid}
-
-## Rich Text Properties
-- **allowed_content_types**: Content types for components/linked items (empty=all)
-- **allowed_item_link_types**: Content types for text links (empty=all)
-- **allowed_blocks**: "images", "text", "tables", "components-and-items" (empty=all)
-- **allowed_image_types**: "adjustable" or "any"
-- **allowed_text_blocks**: "paragraph", "heading-one" through "heading-six", "ordered-list", "unordered-list" (empty=all)
-- **allowed_formatting**: "unstyled", "bold", "italic", "code", "link", "subscript", "superscript" (empty=all, unstyled must be first)
-- **allowed_table_blocks**: "images", "text" (empty=both)
-- **allowed_table_text_blocks**: Same as allowed_text_blocks (empty=all)
-- **allowed_table_formatting**: Same as allowed_formatting (empty=all, unstyled must be first)
-
-## Special Techniques
-- **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
-
-## Best Practices
-- Use descriptive codenames
-- Group related operations in single request
-- Use id:{uuid} format in paths
-- Validate dependencies before adding URL slugs
-- Consider element ordering for move operations
-`;