@kontent-ai/mcp-server 0.27.0 → 0.28.1

package/README.md

@@ -23,7 +23,6 @@ Kontent.ai MCP Server implements the Model Context Protocol to connect your Kont
 - [🔌 Quickstart](#-quickstart)
 - [🛠️ Available Tools](#️-available-tools)
 - [⚙️ Configuration](#️-configuration)
-- [🔧 Response Optimization](#-response-optimization)
 - [🚀 Transport Options](#-transport-options)
 - [💻 Development](#-development)
   - [🛠 Local Installation](#-local-installation)
@@ -177,34 +176,6 @@ For multi-tenant mode (Streamable HTTP only), the server accepts:
 
 This mode allows a single server instance to handle requests for multiple Kontent.ai environments securely without requiring environment variables.
 
-## 🔧 Response Optimization
-
-The MCP server implements automatic token optimization to reduce AI model costs and improve performance:
-
-### Token Reduction Strategy
-
-The server automatically removes empty/default values from responses to reduce token usage. This includes:
-
-- Null and undefined values
-- Empty strings (`""`)
-- Empty arrays (`[]`)
-- Empty objects (`{}`)
-- Rich text placeholders (`"<p><br/></p>"`)
-- Elements with only an ID after empty value removal
-
-### Impact on AI Agents
-
-**Important for AI implementations**: When consuming responses from this MCP server:
-
-1. **Missing properties indicate default values**, not missing data
-2. Missing elements in variants have their type-specific defaults:
-   - Text elements: `""` (empty string)
-   - Rich text: `"<p><br/></p>"` (empty placeholder)
-   - Number/Date: `null`
-   - Custom elements: `null` (for value and searchable_value)
-   - Arrays (assets, taxonomy, etc.): `[]`
-3. When creating/updating content, always send complete data
-
 ## 🚀 Transport Options
 
 ### 📟 STDIO Transport

package/build/test/utils/responseHelper.spec.js

@@ -1,320 +1,20 @@
 import * as assert from "node:assert";
 import { describe, it } from "mocha";
-import { createMcpToolSuccessResponse, createVariantMcpToolSuccessResponse, isEmptyOrDefault, removeEmptyElementsFromVariant, removeEmptyValues, } from "../../utils/responseHelper.js";
-describe("isEmptyOrDefault", () => {
-    describe("should return true for empty/default values", () => {
-        it("returns true for null", () => {
-            assert.strictEqual(isEmptyOrDefault(null), true);
-        });
-        it("returns true for undefined", () => {
-            assert.strictEqual(isEmptyOrDefault(undefined), true);
-        });
-        it("returns true for empty string", () => {
-            assert.strictEqual(isEmptyOrDefault(""), true);
-        });
-        it("returns true for rich text empty paragraph", () => {
-            assert.strictEqual(isEmptyOrDefault("<p><br/></p>"), true);
-        });
-        it("returns true for empty array", () => {
-            assert.strictEqual(isEmptyOrDefault([]), true);
-        });
-        it("returns true for empty object", () => {
-            assert.strictEqual(isEmptyOrDefault({}), true);
-        });
-    });
-    describe("should return false for non-empty values", () => {
-        it("returns false for non-empty string", () => {
-            assert.strictEqual(isEmptyOrDefault("hello"), false);
-        });
-        it("returns false for number zero", () => {
-            assert.strictEqual(isEmptyOrDefault(0), false);
-        });
-        it("returns false for positive number", () => {
-            assert.strictEqual(isEmptyOrDefault(42), false);
-        });
-        it("returns false for boolean false", () => {
-            assert.strictEqual(isEmptyOrDefault(false), false);
-        });
-        it("returns false for boolean true", () => {
-            assert.strictEqual(isEmptyOrDefault(true), false);
-        });
-        it("returns false for non-empty array", () => {
-            assert.strictEqual(isEmptyOrDefault([1, 2, 3]), false);
-        });
-        it("returns false for non-empty object", () => {
-            assert.strictEqual(isEmptyOrDefault({ key: "value" }), false);
-        });
-        it("returns false for Date object", () => {
-            assert.strictEqual(isEmptyOrDefault(new Date()), false);
-        });
-        it("returns false for rich text with actual content", () => {
-            assert.strictEqual(isEmptyOrDefault("<p>Hello world</p>"), false);
-        });
-    });
-});
-describe("removeEmptyValues", () => {
-    describe("primitive values at root level - preserved as-is", () => {
-        it("returns null for null", () => {
-            assert.strictEqual(removeEmptyValues(null), null);
-        });
-        it("returns undefined for undefined", () => {
-            assert.strictEqual(removeEmptyValues(undefined), undefined);
-        });
-        it("preserves empty string at root level", () => {
-            assert.strictEqual(removeEmptyValues(""), "");
-        });
-        it("preserves rich text empty paragraph at root level", () => {
-            assert.strictEqual(removeEmptyValues("<p><br/></p>"), "<p><br/></p>");
-        });
-        it("preserves non-empty string", () => {
-            assert.strictEqual(removeEmptyValues("hello"), "hello");
-        });
-        it("preserves number zero", () => {
-            assert.strictEqual(removeEmptyValues(0), 0);
-        });
-        it("preserves boolean false", () => {
-            assert.strictEqual(removeEmptyValues(false), false);
-        });
-    });
-    describe("arrays", () => {
-        it("returns empty array for empty array at root level", () => {
-            assert.deepStrictEqual(removeEmptyValues([]), []);
-        });
-        it("removes empty values from array", () => {
-            assert.deepStrictEqual(removeEmptyValues([1, null, 2, "", 3]), [1, 2, 3]);
-        });
-        it("returns empty array when all array items are empty at root level", () => {
-            assert.deepStrictEqual(removeEmptyValues([null, "", [], {}]), []);
-        });
-        it("recursively cleans nested arrays", () => {
-            assert.deepStrictEqual(removeEmptyValues([1, [2, null, 3], [null, ""]]), [
-                1,
-                [2, 3],
-            ]);
-        });
-    });
-    describe("objects", () => {
-        it("returns empty object for empty object at root level", () => {
-            assert.deepStrictEqual(removeEmptyValues({}), {});
-        });
-        it("removes null properties", () => {
-            assert.deepStrictEqual(removeEmptyValues({ a: 1, b: null }), { a: 1 });
-        });
-        it("removes undefined properties", () => {
-            assert.deepStrictEqual(removeEmptyValues({ a: 1, b: undefined }), {
-                a: 1,
-            });
-        });
-        it("removes empty string properties", () => {
-            assert.deepStrictEqual(removeEmptyValues({ a: 1, b: "" }), { a: 1 });
-        });
-        it("removes empty array properties", () => {
-            assert.deepStrictEqual(removeEmptyValues({ a: 1, b: [] }), { a: 1 });
-        });
-        it("removes empty object properties", () => {
-            assert.deepStrictEqual(removeEmptyValues({ a: 1, b: {} }), { a: 1 });
-        });
-        it("removes rich text empty paragraph properties", () => {
-            assert.deepStrictEqual(removeEmptyValues({ a: 1, b: "<p><br/></p>" }), {
-                a: 1,
-            });
-        });
-        it("returns empty object when all properties are empty at root level", () => {
-            assert.deepStrictEqual(removeEmptyValues({ a: null, b: "", c: [], d: {} }), {});
-        });
-    });
-    describe("nested structures", () => {
-        it("recursively cleans nested objects", () => {
-            const input = {
-                level1: {
-                    level2: {
-                        value: "keep",
-                        empty: null,
-                    },
-                    emptyObj: {},
-                },
-            };
-            const expected = {
-                level1: {
-                    level2: {
-                        value: "keep",
-                    },
-                },
-            };
-            assert.deepStrictEqual(removeEmptyValues(input), expected);
-        });
-        it("removes nested objects that become empty after cleaning", () => {
-            const input = {
-                keep: "value",
-                remove: {
-                    nested: {
-                        empty: null,
-                    },
-                },
-            };
-            const expected = { keep: "value" };
-            assert.deepStrictEqual(removeEmptyValues(input), expected);
-        });
-        it("handles deeply nested structures", () => {
-            const input = {
-                a: {
-                    b: {
-                        c: {
-                            d: {
-                                value: "deep",
-                                empty: "",
-                            },
-                        },
-                    },
-                },
-            };
-            const expected = {
-                a: {
-                    b: {
-                        c: {
-                            d: {
-                                value: "deep",
-                            },
-                        },
-                    },
-                },
-            };
-            assert.deepStrictEqual(removeEmptyValues(input), expected);
-        });
-    });
-});
-describe("removeEmptyElementsFromVariant", () => {
-    describe("non-object inputs", () => {
-        it("returns null for null", () => {
-            assert.strictEqual(removeEmptyElementsFromVariant(null), null);
-        });
-        it("returns undefined for undefined", () => {
-            assert.strictEqual(removeEmptyElementsFromVariant(undefined), undefined);
-        });
-        it("returns primitive values unchanged", () => {
-            assert.strictEqual(removeEmptyElementsFromVariant("string"), "string");
-            assert.strictEqual(removeEmptyElementsFromVariant(42), 42);
-            assert.strictEqual(removeEmptyElementsFromVariant(true), true);
-        });
-    });
-    describe("elements array filtering", () => {
-        it("removes elements with only element property", () => {
-            const input = {
-                elements: [{ element: { id: "id1" } }, { element: { id: "id2" } }],
-            };
-            const expected = {};
-            assert.deepStrictEqual(removeEmptyElementsFromVariant(input), expected);
-        });
-        it("keeps elements with value property", () => {
-            const input = {
-                elements: [{ element: { id: "id1" }, value: "content" }],
-            };
-            const expected = {
-                elements: [{ element: { id: "id1" }, value: "content" }],
-            };
-            assert.deepStrictEqual(removeEmptyElementsFromVariant(input), expected);
-        });
-        it("filters mixed elements array", () => {
-            const input = {
-                elements: [
-                    { element: { id: "id1" } },
-                    { element: { id: "id2" }, value: "keep" },
-                    { element: { id: "id3" } },
-                    { element: { id: "id4" }, components: [] },
-                ],
-            };
-            const expected = {
-                elements: [
-                    { element: { id: "id2" }, value: "keep" },
-                    { element: { id: "id4" }, components: [] },
-                ],
-            };
-            assert.deepStrictEqual(removeEmptyElementsFromVariant(input), expected);
-        });
-        it("keeps non-object elements in elements array", () => {
-            const input = {
-                elements: ["string", 42, { element: { id: "id1" } }],
-            };
-            const expected = {
-                elements: ["string", 42],
-            };
-            assert.deepStrictEqual(removeEmptyElementsFromVariant(input), expected);
-        });
-    });
-    describe("nested structures", () => {
-        it("processes nested objects with elements arrays", () => {
-            const input = {
-                item: {
-                    elements: [{ element: { id: "id1" } }],
-                },
-            };
-            const expected = {
-                item: {},
-            };
-            assert.deepStrictEqual(removeEmptyElementsFromVariant(input), expected);
-        });
-        it("processes arrays of objects with elements", () => {
-            const input = {
-                variants: [
-                    { elements: [{ element: { id: "id1" } }] },
-                    { elements: [{ element: { id: "id2" }, value: "keep" }] },
-                ],
-            };
-            const expected = {
-                variants: [
-                    {},
-                    { elements: [{ element: { id: "id2" }, value: "keep" }] },
-                ],
-            };
-            assert.deepStrictEqual(removeEmptyElementsFromVariant(input), expected);
-        });
-    });
-    describe("preserves other properties", () => {
-        it("keeps non-elements properties unchanged", () => {
-            const input = {
-                id: "123",
-                name: "Test",
-                elements: [{ element: { id: "id1" } }],
-            };
-            const expected = {
-                id: "123",
-                name: "Test",
-            };
-            assert.deepStrictEqual(removeEmptyElementsFromVariant(input), expected);
-        });
-    });
-});
+import { createMcpToolSuccessResponse } from "../../utils/responseHelper.js";
 describe("createMcpToolSuccessResponse", () => {
-    it("returns correct structure", () => {
+    it("returns correct structure with text content", () => {
         const response = createMcpToolSuccessResponse({ key: "value" });
         assert.strictEqual(response.content.length, 1);
         assert.strictEqual(response.content[0].type, "text");
     });
-    it("removes empty values from response data", () => {
-        const input = {
-            id: "123",
-            name: null,
-            value: "",
-            items: [],
-        };
+    it("serializes object data as JSON string", () => {
+        const input = { id: "123", name: "Test" };
         const response = createMcpToolSuccessResponse(input);
         const parsed = JSON.parse(response.content[0].text);
-        assert.deepStrictEqual(parsed, { id: "123" });
+        assert.deepStrictEqual(parsed, input);
     });
-    it("handles complex nested data", () => {
+    it("serializes nested data as JSON string", () => {
         const input = {
-            contentType: {
-                id: "type-1",
-                name: "Article",
-                elements: [
-                    { id: "el-1", name: "Title", codename: "" },
-                    { id: "el-2", name: null, codename: "body" },
-                ],
-            },
-        };
-        const response = createMcpToolSuccessResponse(input);
-        const parsed = JSON.parse(response.content[0].text);
-        assert.deepStrictEqual(parsed, {
             contentType: {
                 id: "type-1",
                 name: "Article",
@@ -323,262 +23,28 @@ describe("createMcpToolSuccessResponse", () => {
                     { id: "el-2", codename: "body" },
                 ],
             },
-        });
-    });
-});
-describe("createVariantMcpToolSuccessResponse", () => {
-    it("returns correct structure", () => {
-        const response = createVariantMcpToolSuccessResponse({ key: "value" });
-        assert.strictEqual(response.content.length, 1);
-        assert.strictEqual(response.content[0].type, "text");
-    });
-    it("removes empty values and empty elements", () => {
-        const input = {
-            item: { id: "item-1" },
-            language: { id: "lang-1" },
-            elements: [
-                { element: { id: "el-1" }, value: "" },
-                { element: { id: "el-2" }, value: "content" },
-                { element: { id: "el-3" }, value: null },
-            ],
-        };
-        const response = createVariantMcpToolSuccessResponse(input);
-        const parsed = JSON.parse(response.content[0].text);
-        assert.deepStrictEqual(parsed, {
-            item: { id: "item-1" },
-            language: { id: "lang-1" },
-            elements: [{ element: { id: "el-2" }, value: "content" }],
-        });
-    });
-    it("removes elements array when all elements become empty", () => {
-        const input = {
-            item: { id: "item-1" },
-            elements: [
-                { element: { id: "el-1" }, value: "" },
-                { element: { id: "el-2" }, value: null },
-                { element: { id: "el-3" }, value: "<p><br/></p>" },
-            ],
-        };
-        const response = createVariantMcpToolSuccessResponse(input);
-        const parsed = JSON.parse(response.content[0].text);
-        assert.deepStrictEqual(parsed, {
-            item: { id: "item-1" },
-        });
-    });
-    it("handles real-world variant response", () => {
-        const input = {
-            item: { id: "f4b3fc05-e988-4dae-9ac1-a94aba566474" },
-            language: { id: "d1f95fde-af02-b3b5-bd9e-f232311ccab8" },
-            last_modified: "2018-02-27T19:08:25.404Z",
-            workflow: {
-                workflow_identifier: { id: "00000000-0000-0000-0000-000000000000" },
-                step_identifier: { id: "c199950d-99f0-4983-b711-6c4c91624b22" },
-            },
-            elements: [
-                { element: { id: "text-id" }, value: "Article Title" },
-                { element: { id: "rich-id" }, value: "<p><br/></p>", components: [] },
-                { element: { id: "number-id" }, value: null },
-                { element: { id: "assets-id" }, value: [] },
-                { element: { id: "taxonomy-id" }, value: [] },
-            ],
         };
-        const response = createVariantMcpToolSuccessResponse(input);
+        const response = createMcpToolSuccessResponse(input);
         const parsed = JSON.parse(response.content[0].text);
-        assert.deepStrictEqual(parsed, {
-            item: { id: "f4b3fc05-e988-4dae-9ac1-a94aba566474" },
-            language: { id: "d1f95fde-af02-b3b5-bd9e-f232311ccab8" },
-            last_modified: "2018-02-27T19:08:25.404Z",
-            workflow: {
-                workflow_identifier: { id: "00000000-0000-0000-0000-000000000000" },
-                step_identifier: { id: "c199950d-99f0-4983-b711-6c4c91624b22" },
-            },
-            elements: [{ element: { id: "text-id" }, value: "Article Title" }],
-        });
+        assert.deepStrictEqual(parsed, input);
     });
-    it("handles variant with multiple variants (filter-variants response)", () => {
-        const input = {
-            variants: [
-                {
-                    item: { id: "item-1" },
-                    elements: [
-                        { element: { id: "el-1" }, value: "" },
-                        { element: { id: "el-2" }, value: "content" },
-                    ],
-                },
-                {
-                    item: { id: "item-2" },
-                    elements: [
-                        { element: { id: "el-1" }, value: null },
-                        { element: { id: "el-2" }, value: [] },
-                    ],
-                },
-            ],
-            pagination: {
-                continuation_token: null,
-                next_page: "",
-            },
-        };
-        const response = createVariantMcpToolSuccessResponse(input);
+    it("serializes arrays as JSON string", () => {
+        const input = [{ id: "1" }, { id: "2" }];
+        const response = createMcpToolSuccessResponse(input);
         const parsed = JSON.parse(response.content[0].text);
-        assert.deepStrictEqual(parsed, {
-            variants: [
-                {
-                    item: { id: "item-1" },
-                    elements: [{ element: { id: "el-2" }, value: "content" }],
-                },
-                {
-                    item: { id: "item-2" },
-                },
-            ],
-        });
-    });
-});
-describe("variant with all empty elements", () => {
-    it("removes elements array entirely when all elements become empty", () => {
-        const input = {
-            elements: [
-                { element: { id: "text-id" }, value: "" },
-                { element: { id: "rich-id" }, value: "<p><br/></p>", components: [] },
-                { element: { id: "number-id" }, value: null },
-                { element: { id: "assets-id" }, value: [] },
-            ],
-        };
-        const response = createVariantMcpToolSuccessResponse(input);
-        const result = JSON.parse(response.content[0].text);
-        assert.deepStrictEqual(result, {}, "All empty elements should be removed, resulting in an empty object");
+        assert.deepStrictEqual(parsed, input);
     });
-});
-describe("top-level empty value preservation", () => {
-    describe("createMcpToolSuccessResponse", () => {
-        it("returns empty array when input is empty array", () => {
-            const response = createMcpToolSuccessResponse([]);
-            const parsed = JSON.parse(response.content[0].text);
-            assert.deepStrictEqual(parsed, []);
-        });
-        it("returns empty object when input is empty object", () => {
-            const response = createMcpToolSuccessResponse({});
-            const parsed = JSON.parse(response.content[0].text);
-            assert.deepStrictEqual(parsed, {});
-        });
-        it("returns empty object when all properties are removed", () => {
-            const input = { a: null, b: "", c: [] };
-            const response = createMcpToolSuccessResponse(input);
-            const parsed = JSON.parse(response.content[0].text);
-            assert.deepStrictEqual(parsed, {});
-        });
-        it("returns empty array when all array items are removed", () => {
-            const input = [null, "", [], {}];
-            const response = createMcpToolSuccessResponse(input);
-            const parsed = JSON.parse(response.content[0].text);
-            assert.deepStrictEqual(parsed, []);
-        });
-        it("returns valid JSON string (not undefined)", () => {
-            const response = createMcpToolSuccessResponse([]);
-            assert.strictEqual(typeof response.content[0].text, "string");
-            assert.doesNotThrow(() => JSON.parse(response.content[0].text));
-        });
-        it("handles filter-variants-like response with empty data array", () => {
-            const input = {
-                data: [],
-                pagination: {
-                    continuation_token: null,
-                },
-            };
-            const response = createMcpToolSuccessResponse(input);
-            const parsed = JSON.parse(response.content[0].text);
-            assert.deepStrictEqual(parsed, {});
-        });
+    it("passes through string values without JSON encoding", () => {
+        const response = createMcpToolSuccessResponse("plain text");
+        assert.strictEqual(response.content[0].text, "plain text");
     });
-    describe("createVariantMcpToolSuccessResponse", () => {
-        it("returns empty array when input is empty array", () => {
-            const response = createVariantMcpToolSuccessResponse([]);
-            const parsed = JSON.parse(response.content[0].text);
-            assert.deepStrictEqual(parsed, []);
-        });
-        it("returns empty object when input is empty object", () => {
-            const response = createVariantMcpToolSuccessResponse({});
-            const parsed = JSON.parse(response.content[0].text);
-            assert.deepStrictEqual(parsed, {});
-        });
-        it("returns empty object when all properties are removed", () => {
-            const input = { a: null, b: "", c: [] };
-            const response = createVariantMcpToolSuccessResponse(input);
-            const parsed = JSON.parse(response.content[0].text);
-            assert.deepStrictEqual(parsed, {});
-        });
-        it("returns empty array when all array items are removed", () => {
-            const input = [null, "", [], {}];
-            const response = createVariantMcpToolSuccessResponse(input);
-            const parsed = JSON.parse(response.content[0].text);
-            assert.deepStrictEqual(parsed, []);
-        });
-        it("returns valid JSON string (not undefined)", () => {
-            const response = createVariantMcpToolSuccessResponse([]);
-            assert.strictEqual(typeof response.content[0].text, "string");
-            assert.doesNotThrow(() => JSON.parse(response.content[0].text));
-        });
-        it("handles filter-variants-like response with empty data array", () => {
-            const input = {
-                data: [],
-                pagination: {
-                    continuation_token: null,
-                },
-            };
-            const response = createVariantMcpToolSuccessResponse(input);
-            const parsed = JSON.parse(response.content[0].text);
-            assert.deepStrictEqual(parsed, {});
-        });
-        it("handles filter-variants response with variants array becoming empty", () => {
-            const input = {
-                variants: [
-                    {
-                        elements: [
-                            { element: { id: "el-1" }, value: null },
-                            { element: { id: "el-2" }, value: "" },
-                        ],
-                    },
-                ],
-                pagination: {
-                    continuation_token: null,
-                },
-            };
-            const response = createVariantMcpToolSuccessResponse(input);
-            const parsed = JSON.parse(response.content[0].text);
-            // variants array should still be present (with empty variant objects)
-            assert.ok(parsed.variants !== undefined);
-            assert.strictEqual(parsed.variants.length, 1);
-        });
-    });
-});
-describe("undefined input handling - MCP protocol compliance", () => {
-    describe("createMcpToolSuccessResponse", () => {
-        it("returns string when input is undefined", () => {
-            const response = createMcpToolSuccessResponse(undefined);
-            assert.strictEqual(typeof response.content[0].text, "string");
-        });
-        it("returns 'undefined' text when input is undefined", () => {
-            const response = createMcpToolSuccessResponse(undefined);
-            assert.strictEqual(response.content[0].text, "undefined");
-        });
-        it("returns valid JSON string when input is null", () => {
-            const response = createMcpToolSuccessResponse(null);
-            assert.strictEqual(typeof response.content[0].text, "string");
-            assert.doesNotThrow(() => JSON.parse(response.content[0].text));
-        });
+    it("returns 'undefined' text when input is undefined", () => {
+        const response = createMcpToolSuccessResponse(undefined);
+        assert.strictEqual(response.content[0].text, "undefined");
     });
-    describe("createVariantMcpToolSuccessResponse", () => {
-        it("returns string when input is undefined", () => {
-            const response = createVariantMcpToolSuccessResponse(undefined);
-            assert.strictEqual(typeof response.content[0].text, "string");
-        });
-        it("returns 'undefined' text when input is undefined", () => {
-            const response = createVariantMcpToolSuccessResponse(undefined);
-            assert.strictEqual(response.content[0].text, "undefined");
-        });
-        it("returns valid JSON string when input is null", () => {
-            const response = createVariantMcpToolSuccessResponse(null);
-            assert.strictEqual(typeof response.content[0].text, "string");
-            assert.doesNotThrow(() => JSON.parse(response.content[0].text));
-        });
+    it("returns valid JSON string when input is null", () => {
+        const response = createMcpToolSuccessResponse(null);
+        assert.strictEqual(typeof response.content[0].text, "string");
+        assert.doesNotThrow(() => JSON.parse(response.content[0].text));
     });
 });

package/build/tools/bulk-get-items-variants-mapi.js

@@ -1,7 +1,7 @@
 import { createMapiClient } from "../clients/kontentClients.js";
 import { bulkGetItemsWithVariantsSchema } from "../schemas/bulkGetItemsWithVariantsSchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
-import { createVariantMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 import { throwError } from "../utils/throwError.js";
 export const registerTool = (server) => {
     server.tool("bulk-get-items-variants-mapi", "Bulk get Kontent.ai content items with their language variants by item and language reference pairs. Items without a variant in the requested language return the item without the variant property.", bulkGetItemsWithVariantsSchema.shape, async ({ variants, continuation_token }, { authInfo: { token, clientId } = {} }) => {
@@ -17,7 +17,7 @@ export const registerTool = (server) => {
             const response = await (continuation_token
                 ? query.xContinuationToken(continuation_token)
                 : query).toPromise();
-            return createVariantMcpToolSuccessResponse({
+            return createMcpToolSuccessResponse({
                 data: response.rawData.data,
                 pagination: {
                     continuation_token: response.data.pagination.continuationToken,

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

@@ -3,7 +3,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("delete-workflow-mapi", {
+    server.tool("delete-workflow-mapi", "Delete Kontent.ai workflow", {
         id: z.guid().describe("Workflow ID"),
     }, async ({ id }, { authInfo: { token, clientId } = {} }) => {
         const client = createMapiClient(clientId, token);

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
-import { createVariantMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     server.tool("get-latest-variant-mapi", "Get latest Kontent.ai language variant. Variants hold language-specific content; structure defined by content type and its snippets.", {
         itemId: z.string().describe("Item ID"),
@@ -14,7 +14,7 @@ export const registerTool = (server) => {
                 .byItemId(itemId)
                 .byLanguageId(languageId)
                 .toPromise();
-            return createVariantMcpToolSuccessResponse(response.rawData);
+            return createMcpToolSuccessResponse(response.rawData);
         }
         catch (error) {
             return handleMcpToolError(error, "Latest Language Variant Retrieval");

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
-import { createVariantMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     server.tool("get-published-variant-mapi", "Get published Kontent.ai language variant. Variants hold language-specific content; structure defined by content type and its snippets.", {
         itemId: z.string().describe("Item ID"),
@@ -15,7 +15,7 @@ export const registerTool = (server) => {
                 .byLanguageId(languageId)
                 .published()
                 .toPromise();
-            return createVariantMcpToolSuccessResponse(response.rawData);
+            return createMcpToolSuccessResponse(response.rawData);
         }
         catch (error) {
             return handleMcpToolError(error, "Published Language Variant Retrieval");

package/build/tools/search-variants-mapi.js

@@ -2,7 +2,7 @@ import pRetry, { AbortError } from "p-retry";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { searchOperationSchema } from "../schemas/searchOperationSchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
-import { createMcpToolSuccessResponse, createVariantMcpToolSuccessResponse, } from "../utils/responseHelper.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 import { throwError } from "../utils/throwError.js";
 class OperationResultIncompleteError extends Error {
     constructor() {
@@ -84,7 +84,7 @@ export const registerTool = (server) => {
                 maxTimeout: 10000,
                 factor: 1.5,
             });
-            return createVariantMcpToolSuccessResponse({
+            return createMcpToolSuccessResponse({
                 result: resultData,
             });
         }

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

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { languageVariantElementSchema } from "../schemas/contentItemSchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
-import { createVariantMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     server.tool("upsert-language-variant-mapi", "Create or update Kontent.ai variant. Element values must fulfill limitations and guidelines defined in content type.", {
         itemId: z.string().describe("Content item ID"),
@@ -28,7 +28,7 @@ export const registerTool = (server) => {
                 .byLanguageId(languageId)
                 .withData(() => data)
                 .toPromise();
-            return createVariantMcpToolSuccessResponse(response.rawData);
+            return createMcpToolSuccessResponse(response.rawData);
         }
         catch (error) {
             return handleMcpToolError(error, "Language Variant Upsert");

package/build/utils/responseHelper.js

@@ -1,108 +1,13 @@
 /**
- * Utility for creating standardized MCP tool success responses
+ * Utility for creating standardized MCP tool success responses.
+ * Passes API data through to MCP response format without transformation.
  */
-export function isEmptyOrDefault(value) {
-    if (value === null || value === undefined) {
-        return true;
-    }
-    if (typeof value === "string" && value === "") {
-        return true;
-    }
-    if (typeof value === "string" && value === "<p><br/></p>") {
-        return true;
-    }
-    if (Array.isArray(value) && value.length === 0) {
-        return true;
-    }
-    if (typeof value === "object" &&
-        !Array.isArray(value) &&
-        !(value instanceof Date) &&
-        !(value instanceof Function) &&
-        Object.keys(value).length === 0) {
-        return true;
-    }
-    return false;
-}
-export function removeEmptyElementsFromVariant(obj) {
-    if (obj === null || obj === undefined || typeof obj !== "object") {
-        return obj;
-    }
-    if (Array.isArray(obj)) {
-        return obj.map((item) => removeEmptyElementsFromVariant(item));
-    }
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-        if (key === "elements" && Array.isArray(value)) {
-            const filteredElements = value
-                .filter((element) => {
-                if (typeof element !== "object" || element === null) {
-                    return true;
-                }
-                const keys = Object.keys(element);
-                return !(keys.length === 1 && keys[0] === "element");
-            })
-                .map((element) => removeEmptyElementsFromVariant(element));
-            if (filteredElements.length > 0) {
-                result[key] = filteredElements;
-            }
-        }
-        else {
-            const processedValue = removeEmptyElementsFromVariant(value);
-            if (processedValue !== undefined) {
-                result[key] = processedValue;
-            }
-        }
-    }
-    return result;
-}
-function removeEmptyValuesRecursive(obj) {
-    if (obj === null || obj === undefined) {
-        return undefined;
-    }
-    if (typeof obj !== "object") {
-        return isEmptyOrDefault(obj) ? undefined : obj;
-    }
-    if (Array.isArray(obj)) {
-        const cleaned = obj
-            .map((item) => removeEmptyValuesRecursive(item))
-            .filter((item) => item !== undefined);
-        return cleaned.length === 0 ? undefined : cleaned;
-    }
-    const cleaned = {};
-    for (const [key, value] of Object.entries(obj)) {
-        const cleanedValue = removeEmptyValuesRecursive(value);
-        if (cleanedValue !== undefined) {
-            cleaned[key] = cleanedValue;
-        }
-    }
-    const keys = Object.keys(cleaned);
-    return keys.length === 0 ? undefined : cleaned;
-}
-export function removeEmptyValues(obj) {
-    // At root level, preserve the structure even if empty
-    if (typeof obj !== "object" || obj === null) {
-        return obj;
-    }
-    if (Array.isArray(obj)) {
-        return obj
-            .map((item) => removeEmptyValuesRecursive(item))
-            .filter((item) => item !== undefined);
-    }
-    const cleaned = {};
-    for (const [key, value] of Object.entries(obj)) {
-        const cleanedValue = removeEmptyValuesRecursive(value);
-        if (cleanedValue !== undefined) {
-            cleaned[key] = cleanedValue;
-        }
-    }
-    return cleaned;
-}
 /**
  * Converts data to MCP tool success response format.
  * Handles undefined separately as JSON.stringify(undefined) returns undefined (not a string).
  * Skips stringify for strings as they don't need JSON encoding for MCP text response.
  */
-const toMcpSuccessResponse = (data) => {
+export const createMcpToolSuccessResponse = (data) => {
     const text = data === undefined
         ? "undefined"
         : typeof data === "string"
@@ -117,12 +22,3 @@ const toMcpSuccessResponse = (data) => {
         ],
     };
 };
-export const createMcpToolSuccessResponse = (data) => {
-    const cleaned = removeEmptyValues(data);
-    return toMcpSuccessResponse(cleaned);
-};
-export const createVariantMcpToolSuccessResponse = (data) => {
-    const cleaned = removeEmptyValues(data);
-    const optimized = removeEmptyElementsFromVariant(cleaned);
-    return toMcpSuccessResponse(optimized);
-};

package/package.json

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