@kontent-ai/mcp-server 0.31.0 → 0.33.0

package/build/tools/publish-content-item-variant.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const publishContentItemVariant = defineTool("publish-content-item-variant", "Publish or schedule publishing of Kontent.ai content item variant (language version/translation). Transitions content to the published workflow step, making it live. For scheduling, verify current UTC time before using scheduledTo.", {
+    itemId: z.guid().describe("Content item ID"),
+    languageId: z
+        .guid()
+        .describe("Language ID (default: 00000000-0000-0000-0000-000000000000)"),
+    scheduledTo: z.iso
+        .datetime({ offset: true })
+        .optional()
+        .describe("ISO 8601 datetime for scheduled publish (omit for immediate)"),
+    displayTimezone: z
+        .string()
+        .optional()
+        .describe("Timezone for UI display (e.g., America/New_York, UTC)"),
+}, async ({ itemId, languageId, scheduledTo, displayTimezone }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        // Validate that displayTimezone can only be used with scheduledTo
+        if (displayTimezone && !scheduledTo) {
+            throw new Error("The 'displayTimezone' parameter can only be used in combination with 'scheduledTo' parameter for scheduled publishing.");
+        }
+        let action;
+        let message;
+        if (scheduledTo) {
+            // Scheduled publishing
+            const requestData = {
+                scheduled_to: scheduledTo,
+            };
+            // Add display_timezone if provided
+            if (displayTimezone) {
+                requestData.display_timezone = displayTimezone;
+            }
+            await client
+                .publishLanguageVariant()
+                .byItemId(itemId)
+                .byLanguageId(languageId)
+                .withData(requestData)
+                .toPromise();
+            action = "scheduled";
+            message = `Successfully scheduled item variant '${languageId}' for content item '${itemId}' to be published at '${scheduledTo}'${displayTimezone ? ` (timezone: ${displayTimezone})` : ""}.`;
+        }
+        else {
+            // Immediate publishing
+            await client
+                .publishLanguageVariant()
+                .byItemId(itemId)
+                .byLanguageId(languageId)
+                .withoutData()
+                .toPromise();
+            action = "published";
+            message = `Successfully published item variant '${languageId}' for content item '${itemId}'. The content is now live and available through Delivery API.`;
+        }
+        return createMcpToolSuccessResponse({
+            message,
+            result: {
+                itemId,
+                languageId,
+                scheduledTo: scheduledTo || null,
+                displayTimezone: displayTimezone || null,
+                action,
+                timestamp: new Date().toISOString(),
+            },
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Publish/Schedule Language Variant");
+    }
+});

package/build/tools/referencedToolNames.js

@@ -0,0 +1,10 @@
+// Tools whose names are referenced by other tools
+export const searchContentItemVariantsToolName = "search-content-item-variants";
+export const listContentItemVariantsToolName = "list-content-item-variants";
+export const bulkGetContentItemVariantsToolName = "bulk-get-content-item-variants";
+export const createContentItemToolName = "create-content-item";
+export const createContentItemVariantToolName = "create-content-item-variant";
+export const getPatchGuideToolName = "get-patch-guide";
+export const getTaxonomyGroupToolName = "get-taxonomy-group";
+export const listCollectionsToolName = "list-collections";
+export const listLanguagesToolName = "list-languages";

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

@@ -0,0 +1,108 @@
+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 } from "../utils/responseHelper.js";
+import { throwError } from "../utils/throwError.js";
+import { bulkGetContentItemVariantsToolName, listContentItemVariantsToolName, searchContentItemVariantsToolName, } from "./referencedToolNames.js";
+import { defineTool } from "./toolDefinition.js";
+class OperationResultIncompleteError extends Error {
+    constructor() {
+        super("AI operation result is incomplete");
+        this.name = "OperationResultIncompleteError";
+    }
+}
+const isSearchResponseWrapper = (value) => typeof value === "object" && value !== null && "searchResults" in value;
+const extractSearchResults = (response) => {
+    const value = response.result?.value;
+    if (!value) {
+        return {};
+    }
+    const parsed = JSON.parse(value);
+    if (isSearchResponseWrapper(parsed)) {
+        return JSON.parse(parsed.searchResults);
+    }
+    return parsed;
+};
+export const searchContentItemVariants = defineTool(searchContentItemVariantsToolName, `AI semantic search for Kontent.ai content items with content item variants (language versions/translations) by topic, theme, or meaning. Find content by natural language query. Returns only top 50 results. This feature may be unavailable. Use ${listContentItemVariantsToolName} for full content inventory filtering or exact keyword matching. Use ${bulkGetContentItemVariantsToolName} to retrieve full content of the variants.`, searchOperationSchema.shape, async ({ searchPhrase, filter }, { authInfo: { token, clientId } = {} }) => {
+    try {
+        const environmentId = clientId ?? process.env.KONTENT_ENVIRONMENT_ID;
+        if (!environmentId) {
+            throwError("Missing required environment ID");
+        }
+        const client = createMapiClient(environmentId, token);
+        // Step 1: Initiate the AI search operation
+        const searchPayload = {
+            actionName: "Search",
+            type: "multiple-inputs-request-v1",
+            inputs: {
+                searchPhrase: {
+                    type: "string",
+                    value: searchPhrase,
+                },
+                filter: {
+                    type: "content-item-variant-filter",
+                    value: filter,
+                },
+            },
+            trackingData: {
+                type: "empty-operation-tracking-data-v1",
+            },
+        };
+        let searchResponse;
+        try {
+            searchResponse = await client
+                .post()
+                .withAction(`projects/${environmentId}/early-access/ai-operation`)
+                .withData(searchPayload)
+                .toPromise();
+        }
+        catch (error) {
+            if (error?.response?.status === 403 &&
+                error?.response?.data?.message?.includes("AI Feature Not Available")) {
+                return createMcpToolSuccessResponse({
+                    status: "unavailable",
+                    result: `AI search feature is not available for environment ${clientId}`,
+                });
+            }
+            throw error;
+        }
+        const operationData = searchResponse.data;
+        const operationId = operationData.operationId;
+        // Step 2: Poll for results with exponential backoff
+        const resultData = await pRetry(async () => {
+            try {
+                const pollResponse = await client
+                    .get()
+                    .withAction(`projects/${environmentId}/early-access/ai-operation-result/${operationId}`)
+                    .toPromise();
+                const [response] = pollResponse.data;
+                if (response.type === "cumulated-result-v1" &&
+                    !response.result?.isFinished) {
+                    throw new OperationResultIncompleteError();
+                }
+                return response;
+            }
+            catch (error) {
+                if (error?.response?.status === 404 ||
+                    error instanceof OperationResultIncompleteError) {
+                    throw error;
+                }
+                throw new AbortError(error);
+            }
+        }, {
+            // Worst-case retry time: ~1 minute
+            retries: 10,
+            minTimeout: 1000,
+            maxTimeout: 10000,
+            factor: 1.5,
+        });
+        const searchResults = extractSearchResults(resultData);
+        return createMcpToolSuccessResponse({
+            result: searchResults,
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "AI-powered Variant Search");
+    }
+});

package/build/tools/toolDefinition.js

@@ -0,0 +1 @@
+export const defineTool = (name, description, inputSchema, handler) => ({ name, description, inputSchema, handler });

package/build/tools/unpublish-content-item-variant.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const unpublishContentItemVariant = defineTool("unpublish-content-item-variant", "Unpublish or schedule unpublishing of Kontent.ai content item variant (language version/translation). Takes content offline and archives it. For scheduling, verify current UTC time before using scheduledTo.", {
+    itemId: z.guid().describe("Content item ID"),
+    languageId: z
+        .guid()
+        .describe("Language ID (default: 00000000-0000-0000-0000-000000000000)"),
+    scheduledTo: z.iso
+        .datetime({ offset: true })
+        .optional()
+        .describe("ISO 8601 datetime for scheduled unpublish (omit for immediate)"),
+    displayTimezone: z
+        .string()
+        .optional()
+        .describe("Timezone for UI display (e.g., America/New_York, UTC)"),
+}, async ({ itemId, languageId, scheduledTo, displayTimezone }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        // Validate that displayTimezone can only be used with scheduledTo
+        if (displayTimezone && !scheduledTo) {
+            throw new Error("The 'displayTimezone' parameter can only be used in combination with 'scheduledTo' parameter for scheduled unpublishing.");
+        }
+        let action;
+        let message;
+        if (scheduledTo) {
+            // Scheduled unpublishing
+            const requestData = {
+                scheduled_to: scheduledTo,
+            };
+            // Add display_timezone if provided
+            if (displayTimezone) {
+                requestData.display_timezone = displayTimezone;
+            }
+            await client
+                .unpublishLanguageVariant()
+                .byItemId(itemId)
+                .byLanguageId(languageId)
+                .withData(requestData)
+                .toPromise();
+            action = "scheduled for unpublishing";
+            message = `Successfully scheduled item variant '${languageId}' for content item '${itemId}' to be unpublished at '${scheduledTo}'${displayTimezone ? ` (timezone: ${displayTimezone})` : ""}. The content will be removed from Delivery API at the scheduled time.`;
+        }
+        else {
+            // Immediate unpublishing
+            await client
+                .unpublishLanguageVariant()
+                .byItemId(itemId)
+                .byLanguageId(languageId)
+                .withoutData()
+                .toPromise();
+            action = "unpublished";
+            message = `Successfully unpublished item variant '${languageId}' for content item '${itemId}'. The content has been moved to Archived and is no longer available through Delivery API.`;
+        }
+        return createMcpToolSuccessResponse({
+            message,
+            result: {
+                itemId,
+                languageId,
+                scheduledTo: scheduledTo || null,
+                displayTimezone: displayTimezone || null,
+                action,
+                timestamp: new Date().toISOString(),
+            },
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Unpublish/Schedule Unpublishing Language Variant");
+    }
+});

package/build/tools/update-asset.js

@@ -0,0 +1,23 @@
+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";
+import { defineTool } from "./toolDefinition.js";
+export const updateAsset = defineTool("update-asset", "Update (edit) Kontent.ai asset metadata by ID. Modify asset title, descriptions, or taxonomy-based properties.", {
+    id: z.guid().describe("Asset ID"),
+    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/build/tools/update-content-item-variant.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { languageVariantElementSchema } from "../schemas/contentItemSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const updateContentItemVariant = defineTool("update-content-item-variant", "Update Kontent.ai content item variant (language version/translation) content. Write translated content into item elements. Values must fulfill validation rules defined in the content type.", {
+    itemId: z.string().describe("Content item ID"),
+    languageId: z
+        .string()
+        .describe("Language ID (default: 00000000-0000-0000-0000-000000000000)"),
+    elements: z
+        .array(languageVariantElementSchema)
+        .describe("Content elements array"),
+    workflow_step_id: z.string().optional().describe("Workflow step ID"),
+}, async ({ itemId, languageId, elements, workflow_step_id }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    const data = {
+        elements,
+    };
+    if (workflow_step_id) {
+        data.workflow_step = { id: workflow_step_id };
+    }
+    try {
+        const response = await client
+            .upsertLanguageVariant()
+            .byItemId(itemId)
+            .byLanguageId(languageId)
+            .withData(() => data)
+            .toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Language Variant Update");
+    }
+});

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

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { createContentItemToolName } from "./referencedToolNames.js";
+import { defineTool } from "./toolDefinition.js";
+export const updateContentItem = defineTool("update-content-item", "Update (edit) Kontent.ai content item metadata: name, collection.", {
+    id: z.string().describe("Content item ID"),
+    name: z
+        .string()
+        .min(1)
+        .max(200)
+        .optional()
+        .describe("New name (1-200 chars)"),
+    collection: z
+        .object({
+        id: z.string().optional(),
+        codename: z.string().optional(),
+        external_id: z.string().optional(),
+    })
+        .optional()
+        .describe("Collection reference"),
+}, async ({ id, name, collection }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        // First, verify the item exists by trying to get it
+        await client.viewContentItem().byItemId(id).toPromise();
+        // If we get here, the item exists, so we can update it
+        const updateData = {};
+        if (name !== undefined) {
+            updateData.name = name;
+        }
+        if (collection !== undefined) {
+            updateData.collection = collection;
+        }
+        // If no update data is provided, return an error
+        if (Object.keys(updateData).length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Update Content Item: No update data provided. At least one field (name or collection) must be specified.",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const response = await client
+            .upsertContentItem()
+            .byItemId(id)
+            .withData(updateData)
+            .toPromise();
+        return createMcpToolSuccessResponse({
+            message: `Content item '${id}' updated successfully`,
+            updatedItem: response.rawData,
+        });
+    }
+    catch (error) {
+        // Check if the error is because the item doesn't exist
+        if (error?.response?.status === 404 ||
+            error?.message?.includes("not found")) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Update Content Item: Content item with ID '${id}' does not exist. Use ${createContentItemToolName} to create new items.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        return handleMcpToolError(error, "Content Item Update");
+    }
+});

package/build/tools/update-workflow.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { workflowInputSchema } from "../schemas/workflowSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const updateWorkflow = defineTool("update-workflow", "Update (edit) Kontent.ai workflow steps, transitions, and settings. Modify content lifecycle stages.", {
+    id: z.guid().describe("Workflow ID"),
+    ...workflowInputSchema.shape,
+}, async ({ id, name, codename, scopes, steps, published_step, archived_step }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    const data = {
+        name,
+        codename,
+        scopes,
+        steps,
+        published_step,
+        archived_step,
+    };
+    try {
+        const response = await client
+            .updateWorkflow()
+            .byWorkflowId(id)
+            .withData(data)
+            .toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Workflow Update");
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kontent-ai/mcp-server",
-  "version": "0.31.0",
+  "version": "0.33.0",
   "type": "module",
   "mcpName": "io.github.kontent-ai/mcp-server",
   "repository": {
@@ -29,23 +29,24 @@
   "author": "Jiri Lojda",
   "license": "MIT",
   "dependencies": {
-    "@kontent-ai/management-sdk": "^8.3.1",
-    "@modelcontextprotocol/sdk": "^1.26.0",
-    "applicationinsights": "^2.9.8",
-    "dotenv": "^17.2.3",
-    "express": "^5.2.1",
-    "p-retry": "^7.1.1",
-    "zod": "^4.1.13"
+    "@kontent-ai/management-sdk": "8.4.1",
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "applicationinsights": "2.9.8",
+    "dotenv": "17.4.1",
+    "express": "5.2.1",
+    "p-retry": "7.1.1",
+    "zod": "4.3.6"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.8",
-    "@types/express": "^5.0.6",
-    "@types/mocha": "^10.0.10",
-    "@types/node": "^24.10.2",
-    "cross-env": "^10.1.0",
-    "mocha": "^11.7.5",
-    "rimraf": "^6.1.2",
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
+    "@biomejs/biome": "2.4.11",
+    "@types/express": "5.0.6",
+    "@types/mocha": "10.0.10",
+    "@types/node": "24.12.2",
+    "cross-env": "10.1.0",
+    "minisearch": "7.2.0",
+    "mocha": "11.7.5",
+    "rimraf": "6.1.3",
+    "tsx": "4.21.0",
+    "typescript": "5.9.3"
   }
 }

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

@@ -1,47 +0,0 @@
-import { z } from "zod";
-import { createMapiClient } from "../clients/kontentClients.js";
-import { handleMcpToolError } from "../utils/errorHandler.js";
-import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
-    server.tool("add-content-item-mapi", "Add new Kontent.ai content item (creates structure only, use upsert-language-variant-mapi for content)", {
-        name: z.string().min(1).max(200).describe("Item name (1-200 chars)"),
-        type: z
-            .object({
-            id: z.string().optional(),
-            codename: z.string().optional(),
-            external_id: z.string().optional(),
-        })
-            .describe("Content type reference"),
-        codename: z
-            .string()
-            .optional()
-            .describe("Codename (auto-generated if omitted)"),
-        external_id: z.string().optional().describe("External ID"),
-        collection: z
-            .object({
-            id: z.string().optional(),
-            codename: z.string().optional(),
-            external_id: z.string().optional(),
-        })
-            .optional()
-            .describe("Collection reference"),
-    }, async ({ name, type, codename, external_id, collection }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token);
-        try {
-            const response = await client
-                .addContentItem()
-                .withData({
-                name,
-                type,
-                codename,
-                external_id,
-                collection,
-            })
-                .toPromise();
-            return createMcpToolSuccessResponse(response.rawData);
-        }
-        catch (error) {
-            return handleMcpToolError(error, "Content Item Creation");
-        }
-    });
-};

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

@@ -1,38 +0,0 @@
-import { z } from "zod";
-import { createMapiClient } from "../clients/kontentClients.js";
-import { contentGroupSchema, elementSchema, } from "../schemas/contentTypeAndSnippetSchemas.js";
-import { handleMcpToolError } from "../utils/errorHandler.js";
-import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
-    server.tool("add-content-type-mapi", "Add new Kontent.ai content type", {
-        name: z.string().describe("Content type name"),
-        codename: z
-            .string()
-            .optional()
-            .describe("Codename (auto-generated if omitted)"),
-        external_id: z.string().optional().describe("External ID"),
-        elements: z.array(elementSchema).describe("Elements defining structure"),
-        content_groups: z
-            .array(contentGroupSchema)
-            .optional()
-            .describe("Content groups"),
-    }, async ({ name, codename, external_id, elements, content_groups }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token);
-        try {
-            const response = await client
-                .addContentType()
-                .withData(() => ({
-                name,
-                codename,
-                external_id,
-                elements,
-                content_groups,
-            }))
-                .toPromise();
-            return createMcpToolSuccessResponse(response.rawData);
-        }
-        catch (error) {
-            return handleMcpToolError(error, "Content Type Creation");
-        }
-    });
-};

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

