@kontent-ai/mcp-server 0.31.0 → 0.33.0

package/build/tools/bulk-get-content-item-variants.js

@@ -0,0 +1,31 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { bulkGetItemsWithVariantsSchema } from "../schemas/bulkGetItemsWithVariantsSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { throwError } from "../utils/throwError.js";
+import { bulkGetContentItemVariantsToolName } from "./referencedToolNames.js";
+import { defineTool } from "./toolDefinition.js";
+export const bulkGetContentItemVariants = defineTool(bulkGetContentItemVariantsToolName, "Bulk/batch retrieve multiple Kontent.ai content items with their content item variants (language versions/translations) by item and language reference pairs. Fetch full content for item and variant IDs found via other tools.", bulkGetItemsWithVariantsSchema.shape, async ({ variants, continuation_token }, { authInfo: { token, clientId } = {} }) => {
+    try {
+        const environmentId = clientId ?? process.env.KONTENT_ENVIRONMENT_ID;
+        if (!environmentId) {
+            throwError("Missing required environment ID");
+        }
+        const client = createMapiClient(environmentId, token);
+        const query = client.bulkGetItemsWithVariants().withData({
+            variants,
+        });
+        const response = await (continuation_token
+            ? query.xContinuationToken(continuation_token)
+            : query).toPromise();
+        return createMcpToolSuccessResponse({
+            data: response.rawData.data,
+            pagination: {
+                continuation_token: response.data.pagination.continuationToken,
+            },
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Bulk Get Items With Variants");
+    }
+});

package/build/tools/change-content-item-variant-workflow-step.js

@@ -0,0 +1,35 @@
+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 changeContentItemVariantWorkflowStep = defineTool("change-content-item-variant-workflow-step", "Move Kontent.ai content item variant (language version/translation) to a different workflow step. Transition content between lifecycle stages (e.g., draft to review, review to approved/published, or archive).", {
+    itemId: z.guid().describe("Content item ID"),
+    languageId: z.guid().describe("Language ID"),
+    workflowId: z.guid().describe("Workflow ID"),
+    workflowStepId: z.guid().describe("Target workflow step ID"),
+}, async ({ itemId, languageId, workflowId, workflowStepId }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client
+            .changeWorkflowOfLanguageVariant()
+            .byItemId(itemId)
+            .byLanguageId(languageId)
+            .withData({
+            workflow_identifier: {
+                id: workflowId,
+            },
+            step_identifier: {
+                id: workflowStepId,
+            },
+        })
+            .toPromise();
+        return createMcpToolSuccessResponse({
+            message: `Successfully changed workflow step of item variant '${languageId}' for content item '${itemId}' to workflow step '${workflowStepId}'`,
+            result: response.rawData,
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Workflow Step Change");
+    }
+});

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

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { languageVariantElementSchema } from "../schemas/contentItemSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { extractUserIdFromToken } from "../utils/extractUserIdFromToken.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { createContentItemVariantToolName } from "./referencedToolNames.js";
+import { defineTool } from "./toolDefinition.js";
+export const createContentItemVariant = defineTool(createContentItemVariantToolName, "Create Kontent.ai content item variant — translate and localize content into a specific language. Adds a new language version (translation) for a content item. Element values must fulfill the content type definition.", {
+    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 };
+    }
+    if (token) {
+        const userId = extractUserIdFromToken(token);
+        if (userId) {
+            data.contributors = [{ id: userId }];
+        }
+    }
+    try {
+        const response = await client
+            .upsertLanguageVariant()
+            .byItemId(itemId)
+            .byLanguageId(languageId)
+            .withData(() => data)
+            .toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Language Variant Create");
+    }
+});

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

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { createContentItemVariantToolName } from "./referencedToolNames.js";
+import { defineTool } from "./toolDefinition.js";
+export const createContentItem = defineTool("create-content-item", `Create (add) new Kontent.ai content item (creates the container only, use ${createContentItemVariantToolName} to add language versions/translations). Items are language-neutral and hold content item variants for each language.`, {
+    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/create-content-type-snippet.js

@@ -0,0 +1,34 @@
+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";
+import { defineTool } from "./toolDefinition.js";
+export const createContentTypeSnippet = defineTool("create-content-type-snippet", "Create (add) new Kontent.ai content type snippet. Snippets are reusable, shared sets of elements that can be included in multiple content types.", {
+    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/create-content-type.js

@@ -0,0 +1,37 @@
+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";
+import { defineTool } from "./toolDefinition.js";
+export const createContentType = defineTool("create-content-type", "Create (add) new Kontent.ai content type (schema/model). Define content structure with elements, validation rules, and content groups.", {
+    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/create-language.js

@@ -0,0 +1,24 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { addLanguageSchema } from "../schemas/languageSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const createLanguage = defineTool("create-language", "Create (add) and configure new Kontent.ai language locale for translations and localization. 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/create-new-content-item-variant-version.js

@@ -0,0 +1,27 @@
+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 createNewContentItemVariantVersion = defineTool("create-new-content-item-variant-version", "Create new draft version of a published Kontent.ai content item variant (language version/translation). Required before editing published content.", {
+    itemId: z.guid().describe("Content item ID"),
+    languageId: z
+        .guid()
+        .describe("Language ID (default: 00000000-0000-0000-0000-000000000000)"),
+}, async ({ itemId, languageId }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client
+            .createNewVersionOfLanguageVariant()
+            .byItemId(itemId)
+            .byLanguageId(languageId)
+            .toPromise();
+        return createMcpToolSuccessResponse({
+            message: `Successfully created new version of item variant '${languageId}' for content item '${itemId}'`,
+            result: response.rawData,
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Variant Version Creation");
+    }
+});

package/build/tools/create-space.js

@@ -0,0 +1,22 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { addSpaceSchema } from "../schemas/spaceSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const createSpace = defineTool("create-space", "Create (add) new Kontent.ai space for managing a website or channel. Spaces provide channel-specific context with their own domain and preview URLs.", 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/create-taxonomy-group.js

@@ -0,0 +1,18 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { taxonomyGroupSchemas } from "../schemas/taxonomySchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+import { defineTool } from "./toolDefinition.js";
+export const createTaxonomyGroup = defineTool("create-taxonomy-group", "Create (add) new Kontent.ai taxonomy group for content categorization. Taxonomy groups contain hierarchical terms (categories/tags) for classifying content.", taxonomyGroupSchemas, async (taxonomyGroup, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client
+            .addTaxonomy()
+            .withData(taxonomyGroup)
+            .toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Taxonomy Group Creation");
+    }
+});

package/build/tools/create-workflow.js

@@ -0,0 +1,23 @@
+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 createWorkflow = defineTool("create-workflow", "Create (add) new Kontent.ai workflow with custom steps. Workflows define content lifecycle stages for review and approval.", workflowInputSchema.shape, async ({ 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.addWorkflow().withData(data).toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Workflow Creation");
+    }
+});

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

@@ -0,0 +1,25 @@
+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 deleteContentItemVariant = defineTool("delete-content-item-variant", "Delete (remove) Kontent.ai content item variant (language version/translation). Removes translated content for a specific language from an item.", {
+    itemId: z.string().describe("Content item ID"),
+    languageId: z.string().describe("Language ID"),
+}, async ({ itemId, languageId }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client
+            .deleteLanguageVariant()
+            .byItemId(itemId)
+            .byLanguageId(languageId)
+            .toPromise();
+        return createMcpToolSuccessResponse({
+            message: `Language variant '${languageId}' of content item '${itemId}' deleted successfully`,
+            deletedVariant: response.rawData,
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Language Variant Deletion");
+    }
+});

package/build/tools/delete-content-item.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";
+import { defineTool } from "./toolDefinition.js";
+export const deleteContentItem = defineTool("delete-content-item", "Delete (remove) Kontent.ai content item and all its content item variants.", {
+    id: z.string().describe("Content item ID"),
+}, async ({ id }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client
+            .deleteContentItem()
+            .byItemId(id)
+            .toPromise();
+        return createMcpToolSuccessResponse({
+            message: `Content item '${id}' deleted successfully`,
+            deletedItem: response.rawData,
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Content Item Deletion");
+    }
+});

package/build/tools/delete-content-type-snippet.js

@@ -0,0 +1,19 @@
+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 deleteContentTypeSnippet = defineTool("delete-content-type-snippet", "Delete (remove) Kontent.ai content type snippet by ID. Removes the reusable shared element set definition.", {
+    id: z.string().describe("Content type snippet ID"),
+}, async ({ id }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        await client.deleteContentTypeSnippet().byTypeId(id).toPromise();
+        return createMcpToolSuccessResponse({
+            message: `Content type snippet '${id}' deleted successfully`,
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Content Type Snippet Deletion");
+    }
+});

package/build/tools/delete-content-type.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";
+import { defineTool } from "./toolDefinition.js";
+export const deleteContentType = defineTool("delete-content-type", "Delete (remove) Kontent.ai content type by ID. Removes the schema/model definition.", {
+    id: z.string().describe("Content type ID"),
+}, async ({ id }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client
+            .deleteContentType()
+            .byTypeId(id)
+            .toPromise();
+        return createMcpToolSuccessResponse({
+            message: `Content type '${id}' deleted successfully`,
+            deletedType: response.rawData,
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Content Type Deletion");
+    }
+});

package/build/tools/delete-space.js

@@ -0,0 +1,19 @@
+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 deleteSpace = defineTool("delete-space", "Delete (remove) Kontent.ai space by ID. Removes the channel/website context.", {
+    id: z.guid().describe("Space ID"),
+}, 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.js

@@ -0,0 +1,19 @@
+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 deleteTaxonomyGroup = defineTool("delete-taxonomy-group", "Delete (remove) Kontent.ai taxonomy group by ID. Removes the category/tag group and all its terms.", {
+    id: z.guid().describe("Taxonomy group ID"),
+}, 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-workflow.js

@@ -0,0 +1,19 @@
+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 deleteWorkflow = defineTool("delete-workflow", "Delete (remove) Kontent.ai workflow. Cannot delete the default workflow.", {
+    id: z.guid().describe("Workflow ID"),
+}, async ({ id }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        await client.deleteWorkflow().byWorkflowId(id).toPromise();
+        return createMcpToolSuccessResponse({
+            message: `Workflow '${id}' deleted successfully`,
+        });
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Workflow Deletion");
+    }
+});

package/build/tools/get-asset.js

@@ -0,0 +1,17 @@
+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 getAsset = defineTool("get-asset", "Retrieve Kontent.ai asset by ID. Assets are digital media files (images, videos, documents, PDFs) standalone, or referenced from other entities, typically content item variants.", {
+    assetId: z.string().describe("Asset ID"),
+}, async ({ assetId }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client.viewAsset().byAssetId(assetId).toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Asset Retrieval");
+    }
+});

package/build/tools/get-content-item-translations.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";
+import { defineTool } from "./toolDefinition.js";
+export const getContentItemTranslations = defineTool("get-content-item-translations", "Get all Kontent.ai content item translations — every language version (variant) of a specific content item. Retrieve translated content across all languages to see available translations for a single item.", {
+    itemId: z.string().describe("Content item ID"),
+}, async ({ itemId }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client
+            .listLanguageVariantsOfItem()
+            .byItemId(itemId)
+            .toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Content Item Translations Retrieval");
+    }
+});

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

@@ -0,0 +1,22 @@
+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 getContentItemVariant = defineTool("get-content-item-variant", "Retrieve Kontent.ai content item variant (language version/translation). Returns the current version of the variant — draft if one exists, otherwise published. Variants hold translated, language-specific content with structure defined by content type.", {
+    itemId: z.string().describe("Content item ID"),
+    languageId: z.string().describe("Language ID"),
+}, async ({ itemId, languageId }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client
+            .viewLanguageVariant()
+            .byItemId(itemId)
+            .byLanguageId(languageId)
+            .toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Content Item Variant Retrieval");
+    }
+});

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

@@ -0,0 +1,17 @@
+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 getContentItem = defineTool("get-content-item", "Retrieve Kontent.ai content item by ID. Items are language-neutral containers; one item has multiple content item variants (translations).", {
+    id: z.string().describe("Content item ID"),
+}, async ({ id }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client.viewContentItem().byItemId(id).toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Item Retrieval");
+    }
+});

package/build/tools/get-content-type-snippet.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";
+import { defineTool } from "./toolDefinition.js";
+export const getContentTypeSnippet = defineTool("get-content-type-snippet", "Retrieve Kontent.ai content type snippet. Snippets are reusable, shared sets of elements included across multiple content types.", {
+    id: z.string().describe("Content type snippet ID"),
+}, async ({ id }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client
+            .viewContentTypeSnippet()
+            .byTypeId(id)
+            .toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Content Type Snippet Retrieval");
+    }
+});

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

@@ -0,0 +1,17 @@
+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 getContentType = defineTool("get-content-type", "Retrieve Kontent.ai content type (schema/model definition). Content types define content structure: elements, field validation rules, and content groups.", {
+    id: z.string().describe("Content type ID"),
+}, async ({ id }, { authInfo: { token, clientId } = {} }) => {
+    const client = createMapiClient(clientId, token);
+    try {
+        const response = await client.viewContentType().byTypeId(id).toPromise();
+        return createMcpToolSuccessResponse(response.rawData);
+    }
+    catch (error) {
+        return handleMcpToolError(error, "Content Type Retrieval");
+    }
+});