brinkcommerce-dev-mcp 0.1.0-beta.1

package/dist/tools/product-tools.js

@@ -0,0 +1,1918 @@
+import { createProductManagementClient } from "../api-client.js";
+import { logger } from "../logger.js";
+// Annotations for read-only tools (GET operations)
+const readOnlyAnnotations = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true, // Interacts with external BrinkCommerce APIs
+};
+// Annotations for write tools (POST, PUT, PATCH operations)
+const writeAnnotations = {
+    readOnlyHint: false,
+    destructiveHint: false, // Creates or updates, not destructive
+    openWorldHint: true,
+    idempotentHint: true, // PUT/PATCH are idempotent
+};
+// Annotations for destructive tools (DELETE operations)
+const destructiveAnnotations = {
+    readOnlyHint: false,
+    destructiveHint: true,
+    openWorldHint: true,
+};
+/**
+ * MCP Tool Definitions for Product Management
+ */
+export const productTools = {
+    // Product Parent Tools
+    get_product_parent: {
+        name: "get_product_parent",
+        description: "Get a product parent by ID from BrinkCommerce. Returns the product parent details including name, description, translations, and status.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productParentId: {
+                    type: "string",
+                    description: "Unique identifier for the product parent",
+                },
+            },
+            required: ["productParentId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    create_product_parent: {
+        name: "create_product_parent",
+        description: "Create or update a product parent in BrinkCommerce. A product parent is the top-level container for product variants.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productParentId: {
+                    type: "string",
+                    description: "Unique identifier for the product parent",
+                },
+                name: {
+                    type: "string",
+                    description: "Descriptive name of the product parent",
+                },
+                description: {
+                    type: "string",
+                    description: "Description of the product parent",
+                },
+                displayNames: {
+                    type: "object",
+                    description: 'Translations for product name (e.g., {"en": "Product", "sv": "Produkt"})',
+                    additionalProperties: {
+                        type: "string",
+                    },
+                },
+                displayDescriptions: {
+                    type: "object",
+                    description: 'Translations for product description (e.g., {"en": "Description", "sv": "Beskrivning"})',
+                    additionalProperties: {
+                        type: "string",
+                    },
+                },
+                isActive: {
+                    type: "boolean",
+                    description: "Whether the product parent is active",
+                    default: true,
+                },
+                imageUrl: {
+                    type: "string",
+                    description: "Product image URL (absolute URI)",
+                },
+                customAttributes: {
+                    type: "object",
+                    description: "Custom attributes available in Shopper Cart (max 20 char keys, 500 char values)",
+                    additionalProperties: {
+                        type: "string",
+                    },
+                    default: {},
+                },
+            },
+            required: ["productParentId", "name", "description", "displayNames", "displayDescriptions"],
+        },
+        annotations: writeAnnotations,
+    },
+    delete_product_parent: {
+        name: "delete_product_parent",
+        description: "Delete a product parent from BrinkCommerce. WARNING: This will permanently remove the product parent and may affect associated variants.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productParentId: {
+                    type: "string",
+                    description: "Unique identifier for the product parent to delete",
+                },
+            },
+            required: ["productParentId"],
+        },
+        annotations: destructiveAnnotations,
+    },
+    // Product Variant Tools
+    get_product_variant: {
+        name: "get_product_variant",
+        description: "Get a product variant by ID from BrinkCommerce. Returns variant details including name, description, pricing, and stock info.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productVariantId: {
+                    type: "string",
+                    description: "Unique identifier for the product variant",
+                },
+            },
+            required: ["productVariantId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    list_product_variants: {
+        name: "list_product_variants",
+        description: "List all product variants for a product parent. Returns all variants associated with the specified product parent.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productParentId: {
+                    type: "string",
+                    description: "Product parent ID to get variants for",
+                },
+            },
+            required: ["productParentId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    create_product_variant: {
+        name: "create_product_variant",
+        description: "Create or update a product variant in BrinkCommerce. A product variant is the actual sellable product (e.g., size, color).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productVariantId: {
+                    type: "string",
+                    description: "Unique identifier for the product variant",
+                },
+                productParentId: {
+                    type: "string",
+                    description: "Product parent ID this variant belongs to",
+                },
+                name: {
+                    type: "string",
+                    description: "Variant name",
+                },
+                description: {
+                    type: "string",
+                    description: "Variant description",
+                },
+                displayNames: {
+                    type: "object",
+                    description: 'Translations for variant name (e.g., {"en": "Small Blue", "sv": "Liten Blå"})',
+                    additionalProperties: {
+                        type: "string",
+                    },
+                },
+                displayDescriptions: {
+                    type: "object",
+                    description: "Translations for variant description",
+                    additionalProperties: {
+                        type: "string",
+                    },
+                },
+                taxGroupId: {
+                    type: "string",
+                    description: "Tax group ID for the variant",
+                },
+                imageUrl: {
+                    type: "string",
+                    description: "Variant image URL (absolute URI)",
+                },
+                isActive: {
+                    type: "boolean",
+                    description: "Whether the variant is active",
+                    default: true,
+                },
+                tags: {
+                    type: "object",
+                    description: "Discount tags for the variant (e.g., {\"discount\": [\"summer-sale\", \"clearance\"]})",
+                    additionalProperties: {
+                        type: "array",
+                        items: {
+                            type: "string",
+                        },
+                    },
+                    default: {},
+                },
+                customAttributes: {
+                    type: "object",
+                    description: "Custom attributes available in Shopper Cart",
+                    additionalProperties: {
+                        type: "string",
+                    },
+                    default: {},
+                },
+                weight: {
+                    type: "integer",
+                    description: "Weight in grams",
+                },
+                dimensions: {
+                    type: "object",
+                    properties: {
+                        width: {
+                            type: "number",
+                            description: "Width in millimeters",
+                        },
+                        length: {
+                            type: "number",
+                            description: "Length in millimeters",
+                        },
+                        height: {
+                            type: "number",
+                            description: "Height in millimeters",
+                        },
+                    },
+                    required: ["width", "length", "height"],
+                    description: "Product dimensions in millimeters (all fields required if provided)",
+                },
+                shippingAttributes: {
+                    type: "array",
+                    description: "Shipping attributes for the variant",
+                    items: {
+                        type: "string",
+                    },
+                },
+            },
+            required: [
+                "productVariantId",
+                "productParentId",
+                "name",
+                "description",
+                "displayNames",
+                "displayDescriptions",
+                "taxGroupId",
+                "imageUrl",
+            ],
+        },
+        annotations: writeAnnotations,
+    },
+    delete_product_variant: {
+        name: "delete_product_variant",
+        description: "Delete a product variant from BrinkCommerce. WARNING: This will permanently remove the variant.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productVariantId: {
+                    type: "string",
+                    description: "Unique identifier for the product variant to delete",
+                },
+            },
+            required: ["productVariantId"],
+        },
+        annotations: destructiveAnnotations,
+    },
+    // Addon Tools
+    get_addon: {
+        name: "get_addon",
+        description: "Get an addon by ID from BrinkCommerce. Addons are additional items that can be attached to products (e.g., gift wrapping, insurance).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                addonId: {
+                    type: "string",
+                    description: "Unique identifier for the addon",
+                },
+            },
+            required: ["addonId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    create_or_update_addon: {
+        name: "create_or_update_addon",
+        description: "Create or update an addon in BrinkCommerce. Addons are additional items that can be attached to products (e.g., gift wrapping, insurance).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                addonId: {
+                    type: "string",
+                    description: "Unique identifier for the addon",
+                },
+                name: {
+                    type: "string",
+                    description: "Descriptive name of the addon",
+                },
+                description: {
+                    type: "string",
+                    description: "Description of the addon",
+                },
+                displayNames: {
+                    type: "object",
+                    description: 'Translations for addon name (e.g., {"en": "Gift Wrap", "sv": "Presentförpackning"})',
+                    additionalProperties: {
+                        type: "string",
+                    },
+                },
+                displayDescriptions: {
+                    type: "object",
+                    description: "Translations for addon description",
+                    additionalProperties: {
+                        type: "string",
+                    },
+                },
+                taxGroupId: {
+                    type: "string",
+                    description: "Tax group ID for the addon",
+                },
+                imageUrl: {
+                    type: "string",
+                    description: "Addon image URL (absolute URI)",
+                },
+                isActive: {
+                    type: "boolean",
+                    description: "Whether the addon is active",
+                    default: true,
+                },
+                tags: {
+                    type: "object",
+                    description: "Discount tags for the addon",
+                    additionalProperties: {
+                        type: "array",
+                        items: {
+                            type: "string",
+                        },
+                    },
+                    default: {},
+                },
+                customAttributes: {
+                    type: "object",
+                    description: "Custom attributes available in Shopper Cart",
+                    additionalProperties: {
+                        type: "string",
+                    },
+                    default: {},
+                },
+            },
+            required: ["addonId", "name", "description", "displayNames", "displayDescriptions", "taxGroupId", "imageUrl"],
+        },
+        annotations: writeAnnotations,
+    },
+    delete_addon: {
+        name: "delete_addon",
+        description: "Delete an addon from BrinkCommerce. WARNING: This will permanently remove the addon.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                addonId: {
+                    type: "string",
+                    description: "Unique identifier for the addon to delete",
+                },
+            },
+            required: ["addonId"],
+        },
+        annotations: destructiveAnnotations,
+    },
+    list_product_parent_addons: {
+        name: "list_product_parent_addons",
+        description: "List all addons associated with a product parent. Returns all addon configurations for the specified product.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productParentId: {
+                    type: "string",
+                    description: "Product parent ID to get addons for",
+                },
+            },
+            required: ["productParentId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    add_product_parent_addon: {
+        name: "add_product_parent_addon",
+        description: "Add an addon to a product parent. Associates an existing addon with a product so it can be purchased together.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productParentId: {
+                    type: "string",
+                    description: "Product parent ID to add the addon to",
+                },
+                addonId: {
+                    type: "string",
+                    description: "Addon ID to associate with the product",
+                },
+            },
+            required: ["productParentId", "addonId"],
+        },
+        annotations: writeAnnotations,
+    },
+    remove_product_parent_addon: {
+        name: "remove_product_parent_addon",
+        description: "Remove an addon from a product parent. Removes the association between an addon and a product.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productParentId: {
+                    type: "string",
+                    description: "Product parent ID to remove the addon from",
+                },
+                addonId: {
+                    type: "string",
+                    description: "Addon ID to remove from the product",
+                },
+            },
+            required: ["productParentId", "addonId"],
+        },
+        annotations: destructiveAnnotations,
+    },
+    // PATCH operations for partial updates
+    patch_product_parent: {
+        name: "patch_product_parent",
+        description: "Partially update a product parent in BrinkCommerce. Only updates the fields that are provided - other fields remain unchanged.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productParentId: {
+                    type: "string",
+                    description: "Unique identifier for the product parent to update",
+                },
+                name: {
+                    type: "string",
+                    description: "Descriptive name of the product parent",
+                },
+                description: {
+                    type: "string",
+                    description: "Description of the product parent",
+                },
+                displayNames: {
+                    type: "object",
+                    description: 'Translations for product name (e.g., {"en": "Product", "sv": "Produkt"})',
+                    additionalProperties: {
+                        type: "string",
+                    },
+                },
+                displayDescriptions: {
+                    type: "object",
+                    description: 'Translations for product description (e.g., {"en": "Description", "sv": "Beskrivning"})',
+                    additionalProperties: {
+                        type: "string",
+                    },
+                },
+                isActive: {
+                    type: "boolean",
+                    description: "Whether the product parent is active",
+                },
+                isArchived: {
+                    type: "boolean",
+                    description: "Whether the product parent is archived",
+                },
+                imageUrl: {
+                    type: "string",
+                    description: "Product image URL (absolute URI)",
+                },
+                customAttributes: {
+                    type: "object",
+                    description: "Custom attributes available in Shopper Cart (max 20 char keys, 500 char values)",
+                    additionalProperties: {
+                        type: "string",
+                    },
+                },
+            },
+            required: ["productParentId"],
+        },
+        annotations: writeAnnotations,
+    },
+    patch_product_variant: {
+        name: "patch_product_variant",
+        description: "Partially update a product variant in BrinkCommerce. Only updates the fields that are provided - other fields remain unchanged.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productVariantId: {
+                    type: "string",
+                    description: "Unique identifier for the product variant to update",
+                },
+                productParentId: {
+                    type: "string",
+                    description: "Product parent ID to move the variant to (if changing)",
+                },
+                name: {
+                    type: "string",
+                    description: "Variant name",
+                },
+                description: {
+                    type: "string",
+                    description: "Variant description",
+                },
+                displayNames: {
+                    type: "object",
+                    description: 'Translations for variant name (e.g., {"en": "Small Blue", "sv": "Liten Blå"})',
+                    additionalProperties: {
+                        type: "string",
+                    },
+                },
+                displayDescriptions: {
+                    type: "object",
+                    description: "Translations for variant description",
+                    additionalProperties: {
+                        type: "string",
+                    },
+                },
+                taxGroupId: {
+                    type: "string",
+                    description: "Tax group ID for the variant",
+                },
+                imageUrl: {
+                    type: "string",
+                    description: "Variant image URL (absolute URI)",
+                },
+                isActive: {
+                    type: "boolean",
+                    description: "Whether the variant is active",
+                },
+                isArchived: {
+                    type: "boolean",
+                    description: "Whether the variant is archived",
+                },
+                tags: {
+                    type: "object",
+                    description: "Discount tags for the variant (e.g., {\"discount\": [\"summer-sale\", \"clearance\"]})",
+                    additionalProperties: {
+                        type: "array",
+                        items: {
+                            type: "string",
+                        },
+                    },
+                },
+                customAttributes: {
+                    type: "object",
+                    description: "Custom attributes available in Shopper Cart",
+                    additionalProperties: {
+                        type: "string",
+                    },
+                },
+                weight: {
+                    type: "integer",
+                    description: "Weight in grams",
+                },
+                dimensions: {
+                    type: "object",
+                    properties: {
+                        width: {
+                            type: "number",
+                            description: "Width in millimeters",
+                        },
+                        length: {
+                            type: "number",
+                            description: "Length in millimeters",
+                        },
+                        height: {
+                            type: "number",
+                            description: "Height in millimeters",
+                        },
+                    },
+                    required: ["width", "length", "height"],
+                    description: "Product dimensions in millimeters (all fields required if provided)",
+                },
+                shippingAttributes: {
+                    type: "array",
+                    description: "Shipping attributes for the variant",
+                    items: {
+                        type: "string",
+                    },
+                },
+            },
+            required: ["productVariantId"],
+        },
+        annotations: writeAnnotations,
+    },
+    patch_addon: {
+        name: "patch_addon",
+        description: "Partially update an addon in BrinkCommerce. Only updates the fields that are provided - other fields remain unchanged.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                addonId: {
+                    type: "string",
+                    description: "Unique identifier for the addon to update",
+                },
+                name: {
+                    type: "string",
+                    description: "Descriptive name of the addon",
+                },
+                description: {
+                    type: "string",
+                    description: "Description of the addon",
+                },
+                displayNames: {
+                    type: "object",
+                    description: 'Translations for addon name (e.g., {"en": "Gift Wrap", "sv": "Presentförpackning"})',
+                    additionalProperties: {
+                        type: "string",
+                    },
+                },
+                displayDescriptions: {
+                    type: "object",
+                    description: "Translations for addon description",
+                    additionalProperties: {
+                        type: "string",
+                    },
+                },
+                taxGroupId: {
+                    type: "string",
+                    description: "Tax group ID for the addon",
+                },
+                imageUrl: {
+                    type: "string",
+                    description: "Addon image URL (absolute URI)",
+                },
+                isActive: {
+                    type: "boolean",
+                    description: "Whether the addon is active",
+                },
+                isArchived: {
+                    type: "boolean",
+                    description: "Whether the addon is archived",
+                },
+                tags: {
+                    type: "object",
+                    description: "Discount tags for the addon",
+                    additionalProperties: {
+                        type: "array",
+                        items: {
+                            type: "string",
+                        },
+                    },
+                },
+                customAttributes: {
+                    type: "object",
+                    description: "Custom attributes available in Shopper Cart",
+                    additionalProperties: {
+                        type: "string",
+                    },
+                },
+            },
+            required: ["addonId"],
+        },
+        annotations: writeAnnotations,
+    },
+    archive_product_parent: {
+        name: "archive_product_parent",
+        description: "Archive a product parent in BrinkCommerce. This is a soft delete that marks the product as archived. Optionally archives all associated product variants as well.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productParentId: {
+                    type: "string",
+                    description: "Unique identifier for the product parent to archive",
+                },
+                includeProductVariants: {
+                    type: "boolean",
+                    description: "Whether to also archive all product variants associated with this product parent. Defaults to true.",
+                    default: true,
+                },
+            },
+            required: ["productParentId"],
+        },
+        annotations: writeAnnotations,
+    },
+};
+// ============================================================================
+// Product Parent Handlers
+// ============================================================================
+/**
+ * Handle get_product_parent tool call
+ */
+export async function handleGetProductParent(params) {
+    try {
+        logger.info("Handling get_product_parent tool call", {
+            productParentId: params.productParentId,
+        });
+        // Validate required parameters
+        if (!params.productParentId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'productParentId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const productParentId = params.productParentId;
+        // Create API client
+        const client = createProductManagementClient();
+        // Call API
+        const result = await client.getProductParent(productParentId);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Product Parent: ${productParentId}\n\n${JSON.stringify(result.data, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to get product parent: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleGetProductParent", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle create_product_parent tool call
+ */
+export async function handleCreateProductParent(params) {
+    try {
+        logger.info("Handling create_product_parent tool call", {
+            productParentId: params.productParentId,
+        });
+        // Validate required parameters
+        const requiredFields = ["productParentId", "name", "description", "displayNames", "displayDescriptions"];
+        for (const field of requiredFields) {
+            if (!params[field]) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: Missing required field '${field}'`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        // At this point, required fields are guaranteed to exist
+        const productParentId = params.productParentId;
+        const name = params.name;
+        const description = params.description;
+        const displayNames = params.displayNames;
+        const displayDescriptions = params.displayDescriptions;
+        // Create API client
+        const client = createProductManagementClient();
+        // Build request
+        const request = {
+            name,
+            description,
+            displayNames,
+            displayDescriptions,
+            isActive: params.isActive ?? true,
+            customAttributes: params.customAttributes ?? {},
+            ...(params.imageUrl && { imageUrl: params.imageUrl }),
+        };
+        // Call API
+        const result = await client.createProductParent(productParentId, request);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully created product parent: ${productParentId}\n\nProduct parent is now available in BrinkCommerce.`,
+                    },
+                ],
+            };
+        }
+        else {
+            // Build detailed error message
+            let errorText = `Failed to create product parent: ${result.error?.message}\n\nStatus: ${result.error?.status}`;
+            // Add details if available
+            if (result.error?.details) {
+                errorText += `\n\nDetails: ${JSON.stringify(result.error.details, null, 2)}`;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: errorText,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleCreateProductParent", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle delete_product_parent tool call
+ */
+export async function handleDeleteProductParent(params) {
+    try {
+        logger.info("Handling delete_product_parent tool call", {
+            productParentId: params.productParentId,
+        });
+        // Validate required parameters
+        if (!params.productParentId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'productParentId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const productParentId = params.productParentId;
+        // Create API client
+        const client = createProductManagementClient();
+        // Call API
+        const result = await client.deleteProductParent(productParentId);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully deleted product parent: ${productParentId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to delete product parent: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleDeleteProductParent", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ============================================================================
+// Product Variant Handlers
+// ============================================================================
+/**
+ * Handle get_product_variant tool call
+ */
+export async function handleGetProductVariant(params) {
+    try {
+        logger.info("Handling get_product_variant tool call", {
+            productVariantId: params.productVariantId,
+        });
+        // Validate required parameters
+        if (!params.productVariantId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'productVariantId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const productVariantId = params.productVariantId;
+        // Create API client
+        const client = createProductManagementClient();
+        // Call API
+        const result = await client.getProductVariant(productVariantId);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Product Variant: ${productVariantId}\n\n${JSON.stringify(result.data, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to get product variant: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleGetProductVariant", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle list_product_variants tool call
+ */
+export async function handleListProductVariants(params) {
+    try {
+        logger.info("Handling list_product_variants tool call", {
+            productParentId: params.productParentId,
+        });
+        // Validate required parameters
+        if (!params.productParentId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'productParentId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const productParentId = params.productParentId;
+        // Create API client
+        const client = createProductManagementClient();
+        // Call API
+        const result = await client.getProductVariants(productParentId);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Product Variants for: ${productParentId}\n\n${JSON.stringify(result.data, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to list product variants: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleListProductVariants", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle create_product_variant tool call
+ */
+export async function handleCreateProductVariant(params) {
+    try {
+        logger.info("Handling create_product_variant tool call", {
+            productVariantId: params.productVariantId,
+            productParentId: params.productParentId,
+        });
+        // Validate required parameters
+        const requiredFields = [
+            "productVariantId",
+            "productParentId",
+            "name",
+            "description",
+            "displayNames",
+            "displayDescriptions",
+            "taxGroupId",
+            "imageUrl",
+        ];
+        for (const field of requiredFields) {
+            if (!params[field]) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: Missing required field '${field}'`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        // At this point, required fields are guaranteed to exist
+        const productVariantId = params.productVariantId;
+        const productParentId = params.productParentId;
+        const name = params.name;
+        const description = params.description;
+        const displayNames = params.displayNames;
+        const displayDescriptions = params.displayDescriptions;
+        const taxGroupId = params.taxGroupId;
+        const imageUrl = params.imageUrl;
+        // Create API client
+        const client = createProductManagementClient();
+        // Build request
+        // Note: The generated types expect Set<string> for tags/shippingAttributes, but the API
+        // accepts arrays (which get serialized to JSON arrays). The ToJSON converter handles this.
+        const request = {
+            productParentId,
+            name,
+            description,
+            displayNames,
+            displayDescriptions,
+            taxGroupId,
+            imageUrl,
+            isActive: params.isActive ?? true,
+            tags: params.tags ?? {},
+            customAttributes: params.customAttributes ?? {},
+            ...(params.weight && { weight: params.weight }),
+            ...(params.dimensions && { dimensions: params.dimensions }),
+            ...(params.shippingAttributes && { shippingAttributes: params.shippingAttributes }),
+        };
+        // Call API
+        const result = await client.createProductVariant(productVariantId, request);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully created product variant: ${productVariantId}\n\nVariant is now available under product parent: ${productParentId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            // Build detailed error message
+            let errorText = `Failed to create product variant: ${result.error?.message}\n\nStatus: ${result.error?.status}`;
+            // Add details if available
+            if (result.error?.details) {
+                errorText += `\n\nDetails: ${JSON.stringify(result.error.details, null, 2)}`;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: errorText,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleCreateProductVariant", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle delete_product_variant tool call
+ */
+export async function handleDeleteProductVariant(params) {
+    try {
+        logger.info("Handling delete_product_variant tool call", {
+            productVariantId: params.productVariantId,
+        });
+        // Validate required parameters
+        if (!params.productVariantId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'productVariantId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const productVariantId = params.productVariantId;
+        // Create API client
+        const client = createProductManagementClient();
+        // Call API
+        const result = await client.deleteProductVariant(productVariantId);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully deleted product variant: ${productVariantId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to delete product variant: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleDeleteProductVariant", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ============================================================================
+// Addon Handlers
+// ============================================================================
+/**
+ * Handle get_addon tool call
+ */
+export async function handleGetAddon(params) {
+    try {
+        logger.info("Handling get_addon tool call", {
+            addonId: params.addonId,
+        });
+        // Validate required parameters
+        if (!params.addonId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'addonId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const addonId = params.addonId;
+        // Create API client
+        const client = createProductManagementClient();
+        // Call API
+        const result = await client.getAddon(addonId);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Addon: ${addonId}\n\n${JSON.stringify(result.data, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to get addon: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleGetAddon", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle create_or_update_addon tool call
+ */
+export async function handleCreateOrUpdateAddon(params) {
+    try {
+        logger.info("Handling create_or_update_addon tool call", {
+            addonId: params.addonId,
+        });
+        // Validate required parameters
+        const requiredFields = ["addonId", "name", "description", "displayNames", "displayDescriptions", "taxGroupId", "imageUrl"];
+        for (const field of requiredFields) {
+            if (!params[field]) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: Missing required field '${field}'`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        const addonId = params.addonId;
+        const name = params.name;
+        const description = params.description;
+        const displayNames = params.displayNames;
+        const displayDescriptions = params.displayDescriptions;
+        const taxGroupId = params.taxGroupId;
+        const imageUrl = params.imageUrl;
+        // Create API client
+        const client = createProductManagementClient();
+        // Build request
+        const request = {
+            name,
+            description,
+            displayNames,
+            displayDescriptions,
+            taxGroupId,
+            imageUrl,
+            isActive: params.isActive ?? true,
+            tags: params.tags ?? {},
+            customAttributes: params.customAttributes ?? {},
+        };
+        // Call API
+        const result = await client.createOrUpdateAddon(addonId, request);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully created/updated addon: ${addonId}\n\n${JSON.stringify(result.data, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to create/update addon: ${result.error?.message}\n\nStatus: ${result.error?.status}`;
+            if (result.error?.details) {
+                errorText += `\n\nDetails: ${JSON.stringify(result.error.details, null, 2)}`;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: errorText,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleCreateOrUpdateAddon", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle delete_addon tool call
+ */
+export async function handleDeleteAddon(params) {
+    try {
+        logger.info("Handling delete_addon tool call", {
+            addonId: params.addonId,
+        });
+        // Validate required parameters
+        if (!params.addonId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'addonId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const addonId = params.addonId;
+        // Create API client
+        const client = createProductManagementClient();
+        // Call API
+        const result = await client.deleteAddon(addonId);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully deleted addon: ${addonId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to delete addon: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleDeleteAddon", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle list_product_parent_addons tool call
+ */
+export async function handleListProductParentAddons(params) {
+    try {
+        logger.info("Handling list_product_parent_addons tool call", {
+            productParentId: params.productParentId,
+        });
+        // Validate required parameters
+        if (!params.productParentId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'productParentId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const productParentId = params.productParentId;
+        // Create API client
+        const client = createProductManagementClient();
+        // Call API
+        const result = await client.getProductParentAddons(productParentId);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Addons for Product Parent: ${productParentId}\n\n${JSON.stringify(result.data, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to list product parent addons: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleListProductParentAddons", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle add_product_parent_addon tool call
+ */
+export async function handleAddProductParentAddon(params) {
+    try {
+        logger.info("Handling add_product_parent_addon tool call", {
+            productParentId: params.productParentId,
+            addonId: params.addonId,
+        });
+        // Validate required parameters
+        if (!params.productParentId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'productParentId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (!params.addonId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'addonId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const productParentId = params.productParentId;
+        const addonId = params.addonId;
+        // Create API client
+        const client = createProductManagementClient();
+        // Call API
+        const result = await client.addProductParentAddon(productParentId, { addonId });
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully added addon '${addonId}' to product parent '${productParentId}'`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to add addon to product parent: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleAddProductParentAddon", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle remove_product_parent_addon tool call
+ */
+export async function handleRemoveProductParentAddon(params) {
+    try {
+        logger.info("Handling remove_product_parent_addon tool call", {
+            productParentId: params.productParentId,
+            addonId: params.addonId,
+        });
+        // Validate required parameters
+        if (!params.productParentId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'productParentId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (!params.addonId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'addonId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const productParentId = params.productParentId;
+        const addonId = params.addonId;
+        // Create API client
+        const client = createProductManagementClient();
+        // Call API
+        const result = await client.removeProductParentAddon(productParentId, addonId);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully removed addon '${addonId}' from product parent '${productParentId}'`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to remove addon from product parent: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleRemoveProductParentAddon", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ============================================================================
+// PATCH (Partial Update) Handlers
+// ============================================================================
+/**
+ * Handle patch_product_parent tool call
+ */
+export async function handlePatchProductParent(params) {
+    try {
+        logger.info("Handling patch_product_parent tool call", {
+            productParentId: params.productParentId,
+        });
+        // Validate required parameters
+        if (!params.productParentId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'productParentId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const productParentId = params.productParentId;
+        // Create API client
+        const client = createProductManagementClient();
+        // Build request with only provided fields (partial update)
+        const request = {};
+        if (params.name !== undefined)
+            request.name = params.name;
+        if (params.description !== undefined)
+            request.description = params.description;
+        if (params.displayNames !== undefined)
+            request.displayNames = params.displayNames;
+        if (params.displayDescriptions !== undefined)
+            request.displayDescriptions = params.displayDescriptions;
+        if (params.isActive !== undefined)
+            request.isActive = params.isActive;
+        if (params.isArchived !== undefined)
+            request.isArchived = params.isArchived;
+        if (params.imageUrl !== undefined)
+            request.imageUrl = params.imageUrl;
+        if (params.customAttributes !== undefined)
+            request.customAttributes = params.customAttributes;
+        // Call API
+        const result = await client.patchProductParent(productParentId, request);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully patched product parent: ${productParentId}\n\n${JSON.stringify(result.data, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to patch product parent: ${result.error?.message}\n\nStatus: ${result.error?.status}`;
+            if (result.error?.details) {
+                errorText += `\n\nDetails: ${JSON.stringify(result.error.details, null, 2)}`;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: errorText,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handlePatchProductParent", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle patch_product_variant tool call
+ */
+export async function handlePatchProductVariant(params) {
+    try {
+        logger.info("Handling patch_product_variant tool call", {
+            productVariantId: params.productVariantId,
+        });
+        // Validate required parameters
+        if (!params.productVariantId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'productVariantId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const productVariantId = params.productVariantId;
+        // Create API client
+        const client = createProductManagementClient();
+        // Build request with only provided fields (partial update)
+        const request = {};
+        if (params.productParentId !== undefined)
+            request.productParentId = params.productParentId;
+        if (params.name !== undefined)
+            request.name = params.name;
+        if (params.description !== undefined)
+            request.description = params.description;
+        if (params.displayNames !== undefined)
+            request.displayNames = params.displayNames;
+        if (params.displayDescriptions !== undefined)
+            request.displayDescriptions = params.displayDescriptions;
+        if (params.taxGroupId !== undefined)
+            request.taxGroupId = params.taxGroupId;
+        if (params.imageUrl !== undefined)
+            request.imageUrl = params.imageUrl;
+        if (params.isActive !== undefined)
+            request.isActive = params.isActive;
+        if (params.isArchived !== undefined)
+            request.isArchived = params.isArchived;
+        if (params.tags !== undefined)
+            request.tags = params.tags;
+        if (params.customAttributes !== undefined)
+            request.customAttributes = params.customAttributes;
+        if (params.weight !== undefined)
+            request.weight = params.weight;
+        if (params.dimensions !== undefined)
+            request.dimensions = params.dimensions;
+        if (params.shippingAttributes !== undefined)
+            request.shippingAttributes = params.shippingAttributes;
+        // Call API
+        const result = await client.patchProductVariant(productVariantId, request);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully patched product variant: ${productVariantId}\n\n${JSON.stringify(result.data, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to patch product variant: ${result.error?.message}\n\nStatus: ${result.error?.status}`;
+            if (result.error?.details) {
+                errorText += `\n\nDetails: ${JSON.stringify(result.error.details, null, 2)}`;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: errorText,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handlePatchProductVariant", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle patch_addon tool call
+ */
+export async function handlePatchAddon(params) {
+    try {
+        logger.info("Handling patch_addon tool call", {
+            addonId: params.addonId,
+        });
+        // Validate required parameters
+        if (!params.addonId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'addonId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const addonId = params.addonId;
+        // Create API client
+        const client = createProductManagementClient();
+        // Build request with only provided fields (partial update)
+        const request = {};
+        if (params.name !== undefined)
+            request.name = params.name;
+        if (params.description !== undefined)
+            request.description = params.description;
+        if (params.displayNames !== undefined)
+            request.displayNames = params.displayNames;
+        if (params.displayDescriptions !== undefined)
+            request.displayDescriptions = params.displayDescriptions;
+        if (params.taxGroupId !== undefined)
+            request.taxGroupId = params.taxGroupId;
+        if (params.imageUrl !== undefined)
+            request.imageUrl = params.imageUrl;
+        if (params.isActive !== undefined)
+            request.isActive = params.isActive;
+        if (params.isArchived !== undefined)
+            request.isArchived = params.isArchived;
+        if (params.tags !== undefined)
+            request.tags = params.tags;
+        if (params.customAttributes !== undefined)
+            request.customAttributes = params.customAttributes;
+        // Call API
+        const result = await client.patchAddon(addonId, request);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully patched addon: ${addonId}\n\n${JSON.stringify(result.data, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to patch addon: ${result.error?.message}\n\nStatus: ${result.error?.status}`;
+            if (result.error?.details) {
+                errorText += `\n\nDetails: ${JSON.stringify(result.error.details, null, 2)}`;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: errorText,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handlePatchAddon", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ============================================================================
+// Archive Handler
+// ============================================================================
+/**
+ * Handle archive_product_parent tool call
+ */
+export async function handleArchiveProductParent(params) {
+    try {
+        logger.info("Handling archive_product_parent tool call", {
+            productParentId: params.productParentId,
+            includeProductVariants: params.includeProductVariants,
+        });
+        // Validate required parameters
+        if (!params.productParentId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'productParentId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const productParentId = params.productParentId;
+        // Create API client
+        const client = createProductManagementClient();
+        // Build request
+        const request = {
+            includeProductVariants: params.includeProductVariants ?? true,
+        };
+        // Call API
+        const result = await client.archiveProductParent(productParentId, request);
+        if (result.success) {
+            const variantNote = request.includeProductVariants
+                ? " All associated product variants have also been archived."
+                : "";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully archived product parent: ${productParentId}${variantNote}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to archive product parent: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleArchiveProductParent", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}