@@ -1,35 +0,0 @@
-import { z } from "zod";
-import { createMapiClient } from "../clients/kontentClients.js";
-import { snippetElementSchema } from "../schemas/contentTypeAndSnippetSchemas.js";
-import { handleMcpToolError } from "../utils/errorHandler.js";
-import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
-    server.tool("add-content-type-snippet-mapi", "Add new Kontent.ai content type snippet", {
-        name: z.string().describe("Snippet name"),
-        codename: z
-            .string()
-            .optional()
-            .describe("Codename (auto-generated if omitted)"),
-        external_id: z.string().optional().describe("External ID"),
-        elements: z
-            .array(snippetElementSchema)
-            .describe("Elements defining structure"),
-    }, async ({ name, codename, external_id, elements }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token);
-        try {
-            const response = await client
-                .addContentTypeSnippet()
-                .withData(() => ({
-                name,
-                codename,
-                external_id,
-                elements,
-            }))
-                .toPromise();
-            return createMcpToolSuccessResponse(response.rawData);
-        }
-        catch (error) {
-            return handleMcpToolError(error, "Content Type Snippet Creation");
-        }
-    });
-};

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

@@ -1,25 +0,0 @@
-import { createMapiClient } from "../clients/kontentClients.js";
-import { addLanguageSchema } from "../schemas/languageSchemas.js";
-import { handleMcpToolError } from "../utils/errorHandler.js";
-import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
-    server.tool("add-language-mapi", "Add new Kontent.ai language via Management API. Languages are always created as active.", addLanguageSchema.shape, async ({ name, codename, fallback_language, external_id }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token);
-        try {
-            const response = await client
-                .addLanguage()
-                .withData({
-                name,
-                codename,
-                is_active: true,
-                fallback_language,
-                external_id,
-            })
-                .toPromise();
-            return createMcpToolSuccessResponse(response.rawData);
-        }
-        catch (error) {
-            return handleMcpToolError(error, "Language Creation");
-        }
-    });
-};

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

@@ -1,23 +0,0 @@
-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");
-        }
-    });
-};