brinkcommerce-dev-mcp 0.1.0-beta.1

package/dist/tools/stock-tools.js

@@ -0,0 +1,1046 @@
+import { createStockManagementClient } 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 Stock Management
+ */
+export const stockTools = {
+    update_product_variant_inventory: {
+        name: "update_product_variant_inventory",
+        description: "Update inventory levels for a product variant at a specific inventory location in BrinkCommerce.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productVariantId: {
+                    type: "string",
+                    description: "Unique identifier for the product variant",
+                },
+                inventoryId: {
+                    type: "string",
+                    description: "Unique identifier for the inventory location (warehouse, store, etc.)",
+                },
+                quantity: {
+                    type: "integer",
+                    description: "Stock quantity at this location",
+                    minimum: 0,
+                },
+            },
+            required: ["productVariantId", "inventoryId", "quantity"],
+        },
+        annotations: writeAnnotations,
+    },
+    delete_product_variant_inventory: {
+        name: "delete_product_variant_inventory",
+        description: "Delete inventory configuration for a product variant at a specific inventory location. WARNING: This removes the inventory record.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productVariantId: {
+                    type: "string",
+                    description: "Unique identifier for the product variant",
+                },
+                inventoryId: {
+                    type: "string",
+                    description: "Unique identifier for the inventory location to remove",
+                },
+            },
+            required: ["productVariantId", "inventoryId"],
+        },
+        annotations: destructiveAnnotations,
+    },
+    // ==========================================
+    // Inventory Location Management
+    // ==========================================
+    list_inventories: {
+        name: "list_inventories",
+        description: "List all inventory locations (warehouses, stores, etc.) in BrinkCommerce.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    get_inventory: {
+        name: "get_inventory",
+        description: "Get details of a specific inventory location in BrinkCommerce.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                inventoryId: {
+                    type: "string",
+                    description: "Unique identifier for the inventory location",
+                },
+            },
+            required: ["inventoryId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    create_or_update_inventory: {
+        name: "create_or_update_inventory",
+        description: "Create or update an inventory location (warehouse, store, etc.) in BrinkCommerce.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                inventoryId: {
+                    type: "string",
+                    description: "Unique identifier for the inventory location",
+                },
+                name: {
+                    type: "string",
+                    description: "A descriptive name for the inventory location",
+                },
+                description: {
+                    type: "string",
+                    description: "A description of the inventory location",
+                },
+                type: {
+                    type: "string",
+                    enum: ["WAREHOUSE", "STORE", "DROP_SHIP", "INBOUND"],
+                    description: "The type of inventory location (defaults to WAREHOUSE)",
+                },
+                address: {
+                    type: "object",
+                    description: "Physical address of the inventory location",
+                    properties: {
+                        streetAddress: {
+                            type: "string",
+                            description: "Street address",
+                        },
+                        city: {
+                            type: "string",
+                            description: "City",
+                        },
+                        region: {
+                            type: "string",
+                            description: "Region/state/province code (e.g., WA for Washington)",
+                        },
+                        postalCode: {
+                            type: "string",
+                            description: "Postal/zip code",
+                        },
+                        country: {
+                            type: "string",
+                            description: "Country code (ISO-3166-1 alpha-2)",
+                        },
+                    },
+                    required: ["streetAddress", "city", "region", "postalCode", "country"],
+                },
+            },
+            required: ["inventoryId", "name", "description"],
+        },
+        annotations: writeAnnotations,
+    },
+    delete_inventory: {
+        name: "delete_inventory",
+        description: "Delete an inventory location from BrinkCommerce. WARNING: This removes the inventory location permanently.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                inventoryId: {
+                    type: "string",
+                    description: "Unique identifier for the inventory location to delete",
+                },
+            },
+            required: ["inventoryId"],
+        },
+        annotations: destructiveAnnotations,
+    },
+    // ==========================================
+    // Product Variant Stock
+    // ==========================================
+    get_product_variant_stock: {
+        name: "get_product_variant_stock",
+        description: "Get stock information for a product variant including total quantity and per-inventory breakdown.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productVariantId: {
+                    type: "string",
+                    description: "Unique identifier for the product variant",
+                },
+            },
+            required: ["productVariantId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    update_product_variant_stock_config: {
+        name: "update_product_variant_stock_config",
+        description: "Update stock configuration for a product variant (e.g., whether stock should be validated).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productVariantId: {
+                    type: "string",
+                    description: "Unique identifier for the product variant",
+                },
+                validateStock: {
+                    type: "boolean",
+                    description: "Whether stock should be validated for this product variant",
+                },
+            },
+            required: ["productVariantId", "validateStock"],
+        },
+        annotations: writeAnnotations,
+    },
+    patch_product_variant_inventory: {
+        name: "patch_product_variant_inventory",
+        description: "Adjust inventory quantity for a product variant (add or subtract from current stock). " +
+            "Use positive values to add stock, negative values to remove stock.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                productVariantId: {
+                    type: "string",
+                    description: "Unique identifier for the product variant",
+                },
+                inventoryId: {
+                    type: "string",
+                    description: "Unique identifier for the inventory location",
+                },
+                quantityAdjustment: {
+                    type: "integer",
+                    description: "The quantity to adjust (e.g., -10 removes 10 from stock, +5 adds 5 to stock)",
+                },
+            },
+            required: ["productVariantId", "inventoryId", "quantityAdjustment"],
+        },
+        annotations: writeAnnotations,
+    },
+    // ==========================================
+    // Store Market Inventories
+    // ==========================================
+    get_store_market_inventories: {
+        name: "get_store_market_inventories",
+        description: "Get store market configuration with associated inventory locations and their priorities.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                storeGroupId: {
+                    type: "string",
+                    description: "Unique identifier for the store group",
+                },
+                countryCode: {
+                    type: "string",
+                    description: "ISO-3166-1 alpha-2 country code (e.g., SE, NO, DK)",
+                    pattern: "^[A-Z]{2}$",
+                },
+            },
+            required: ["storeGroupId", "countryCode"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    update_store_market_inventories: {
+        name: "update_store_market_inventories",
+        description: "Update the inventory locations for a store market. Sets which inventories serve the market and their priority order.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                storeGroupId: {
+                    type: "string",
+                    description: "Unique identifier for the store group",
+                },
+                countryCode: {
+                    type: "string",
+                    description: "ISO-3166-1 alpha-2 country code (e.g., SE, NO, DK)",
+                    pattern: "^[A-Z]{2}$",
+                },
+                inventoryIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Array of inventory IDs in priority order (first = highest priority)",
+                },
+            },
+            required: ["storeGroupId", "countryCode", "inventoryIds"],
+        },
+        annotations: writeAnnotations,
+    },
+};
+/**
+ * Handle update_product_variant_inventory tool call
+ */
+export async function handleUpdateProductVariantInventory(params) {
+    try {
+        logger.info("Handling update_product_variant_inventory tool call", {
+            productVariantId: params.productVariantId,
+            inventoryId: params.inventoryId,
+        });
+        // Validate required parameters
+        const requiredFields = ["productVariantId", "inventoryId", "quantity"];
+        for (const field of requiredFields) {
+            if (params[field] === undefined) {
+                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 inventoryId = params.inventoryId;
+        const quantity = params.quantity;
+        // Create API client
+        const client = createStockManagementClient();
+        // Build request
+        const request = {
+            quantity,
+        };
+        // Call API
+        const result = await client.updateProductVariantInventory(productVariantId, inventoryId, request);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✓ Successfully updated inventory for variant: ${productVariantId}\n\nInventory location: ${inventoryId}\nQuantity: ${quantity}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✗ Failed to update inventory: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleUpdateProductVariantInventory", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✗ Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle delete_product_variant_inventory tool call
+ */
+export async function handleDeleteProductVariantInventory(params) {
+    try {
+        logger.info("Handling delete_product_variant_inventory tool call", {
+            productVariantId: params.productVariantId,
+            inventoryId: params.inventoryId,
+        });
+        // Validate required parameters
+        const requiredFields = ["productVariantId", "inventoryId"];
+        for (const field of requiredFields) {
+            if (!params[field]) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: Missing required field '${field}'`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        const productVariantId = params.productVariantId;
+        const inventoryId = params.inventoryId;
+        // Create API client
+        const client = createStockManagementClient();
+        // Call API
+        const result = await client.deleteProductVariantInventory(productVariantId, inventoryId);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✓ Successfully deleted inventory for variant: ${productVariantId}\n\nInventory location ${inventoryId} has been removed.`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✗ Failed to delete inventory: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleDeleteProductVariantInventory", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✗ Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ==========================================
+// Inventory Location Management Handlers
+// ==========================================
+/**
+ * Handle list_inventories tool call
+ */
+export async function handleListInventories() {
+    try {
+        logger.info("Handling list_inventories tool call");
+        const client = createStockManagementClient();
+        const result = await client.listInventories();
+        if (result.success && result.data) {
+            const inventories = result.data.inventories ?? [];
+            if (inventories.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No inventory locations found.",
+                        },
+                    ],
+                };
+            }
+            const inventoryList = inventories
+                .map((inv) => `- **${inv.id}**: ${inv.name} (${inv.type})\n  Description: ${inv.description}`)
+                .join("\n");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Inventory Locations (${inventories.length}):\n\n${inventoryList}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to list inventories: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleListInventories", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle get_inventory tool call
+ */
+export async function handleGetInventory(params) {
+    try {
+        logger.info("Handling get_inventory tool call", {
+            inventoryId: params.inventoryId,
+        });
+        if (!params.inventoryId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'inventoryId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const client = createStockManagementClient();
+        const result = await client.getInventory(params.inventoryId);
+        if (result.success && result.data) {
+            const inv = result.data;
+            let text = `Inventory: ${inv.id}\n\n`;
+            text += `Name: ${inv.name}\n`;
+            text += `Description: ${inv.description}\n`;
+            text += `Type: ${inv.type}\n`;
+            text += `Created: ${inv.created}\n`;
+            text += `Updated: ${inv.updated}\n`;
+            if (inv.address) {
+                text += `\nAddress:\n`;
+                text += `  ${inv.address.streetAddress}\n`;
+                text += `  ${inv.address.city}, ${inv.address.region} ${inv.address.postalCode}\n`;
+                text += `  ${inv.address.country}\n`;
+            }
+            return {
+                content: [{ type: "text", text }],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to get inventory: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleGetInventory", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle create_or_update_inventory tool call
+ */
+export async function handleCreateOrUpdateInventory(params) {
+    try {
+        logger.info("Handling create_or_update_inventory tool call", {
+            inventoryId: params.inventoryId,
+        });
+        // Validate required fields
+        const requiredFields = ["inventoryId", "name", "description"];
+        for (const field of requiredFields) {
+            if (!params[field]) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: Missing required field '${field}'`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        const inventoryId = params.inventoryId;
+        const client = createStockManagementClient();
+        const request = {
+            name: params.name,
+            description: params.description,
+        };
+        if (params.type) {
+            request.type = params.type;
+        }
+        if (params.address) {
+            request.address = {
+                streetAddress: params.address.streetAddress,
+                city: params.address.city,
+                region: params.address.region,
+                postalCode: params.address.postalCode,
+                country: params.address.country,
+            };
+        }
+        const result = await client.createOrUpdateInventory(inventoryId, request);
+        if (result.success && result.data) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully created/updated inventory: ${inventoryId}\n\nName: ${result.data.name}\nType: ${result.data.type}\nDescription: ${result.data.description}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to create/update inventory: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleCreateOrUpdateInventory", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle delete_inventory tool call
+ */
+export async function handleDeleteInventory(params) {
+    try {
+        logger.info("Handling delete_inventory tool call", {
+            inventoryId: params.inventoryId,
+        });
+        if (!params.inventoryId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'inventoryId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const inventoryId = params.inventoryId;
+        const client = createStockManagementClient();
+        const result = await client.deleteInventory(inventoryId);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully deleted inventory: ${inventoryId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to delete inventory: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleDeleteInventory", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ==========================================
+// Product Variant Stock Handlers
+// ==========================================
+/**
+ * Handle get_product_variant_stock tool call
+ */
+export async function handleGetProductVariantStock(params) {
+    try {
+        logger.info("Handling get_product_variant_stock tool call", {
+            productVariantId: params.productVariantId,
+        });
+        if (!params.productVariantId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'productVariantId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const client = createStockManagementClient();
+        const result = await client.getProductVariantStock(params.productVariantId);
+        if (result.success && result.data) {
+            const pv = result.data;
+            let text = `Product Variant Stock: ${pv.id}\n\n`;
+            text += `Total Stock Quantity: ${pv.stockQuantity}\n`;
+            text += `Validate Stock: ${pv.validateStock}\n`;
+            text += `\nInventory Breakdown:\n`;
+            if (pv.inventories && pv.inventories.length > 0) {
+                for (const inv of pv.inventories) {
+                    text += `- ${inv.inventoryId}: ${inv.quantity} units\n`;
+                }
+            }
+            else {
+                text += "No inventory records found.\n";
+            }
+            return {
+                content: [{ type: "text", text }],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to get product variant stock: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleGetProductVariantStock", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle update_product_variant_stock_config tool call
+ */
+export async function handleUpdateProductVariantStockConfig(params) {
+    try {
+        logger.info("Handling update_product_variant_stock_config tool call", {
+            productVariantId: params.productVariantId,
+        });
+        if (!params.productVariantId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'productVariantId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (params.validateStock === undefined) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'validateStock'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const productVariantId = params.productVariantId;
+        const client = createStockManagementClient();
+        const result = await client.updateProductVariantStockConfig(productVariantId, {
+            validateStock: params.validateStock,
+        });
+        if (result.success && result.data) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully updated stock config for: ${productVariantId}\n\nValidate Stock: ${result.data.validateStock}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to update stock config: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleUpdateProductVariantStockConfig", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle patch_product_variant_inventory tool call
+ */
+export async function handlePatchProductVariantInventory(params) {
+    try {
+        logger.info("Handling patch_product_variant_inventory tool call", {
+            productVariantId: params.productVariantId,
+            inventoryId: params.inventoryId,
+        });
+        // Validate required fields
+        const requiredFields = ["productVariantId", "inventoryId", "quantityAdjustment"];
+        for (const field of requiredFields) {
+            if (params[field] === undefined) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: Missing required field '${field}'`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        const productVariantId = params.productVariantId;
+        const inventoryId = params.inventoryId;
+        const quantityAdjustment = params.quantityAdjustment;
+        const client = createStockManagementClient();
+        const result = await client.patchProductVariantInventory(productVariantId, inventoryId, {
+            quantityAdjustment,
+        });
+        if (result.success && result.data) {
+            const adjustment = quantityAdjustment >= 0 ? `+${quantityAdjustment}` : `${quantityAdjustment}`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully adjusted inventory for: ${productVariantId}\n\nInventory: ${inventoryId}\nAdjustment: ${adjustment}\nNew Quantity: ${result.data.quantity}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to patch inventory: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handlePatchProductVariantInventory", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ==========================================
+// Store Market Inventories Handlers
+// ==========================================
+/**
+ * Handle get_store_market_inventories tool call
+ */
+export async function handleGetStoreMarketInventories(params) {
+    try {
+        logger.info("Handling get_store_market_inventories tool call", {
+            storeGroupId: params.storeGroupId,
+            countryCode: params.countryCode,
+        });
+        // Validate required fields
+        if (!params.storeGroupId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'storeGroupId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (!params.countryCode) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'countryCode'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Validate country code format
+        if (!/^[A-Z]{2}$/.test(params.countryCode)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Invalid countryCode format. Must be 2-character ISO code (e.g., SE, NO)",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const client = createStockManagementClient();
+        const result = await client.getStoreMarketInventories(params.storeGroupId, params.countryCode);
+        if (result.success && result.data) {
+            const sm = result.data;
+            let text = `Store Market: ${sm.id}\n\n`;
+            text += `Store Name: ${sm.storeName}\n`;
+            text += `Store Description: ${sm.storeDescription}\n`;
+            text += `Created: ${sm.created}\n`;
+            text += `Updated: ${sm.updated}\n`;
+            text += `\nInventories (priority order):\n`;
+            if (sm.inventories && sm.inventories.length > 0) {
+                sm.inventories.forEach((inv, index) => {
+                    text += `${index + 1}. ${inv.id} - ${inv.name} (${inv.type})\n`;
+                });
+            }
+            else {
+                text += "No inventories configured.\n";
+            }
+            return {
+                content: [{ type: "text", text }],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to get store market inventories: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleGetStoreMarketInventories", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle update_store_market_inventories tool call
+ */
+export async function handleUpdateStoreMarketInventories(params) {
+    try {
+        logger.info("Handling update_store_market_inventories tool call", {
+            storeGroupId: params.storeGroupId,
+            countryCode: params.countryCode,
+        });
+        // Validate required fields
+        const requiredFields = ["storeGroupId", "countryCode", "inventoryIds"];
+        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 inventoryIds = params.inventoryIds;
+        // Validate country code format
+        if (!/^[A-Z]{2}$/.test(countryCode)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Invalid countryCode format. Must be 2-character ISO code (e.g., SE, NO)",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const client = createStockManagementClient();
+        const result = await client.updateStoreMarketInventories(storeGroupId, countryCode, {
+            inventoryIds: new Set(inventoryIds),
+        });
+        if (result.success && result.data) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully updated store market inventories\n\nStore Group: ${storeGroupId}\nCountry: ${countryCode}\nInventories: ${inventoryIds.join(", ")}`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to update store market inventories: ${result.error?.message}\n\nStatus: ${result.error?.status}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        logger.error("Error in handleUpdateStoreMarketInventories", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}