brinkcommerce-dev-mcp 0.1.0-beta.1

package/dist/tools/price-tools.js

@@ -0,0 +1,902 @@
+import { createPriceManagementClient } from "../api-client.js";
+import { logger } from "../logger.js";
+import { validateCountryCode, validateArraySize, validateNoDuplicates } from "./validation.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 Price Management
+ */
+export const priceTools = {
+    update_product_variant_prices: {
+        name: "update_product_variant_prices",
+        description: "Update prices for a product variant in a store group across multiple markets. Supports base price, sale price, and reference price in minor currency units (e.g., cents).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                storeGroupId: {
+                    type: "string",
+                    description: "Store group ID where prices will be set",
+                },
+                productVariantId: {
+                    type: "string",
+                    description: "Product variant ID to set prices for",
+                },
+                productVariantPrices: {
+                    type: "array",
+                    description: "Array of prices for different markets (max 200 entries)",
+                    maxItems: 200,
+                    items: {
+                        type: "object",
+                        properties: {
+                            countryCode: {
+                                type: "string",
+                                description: "ISO-3166-1 alpha-2 country code (e.g., SE, NO, DK)",
+                                pattern: "^[A-Z]{2}$",
+                            },
+                            basePriceAmount: {
+                                type: "integer",
+                                description: "Base price in minor currency units (e.g., 9900 for 99.00 SEK)",
+                                minimum: 0,
+                            },
+                            salePriceAmount: {
+                                type: "integer",
+                                description: "Sale price in minor currency units (must be ≤ basePriceAmount)",
+                                minimum: 0,
+                            },
+                            referencePriceAmount: {
+                                type: "integer",
+                                description: "Optional reference/historic price in minor currency units",
+                                minimum: 0,
+                            },
+                        },
+                        required: ["countryCode", "basePriceAmount", "salePriceAmount"],
+                    },
+                },
+            },
+            required: ["storeGroupId", "productVariantId", "productVariantPrices"],
+        },
+        annotations: writeAnnotations,
+    },
+    delete_product_variant_prices: {
+        name: "delete_product_variant_prices",
+        description: "Delete all prices for a product variant in a store group. WARNING: This removes all market-specific pricing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                storeGroupId: {
+                    type: "string",
+                    description: "Store group ID where prices will be deleted",
+                },
+                productVariantId: {
+                    type: "string",
+                    description: "Product variant ID to delete prices for",
+                },
+            },
+            required: ["storeGroupId", "productVariantId"],
+        },
+        annotations: destructiveAnnotations,
+    },
+    get_product_variant_all_prices: {
+        name: "get_product_variant_all_prices",
+        description: "Get all prices for a product variant across all store groups. Returns prices organized by store group and market.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productVariantId: {
+                    type: "string",
+                    description: "Product variant ID to get prices for",
+                },
+            },
+            required: ["productVariantId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    get_product_variant_prices: {
+        name: "get_product_variant_prices",
+        description: "Get prices for a product variant in a specific store group. Returns all market-specific prices for the variant.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                storeGroupId: {
+                    type: "string",
+                    description: "Store group ID to get prices from",
+                },
+                productVariantId: {
+                    type: "string",
+                    description: "Product variant ID to get prices for",
+                },
+            },
+            required: ["storeGroupId", "productVariantId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    get_product_variant_price: {
+        name: "get_product_variant_price",
+        description: "Get the price for a product variant in a specific market. Returns the full price details including base, sale, and reference prices.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                storeGroupId: {
+                    type: "string",
+                    description: "Store group ID",
+                },
+                countryCode: {
+                    type: "string",
+                    description: "ISO-3166-1 alpha-2 country code (e.g., SE, NO, DK)",
+                    pattern: "^[A-Z]{2}$",
+                },
+                productVariantId: {
+                    type: "string",
+                    description: "Product variant ID to get price for",
+                },
+            },
+            required: ["storeGroupId", "countryCode", "productVariantId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    get_addon_price: {
+        name: "get_addon_price",
+        description: "Get the price for an addon in a specific market. Returns the full price details including base, sale, and reference prices.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                storeGroupId: {
+                    type: "string",
+                    description: "Store group ID",
+                },
+                countryCode: {
+                    type: "string",
+                    description: "ISO-3166-1 alpha-2 country code (e.g., SE, NO, DK)",
+                    pattern: "^[A-Z]{2}$",
+                },
+                addonId: {
+                    type: "string",
+                    description: "Addon ID to get price for",
+                },
+            },
+            required: ["storeGroupId", "countryCode", "addonId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    patch_product_variant_prices: {
+        name: "patch_product_variant_prices",
+        description: "Partially update prices for a product variant in a store group. Only updates the specified price fields for the specified markets.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                storeGroupId: {
+                    type: "string",
+                    description: "Store group ID where prices will be updated",
+                },
+                productVariantId: {
+                    type: "string",
+                    description: "Product variant ID to update prices for",
+                },
+                priceUpdates: {
+                    type: "object",
+                    description: "Map of country codes to price updates. Each entry specifies which price fields to update for that market.",
+                    additionalProperties: {
+                        type: "object",
+                        properties: {
+                            basePriceAmount: {
+                                type: "integer",
+                                description: "Base price in minor currency units (e.g., 9900 for 99.00 SEK)",
+                                minimum: 0,
+                            },
+                            salePriceAmount: {
+                                type: "integer",
+                                description: "Sale price in minor currency units (must be <= basePriceAmount)",
+                                minimum: 0,
+                            },
+                            referencePriceAmount: {
+                                type: ["integer", "null"],
+                                description: "Reference/historic price in minor currency units, or null to remove",
+                                minimum: 0,
+                            },
+                        },
+                    },
+                },
+            },
+            required: ["storeGroupId", "productVariantId", "priceUpdates"],
+        },
+        annotations: writeAnnotations,
+    },
+};
+/**
+ * Handle update_product_variant_prices tool call
+ */
+export async function handleUpdateProductVariantPrices(params) {
+    try {
+        logger.info("Handling update_product_variant_prices tool call", {
+            storeGroupId: params.storeGroupId,
+            productVariantId: params.productVariantId,
+        });
+        // Validate required parameters
+        const requiredFields = ["storeGroupId", "productVariantId", "productVariantPrices"];
+        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 storeGroupId = params.storeGroupId;
+        const productVariantId = params.productVariantId;
+        const productVariantPrices = params.productVariantPrices;
+        // Validate prices array
+        if (!Array.isArray(productVariantPrices) || productVariantPrices.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: productVariantPrices must be a non-empty array",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Validate array size (max 200 items)
+        const arraySizeValidation = validateArraySize(productVariantPrices, 200, "prices");
+        if (!arraySizeValidation.valid) {
+            logger.warn("Array size validation failed", { count: productVariantPrices.length });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: arraySizeValidation.error ?? "Too many prices",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Validate no duplicate country codes
+        const duplicateValidation = validateNoDuplicates(productVariantPrices, (price) => price.countryCode, "country codes");
+        if (!duplicateValidation.valid) {
+            logger.warn("Duplicate country codes found in prices");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: duplicateValidation.error ?? "Duplicate country codes found",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Validate country code format for each price
+        for (const price of productVariantPrices) {
+            const countryValidation = validateCountryCode(price.countryCode);
+            if (!countryValidation.valid) {
+                logger.warn("Invalid country code in prices", { countryCode: price.countryCode });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: countryValidation.error ?? "Invalid country code",
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        // Validate price constraints
+        for (const price of productVariantPrices) {
+            if (price.salePriceAmount > price.basePriceAmount) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: Sale price (${price.salePriceAmount}) cannot be greater than base price (${price.basePriceAmount}) for country ${price.countryCode}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        // Create API client
+        const client = createPriceManagementClient();
+        // Convert array to Set as required by the API
+        const productVariantPricesSet = new Set(productVariantPrices);
+        // Build request
+        const request = {
+            productVariantPrices: productVariantPricesSet,
+        };
+        // Call API
+        const result = await client.updateProductVariantPrices(storeGroupId, productVariantId, request);
+        if (result.success) {
+            const countries = productVariantPrices.map((p) => p.countryCode).join(", ");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✓ Successfully updated prices for variant: ${productVariantId}\n\nStore group: ${storeGroupId}\nMarkets: ${countries}\nTotal prices updated: ${productVariantPrices.length}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✗ Failed to update prices: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleUpdateProductVariantPrices", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✗ Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle delete_product_variant_prices tool call
+ */
+export async function handleDeleteProductVariantPrices(params) {
+    try {
+        logger.info("Handling delete_product_variant_prices tool call", {
+            storeGroupId: params.storeGroupId,
+            productVariantId: params.productVariantId,
+        });
+        // Validate required parameters
+        const requiredFields = ["storeGroupId", "productVariantId"];
+        for (const field of requiredFields) {
+            if (!params[field]) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: Missing required field '${field}'`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        // Create API client - Note: Price API doesn't have delete endpoint
+        // We would use PATCH with empty array instead, but for this implementation
+        // we'll return an informative message
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `⚠️ Price deletion not available via API\n\nThe Price Management API does not support direct deletion of prices.\n\nTo remove prices, use update_product_variant_prices with an empty productVariantPrices array,\nor use the PATCH endpoint to update specific markets.`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    catch (error) {
+        logger.error("Error in handleDeleteProductVariantPrices", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✗ Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle get_product_variant_all_prices tool call
+ */
+export async function handleGetProductVariantAllPrices(params) {
+    try {
+        logger.info("Handling get_product_variant_all_prices 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 = createPriceManagementClient();
+        // Call API
+        const result = await client.getAllProductVariantPrices(productVariantId);
+        if (result.success && result.data) {
+            const storeGroups = result.data.storeGroups || [];
+            if (storeGroups.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No prices found for variant: ${productVariantId}\n\nThe product variant may not have any prices configured yet.`,
+                        },
+                    ],
+                };
+            }
+            // Format response
+            let output = `Prices for variant: ${productVariantId}\n\n`;
+            output += `Store Groups: ${storeGroups.length}\n`;
+            output += "─".repeat(50) + "\n\n";
+            for (const storeGroup of storeGroups) {
+                output += `Store Group: ${storeGroup.storeGroupId}\n`;
+                output += `Markets: ${storeGroup.marketPrices?.length ?? 0}\n`;
+                if (storeGroup.marketPrices && storeGroup.marketPrices.length > 0) {
+                    for (const marketPrice of storeGroup.marketPrices) {
+                        const price = marketPrice.price;
+                        output += `  ${marketPrice.countryCode}: Base ${price.basePriceAmount}, Sale ${price.salePriceAmount}`;
+                        if (price.referencePriceAmount) {
+                            output += `, Ref ${price.referencePriceAmount}`;
+                        }
+                        output += "\n";
+                    }
+                }
+                output += "\n";
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: output,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✗ Failed to get prices: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleGetProductVariantAllPrices", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✗ Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle get_product_variant_prices tool call
+ */
+export async function handleGetProductVariantPrices(params) {
+    try {
+        logger.info("Handling get_product_variant_prices tool call", {
+            storeGroupId: params.storeGroupId,
+            productVariantId: params.productVariantId,
+        });
+        // Validate required parameters
+        const requiredFields = ["storeGroupId", "productVariantId"];
+        for (const field of requiredFields) {
+            if (!params[field]) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: Missing required field '${field}'`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        const storeGroupId = params.storeGroupId;
+        const productVariantId = params.productVariantId;
+        // Create API client
+        const client = createPriceManagementClient();
+        // Call API
+        const result = await client.getProductVariantPrices(storeGroupId, productVariantId);
+        if (result.success && result.data) {
+            const data = result.data;
+            const prices = data.productVariantPrices || [];
+            // Format response
+            let output = `Prices for variant: ${productVariantId}\n`;
+            output += `Store Group: ${storeGroupId}\n`;
+            output += "─".repeat(50) + "\n\n";
+            if (prices.length === 0) {
+                output += "No prices configured for this variant in this store group.\n";
+            }
+            else {
+                output += `Markets: ${prices.length}\n\n`;
+                for (const priceEntry of prices) {
+                    output += `Market: ${priceEntry.countryCode}\n`;
+                    output += `  Base Price: ${priceEntry.basePriceAmount}\n`;
+                    output += `  Sale Price: ${priceEntry.salePriceAmount}\n`;
+                    if (priceEntry.referencePriceAmount) {
+                        output += `  Reference Price: ${priceEntry.referencePriceAmount}\n`;
+                    }
+                    output += "\n";
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: output,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✗ Failed to get prices: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleGetProductVariantPrices", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✗ Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle get_product_variant_price tool call
+ */
+export async function handleGetProductVariantPrice(params) {
+    try {
+        logger.info("Handling get_product_variant_price tool call", {
+            storeGroupId: params.storeGroupId,
+            countryCode: params.countryCode,
+            productVariantId: params.productVariantId,
+        });
+        // Validate required parameters
+        const requiredFields = ["storeGroupId", "countryCode", "productVariantId"];
+        for (const field of requiredFields) {
+            if (!params[field]) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: Missing required field '${field}'`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        const storeGroupId = params.storeGroupId;
+        const countryCode = params.countryCode;
+        const productVariantId = params.productVariantId;
+        // Validate country code format
+        const countryValidation = validateCountryCode(countryCode);
+        if (!countryValidation.valid) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: countryValidation.error ?? "Invalid country code",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Create API client
+        const client = createPriceManagementClient();
+        // Call API
+        const result = await client.getProductVariantPrice(storeGroupId, countryCode, productVariantId);
+        if (result.success && result.data) {
+            const price = result.data;
+            // Format response
+            let output = `Price Details\n`;
+            output += "─".repeat(50) + "\n\n";
+            output += `Product Variant: ${price.productVariantId}\n`;
+            output += `Product Parent: ${price.productParentId}\n`;
+            output += `Store Group: ${price.storeGroupId}\n`;
+            output += `Store Name: ${price.storeName}\n`;
+            output += `Market: ${price.countryCode}\n`;
+            output += `Currency: ${price.currencyCode}\n\n`;
+            output += `Pricing:\n`;
+            output += `  Base Price: ${price.basePriceAmount} (minor units)\n`;
+            output += `  Sale Price: ${price.salePriceAmount} (minor units)\n`;
+            output += `  Discount Amount: ${price.discountAmount} (minor units)\n`;
+            if (price.referencePriceAmount) {
+                output += `  Reference Price: ${price.referencePriceAmount} (minor units)\n`;
+            }
+            output += `\nCreated: ${price.created}\n`;
+            output += `Updated: ${price.updated}\n`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: output,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✗ Failed to get price: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleGetProductVariantPrice", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✗ Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle get_addon_price tool call
+ */
+export async function handleGetAddonPrice(params) {
+    try {
+        logger.info("Handling get_addon_price tool call", {
+            storeGroupId: params.storeGroupId,
+            countryCode: params.countryCode,
+            addonId: params.addonId,
+        });
+        // Validate required parameters
+        const requiredFields = ["storeGroupId", "countryCode", "addonId"];
+        for (const field of requiredFields) {
+            if (!params[field]) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: Missing required field '${field}'`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        const storeGroupId = params.storeGroupId;
+        const countryCode = params.countryCode;
+        const addonId = params.addonId;
+        // Validate country code format
+        const countryValidation = validateCountryCode(countryCode);
+        if (!countryValidation.valid) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: countryValidation.error ?? "Invalid country code",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Create API client
+        const client = createPriceManagementClient();
+        // Call API
+        const result = await client.getAddonPrice(storeGroupId, countryCode, addonId);
+        if (result.success && result.data) {
+            const price = result.data;
+            // Format response
+            let output = `Addon Price Details\n`;
+            output += "─".repeat(50) + "\n\n";
+            output += `Addon ID: ${price.addonId}\n`;
+            output += `Product Parent: ${price.productParentId}\n`;
+            output += `Store Group: ${price.storeGroupId}\n`;
+            output += `Store Name: ${price.storeName}\n`;
+            output += `Market: ${price.countryCode}\n`;
+            output += `Currency: ${price.currencyCode}\n\n`;
+            output += `Pricing:\n`;
+            output += `  Base Price: ${price.basePriceAmount} (minor units)\n`;
+            output += `  Sale Price: ${price.salePriceAmount} (minor units)\n`;
+            output += `  Discount Amount: ${price.discountAmount} (minor units)\n`;
+            if (price.referencePriceAmount) {
+                output += `  Reference Price: ${price.referencePriceAmount} (minor units)\n`;
+            }
+            output += `\nCreated: ${price.created}\n`;
+            output += `Updated: ${price.updated}\n`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: output,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✗ Failed to get addon price: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleGetAddonPrice", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✗ Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle patch_product_variant_prices tool call
+ */
+export async function handlePatchProductVariantPrices(params) {
+    try {
+        logger.info("Handling patch_product_variant_prices tool call", {
+            storeGroupId: params.storeGroupId,
+            productVariantId: params.productVariantId,
+        });
+        // Validate required parameters
+        const requiredFields = ["storeGroupId", "productVariantId", "priceUpdates"];
+        for (const field of requiredFields) {
+            if (!params[field]) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: Missing required field '${field}'`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        const storeGroupId = params.storeGroupId;
+        const productVariantId = params.productVariantId;
+        const priceUpdates = params.priceUpdates;
+        // Validate priceUpdates is a non-empty object
+        if (!priceUpdates || typeof priceUpdates !== "object" || Object.keys(priceUpdates).length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: priceUpdates must be a non-empty object with country codes as keys",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Validate country codes in priceUpdates
+        for (const countryCode of Object.keys(priceUpdates)) {
+            const countryValidation = validateCountryCode(countryCode);
+            if (!countryValidation.valid) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: Invalid country code '${countryCode}' in priceUpdates. ${countryValidation.error}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            // Validate price constraints if both base and sale are provided
+            const update = priceUpdates[countryCode];
+            if (update.basePriceAmount !== undefined &&
+                update.salePriceAmount !== undefined &&
+                update.salePriceAmount > update.basePriceAmount) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: Sale price (${update.salePriceAmount}) cannot be greater than base price (${update.basePriceAmount}) for country ${countryCode}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        // Create API client
+        const client = createPriceManagementClient();
+        // Build request - the API expects a map of country code to price updates
+        const request = {
+            productVariantPrices: priceUpdates,
+        };
+        // Call API
+        const result = await client.patchProductVariantPrices(storeGroupId, productVariantId, request);
+        if (result.success) {
+            const countries = Object.keys(priceUpdates).join(", ");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✓ Successfully patched prices for variant: ${productVariantId}\n\nStore group: ${storeGroupId}\nMarkets updated: ${countries}\nTotal markets: ${Object.keys(priceUpdates).length}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✗ Failed to patch prices: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handlePatchProductVariantPrices", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✗ Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}